多态数组+冒泡排序+向下转型+类型判断

今晚做了一个练习题：

案例题目描述:

(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) ,学生玩的是足球，老师玩的是象棋，此方法是返回字符串的，分别返回”xx爱玩足球”和”xx爱玩象棋” (其中xx分别代表学生和老师的姓名)。因为玩的方法名称都一样，所以要求此方法定义在父类中，子类实现重写。

package com.extends2;
//父类
public class Person {
    private String name;
    private String sex;
    private int age;

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

    public void play(){
        System.out.println("爱玩");
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    //要打印出一个基本信息
    public String basicInfo(){
        return "姓名: " + name + "n年龄" + age + "n性别: " + sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", sex='" + sex + ''' +
                ", age=" + age +
                '}';
    }
}

package com.extends2;

public class Student extends Person{
    private String stu_id;

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

    public String getStu_id() {
        return stu_id;
    }

    public void setStu_id(String stu_id) {
        this.stu_id = stu_id;
    }
    //特有方法
    public void study(){
        System.out.println("我承诺我会好好学习");
    }

    @Override
    public void play() {
        System.out.println("学生爱玩篮球");
    }
    //编写一个输出信息的方法，这样体现封装
    public void printInfo(){
        System.out.println("学生的信息");
        System.out.println(super.basicInfo());
        System.out.println("学号： " + stu_id);
        //组合
        study();
        play();
    }

    @Override
    public String toString() {
        return "Student{" +
                "stu_id='" + stu_id + ''' +
                '}'+super.toString();//拼接把父类的基本信息带过来了
    }
}

package com.extends2;

public class Teach extends Person{
    private int work_age;

    public Teach(String name, String sex, int age, int work_age) {
        super(name, sex, age);
        this.work_age = work_age;
    }
    //特有方法
    public void teach(){
        System.out.println("我承诺会好好教书");
    }

    @Override
    public void play() {
        System.out.println("老师爱玩足球");
    }
    public void printInfo() {
        System.out.println("老师的信息");
        System.out.println(super.basicInfo());
        System.out.println("工龄: " + work_age);
        //组合
        teach();
        play();
    }

    @Override
    public String toString() {
        return "Teach{" +
                "work_age=" + work_age +
                '}'+super.toString();//拼接把父类的基本信息带过来了
    }
}

package com.extends2;

public class Test {
    public static void main(String[] args) {
        Person person = new Person("iug","男",13);
        Student student = new Student("ytf","女",12,"123456");
        Teach teach = new Teach("jgh","女",13,15);
        student.printInfo();
        System.out.println("=======================");
        teach.printInfo();
        //定义多态数组,里面保存2个学生2个老师，要求按年龄从高到低排序
        Person[] persons = new Person[4];
        persons[0] = new Student("ytf","女",12,"123456");
        persons[1] = new Student("uytgu","男",13,"67477");
        persons[2] = new Teach("jgh","女",15,15);
        persons[3] = new Teach("yurtfyt","男",34,12);
            }
}

(7)定义多态数组，里面保存2个学生和2个教师，要求按年龄从高到低排序

(8)定义方法，形参为Person类型，功能:调用学生的study或教师的 teach方法

要求7用到多态数组+冒泡排序在我之前的文章里面有一毛一样的做法：https://mp.weixin.qq.com/s/p9swjuQcBGiFIkBuvgvKjg

要求8用到多态数组+向下转型+类型判断在我之前写过的文章里面有一毛一样的做法：https://mp.weixin.qq.com/s/ruoWhNgSfOq0J0MYAIqijw

        //创建对象
        Test test = new Test();
        test.bubbleSort(persons);

        //输出排序后的数组
        System.out.println("------------排序后的数组------------");
        for (int i = 0; i < persons.length; i++) {
            System.out.println(persons[i].toString());
        }
        //遍历数组，调用test()
        System.out.println("=======================");
        for (int i = 0; i < persons.length; i++) {
            test.test(persons[i]);
        }
    }
    //定义方法，形参为Person类型，调用各自特有方法
    //这里会用到向下转型和类型判断
    public void test(Person p){
        if(p instanceof Student){
            ((Student) p).study();//向下转型
        }else if(p instanceof Teach){
            ((Teach) p).teach();
        }else if(p instanceof Person){
            //不做处理
        }else {
            System.out.println("类型有误");
        }
    }
    //方法，完成年龄从高到低排序
    public void bubbleSort(Person[] persons){
        Person temp = null;
        for (int i = 0; i < persons.length-1; i++) {
            for (int j = 0; j < persons.length-1-i; j++) {
                if(persons[j].getAge() < persons[j+1].getAge()){
                    temp = persons[j];
                    persons[j] = persons[j+1];
                    persons[j+1] = temp;
                }
            }
        }