多态应用操作题

多态应用

​

应用实例

多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型
现有一个继承结构如下：要求创建一个Person对象、2个student对象

和两个Teacher有一个teach，同一放在数组中，并调用say方法

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

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

    }

    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 say(){   //返回名字和年龄 
        return name + "\t" +age;
    }
}
public class Student  extends Person{
    private double score;

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
    //重写父类方法
    @Override
    public String say() {
        return super.say()+ " "+"score=" + " "+score;
    }
}
public class Teacher extends Person{
    private  double sal;

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

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }
    //重写父类方法

    @Override
    public String say() {
        return super.say()+" "+"salary"+" "+sal;
    }
}
public class ployArray {
    public static void main(String[] args) {
        //现有一个继承结构如下：要求创建一个Person对象、2个student对象
        //和两个Teacher有一个teach，同一放在数组中，并调用say方法
        Person[] persons = new Person[5];
        persons[0] = new Person("jack",20);
        persons[1] = new Student("jack",18,100);
        persons[2] = new Student("smith",19,50);
        persons[3] = new Teacher("scort",50,25000);
        persons[4] = new Teacher("fewfs",50,25000);
        //循环调用每个对象
        for (int i=0;i< persons.length;i++){
            //persons[i]编译类型是Persons，运行类型是根据实际情况有jvm判断
            System.out.println(persons[i].say());//动态绑定机制
        }
    }
}

升级版本

如何调用子类特有方法，比如teacher有一个teach，Student有一个study

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

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

    }

    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 say(){   //返回名字和年龄 
        return name + "\t" +age;
    }
}
public class Student  extends Person{
    private double score;

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
    //重写父类方法
    @Override
    public String say() {
        return super.say()+ " "+"score=" + " "+score;
    }
    //学生特有方法
    public void study(){
        System.out.println(getName()+"学生"+"正在学习");
    }
}
public class Teacher extends Person{
    private  double sal;

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

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }
    //重写父类方法

    @Override
    public String say() {
        return super.say()+" "+"salary"+" "+sal;
    }
    //特有方法
    public void teach(){
        System.out.println(getName()+"老师"+"正在讲课");
    }
}
public class ployArray {
    public static void main(String[] args) {
        //现有一个继承结构如下：要求创建一个Person对象、2个student对象
        //和两个Teacher有一个teach，同一放在数组中，并调用say方法
        Person[] persons = new Person[5];
        persons[0] = new Person("jack",20);
        persons[1] = new Student("jack",18,100);
        persons[2] = new Student("smith",19,50);
        persons[3] = new Teacher("scort",50,25000);
        persons[4] = new Teacher("fewfs",50,25000);
        //循环调用每个对象
        for (int i=0;i< persons.length;i++){
            //persons[i]编译类型是Persons，运行类型是根据实际情况有jvm判断
            System.out.println(persons[i].say());//动态绑定机制
            if (persons[i] instanceof Student){//判断person[i]的运行类型是不是Student
                System.out.println("\n");
                ((Student) persons[i]).study();//向下转型
            }
            else if (persons[i] instanceof Teacher){//判断person[i]的运行类型是不是Teacher
                System.out.println("\n");
                ((Teacher) persons[i]).teach();//向下转型
            }else if (persons[i] instanceof Person){

            }else{
                System.out.println("类型有误，请重新输入");
            }
        }
    }
}

instanceof

比较操作符，用于判断对象的运行类型是否为XX类型或XX；

多态参数

定义员工类Employee，包含姓名月工资（private），以及计算年工资getAnnual

的方法。普通员工和经理继承了员工，经理类多了奖金bonus属性和管理manage

方法，普通员工类多了work方法，普通员工和经理类要求分别重写getAnnua方法

测试类中添加一个方法showEmpAnnal(Emplyee e),实现获取任何员工对象的年

工资，并在main方法中调用该方法[e.getAnnua()]

测试类中添加一个方法，testWork，如果是普通员工，则调用work方法，如果是经理，则

调用manage方法

public class Employee {
    /**
     * 定义员工类Employee，包含姓名月工资（private），以及计算年工资getAnnual
     * 的方法。普通员工(General)和经理(Manager)继承了员工(Employee)，经理类多了奖金bonus属性和
     * 管理manage方法，普通员工类多了work方法，普通员工和经理类要求分别重写getAnnua方法
     * */
    private String name;
    private double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    //得到年工资的方法
    public double getAnnual(){
        return  12* salary;
    }
    public String getName(){
        return name;
    }
}
public class Manager extends Employee{
   private double bonus;

    public Manager(String name, double salary, double bonus) {
        super(name, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
    public  void manage(){
        System.out.println(getName()+" "+"经理"+" "+"is manageing");
    }
    //重写获取年薪方法

    @Override
    public double getAnnual() {
        return super.getAnnual()+bonus;
    }
}
public class General extends Employee {
    public General(String name, double salary) {
        super(name, salary);
    }
    public void work(){
        System.out.println(getName()+" "+"普通员工" +" "+"is working");
    }

    @Override
    public double getAnnual() {
        //因为普通员工没有其他收入，则直接调用父类方法
        return super.getAnnual();
    }
}
public class Test {
    public static void main(String[] args) {
        General tom = new General("tom",2500);
        Manager skip = new Manager("skip",5000,2000);
        Test test = new Test();
        test.showEmpAnnal(tom);
        test.showEmpAnnal(skip);
        test.testWork(tom);
        test.testWork(skip);
    }
     /**
      *  测试类中添加一个方法showEmpAnnal(Employee e),实现获取任何员工对象的年
      *  工资，并在main方法中调用该方法[e.getAnnua()]*/
     public void showEmpAnnal(Employee e){
         System.out.println(e.getAnnual());
     }
     /**
      * 测试类中添加一个方法，testWork，如果是普通员工，则调用work方法，如果是经理，则
      * 调用manage方法**/
     public void testWork(Employee e){
         if (e instanceof General){
             ((General) e).work();//向下转型
         }else if (e instanceof Manager){
             ((Manager) e).manage();
         }
     }
}