什么是多态

简单的理解多态

多态，简而言之就是同一个行为具有多个不同表现形式或形态的能力。比如说，有一杯水，我不知道它是温的、冰的还是烫的，但是我一摸我就知道了。我摸水杯这个动作，对于不同温度的水，就会得到不同的结果。这就是多态。

public class Water {
    public void showTem(){
        System.out.println("我的温度是: 0度");
    }
}

public class IceWater extends Water {
    public void showTem(){
        System.out.println("我的温度是: 0度");
    }
}

public class WarmWater extends Water {
    public void showTem(){
        System.out.println("我的温度是: 40度");
    }
}

public class HotWater extends Water {
    public void showTem(){
        System.out.println("我的温度是: 100度");
    }
}

public class TestWater{
    public static void main(String[] args) {
        Water w = new WarmWater();
        w.showTem();

        w = new IceWater();
        w.showTem();

        w = new HotWater();
        w.showTem();

    }
}

//结果:
//我的温度是: 40度
//我的温度是: 0度
//我的温度是: 100度

向上转型

子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口。

案例驱动

看一个大家都知道的例子：

public class Animal {
    public void eat(){
        System.out.println("animal eatting...");
    }
}

public class Cat extends Animal{

    public void eat(){

        System.out.println("我吃鱼");
    }
}

public class Dog extends Animal{

    public void eat(){

        System.out.println("我吃骨头");
    }

    public void run(){
        System.out.println("我会跑");
    }
}

public class Main {

    public static void main(String[] args) {

        Animal animal = new Cat(); //向上转型
        animal.eat();

        animal = new Dog();
        animal.eat();
    }

}

//结果:
//我吃鱼
//我吃骨头

这就是向上转型，Animal animal = new Cat();将子类对象Cat转化为父类对象Animal。这个时候animal这个引用调用的方法是子类方法。

转型过程中需要注意的问题

向上转型时，子类单独定义的方法会丢失。比如上面Dog类中定义的run方法，当animal引用指向Dog类实例时是访问不到run方法的，animal.run()会报错。
子类引用不能指向父类对象。Cat c = (Cat)new Animal()这样是不行的。

向上转型的好处

• 减少重复代码，使代码变得简洁。
• 提高系统扩展性。

举个例子：比如我现在有很多种类的动物，要喂它们吃东西。如果不用向上转型，那我需要这样写：

public void eat(Cat c){
    c.eat();
}

public void eat(Dog d){
    d.eat();
}
//......

eat(new Cat());
eat(new Cat());
eat(new Dog());
//......

一种动物写一个方法，如果我有一万种动物，我就要写一万个方法，写完大概猴年马月都过了好几个了吧。好吧，你很厉害，你耐着性子写完了，以为可以放松一会了，突然又来了一种新的动物，你是不是又要单独为它写一个eat方法？开心了么？

那如果我使用向上转型呢？我只需要这样写：

public void eat(Animal a){
    a.eat();
}

eat(new Cat());
eat(new Cat());
eat(new Dog());
//.....

恩，搞定了。代码是不是简洁了许多？而且这个时候，如果我又有一种新的动物加进来，我只需要实现它自己的类，让他继承Animal就可以了，而不需要为它单独写一个eat方法。是不是提高了扩展性？

请等待下期向上转型

向上向下转型

定义一个父类Animals包含eat()方法、age初始值为0

然后再定义两个子类：Dog和Cat,都重写了eat()方法和age，然后再分别有自己的特有方法狗咆叫bark()，猫睡觉sleep()

向上转型：Animals a = new Cat()

向下转型：Cat cat = (Cat) a,必须要先经过向上转型的变量–再向下转型，此时cat就拥有子类自己定义的特有方法cat.sleep()

instanceof用法：a instanceof Cat 这里a必须是经过向上转型后的父类对象，而Cat是继承父类的子类

// 父类
public class Animals {
    public int age = 0;

    public void eat(){
        System.out.println("Eat...");
    }
}

