Java面向对象（五）：OOP三大特性之多态 — final 关键字

一、多态 

   理解：多态本意是指同一事物在不同的条件会有不同的形态；

映射到Java中可以理解为：同一个父类方法被不同的子类调用，会产生不同的行为（重写父类的方法）；

也可表述为：不同子类的对象对父类同一消息能做出不同的响应（重写父类的方法）。 即同一消息可以根据发送对象的不同而采用多种不同的行为方式（发送消息就是函数调用）。

1、面向对象的多态的实现前提：

（1）要有继承：类与类之间必须有继承关系；

（2）要有重写：子类重写父类的成员方法（可以不重写，但这就失去了多态的意义）；

（3）向上转型：父类引用可以指向任何一个子类的对象。

2、向上转型(子类自动转为父类)：子类"伪装"成父类，执行子类的方法；

class Fu { 

　　..... 

} 

class Zi extends Fu {

 　　.....

} 

      Fu  fu      =   new Zi();

父类  父类引用 =  子类对象 

注：

1、Java指向的两个时期：编译器与执行器，编译期看类型，执行期看对象。

2、多态调用函数的处理过程： 编译器从父类查找是否有该函数，没有的话报错,有的话在执行期执行子类中重写的同名函数，而不是父类。 

例程：duotai包：ZMS.java ZMSSON.java

3、向下转型（父类强制转化为子类）："伪装"成父类的"子类"还原成真正的子类

Zi zi = (Zi) fu; //类似于强制转换大范围到小范围 

例程：duotai包：ZMS.java ZMSSON.java

ZMS.java

package duoTai;

public class ZMS {
    String name;
    int age;

    public void teach() {
        
        System.out.println("我是父类ZMS教Java");
    }
    
    public void show() {
        System.out.println(name+age);
        
    }
    
}

ZMSSON.java

package duoTai;
/**
 * 创建ZMS子类
 * 多态的测试
 * 
 * */
public class ZMSSON extends ZMS {
    
    //重写父类中同名方法
    public void teach() {
        
        System.out.println("我是ZMS子类教文学");
    //    like();
    }
    
    //子类自己的成员方法
    public void like() {
        System.out.println("ZMSSON喜欢踢球");
        
    }
    
    public static void main(String[] args) {
    
        /*
         * 多态的表示：父类 父类引用名 = 子类对象
         * 多态调用函数的处理过程： 编译器从父类查找是否有该函数，没有的话报错，
         *                                                 有的话在执行期执行子类中重写的同名函数，而不是父类。
         * 
         * */
        ZMS zmsText = new ZMSSON();
        zmsText.teach();
        
        //调用不了父类没有的方法
        //zmsText.like();
    
        //调用父类的成员变量方法
        zmsText.name = "zms";
        zmsText.age = 65;
        zmsText.show();
    
        //
        ZMSSON zmsSon = (ZMSSON) zmsText;
        zmsSon.teach();
        zmsSon.like();
        
    }
    
}

4、多态的好处：

（1）提高了代码的复用性（继承）

（2）提高了代码的扩展性（多态）

5、instanceof 关键字：

      boolean b = a instanceof b;

      判断a类是否属于另一个b类，是返回true，否则返回false。

 练习：跟据从键盘输入数字不同选择不同的子类对象，执行不同的响应（重点理解）；   

例程：duotai包：Animal.java duoTaiAnimal.java

创建父类：

package duoTai;

public class Animal {
    public String name ;
    public int age;
    
    public void eat() {
        System.out.println(name+"动物吃东西");
    }
    
}

创建两个子类：

package duoTai;

public class Cat extends Animal{
    
    //重写父类方法
    public void eat() {
        System.out.println("猫吃鱼");
        
    }
    
    //写子类自己的方法
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
    
}


// 在另一个java文件中创建
package duoTai;

public class Dog extends Animal{
        
       //重写父类方法
        public void eat() {
            System.out.println("吃狗粮");
        }
        
        //写子类自己的方法
        public void kanMen() {
            System.out.println("狗看门");
        }
}

　　创建测试功能类：　　

package duoTai;

/**
 * @author  Kanekiyi
 * 理解多态的意义：同一消息（函数）可以根据发出的对象不同而产生不同的行为方式。
 *                          Or   不同的对象调用同一个函数能够产生不同的行为方式。
 */
import java.util.Scanner;

public class duoTaiAnimal {
    
    @SuppressWarnings("resource")
    public static void main(String[] args) {
        
        System.out.println("请输入数字1选择猫，数字2选择狗");
        Scanner sc  = new Scanner(System.in);

        int num = sc.nextInt();
        Animal animal = new Animal();
        /*
         * 向上转型时，根据指令选择不同的对象源
         */
        if (num == 1) {
            animal = new Cat();
        }    else if (num == 2) {
            animal = new Dog();
        }    else {
            System.out.println("输入数字错误请重新输入数字1或者2");
        }
        
        runAnimal ( animal);
        
    }
    
    public static  void runAnimal(Animal a) {
        
        //根据对象的不同执行子类重写的eat()方法；
        a.eat();                                
        
        /*
         * 向下转型时，注意转型目标子类类型是否符合
         * 目的：执行子类中特有的功能
         *          
         */
        
        if (a instanceof Cat) {
            Cat cat = (Cat) a;
            cat.catchMouse();
            
        }    else if (a instanceof Dog) {
            Dog dog = (Dog) a;                                    
            dog.kanMen();
            
        }    else {
            System.out.println("输入错误，不属于cat类也不属于Dog类");
        }
        
    }

}

二、final 关键字

2.1 final修饰类

　　final修饰的类不能被继承;

2.2 final修饰变量

final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象，但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。（存疑）。

final与static一起修饰成员变量构成常量，声明的时候常量名全部大写，可以直接通过类名访问。

例程：

package Fianal;


//public class Final1 extends Final0{        final修饰的类不能够被继承
public class Final1 {
    
    int IDCard ;
     //final修饰的成员变量声明时初始化且有且只初始化一次。
    final int IDCardNum =314;         
    final int IDCardNum1;                                 

    static final String IDCARD= "36452345245X";
    
    //通过构造函数给final修饰的成员变量初始化
    public Final1() {
        super();
        IDCardNum1 =314; 
        
    }

    public final void textMath() {
        
        System.out.println("我是Final1类的final方法");
    }
    
     
}

2.3 final 修饰方法

final 修饰成员方法，可以被子类继承，但是不能被重写；

注：

1、final 修饰的成员变量初始化的两种方式：

（1） 声明时就初始化；

（2）通过构造函数初始化。

且只初始化一次，初始化后就不能修改。

2、final 修饰的变量为常量时，在加载时系统会将变量替换为其所表示的常量。

例程：

package Fianal;

public class Final2 extends Final1 {
    
    //父类final修饰的成员方法不能重写，只能调用
    //public final void textMath() {}
    
    public static void main(String[] args) {
        Final2 textFinal = new Final2();
        textFinal.IDCard = 2;
        
        //final修饰的变量在声明时就初始化且只能初始化一次，只能被调用不能被修改
        //textFinal.IDCardNum = 3;
        System.out.println("普通成员变量IDCard："+textFinal.IDCard);
        System.out.println("final修饰的成员变量IDCardNum："+textFinal.IDCardNum);
        //System.out.println("final和static修饰的成员变量IDCARD："+textFinal.IDCARD);
        //常量可以直接调用或类名调用
        System.out.println("final和static修饰的成员变量IDCARD："+Final1.IDCARD);
        System.out.println("final和static修饰的成员变量IDCARD："+IDCARD);

        textFinal.textMath();
        
    }
    
}