面向对象三大特征之多态

 多态

1 程序中的多态; 声明父类,实例化子类;

要建的类

对动物喂食

package com.lv.tai;

public class Person {
    
    //给动物喂食
    public void feed(Dog dog){
        
        System.out.println("喂食");
        dog.eat();
    }
    
    public void feed(Bird bird){
        
        System.out.println("喂食");
        bird.eat();
    }
    
    public void feed(Snake snake){
        
        System.out.println("喂食");
        snake.eat();
    }
    
    //新添加子类的话，必须在这里提供方法的重载
    public void feed(Cat cat){
        
        System.out.println("喂食");
        cat.eat();
    }
    
    public void feed(Fish fish){
        
        System.out.println("喂食");
        fish.eat();
    }
}

利用多态给动物喂食

package com.lv.tai;

public class PersonSuper {
    
    public void feed(Animal animal){
        
        //就算你添加100个子类  当前的feed方法也不需要修改
        //我们这里利用了多态的特性
        System.out.println("喂食");
        animal.eat();//如果传递的是子类 就会执行对应的子类eat方法
    }

}

测试类

package com.lv.tai;

public class Test4 {

    public static void main(String[] args) {
        
        //分别养了一只狗 一条蛇 一条鱼 一只鸟
        //必须的喂养这4个动物
        //吃午餐的时间到了
        
        test1();
        System.out.println("++++++++++++++++++");
        test2();
        
        
    }
    
    public static void test2(){
        PersonSuper person=new PersonSuper();
        
        Animal animal1=new Bird();
        person.feed(animal1);
        
        Animal animal2=new Dog();
        person.feed(animal2);
        
        Animal animal3=new Fish();
        person.feed(animal3);
        
        Animal animal4=new Snake();
        person.feed(animal4);
        
        Animal animal5=new Cat();
        person.feed(animal5);
    }
    
    public static void test1(){

        Person person =new Person();
        
        //喂鸟
        Bird bird=new Bird();
        person.feed(bird);
        
        //喂蛇
        Snake snake=new Snake();
        person.feed(snake);
        
        //喂鱼
        Fish fish=new Fish();
        person.feed(fish);
        
        
        //喂狗
        Dog dog=new Dog();
        person.feed(dog);
    }

}

2 多态的使用场景;

 父类作为形参, PersonSuper.java

:父类作为返回值; MaiChongSuper.java

3 向上转型; 实例化的子类,将地址赋值父类的声明;

4 向下转型;将父类的引用,转换成子类的引用;

package com.lv.pm;

import com.lv.tai.Animal;
import com.lv.tai.Dog;

public class Test1 {

    public static void main(String[] args) {
        //什么是向上转型
        Animal animal=new Dog();
        //声明一个父类，实例化一个子类，然后赋值给父类的引用，我们就叫他为向上转型
        
        
        //向下转型：就是将我们父类的引用转换成子类的引用
        Dog dog1=(Dog) animal;//这个过程就叫做向下转型
        
        Dog dog2=(Dog) animal;
        
        //dog1和dog2他们除了地址不一样所有的东西都一样对属性的调用，对方法的调用
    }

}

5 instanceof关键字;用来判断引用是否是某一个具体的对象的类型;

package com.lv.pm;

import com.lv.tai.Animal;
import com.lv.tai.Bird;
import com.lv.tai.Cat;
import com.lv.tai.Dog;
import com.lv.tai.MaiChongSuper;

public class Test3 {

    public static void main(String[] args) {
        MaiChongSuper mcs=new MaiChongSuper();
        
        Animal am=mcs.sell("bird");
        
        if(am instanceof Dog ){//如果这个am是dog类型
            
            Dog dg=(Dog)am;//是狗才可以把他强制转换成一条狗
            //我可以调用dog里面独有的方法
            dg.eat();
        }else if(am instanceof Cat){
            Cat ct=(Cat)am;
            //我可以调用cat里面独有的方法
            ct.eat();
        }else if(am instanceof Bird){
            Bird bird=(Bird)am;
            bird.eat();
            
        }
        
        System.out.println("一切正常结束，啥也没发生");
    }

}