解析java中的多态

Java
300
0
0
2023-12-09
Java 集合框架体系总览
上一篇
JVM成神路对象内存布局、分配过程、从生至死历程、强弱软件引用
下一篇

怎么使用多态

3.1 使用 多态 的前提

两个类之间 必须存在父子关系 (继承关系)

必须实现了方法的重写,因为多态主要是指的是 方法的多态性 ,和属性没关系

3.2 多态运行的机制

3.2.1 编译期(静态)

编译时看的是左边,编译阶段会检查对象.属性/方法是否是父类里面定义的属性和方法(若父类还有其父亲,也要在父类型特征区去进行寻找),若存在,才允许编译通过,若不存在则编译不通过

编译不通过示例代码

Animal01

 package Work;

public class Animal {
 
     private  String name;
    //姓名
    private int age;
    //年龄
    private String sex;
    //性别

    public Animal() {
 
    }

    public Animal(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 void say(Animal animal01){
 
        System.out.println("名字为: "+animal.getName()+"年龄为: "+animal01.getAge()+"性别为: "+animal01.getSex()+"的狗在汪汪汪");
    }

}

Dog01

 package Work;
public class Dog extends Animal01{
 
    int weight;
    //Dog独有的属性
    public Dog() {
 
    }

    public Dog(String name, int age, String sex) {
 
        super(name, age, sex);
    }
}

Test

 package Work;
public class Test {
 
    public  static  void main(String[] args) {
 
        //建立一个父类对象,启动say方法
       Animal a=new Dog01("王富贵",5,"雌性");
       System.out.println(a.weight);;
    }
}

错误示例截图

3.2.1 运行期(动态)

因为编译期会把 人类的独有方法被过滤掉 ,因此运行的时候只需要考虑.的方法是否在子类型 实例化的空间里面 存在了。

运行看的是右边,若子类 重写了.调用的方法 ,那么用多态时候调用的就是子类的方法，若没有重写,调用的是子类中的父类型特征区里面的方法(继承时从父类那边拷贝一份过来的)

示例代码

Animal01类

 package Work;

public class Animal {
 
    private String name;
    //姓名
    private int age;
    //年龄
    private String sex;
    //性别

    public Animal() {
 
    }

    public Animal(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 void say(){
 
        System.out.println("动物在说话!!!");
    }
    public void test(){
 
        System.out.println("测试父类中没有被子类重写的方法是否能被调用");
    }

}

Dog01类

 package Work;
public class Dog extends Animal01{
 
    int weight;
    //Dog独有的属性
    public Dog() {
 
    }

    public Dog(String name, int age, String sex) {
 
        super(name, age, sex);
    }

    @Override
    public void say() {
 
        System.out.println("狗狗在说话");
    }
} 
 package Work;
public class Test {
 
    public static void main(String[] args) {
 
        //建立一个父类对象,启动say方法
       Animal a=new Dog01("王富贵",5,"雌性");
       a.test();
       a.say();
    }
}

示例代码运行截图

3.2.3 为什么多态运行的机制要设计成这样???

编译期间

在多个类之间进行参数的传递时,传递的具体是哪个类型,编译器并不清楚。在new的过程中,是哪个类型也不知道, 为了保证一定有一个方法能够在运行期间能够顺利启动 ,所以编译期才必须要求调用的方法一定是父类型的方法,调用的属性一定是父类型的属性

运行期间

为了体现 子类实例化对象的差异性 ,例如狗的叫声是汪汪汪,猫的叫声是喵喵喵

3.3 多态是编译时状态还是运行时状态

解答: 运行时状态 ,因为你在编译的过程中并不知道你 实例化 的对象是什么类型的,只有在方法调用的时候才知道

3.4 方法重载 是运行时状态还是编译时状态

解答:方法的重载是编译时状态,因为你在用方法的时候就确定是那个方法了,不会有其他的可能性的。是静态的

3.5 多态的三个常见的使用场景

a 父类中有一个方法且该方法没有被子类重写,不同的子类调用该方法时,想根据子类的类型去得到对应的结果

典型题目

存在一个父类Animal01,子类Dog01、子类Cat01,其中Animal类中有一个say()叫声方法,此方法没有被子类重写,然后你想要Dog01调用say()方法打印汪汪汪,Cat01调用时say()方法时打印喵喵喵

示例代码

Animal01类

 package Work;

public class Animal {
 
    private String name;
    //姓名
    private int age;
    //年龄
    private String sex;
    //性别

    public Animal() {
 
    }

