设计Teacher类，继承Person类，将Person类的成员变量改为出生日期，再设计age()方法求年龄。

A：

class Person:
    def __init__(self, birthdate):
        self.birthdate = birthdate
        
class Teacher(Person):
    def __init__(self, birthdate):
        super().__init__(birthdate)
        
    def age(self):
        today = datetime.date.today()
        age = today.year - self.birthdate.year
        if (today.month, today.day) < (self.birthdate.month, self.birthdate.day):
            age -= 1
        return age

在Person类中，我们只需要一个出生日期属性。在Teacher类中，我们继承了Person类，因此我们只需要调用super()方法来初始化我们从Person类继承的属性。我们还添加了age()方法，该方法将根据出生日期计算年龄，并返回一个整数表示。

相关问题

设计Teacher类，继承Person类。将Person类的成员变量改为出生日期，再设计age()方法求年龄。

A：

class Person:
    def __init__(self, name:str, birth_date:str):
        self.name = name
        self.birth_date = birth_date

class Teacher(Person):
    def __init__(self, name:str, birth_date:str):
        super().__init__(name, birth_date)

    def age(self):
        birth_year = int(self.birth_date[:4])
        current_year = datetime.datetime.now().year
        age = current_year - birth_year
        return age

在这个例子中，我们首先定义了一个基类Person，其包含了姓名（name）和出生日期（birth_date）两个成员变量。

接下来，我们定义了一个Teacher类，它继承自Person类。Teacher类不需要再定义姓名和出生日期，因为它继承了Person类中的这两个成员变量。

但是，我们需要重新实现Teacher类中的age()方法，因为Teacher的年龄的计算方式与Person可能不同。在上面这个例子中，我们假设Teacher的年龄等于当前时间与出生年份之差。

这里使用了datetime模块来获取当前年份。我们假设birth_date是一个字符串，它的前四位是出生年份。我们将它转换为一个整数（int），然后将当前年份减去出生年份，就得到了教师的年龄。

设计接口Action表示人的活动，抽象方法有say(String msg);eating(String food); 设计抽象类Person，成员变量name和age，重写toString()方法，省略构造方法和setter、getter方法； 定义Worker类实现Action接口继承Person类。 定义Teacher类实现Action接口继承Person类。

下面是代码实现：

public interface Action {
    void say(String msg);
    void eating(String food);
}

public abstract class Person {
    protected String name;
    protected int age;

    @Override
    public String toString() {
        return "Name: " + name + ", Age: " + age;
    }
}

public class Worker extends Person implements Action {
    public Worker(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public void say(String msg) {
        System.out.println("Worker " + name + " says: " + msg);
    }

    @Override
    public void eating(String food) {
        System.out.println("Worker " + name + " is eating " + food);
    }
}

public class Teacher extends Person implements Action {
    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public void say(String msg) {
        System.out.println("Teacher " + name + " says: " + msg);
    }

    @Override
    public void eating(String food) {
        System.out.println("Teacher " + name + " is eating " + food);
    }
}

在上面的代码中，我们定义了一个接口 `Action`，其中包含了两个抽象方法 `say` 和 `eating`。然后我们定义了一个抽象类 `Person`，其中包含了两个成员变量 `name` 和 `age`，以及重写了 `toString` 方法。最后，我们定义了两个类 `Worker` 和 `Teacher`，它们都实现了 `Action` 接口，并且继承了 `Person` 抽象类。在这两个类中，我们实现了接口中的两个抽象方法，同时也可以使用 `Person` 抽象类中的成员变量和方法。