Java final关键字与多态全解析

final(关键字)

修饰方法 被修饰的方法不能被重写
修饰变量 
  1.被final 修饰的对象的地址不能改变(不能重写指向)
  2.final 基本数据类型变量  不能被重写赋值
修饰类 被修饰的类不能被继承

代码举例分析:

public class Demo01 {
    public static void main(String[] args) {
    /*  ClassA classA = new ClassA();
        classA.fun();   
        final 修饰引用数据类型时 对象值能发生变化 可以被修改
        final ClassA a = new ClassA();      
        a.num = 10;
        a.num = 15;     
        System.out.println(a.num);
        被final修饰对象的地址不能改变(不能重写指向)
        a = new ClassA();*/         
    }
}

     class ClassA{
         // num 创建对象的时候有默认的初始值 0 但是这个初值是无效的
         // final 修饰成员变量的时候需要 该成员变量必须要有有效的初值
        // 被final 修饰的变量 程序中不能被修改 相当于常量
         int num;    
        public final void fun() {
            System.out.println("我是ClassA的fun方法");       
            // final 基本数据类型变量  不能被重写赋值
            final int num = 10;
            // num = 15;
        }
    }

    class ClassB extends ClassA{
        // 参数也可以被final 修饰 相当于修饰的是局部变量
        // public final void fun(final int i) {
        //  System.out.println("我是ClassB的fun方法");
        // }

        }

多态

一种事物的多种形态
 1.类与类之间要产生联系 继承关系
 2.要有方法的重写(没有方法的重新 多态的意义不大)
 3.核心: 父类引用指向子类空间

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

多态 调用 成员变量

编译和运行都看等号左边(父类的引用) 当使用父类引用 指向子类空间的时候
父类的引用 只能看见或者访问到子类空间中 属于父类的那部分(super 访问的部分)
当本类引用指向本类空间的时候 本类的引用可以访问到整个空间
核心:父类的指针 指向 子类的空间

代码举例分析:

public class Demo04 {
    public static void main(String[] args) {
        // 多态形式创建
        Father father = new Son();
        System.out.println(father.num);
        father.print();     // 向上转型
        /* 动态绑定
         * 编译时:寻找父类中有没有该方法(看等号左边)
         * 运行时:调用的是子类中重写的方法
         * 编译看左边(看父类) 运行看右边(看子类)
         * /
         // 多态下是不能创建出来的对象 是不能直接调用子类的特有方法        
        // person.hit();
        // 需要把这个对象进行向下转型 相当于强制类型转化
        // 现有向上 才会有向下转型
        //Son son = (Son)father;
        //son.fun();
        Son son = new Son();
        System.out.println(son.num);
        son.print();
    }
}

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

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

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

例题:

/*
 * 铁桶僵尸(zombie) 血量 方法:被打一次掉2血 直到被打死
 * 帽子僵尸 血量 方法:被打一次掉5血 直到被打死
 * 封装一个 打僵尸的方法
 */

public class Demo07 {
    public static void main(String[] args) {
        TieZombie z1 = new TieZombie();
        z1.setHp(100);
        hit(z1);
        MZombie z2 = new MZombie();
        z2.setHp(100);
        hit(z1);
        hit(z2);
    }

    public static void hit(Zombie zombie) {
        zombie.hit();
    }
}

    class Zombie{
        private int hp;
        public void hit() {         
        }
        public int getHp() {
            return hp;
        }
        public void setHp(int hp) {
            this.hp = hp;
        }
    }
    class TieZombie extends Zombie{
        @Override
        public void hit() {
            while (true) {
                if (this.getHp() <= 0 ) {
                    System.out.println("铁桶僵尸被打死了");
                    break;
                }
                this.setHp(this.getHp() - 2);
                System.out.println("剩余血量" + this.getHp());
            }
        }       
    }

    class MZombie extends Zombie{
        @Override
        public void hit() {
            if (this.getHp() <= 0) {
                System.out.println("帽子僵尸被打死了");
                return;     //结束整个方法
            }
            this.setHp(this.getHp() - 5);
            System.out.println("剩余血量" + this.getHp());
            // 继续打
            hit();
        }
    }