7.java三大特征之一：多态

柔情只为你懂 2024-04-01 19:33 80阅读 0赞

①封装

将属性和方法书写到类里面的操作就是封装

封装可以为属性和方法添加私有权限

②继承

子类默认继承父类的所有属性和方法

子类可以重写父类属性和方法

③多态

传入不同的对象，产生不同的结果

重写

![be7ac59a9a14458698be64c9d53ebd30.png][]

![81a7fd9ca498484e8aceeed2c18c9bde.png][]

package extend;
    
    public class Test {
        public static void main(String[] args) {
            Dog dog = new Dog();
            dog.cry();
        }
    
    }
    class Animal{
        public Object cry() {
            System.out.println("动物叫");
            return null;
        }
    }
    class Dog extends Animal{
        public String cry() {
            System.out.println("狗叫");
            return null;
        }
    }

重载与重写的区别

![2fd19a7b52974d0087c714ac45304044.png][]

多态

![9056bb6c6b724aabb4b6a26f70f08b42.png][]

对象的多态

引入代码

public class Test {
        public static void main(String[] args) {
            Master master = new Master();
            master.name = "ljw";
            Dog dog = new Dog();
            dog.name = "大黄";
            Bone bone = new Bone("骨头");
            master.feed(dog,bone);
            Cat cat = new Cat();
            cat.name = "tom";
            Fish fish = new Fish("带鱼");
            master.feed(cat,fish);
        }
    
    }
    class Master{
        String name;
        public void feed(Dog dog,Bone bone){
            System.out.println(name+"给  "+dog.name+" 吃 "+bone.name);
        }
        public void feed(Cat cat,Fish fish){
            System.out.println(name+" 给 "+cat.name+" 吃 "+fish.name);
        }
    }
    class Food{
        String name;
    }
    class Bone extends Food{
        String name;
        public Bone(String name){
            this.name = name;
        }
    }
    class Fish extends Food{
        String name;
        public Fish(String name){
            this.name = name;
        }
    }
    class Animal{
        String name;
        public Object cry() {
            System.out.println("动物叫");
            return null;
        }
    }
    class Dog extends Animal{
        public String cry() {
            System.out.println("狗叫");
            return null;
        }
    }
    class Cat extends Animal{
        public String cry() {
            System.out.println("猫叫");
            return null;
        }
    }

![829a3f25ff8643d28fab055e368874c5.png][]

编译时类型和运行时类型

Java的引用变量有两个类型，一个是编译时类型，一个是运行时类型，栈中存放的是一些引用和一些变量，而堆内存中存放的是对象。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。

Person p=new Women()(Women类继承自Person类)

假如p的属性修饰符为public 访问属性时得到的是Person类的属性还是Women类的属性，方法调用又是哪个类？

答案：会得到Person类的属性，调用Women类的方法。

编译时类型

编译时，JVM会在栈中静态创建基本数据变量，和引用数据变量的引用，回到刚刚那句代码，显然，p这个引用就是在编译时创建的，那么，p的编译时类型就是Person了。

编译时期可以理解为堆内存中还没有为该对象创建内存，只是在栈中创建了一些基本类型的变量和引用，所以编译时类型就是指在new该对象之前被加载到栈中的属性或方法。

运行时类型

当运行这句java代码时，JVM在堆中为p新建一块内存，对应new Women（）这句代码，所以p的运行时类型就是Women

运行时类型，是指new了一个对象出来，在栈中为该对象分配了内存，此时的运行时类型也就是栈中对象的属性或方法了。

Person person = new student();

这里就可以很好地理解编译时类型和运行时类型了。编译时类型是Person，当new了一个对象之后，堆内存中产生了一个Student对象，此时的类型就是运行时类型，也就是Student类型了。

如果编译时类型和运行时类型不一致，会出现所谓的多态。因为子类其实是一种特殊的父类，因此java允许把一个子类对象直接赋值给一个父类引用变量，无须任何类型转换，

或者被称为向上转型，由系统自动完成。

![18b7abf627bf4056ba14cdaec8dc6215.png][]

public class Test {
        public static void main(String[] args) {
            Animal dog = new Dog();
            dog.cry();
        }
    }
    class Animal{
        public Object cry() {
            System.out.println("动物叫");
            return null;
        }
    }
    class Dog extends Animal{
        public String cry() {
            System.out.println("狗叫");
            return null;
        }
    }

