java之多态

## 多态：

​    多态是继封装性，封装性，面向对象的第三大特性。

###     定义：

​        多态：是指同一行为，具有多个不同的表现形式。

​            比如： 生活中，跑的动作，猫 狗 大象 跑的动作都是不一样的。可见，同一行为，通过不同的事物，可以表现出不同的形态，多态， 描述的就是这样的一种状态。

### 前提：

1. ​    继承或者实现【二选其一】
2.  父类的引用指向子类的对象【格式体现】
3.  方法的重写【意义：不重写，是无意义的】

### 多态的变现：

​    多态表现得格式：

```java
父类类型    变量名    =    new 子类对象;
变量名.方法名();
```

备注：父类类型指的是子类对象继承的父类类型，或者实现的父接口类型

```java
public class Fu{
    public void method(){
        
        System.out.println("这是父类的method方法");
    }
    
}

public class Zi extends Fu{
    @Override
    public void method(){
        System.out.println("这是子类的method方法");
    }
}

public class polymorphism{
    
    public static void main(String[] args){
        // 多条的格式
        /*
            父类类型 变量名 = new 子类对象;
            变量名.方法名();
        */
        // 父类的引用 指向了子类的对象
        Fu fu = new Zi();
        fu.method(); // 这是子类的method方法    本质调用的是 子类重写后的方法
    }
}
```

如果在使用多态方式调用方法时，首先检查父类当中的是否有该方法，如果没有，则编译报错，如果有执行的是子类重写后的方法

### 多态的好处：

​    在实际开发中，父类类型作方法的形式参数（不同于实际参数），传递子类对象(实参)给方法，进行方法的调用，更能体现出多态的扩展性和便利性。代码如下：

```java
// 定义抽象的父类
public abstract class Animal{
    // 定义一个抽象的方法
    public abstract void eat();
    public void run(){
        System.out.println("用脚跑。。。");
    }
}
// 定义子类
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
}
public class Bird extends Animal {
    @Override
    public void eat(){
        System.out.println("鸟吃虫");
    }
}

// 定义测试类
public class TestDemo03 {
    
    public static void main(String[] args) {
        // 根据不同的对象，来表现不同的吃的内容
        Cat c = new Cat();
        showCatEat(c);// 猫吃鱼
        
        Dog dog = new Dog();
        showDogEat(dog);// 狗啃骨头
        
        Bird bird = new Bird();
        bird.eat();// 鸟吃虫子。。
        
        Cat c2 = new Cat();
        showAnimalEat(c2);
        
        // 
        Dog dog2 = new Dog();
        showAnimalEat(dog2);
        
    }
    
   /* public static void showCatEat(Cat cat) {
        cat.eat();// 猫吃鱼
    }
    public static void showDogEat(Dog dog) {
        dog.eat();
    }
    public static void showBirdEat(Bird bird) {
        bird.eat();
    }*/
    
    /*
       以上三个方法可以用来多态进行优化,可以被showAnimalEat方法所替代
    */
    public static void showAnimalEat(Animal animal) {
        animal.eat();
        animal.run();
    }
    
}

```

说明：用于多态特性的支持，showAnimalEat方法当中的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把cat对象和dog对象传递给方法。

当程序执行过程中。执行eat方法实际执行的是各自子类对象重写之后的eat方法

不仅仅可以做到替代，在扩展性方面，无论之后出现多个子类，都不需要编写showXxxEat方法了，直接使用showAnimalEat()方法了。

所以，多态的好处，体现在可以使程序编写更简单，并且具有良好的扩展性。    

### 访问类中的【成员变量】有两种方式：

1. ​    直接通过对象名访问成员变量: 看等号左边是谁，优先用谁,没有继续往上找
2.  间接通过成员方法访问成员变量： 看该方法属于谁，优先用谁，没有则继续往上找

```java
//定义一个父类
public class Fu{
    int num = 10;
    // 定义一个成员方法
    public void showNum(){
        System,out.println(num)
    }
    
}
public class Zi extends Fu{
    int num =20;
    @Override
      public void showNum(){
        System,out.println(num)
    }
}
public class Testpolymorphism{
    // 多态的表示形式
    Fu fu  = new Zi();
    // 变量名.成员变量
    System.out.println(fu.num);  // 10
    fu.showNum();   // 20
    
}
```

#### 引用数据类型的转型

​    多态的转型分为向上转型和向下转型：

####     对象向上转型：

​        向上转型：多态本身就是子类类型向父类类型向上转型的过程，这个过程是默认的。当一个父类引用指向了一个子类对象，便是向上转型。

​    使用格式：

```java
父类类型 变量名 = new 子类类型();
比如：Animal animal = new Cat();
```

#### 对象向下转型：

​    向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象 ，将父类的引用转为子类的引用，可以使用强制类型转换的一种格式，便是向下转型。

使用格式：

```java
子类类型 变量名 = (子类类型) 父类变量名;
比如: Cat cat = (Cat) animal;
```

#### 转型的异常:

​    在进行向下 转型的过程中，一不小心就会出现 java.lang.ClassCastException 类型转换异常，为了避免这种类型转换异常的发生，java提供了 instanceof 关键字 用来给引用变量 做类型的校验。

格式如下：

```java
对象 instanceof 类
如果变量属于该数据类型，则返回true
    如果变量不属于该数据类型，则返回false
```

所以，我们在转换前，我们最好 先进行 引用变量的类型判断，代码如下：

```java
public class Test{
    public static void main(String[] args){
        //向上转型
        Animal animal = new Cat();
        // 向下转型
        if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.eat();
            cat.catchMouse();
        }else if(animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.lookDoor(); //看门
        }
    }
}
```