    public Animal(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 void say(Animal animal01){
 
       if(animal  instanceof  Dog01){
 
           System.out.println("汪汪汪");
       }else if(animal instanceof Cat01){
 
           System.out.println("喵喵喵");
       }
    }


}

Cat01类

 package Work;

public class Cat extends  Animal01{
 
    public Cat() {
 
    }

    public Cat(String name, int age, String sex) {
 
        super(name, age, sex);
    }
}

Dog01类

 package Work;
public class Dog extends Animal01{
 
    public Dog() {
 
    }

    public Dog(String name, int age, String sex) {
 
        super(name, age, sex);
    }

} 
 package Work;
public class Test {
 
    public static void main(String[] args) {
 
        //建立一个父类对象animal,启动say方法
        Animal animal01=new Animal01();
        animal.say(new Dog01());
        animal.say(new Cat01());
    }
}

示例代码运行截图

b 父类中有一个方法且该方法没有被子类重写,不同的子类调用该方法时会去执行其独有的方法

典型题目

存在一个父类Animal01,子类Dog01、子类Cat01,其中Animal类中有一个action()行为方法,此方法没有被子类重写,然后你想要Dog01调用action()方法会调用Dog01中特有的方法guardDoor看门,Cat01调用时action()方法时会去调用Cat01中特有的方法catchMouse()

示例代码

Animal01类

 package Work;

public class Animal {
 
    private String name;
    //姓名
    private int age;
    //年龄
    private String sex;
    //性别

    public Animal() {
 
    }

    public Animal(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 void action(Animal animal01){
 
       if(animal instanceof Dog01){
 
           ((Dog)animal01).guardDoor();
       }else if(animal instanceof Cat01){
 
           ((Cat)animal01).catchMouse();
       }
    }


}

Cat01类

 package Work;

public class Cat extends  Animal01{
 
    public Cat() {
 
    }

    public Cat(String name, int age, String sex) {
 
        super(name, age, sex);
    }
    public void catchMouse(){
 
        System.out.println("猫咪在捉老鼠");
    }
}

Dog01类

 package Work;
public class Dog extends Animal01{
 
    public Dog() {
 
    }

    public Dog(String name, int age, String sex) {
 
        super(name, age, sex);
    }
    public void guardDoor(){
 
        System.out.println("狗狗在看门");
    }
} 
 package Work;
public class Test {
 
    public static void main(String[] args) {
 
        //建立一个父类对象animal,启动action方法
        Animal animal01=new Animal01();
        animal.action(new Dog01());
        animal.action(new Cat01());
    }
}

示例代码运行截图

c 父类中有一个方法且该方法被子类重写,不同的子类调用该方法时,调用的是子类中重写的方法,从而表现出子类对象的差异性

典型题目

存在一个父类Animal01,子类Dog01、子类Cat01,其中Animal类中有一个eat()叫声方法, 此方法被其所有子类重写 ,存在一个Master主人类,主人根据不同的实例化对象，进行不同的喂养方法

示例代码

Animal01类

 package Work;

public class Animal {
 
    private String name;
    //姓名
    private int age;
    //年龄
    private String sex;
    //性别

    public Animal() {
 
    }

    public Animal(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 void eat(){
 
        System.out.println("父类对象提供方法给子类对象去重写它");
    }


}

Cat01类

 package Work;

public class Cat extends  Animal01{
 
    public Cat() {
 
    }

    public Cat(String name, int age, String sex) {
 
        super(name, age, sex);
    }
    @Override
    public void eat() {
 
        System.out.println("猫咪在吃鱼");
    }
}

Dog01类

 package Work;
public class Dog extends Animal01{
 
    public Dog() {
 
    }

    public Dog(String name, int age, String sex) {
 
        super(name, age, sex);
    }

    @Override
    public void eat() {
 
        System.out.println("狗在啃骨头");
    }
}

Master类

 package Work;
public class Master {
 
    public void feed(Animal animal01){
 
        animal.eat();
        //不用去进行对象是哪个类型的判断,调用是子类被重写的方法
        //结论:只要调用的是子类的重写的方法,那么就无需进行对象的类型的判断
    }
} 
 package Work;
public class Test {
 
    public static void main(String[] args) {
 
        Master master=new Master();
        master.feed(new Dog());
        master.feed(new Cat());
    }
}

示例代码运行截图

Java 集合框架体系总览
上一篇
JVM成神路对象内存布局、分配过程、从生至死历程、强弱软件引用
下一篇