面向对象:多态,引用数据类型之间的转换和final关键字

多态

概述：

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

定义：

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

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

前提条件

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方法");
    }
}
public class TestPolyDeom01 {
    public static void main(String[] args) {
        //多态的格式
        /*
        	父类类型 变量名 = new 子类对象;
			变量名.方法名();
        */
        //父类引用指向了子类对象
        Fu fu = new Zi();
        fu.method();//本质调用的是子类重写之后的method方法
    }
}
//结果： 这是子类的method方法

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

多态的好处

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

public abstract class Animal{
    //定义一个抽象的方法
    public abstract void eat();
}
//定义子类
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 TestPolyDeom02 {
	public static void main(String[] args) {
        
		Cat cat = new Cat();
		cat.showCatEat();

		Dog dog = new Dog();
		dog.showDogEat();
        
        Animal animal = new Cat();
        showAnimalEat(animal)
	}
    
    public static void showCatEat(Cat cat){
        cat.eat();
    }
    public static void showCatDog(Dog dog){
        dog.eat();
    }
    /*以上两种方法可以简化为下面的一个方法*/
    
    public static void showAnimalEat(Animal animal){
        animal.eat();//猫吃鱼
    }
}

说明：由于多态的支持，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;
    public void showNum(){
        System.out.println(num);
    }
}
//定义测试类
public class TestPolyFiledDeom01 {
	public static void main(String[] args) {
        //父类类型 变量名 = new 子类对象;
        //变量名.成员变量
        Fu fu = new Zi();
        System.out.println(fu.num);//10  通过对象名访问成员变量
        fu.showNum();//20  间接通过成员方法访问成员变量
    }
}

引用数据类型的转换

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

向上转型：

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

使用格式

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

向下转型

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

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

使用格式：

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

向上转型一定是安全的，没有问题，但也有弊端，对象一旦向上转型为父类，就无法调用子类特有的内容。

public abstract class Animal {
	public abstract void eat(); 	
}
public class Cat extends Animal {
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃鱼");
	}
	public void mouse() {
		System.out.println("抓老鼠");
	}
}
public class Dog extends Animal{
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃骨头");
	}

	public void lookHome() {
		System.out.println("看门");
	}	
}
public class TestPolyDeom05 {
	public static void main(String[] args) {
		Animal animal =  new Cat();
		animal.eat();	
        //向下转换
		Cat cat = (Cat)animal;
		cat.mouse();	
		Dog dog = (Dog)animal;
		dog.lookHome();	
	}
}
// java.lang.ClassCastException 类型转换异常

转型异常

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

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

格式如下

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

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

public class TestPolyDeom05 {
	public static void main(String[] args) {
        //向上转型
		Animal animal =  new Cat();
		//向下转型
        if (animal instanceof Cat){
            //表明就是一只猫
            Cat cat = (Cat)animal;
            cat.mouse();
        }else if(animal instanceof Dog){
            Dog dog = (Dog)animal;
			dog.lookHome();
        }
	}
}

final关键字

代表最终的，不可变的

常见的四种用法

1. 可以用来修饰类
2. 可以修饰一个方法
3. 可以修饰一个局部变量
4. 可以修饰一个成员变量

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

==1.==当final关键字修饰一个类的时候

public final class 类名称{
    
}

特点：当前这个类不能有任何的子类。但这个类依然可以有父类

注意：如果一个是final的，那么其中所有的成员方法都无法进行覆盖重写(因为没有子类)

一个类不能继承被final关键字修饰的类

==2.==当final关键字修饰一个方法的时候

这个方法就是最终的方法，也就是这个方法不能被覆盖重写

修饰符 final 返回值类型 方法名称(参数列表) {
    //方法体内容
}

注意事项：对于类，方法来说，abstract关键字和final关键字不能同时使用

==3.==修饰一个局部变量

只能赋值一次

一旦使用了final关键字修饰了局部变量，这个局部变量就不能进行更改了

对于基本数据类型来说，不可变说的是变量当中的数据不可改变

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

对于应用数据类型，不可变说的是变量当中的内存地址值不可改变，内容的值是可以发生改变的

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

==4.==修饰一个成员变量

对于成员变量来说，如果使用final关键字修饰，那么这个变量也是不可改变的

1. 由于成员变量有默认值，用final之后必须手动赋值，不再有默认值

2. 被final修饰的的成员变量，要么使用直接赋值，要么通过构造方法赋值，二选其一

   • 显示初始化；

   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;
         }
     }
     

3. 必须保证类当中的所有的重载的构造方法，都最终会对final成员变量进行赋值。

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