Java基础(十二)— —多态

多态

概述

　　　多态是继封装性、继承性之后，面向对象的第三大特性。

定义

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

　　 生活中，比如跑的动作，猫、狗、大象跑起来的动作都是不一样的，再比如飞的动作，昆虫、鸟类、人造飞机，飞起来的动作内容都是不一样的。可见同一行为，通过不同的事物，可以表现出不同的形态。多态，描述的就是这样的一种状态。

前提　

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

多态的表现

　　多态表现的格式：

　　

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

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

public class Fu{
    public void method(){
        System.out.println("这是父类的method方法");
    }
}
public class Zi extends Fu{
    @Override
    public void method(){
        System.out.println("这是子类的method方法");
    }
}
//polymorphism  多态
public class TestPolyDemo01{
    public static void main(String[] args){
        //多态的格式
        /*
            父类类型 变量名 = new 子类对象;
            变量名.方法名();
        */
        //3.父类的引用指向了子类的对象
        Fu fu = new Zi();
        fu.method();//本质调用的是子类当中的method()方法
    }
}

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

多态的好处

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

// 定义抽象的父类
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. 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则继续往上找。

// 定义一个父类
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(super.num);
    }
}
// 定义测试类
public class TestPolyFieldDemo01 {
    public static void main(String[] args) {
        // 多态的表示形式
        // 父类类型 变量名 = new 子类对象;
        // 变量名.成员变量名
        Fu fu = new Zi();
        System.out.println(fu.num);// 10  
        fu.showNum();// 20
        Zi zi = new Zi();
    }   
}

引用数据类型的转型

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

向上转型

　　  向上转型：多态本身就是子类类型向父类类型向上转型的过程，这个过程是默认的。

　　当一个父类引用执行了一个子类对象是，便是向上转型。

　　使用格式： 

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

向下转型

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

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

　　使用格式： 

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

转型的异常

　　在进行向下转换的过程中，一不小心就出现java.lang.ClassCastException类型转换异常。

　　为了避免这种类型转换异常的发生，Java提供了instanceof关键字，给引用变量做类型的校验。

　　格式如下： 

变量名  instanceof  数据类型
如果变量属于该数据类型，则返回true
如果变量不属于该数据类型，则返回false

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

public class Test {
    
    public static void main(String[] args) {
        // 向上转型
        Animal animal = new Cat();
        // 向下转型
        if (animal instanceof Cat) {
            // 表明animal就是一只猫
            Cat cat = (Cat) animal;
            cat.eat();// 吃鱼
            cat.catchMouse();// 逮老鼠
        } else if (animal instanceof Dog) {
            // 表明animal就是一只狗
            Dog dog = (Dog) animal;
            dog.lookDoor();
        }
    }
}

final修饰符

　　概述

　　由于Java当中提供了继承特性，子类可以在父类的基础上改写父类的内容，比如：方法的重写，那么能不能随意的继承API当中提供的类，改写其内容呢？显然是不行的，为了避免这种随意更改的情况，Java提供了final关键字，用于修饰不可改变的内容。

• final：不可变。用于修饰类、方法和变量
• 类：被修饰的类，不能被继承
• 方法：被修饰的方法，不能被重写
• 变量：被修饰的变量，不能被【重新赋值】

　 使用方式

　　　　修饰类

　　　　格式如下：

 public final class 类名 {
          // 类信息
  }

　　通过查询API发现，JDK官方提供了很多的被final修饰的类如：String、Math、Scanner、Character等，这些类都是被final修饰的，目的是让我们仅使用，而不让我们更改其内容。

　　修饰方法

　　格式如下： 

修饰符   final   返回值类型   方法名（参数列表） {
    // 方法体内容。。。。。
}

重写final修饰的方法，编译无法通过。

　　修饰变量

　　　　1.修饰局部变量------基本类型

　　　　　 基本类型的局部变量，被final修饰后，只能赋值一次，不能被更改。代码如下：

public class Demo {
       public static void main(String[] args) {
           // 声明局部变量
           final int num;
           // 第一次赋值
           num = 10;
           // 第二次赋值
           num = 20;// 编译报错
       }
   }

　　　　2.局部变量------引用类型

　　　引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能发生改变，但是不影响对象内部的成员变量的修改。代码如下：

public class FinalDemo2 {
      public static void main(String[] args) {
          // 构建一个对象
          final   People  p1 = new People();
          p1 = new People();// 报错，编译无法通过
          // 调用setName()方法
          p1.setName("小王");// 可以修改
      }
  }

成员变量

成员变量涉及到【初始化】的问题，初始化方式有两种，二选其一：

• 显示初始化

public class People {
    final String NAME = "小王";
     private int age;
}

• 构造方法初始化

public class People {
    final String NAME;
    private int age;
    public People(String name) {
        this.name = name;
    }
}

备注：被final修饰的常量名称，一般都有书写规范，所有字母均为【大写】。