// 子类 继承 父类 Animals
public class Dog extends Animals {
    public int age = 10;

    @Override
    public void eat(){
        System.out.println("eat bone...");
    }

    public void bark(){
        System.out.println("dog bark...");
    }
}

public class Cat extends Animals{
    public int age = 2;
    @Override
    public void eat(){
        System.out.println("eat fish...");
    }

    public void sleep(){
        System.out.println("cat sleep...");
    }
}

有一个宠物店AnimalsShop将宠物放入后，统计个数，以及可以取出该宠物

public class AnimalsShop {
    // 注意这里用的Animals泛型，加入宠物时，不关心宠物的具体类型
    private List<Animals> list = new ArrayList<Animals>();
    // 当加入一个宠物时，相当于进行了向上转型
    public void add(Animals a){
        list.add(a);
    }

    public int getSize(){
        return list.size();
    }
    // 取出的宠物也是经过向上转型的，此时类型为Animals
    public Animals getAnimal(int position){
        return list.get(position);
    }
}

public static final int DOG = 0;
public static final int CAT = 1;
    @Test
    public void test4(){
        // 通过泛型进行向上转型将不同类型的动物加入集合，此时不需要动物的不同特性，只需要知道个数即可
        AnimalsShop as = new AnimalsShop();
        as.add(new Dog());
        as.add(new Cat());

        // 获取动物个数
        System.out.println(as.getSize());

        // 查看所有的宠物
        Dog dog = (Dog) as.getAnimal(DOG); // 直接向下转型，并不安全，因为可以编译通过但运行出错
        dog.eat();
        dog.bark();

        Animals a = as.getAnimal(CAT);  // 获取已经向上转型Cat
        System.out.println(a instanceof Dog); // false，向上转型的Cat和Dog不构成子类关系
        // (（已经经过向上转型的）父类对象 instanceof 子类 ) 来判断是否可以向下转型更安全，防止ClassCastException转换异常
        if(a instanceof Cat){
            Cat cat = (Cat) as.getAnimal(CAT);
            cat.eat();
            cat.sleep();
        }

    }

向下转型的最大好处是：java的泛型编程，用处很大，Java的集合类都是这样的。
参考博客

Java向下转型的意义

Java对象类型向上转型

多态的特点

多态的前提：

• 存在继承或实现接口extend或implement
• 重写方法@Override
• 父类引用指向子类对象Animals a = new Cat()

多态的特点：

• 相同变量看父类a.age = 0
• 重写方法看子类eat()看子类
• 子类特有方法不可用a.sleep()不可用

    public static void animalEat(Animals a){
        a.eat();
    }

    @Test
    public void test3(){
        Animals a1 = new Dog();
        System.out.println(a1.age); // 1. 变量看父类
        a1.eat(); // 2. 方法看子类
//        a1.bark();  3. 子类特有不可用

        Animals a2 = new Cat();
        a2.eat();

        // 当向上转型后，通过一个通用方法调用不同的子类，即可实现子类的方法
        animalEat(new Dog());
        animalEat(new Cat());
    }

前言

为了解决代码的复用，提高扩展性

一、多态是什么？

同一个引用类型，使用不同的实例而执行不同操作。

二、多态的好处

1.解决代码复用
2.扩展性提高

三、多态实现前提条件

1.多态实现必须有继承
2.有方法重写
3.父类引用指向子类对象(父类引用 赋值的子类对象)

1、多态的两种体现形式

1）以父类类型作为方法的形参
代码如下（示例）：

//参数形式实现多态
    public  void  feed(Pet pet){
        //1.输出描述文字
        System.out.println("小姑娘喂养宠物....");
        //2.小狗吃东西
        //Dog dog = new Dog(); //创建一个新的对象, 该方法每调用一次,产生一个对象
        pet.eat();
    }

