Java类（多态）

final（关键字）

修饰方法 
  作用：不能被重写
修饰变量 
  作用：final 修饰的基本数据类型的变量 不能被重新赋值
  被final修饰的对象的地址不能改变（不能重新指向）
修饰类   
  作用：被修饰类 不能被继承

举例：

public class Demo01 {
    public static void main(String[] args) {
        /*
        ClassA a = new ClassA();
        a.fun();        
        */
        /*
        //  final 修饰的基本数据类型的变量 不能被重新赋值
        final int num = 10;
        System.out.println(num);

        //  final 修饰引用数据类型时 
        //  对象中成员变量值 是可以被修改的
        final ClassA a1 = new ClassA();
        //  修改成员变量
        a1.num = 10;
        a1.num = 15;
        System.out.println(a1.num);
        //  被final修饰的对象的地址不能改变（不能重新指向）
        //a1 = new ClassA();
         * 
         */
    }
}

class ClassA {
    //  num创建对象时 有默认初始值 是 0
    //  但是这个初始值 是无效的
    int num;

    public final void fun() {
        System.out.println("我是ClassA的fun方法");
    }
}

class ClassB extends ClassA {

}

举例

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(ClassC.MAX_VALUE);
    }
}

class ClassC {
    //  修饰成员变量 该成员变量 必须有有效的初值
    //  被final修饰变量 程序中不能被修改 相当于常量
    /*
     * 使用场景
     * 一般会与public static 连用
     * 常量命名规范
     * 纯大写 多个用下划线 分开
     */
    public static final int MAX_VALUE = 10;

    //  参数也可以被final修饰 相当于修饰的是局部变量
    public void fun(final int i) {      
        System.out.println(MAX_VALUE);
    }
}

多态规则

前提

一种事件的多种形态

1.类与类之间 要产生联系 继承关系
2.要有方法重写（没有方法的重写 多态的意义不大）
3.核心：父类引用（指针）指向子类空间（声明方式）

举例

public class Demo03 {
    public static void main(String[] args) {
        //  本类的引用指向 本类对象空间
        //  Cat cat = new Cat();
        //  父类引用 指向 子类对象空间
        Animal a1 = new Cat();
        a1.cry();
        //  使用多态 来声明子类对象
        Animal a2 = new Dog();
        a2.cry();
    }
}

class Animal {
    String name;
    String kind;

    //  叫
    public void cry() {
        System.out.println("我是动物叫出声");
    }

    public String toString() {
        return "名字：" + name + " 种类：" + kind;
    }
}

class Cat extends Animal {
    public void cry() {
        System.out.println("喵喵喵");
    }
}

多态时 调用成员变量 和 成员方法
在内存中的表现

多态 调用成员变量时
简单记 编译和运行 都看等号 左边（父类引用）

当使用父类引用 指向子类空间时
父类的引用 只能访问到
子类空间中 属于 父类的那部分（super访问的部分）

当本类引用 指向本类的空间时
本类的引用可以访问到整个空间

多态的弊端：
使用多态声明对象时 无法直接调用子类的特有方法
只能通过向下转型后 才能使用子类特有方法

多态好处：
1.代码维护性强（建立在继承的基础上）
2.方法的扩展性强（核心好处）

public class Demo04 {
    public static void main(String[] args) {
        //  多态的形式创建对象
        Father f = new Son();
        //System.out.println(f.num); //  10
        /* 动态绑定
         * 编译时：
         * 寻找父类中有没有该方法（看等号 左边）
         * 运行时：
         * 运行时 调用子类中重写的方法
         * 
         * 简单记（编译看左边（看父类）运行看右边（看子类））
         */
        f.print();

        /*
        Son s = new Son();
        System.out.println(s.num); //  20
        */
    }
}

class Father {
    int num = 10;   
    public void print() {
        System.out.println("我是Father类的print方法");
    }
}

class Son extends Father {
    int num = 20;   
    public void print() {
        System.out.println("我是Son类的print方法");
    }
}

举例

定义主板类 
主板
启动方法
插卡方法(例如声卡 网卡)

public class Demo08 {
    public static void main(String[] args) {
        //  创建一个主板类
        MainBoard mainBoard = new MainBoard();
        mainBoard.run();
        //  插声卡
        Audio audio = new Audio();
        //  插到主板里
        mainBoard.addCard(audio);

        Adapter adapter = new Adapter();
        mainBoard.addCard(adapter);
    }
}

//  主板类
class MainBoard {
    //  启动方法
    public void run() {
        System.out.println("主板启动了");
    }

    //  插卡方法
    public void addCard(Card card) {
        card.strat();
        card.stop();
    }   
}

//  卡类
class Card {
    //  开始运转
    public void strat() {
        System.out.println("开始运转");
    }
    public void stop() {
        System.out.println("结束运转");
    }
}
//  声卡类
class Audio extends Card {
    @Override
    public void strat() {
        System.out.println("播放音乐");
    }
    @Override
    public void stop() {
        System.out.println("结束播放");
    }
}

//  网卡类
class Adapter extends Card {
    @Override
    public void strat() {
        System.out.println("上网");
    }
    @Override
    public void stop() {
        System.out.println("断网");
    }
}