【java特性_面向对象】多态 向上转型 向下转型 equals()方法重写中的向下转型

多态（Polymorphism）

多态的定义：

1. 多态与属性无关，多态指方法的多态，不是属性的多态
2. 先有父类再有子类是继承，先有子类再有父类是泛化
3. 多态是多种状态：同一行为，不同子类表现出来的不同形态
4. 多态指的是同一方法的调用，由于对象不同会产生不同的行为

多态的优势：

提高代码的扩展性，符合面向对象的设计原则，开闭原则（扩展是开放的，修改是关闭的）
**注意：**多态可以提高代码扩展性，反射更好。

多态的要素：

1. 继承
2. 重写：子类对父类的方法进行重写，案例中的shout（）方法
3. 父类引用指向子类对象

Cat c = new Cat();
Animal an = c;

//合并之后：
//=左侧：编译期的类型 
//=右侧：运行期的类型
Animal an = new Cat();

public void play(Animal an){//Animal an = an = new Cat();
       an.shout();
   }
//常见的多态应用形式：父类当方法的形参传入具体的子类对象
调用相同的方法，传入的子类不同展现的效果也不同，构成了多态。

多态应用场景

1. 父类当方法的形参，传入具体的子类对象
2. 父类当作方法的返回值，返回具体的子类对象
3. 接口方法的形参，传入具体的实现类的对象
4. 接口当作方法的返回值，返回具体的实现类的对象

案例

原来的：

public class Cat {
    public void shut(){
        System.out.println("猫叫...");
    }
    public void scratch(){
        System.out.println("挠人...");
    }
}

public class Dog {
    public void shut(){
        System.out.println("狗叫...");
    }
    public void guard(){
        System.out.println("看门...");
    }
}
public class Girl {
    public void play(Cat cat){
        cat.scratch();

    }
    //重载
    public void play(Dog dog){
        dog.shut();
    }
}
public class Test {
    public static void main(String[] args) {
        Cat c = new Cat();
        Girl g = new Girl();
        //1.小女孩和猫玩
        g.play(c);
        //2.和狗玩
        Dog d = new Dog();
        g.play(d);
    }
}

多态之后：

public class Test {
    public static void main(String[] args) {
        Girl g = new Girl();
        /*1.小女孩和猫玩
        Cat c = new Cat();
         g.play(c);*/
        /*2.和狗玩
        Dog d = new Dog();
        g.play(d);*/
        Cat c = new Cat();
        Animal an = c;
        g.play(an);//和猫玩：猫叫...
    }
}

public class Girl {
    /*public void play(Cat cat){
        cat.scratch();
    }
    //重载
    public void play(Dog dog){
        dog.shut();
    }*/
    public void play(Animal an){
        an.shout();
    }
}

public class Animal {
    public void shout(){
        System.out.println("动物叫...");
    }

}
public class Cat extends Animal{
    public void shout(){
        System.out.println("猫叫...");
    }
    public void scratch(){
        System.out.println("挠人...");
    }
}
public class Dog extends Animal{
    public void shout(){
        System.out.println("狗叫...");
    }
    public void guard(){
        System.out.println("看门...");
    }
}

多态的内存分析

public class Animal {
int age;
    public void shout(){
        System.out.println("动物叫...");
    }
}
public class Pig extends Animal{
double weight;
    public void shout(){
        System.out.println("猪叫...");
    }
    public void eat(){
        System.out.println("eat...");
    }
}

向下转型 向上转型

public class Test {
    public static void main(String[] args) {
        Girl g = new Girl();
        Pig p = new Pig();
        Animal an = p; //转型：向上转型
        g.play(an);
        
        Pig pig = (Pig) an;//向下转型，将Animal转为Pig类型
        pig.age = 10;
        pig.eat();
        p.weight = 60.9;
    }
}

上下转型的内存分析

equals（）方法中的向下转型，Object类型转为Phone，父类引用指向子类对象，可以使用Phone对象的特有属性和方法

https://blog.csdn.net/ityin/article/details/126239038?spm=1001.2014.3001.5501