//重写了父类的eat方法
    @Override
    public void eat() {
        System.out.println("小狗吃狗粮.....");
        //加健康值与亲密度
        //加健康值 + 10  在原来的健康值上加10
        //this.getHealth() 获取它原来的值
        this.setHealth(this.getHealth() + 10);
        //亲密度 + 5
        this.setLove(this.getLove() + 5);
    }

2）以父类类型作为方法的返回值类型

public Pet lyPet(int num){
	swich(num){
	case 1:
		return new Dog();
	case 2:
		return new Cat();
	}
	return null;
}

聚合

多态: 迟绑定,动态绑定

​ 所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
多态：父类引用指向子类对象 代码表示：
Pet pet=new Dog();
Pet pet=new Cat();
3)Pet pet = new Dog();与Dog dog = new Dog(); 的区别

由于在编译阶段，只是检查参数的引用类型。然而在运行时，
java虚拟机(JVM)指定对象的类型并且运行该对象的方法。
因此在下面的例子中，
b.move()之所以能编译成功，是因为Pet类中存在move方法，所以编译成功，然而运行时，
运行的是特定对象的方法，
即运行的是Dog类的move方法。而对Dog c而言，编译阶段首先是去Dog中查找bark()，
因此能编译成功，同时也能运行成功；但是对于b.bark()而言，首先是去Pet类中寻找bark()，
因为找不到，因而编译错误。
 
public class Person {
    public static class Pet {
        public void eat() {
            System.out.println("Pet中的eat方法");
        }
    }
 
    public static class Dog extends Pet{
        public void eat() {
            System.out.println("dog中的eat方法");
        }
 
        public void bark() {
            System.out.println("狗可以吠叫");
        }
    }
 
    public static void main(String args[]) {
        Pet a = new Pet(); // Pet 对象
        Pet b = new Dog(); // Dog 对象
        Dog c = new Dog();
        a.move();// 执行 Pet 类的方法
        b.move();// 执行 Dog 类的方法
        b.bark();
        c.bark();
 
    }
 
}

四、向上转型

1）类结构图

父(辈)类类型 变量 接收一个子类对象, 把子类对象赋值给父类引用
向上转型，自动类型转换
2）优缺点
1.优点:实现多态

2.缺点:父类的引用调用不到子类特有的属性/方法

 public static void main(String[] args) {
        //使用子类对象接收
        Dog dog = new Dog("旺财",70,50,"泰迪");
        //dog调用特有属性方法
        dog.setType("牧羊犬");  //没有问题
        //向上转型: 把子类对象赋值给父类引用
        Pet pet = dog;
        //使用父类引用调用子类特有属性方法  调用不到
        //pet.setType("泰迪");  //报错
        
    }

五、向下转型

1.语法
把父类转换为子类, 需要强制类型转换

子类 子类变量名 =  (子类名)父类对象;

2.目的
需要调用子类特有的属性和方法
3.instanceof使用
如果直接强制转换可能出现ClassCastException

从而就Java提供了instanceof
instanceof 使用场景, 当你需要向下转型的时候
java提供 instanceof 对象 instanceof 类名/接口名 判断对象是否是右边的类或者接口的对象,或者是子类对象 结果: boolean ture: 表示对象是类的一个对象,或者子类对象 false 否则

 public static void main(String[] args) {
        Dog dog = new Dog();
        Penguin penguin = new Penguin();
        Pet p1 = penguin;


        System.out.println(dog instanceof  Dog); //true
        System.out.println(dog instanceof  Pet); //true

        System.out.println(penguin instanceof  Penguin); //true
        System.out.println(penguin instanceof  Pet);  //true

        System.out.println(p1 instanceof  Penguin); //true
        System.out.println(p1 instanceof  Dog);  //false
        System.out.println(p1 instanceof  Pet);  //true
    }

六、总结

1）.多态的两种形式：
1.以父类类型作为方法的形参
2.以父类类型作为方法的返回值类型
2）.向上转型：
可直接转但是不能 使用子类特有的属性和方法
3）.向下转型
不能直接转，需要用到instanceof关键字,应用场景就是需要调用子类特有方法与属性