2020-11-25day13 多态，final关键字

 

复习接口：

         1.接口没有静态代码块也没有构造方法

         2.一个类只能继承一个父类，但是一个类可以实现多个接口

              一个接口可以继承多个接口，类与类之间是一种单继承关系，类与接口之间是一种多实现关系

         3.如果一个类实现了多个接口，存在重名的抽象方法，只需要重写一次抽象方法。

         4.如果一个类没有重写接口当中的所有抽象方法，那么该类必须是抽象类

         5.如果一个类实现了多个接口，接口当中存在有重名的默认方法，那么实现类一定要对冲突的默认方法重写

         6.如果一个类之间继承了一个父类又同时实现了多个接口，父类当中的成员方法和接口当中的默认方法存在重名，优先调用父类当中的成员方法；

多态

     概述：

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

    定义：

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

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

    前提：

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

    多态的表现：

          格式：

          

父类类型   变量名  =new 子类对象;

变量名.方法名();

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

public class  Fu {
    public void method() {
        System.out.println("这是父类的method方法");
    }    
}
// 1. 继承关系
public class Zi extends Fu {
    // 2. 方法的重写
    @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 show(){
 
    System.out.println(num);

  }   
   
}
//定义一个子类
public class Zi extends Fu{
    int num=20;
    public void show(){
 
    System.out.println(num);

  }   
}


public class  Test{
   
   public static void main(String[] args){
   
    //多态的表示形式
    //父类类型  变量名 = new 子类对象;
    //变量名.成员变量名
    Fu  fu = new Zi();
    System.out.println(fu.num);//10
    fu.show();//20
 }
}

引用数据类型的转型

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

       向上转型:

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

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

            格式：

父类类型   变量名  =  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){
         //表明就是一只猫
         Cat  cat=(Cat)  animal;
  
         cat.eat();//吃鱼
   
          cat.catchMouse();//抓老鼠
   
       }else if(animal  instanceof  Dog){
  
          //表明你就是一只狗
   
          Dog  dog = (Dog) animal;
   
          dog.lookDoor();//看门
       }
    }
}
         

final关键字

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

 

    常见的四种用法：（不可变，用于修饰类，方法和变量）

       1.可以用来修饰一个类（被修饰的类不能被继承）

       2.可以修饰一个方法（被修饰的方法不能被重写）

       3.可以修饰一个变量（被修饰的变量，不能被【重新赋值】）

       

     当final关键字修饰一个类时：该类不能被继承，不能有任何的子类，但可以有父类。

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

     注意：一个类如果被final修饰，那么其中的所有的成员方法都无法进行覆盖重写（因为没有子类）；

public final class 类名{
    //....
    //....
    //final 类不能被继承，没有类能够继承 final 类的任何特性。
}

  当一个方法被final关键字修饰的时候，这个方法就是一个最终的方法，也就是不能被覆盖重写。

  注意：final关键字不能与abstract同时使用。

修饰符  final 返回值类型  方法名（参数列表）{

     //方法体内容...

}


public class A{
    
    public final void method(){
    
      System.out.println("父类的方法被加载");
  
    }
}

public class B extends A{
 

    public void method(){
      
 
        //编译不通过 
  
   } 
}

当final修饰变量时：

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

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

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

思考：

      如下两种写法，哪种可以通过编译？

     

//第一种写法
final  int num=0;
for(int i=0;i<10;i++){
  
     num=i;
     System.out.println(num);

}
//第二种写法
for(int i=0;i<10;i++){
     
   final int num=i;
   System.out.println(num);
}

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

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

public class Demo2{
  
   public static void main(String[] args){
 
      //构建一个对象
    
      final  People  p1=new People();
      p1 = new People();//报错，编译无法通过

     //调用setName()方法
       p1.setName("小王");//可以修改
    }
}

3.成员变量

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

    显示初始化：

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修饰的常量名称，一般都有书写规范，所有的字母均为【大写】；