【面向对象】final关键字,多态,多态访问成员的特点（重点）,.多态的弊端,抽象类,方法重写的注意事项

继承

1.final关键字

有些时候，我们不想让子类覆盖重写父类中的方法或者功能，只能让子类去使用。
那怎么办呢？

（1） 定义

针对这个情况，java提供了一个关键字：final

    final:最终的意思。可以修饰类，成员变量，成员方法。

（2） final的特点：

final:最终的的意思。它可以修饰类，成员变量，成员方法

特点：
1、修饰类，类不能被继承
2、修饰成员变量，变量变常量，并且只能赋值一次,在构造方法完毕之前赋值即可。
常量：
字面值常量
自定义常量：被final修饰变量变成自定义常量
3、final修饰成员方法：方法不能被重写
举例：

       public class FianalDemo02 {
   
    public static void main(String[] args) {
   
        Z z=new Z();
        z.show();
        System.out.println(z.num);
    }
}
class X{
   
    int num=10;
    final int num1=100;//变量变常量
    X(){
   
        System.out.println("父类构造方法");
    }
    public final void show1(){
   
        System.out.println("111");
    } //此方法不能被重写
    public void show(){
   

        //num1=900;//无法为num1赋值，会报错
        System.out.println(num);
        System.out.println(num1);
    }
}
 final class Y{
   //此类不能被Z，X继承

 }
class Z extends X{
   
    @Override
    public void show() {
   

        super.show();
        num=500;
      //  num1=800;//无法为num1赋值，会报错
    }
    

}

（3）.final修饰引用数据类型时

面试题：
final修饰局部变量

1、在方法内部，修饰基本数据类型的变量，变量值只能赋值一次，不能发生改变
2、final修饰引用数据类型的变量呢？
引用的地址值不可以发生改变你，但是该对象的堆内存中的值是可以发生改变的。
举例：

        class Student {
   
    int age = 10;
}
public class FinalDemo03{
   
    public static void main(String[] args) {
   
        int x=100;
        x=300;
        System.out.println(x);

        final int y = 200;
//        y = 400; //无法为最终变量y分配值
        System.out.println(y);
        Student student = new Student();
        System.out.println(student.age);

       final Student s2 = new Student();//s2为被final修饰
       //的引用数据类型
        System.out.println(s2.age);

        s2.age = 1000;//由于final修饰的是s2，
//它是一个地址值，所以s2.age可以被改变，而因为s2被final修饰s2这
//个地址值是不可以被改变的
        System.out.println(s2.age);
        System.out.println("==========================");
//        s2 = new Student(); //无法为最终变量s2分配值
    }
}

多态

1.多态的引入

多态：某一事物，在不同时刻表现出来的不同状态

    举例：
        水：
            固态、液态、气态
            固态的水是水、液态的水也是水、气态的水也是水
        水果：
            波罗蜜、香蕉、榴莲
            波罗蜜是水果、香蕉是水果、榴莲是水果
            水果是波罗蜜。// 反过来说是有问题的
        动物：
            狗、虎、猫、大象
            狗是动物，这么说是没问题的
            动物是狗，这么说是不可以。

   说了这么多，总结出一个思想，这个思想叫做：多态
   通过观察例子发现，要想有多态，就必须要继承，继承是多态的前提。

2.多态的前提

多态的前提：
1、要有继承关系
2、要有方法的重写。
其实没有重写也是可以的，但是不重写就没有意义
动物都有吃这个方法，但是每个具体的动物吃的实现不一样，变现出不同动物的特有属性
3、要有父类的引用指向子类对象
父类名 f = new 子类名(…);

3.多态访问成员的特点（重点）

（1）、成员变量
编译看左，运行看左
（2）、构造方法
创建子类对象的时候，先访问父类中的构造方法，对父类的数据先进行初始化
（3）、成员方法
编译看左，运行看右。
因为成员方法存在重写，所以访问看右边
（4）、静态成员方法
编译看左，运行也看左。
由于被static修饰的成员都是与类相关的，这里不是重写，所以运行的时候，访问的还是左边的。

举例：

public class DuoTaiDemo04 {
   
    public static void main(String[] args) {
   
        Father4 f=new Son4();
        System.out.println(f.num);//多态访问成员变量编译看左，
        //运行看左,结果为：100
        f.show();//多态访问成员方法  编译看左，运行看右。访问子
        //类的
        f.show1();//多态访问静态成员方法 编译看左，运行也看左
        //因此会执行父类中的静态成员方法


    }
}
class Father4{
   
    int num=100;
    Father4(){
   
        System.out.println("这是父类的构造方法");
    }
    public void show(){
   
        System.out.