OOP练习2-继承与重写

案例题目描述

(1)做一个Student类，Student类有名称(name)，性别(sex),年龄(age)，学号(stu id)，做合理封装，通过构造器在创建对象时将4个属性赋值。
(2)写一个Teacher类，Teacher类有名称(name)，性别(sex) ，年龄(age)，工龄(work age),做合理封装，通过构造器在创建对象时将4个属性赋值。
(3)抽取一个父类Person类，将共同属性和方法放到Person类
(4)学生需要有学习的方法(study) ，在方法里写生“我承诺，我会好好学习。”。
(5)教师需要有教学的方法(teach) ，在方法里写上“我承诺，我会认真教学。”
(6)学生和教师都有玩的方法(play) ，学生玩的是足球，老师玩的是象棋，此方法是返回字符串的，分别返回"x爱玩足球"和“xx爱玩象棋”(其中xx分别代表学生和老师的姓名)。因为玩的方法名称都一样，所以要求此方法定义在父类中，子类实现重写。

打印效果如下

完成思路

1. 创建一个Person类作为父类，包含共同的属性和方法，如名称(name)，性别(sex)，年龄(age)，以及play()抽象方法。这个类应该是一个抽象类。

2. 创建一个Student类继承自Person类。在Student类中，定义一个私有属性学号(stu id)，并创建构造函数用于初始化所有属性。实现重写父类的play()方法和学习的方法study()。

3. 创建一个Teacher类继承自Person类。在Teacher类中，定义一个私有属性工龄(work age)，并创建构造函数用于初始化所有属性。实现重写父类的play()方法和教学的方法teach()。

4. 通过重写play方法以及调用父类的play方法完成输出

5. 在主函数中，创建Student和Teacher对象，通过调用playInfo方法来输出。

运行截图

完成代码

Person类

public class Person {
    private String name;
    private int age;
    private String sex;

    public Person(String name, int age,String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    public String play(){
        return this.getName()+"爱玩";
    }
    public String info(){
        return "姓名:"+this.getName()+"\n年龄:"+this.getAge()+"\n性别:"+this.getSex();
    }
}

Student类

public class Student extends Person{
    private int stu_id;
    public Student(String name, int age, String sex,int stu_id) {
        super(name, age, sex);
        this.stu_id=stu_id;
    }

    public int getStu_id() {
        return stu_id;
    }

    public void setStu_id(int stu_id) {
        this.stu_id = stu_id;
    }
    public String study(){
        return "我承诺,我会好好学习。";
    }

    @Override
    public String play() {
        return super.play()+"足球";
    }
    public  void printInfo(){
        System.out.println("学生的信息:");
        System.out.println(this.info());
        System.out.println("学号:"+this.getStu_id());
        System.out.println(study());
        System.out.println(play());
    }
}

Teacher类

public class Teacher extends Person{
    private int work_age;

    public Teacher(String name, int age, String sex, int work_age) {
        super(name, age, sex);
        this.work_age = work_age;
    }

    public int getWork_age() {
        return work_age;
    }

    public void setWork_age(int work_age) {
        this.work_age = work_age;
    }
    public String teach(){
        return "我承诺,我会认真教学。";
    }
    @Override
    public String play() {
        return super.play()+"象棋";
    }
    public  void printInfo(){
        System.out.println("老师的信息:");
        System.out.println(this.info());
        System.out.println("工龄:"+this.getWork_age());
        System.out.println(teach());
        System.out.println(play());
    }
}

homework类

public class homework {
    public static void main(String[] args) {
        Person[] person = new Person[2];
        person[0]=new Student("小明",15,"男",0001);
        person[1]=new Teacher("张飞",30,"男",5);
        ((Teacher)person[1]).printInfo();
        System.out.println("----------------");
        ((Student)person[0]).printInfo();
    }
}

总结

在这个案例中，我们实现了三个类：Person、Student和Teacher。Person类是一个抽象类，它包含了名称、性别和年龄这些共同的属性，以及play()方法。Student类和Teacher类分别继承自Person类，并重写了play()方法，实现了各自特有的功能。

通过合理封装和构造器的使用，我们可以在创建对象时将所有属性进行赋值。这样做的好处是可以维护数据的封装性和代码的可读性，同时避免了属性被直接修改。

在每个类中，我们实现了相应的方法。学生类中有study()方法来表示学习的行为，教师类中有teach()方法来表示教学的行为。play()方法是父类中的抽象方法，子类通过重写来实现各自的玩的内容。

此外，我们还实现了一个printInfo()方法用于打印每个类的基本信息。通过调用对象的方法，我们可以打印出学生和教师的具体信息，包括姓名、年龄、性别、学号（学生类）和工龄（教师类），以及学生的study()和play()方法，教师的teach()和play()方法。

最后，在主函数中我们创建了一个Person类型的数组，并通过向数组中添加学生和教师对象来演示多态性的用法。通过强制类型转换，我们可以调用子类中独有的方法和打印具体的信息。

总之，通过这个案例我们学到了如何设计继承关系和构建对象，如何利用重写来实现特定的功能，并且了解到多态性的应用。这些概念和技巧对于面向对象编程非常重要，可以提高代码的重用性、可维护性和可扩展性。