编写一个person类，属性姓名，年龄。方法吃饭，睡觉。子类学生，工人

当然，我们可以进一步扩展刚才的Person类，添加子类Student和Worker来实现特定的职业特性。这里有一个例子，用Python来演示：

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

    # 基本方法：吃饭和睡觉
    def eat(self):
        print(f"{self.name}正在吃饭.")
    
    def sleep(self):
        print(f"{self.name}正在睡觉.")

# 子类：学生
class Student(Person):
    def study(self):
        print(f"{self.name}正在学习.")

# 子类：工人
class Worker(Person):
    def work(self):
        print(f"{self.name}正在工作.")

# 创建Person、Student和Worker实例
p = Person("李四", 25)
p.eat()
p.sleep()

s = Student("王五", 18)
s.study()
s.eat()  # 调用父类的eat方法

w = Worker("赵六", 35)
w.work()
w.sleep()

相关问题

编写一个person类，属性：姓名，年龄。方法吃饭，睡觉。子类学生，工人。

在Python中，你可以创建一个名为`Person`的基础类，然后定义两个子类`Student`和`Worker`。下面是一个简单的例子：

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

    # 定义通用的行为方法
    def eat(self):
        print(f'{self.name}正在吃饭')

    def sleep(self):
        print(f'{self.name}正在睡觉')


# 子类：学生
class Student(Person):
    def study(self):
        print(f'{self.name}在学习')

# 子类：工人
class Worker(Person):
    def work(self):
        print(f'{self.name}正在工作')

# 创建实例并展示多态
student = Student('小明', 20)
worker = Worker('老张', 40)

student.eat()  # 输出：小明正在吃饭
worker.sleep()  # 输出：老张正在睡觉

# 虽然学生和工人有各自的特定方法，但他们也共享基础类的行为
student.study()  # 输出：小明在学习
worker.work()   # 输出：老张正在工作

在这个例子中，`eat()`和`sleep()`方法在所有类中都被重写，展示了多态性。当通过`student`和`worker`对象调用这些方法时，会分别执行各自类的版本。

java编写一个person类属性姓名年龄方法吃饭和睡觉两个方法子类学生学生有自己的属性学号和学习方法工人工人有自己的属性工号和工作方法

在Java中，你可以创建一个名为`Person`的基类，然后定义一些通用属性如姓名和年龄，并提供吃饭和睡觉这两个方法。接着，为了实现多态，你可以为`Person`创建两个子类，如`Student`和`Worker`，每个子类添加特定的属性（学号和工号）以及特有的方法（学习和工作）。下面是一个简单的示例：

// Person基类
public class Person {
    private String name;
    private int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 公共方法
    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

// Student子类
public class Student extends Person {
    private String studentId;

    public Student(String name, int age, String studentId) {
        super(name, age);
        this.studentId = studentId;
    }

    // 学生特有的方法
    public void study() {
        System.out.println(name + " is studying (" + studentId + ").");
    }
}

// Worker子类
public class Worker extends Person {
    private String workerId;

    public Worker(String name, int age, String workerId) {
        super(name, age);
        this.workerId = workerId;
    }

    // 工人的特有方法
    public void work() {
        System.out.println(name + " is working (" + workerId + ").");
    }
}

在这个例子中，`Student`和`Worker`都继承了`Person`，并且覆盖或重写了`eat()`和`sleep()`方法，同时各自添加了`study()`和`work()`方法。这展示了多态性如何允许不同类型的对象通过相同的接口（即`Person`类的方法）表现出不同的行为。