package extend;
    
    public class Test {
        public static void main(String[] args) {
            Master master = new Master();
            master.name = "ljw";
            Animal dog = new Dog("大黄");
            Food bone = new Bone("骨头");
            master.feed(dog,bone);
            Animal cat = new Cat("tom");
            Food fish = new Fish("带鱼");
            master.feed(cat,fish);
        }
    
    }
    class Master{
        String name;
        public void feed(Animal animal,Food food){
            System.out.println(name+"给  "+animal.name+" 吃 "+food.name);
        }
    }
    class Food{
        String name;
    }
    class Bone extends Food{
        public Bone(String name){
            this.name = name;
        }
    }
    class Fish extends Food{
        public Fish(String name){
            this.name = name;
        }
    }
    class Animal{
        String name;
        public Object cry() {
            System.out.println("动物叫");
            return null;
        }
    }
    class Dog extends Animal{
        public Dog(String name){
            this.name = name;
        }
        public String cry() {
            System.out.println("狗叫");
            return null;
        }
    }
    class Cat extends Animal{
        public Cat(String name){
            this.name = name;
        }
        public String cry() {
            System.out.println("猫叫");
            return null;
        }
    }

#### 向上转型 ####

父类 父类对象 = new 子类();

![dfb3ebaecf674a77ba7f4e4a2312b74e.png][]

![976e8ca70db24d5793d6f16fc210a977.png][]

package extend;
    
    public class Test {
        public static void main(String[] args) {
           Animal animal = new Dog();
           animal.cry();
    //       animal.a();
        }
    
    }
    class Animal{
        public void cry() {
            System.out.println("动物叫");
        }
    }
    class Dog extends Animal{
        public void a() {
            System.out.println("狗叫");
        }
    }

#### 向下转型 ####

![b015233fa9a94728958ebce1e9e661ed.png][]

![af6bbad0e1ea40daadd10cf40a84371a.png][]

public class Test {
        public static void main(String[] args) {
           Animal animal = new Dog();
           animal.cry();
           //！！要和         ^^^这个一样
           Dog dog = (Dog) animal;
           dog.a();
        }
    
    }
    class Animal{
        public void cry() {
            System.out.println("动物叫");
        }
    }
    class Dog extends Animal{
        public void a() {
            System.out.println("狗叫");
        }
    }

java多态中 方法看运行类型 属性看编译类型 方法重写属性不重写

package extend;
    
    public class Test {
        public static void main(String[] args) {
           Animal animal = new Dog();
           animal.cry();
           System.out.println(animal.age);
        }
    }
    class Animal{
        int age = 10;
        public void cry() {
            System.out.println("动物叫");
        }
    }
    class Dog extends Animal{
        int age = 111;
        public void cry() {
            System.out.println("狗叫");
        }
    }

instanceof:看该对象的运行时类型是否为xx类型或他的子类型

[be7ac59a9a14458698be64c9d53ebd30.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/ec2a84c8f26c44f487167925fcc97089.png
[81a7fd9ca498484e8aceeed2c18c9bde.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/58004dc98d9043ca9da5aea54f09dc17.png
[2fd19a7b52974d0087c714ac45304044.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/06b8e0448c654a82a17daa2120228f83.png
[9056bb6c6b724aabb4b6a26f70f08b42.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/a218d061b68a4d6e9ef665ffce495812.png
[829a3f25ff8643d28fab055e368874c5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7baaa410bd5247daac6ab58cfb84ddfa.png
[18b7abf627bf4056ba14cdaec8dc6215.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6f841901d59445648b66a1830ece2d12.png
[dfb3ebaecf674a77ba7f4e4a2312b74e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2fcbea6f3e054b61841b7dd81f3644b4.png
[976e8ca70db24d5793d6f16fc210a977.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/074e3dd06d18409fa7753373220a90f4.png
[b015233fa9a94728958ebce1e9e661ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/de6082ec05f441c1955596ecd1a88b8a.png
[af6bbad0e1ea40daadd10cf40a84371a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/9cb95b0a096e42fda8a4754b5c42db0d.png