Java final关键字与多态全解析

原创 2018年01月11日 20:33:53

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

final关键词在多线程环境中的使用

原文:http://www.javamex.com/tutorials/synchronization_final.shtml  Contents 为什么final在多线程中是必要的 final对...
  • xiaoxiaoxuanao
  • xiaoxiaoxuanao
  • 2016年09月18日 13:57
  • 2472

java中final关键字的使用及static final 和final的区别

javastring优化 java中final关键字可以用在类成员(是不是所谓的域),类的方法及类中。 一、final用在域中表示: 1,一个永不改变的编译时常量。 2,一个在运行时被...
  • u013256831
  • u013256831
  • 2014年09月13日 16:53
  • 3453

Java关键字final、static、abstract使用总结

一、final 根据程序上下文环境,Java关键字final有“无法改变”或者“终态”的含义,它可以修饰非抽象类、非抽象类成员方法和变量。final类不能被继承,没有子类,final类中的方法默认...
  • u013842976
  • u013842976
  • 2016年05月10日 13:48
  • 1341

杰神之Java关键字final和多态继承全解

final(关键字) /* * final(关键字) * 1.修饰方法 * 作用:不能被重写 * 2.修饰变量 * 作用: final修饰的变量不允许被再次赋值 * 3.修饰类 *...
  • lyj243719866
  • lyj243719866
  • 2018年01月11日 21:35
  • 15

JAVA面向对象之final关键字与多态详解

JAVA面向对象 final关键字(绝育的) 特点 1.修饰方法 作用 这个被修饰的方法不能被重写 2.修饰变量 作用 修饰的基本数据类型的变量 不能被重新复制 ...
  • liurongsheng123
  • liurongsheng123
  • 2018年01月11日 21:04
  • 54

java开发中/final关键字/多态/抽象类/接口/形式参数与返回值/内部类/匿名内部类知识梳理

一,final关键字 1.    final修饰类,该类不能被继承, 2.    final修饰成员方法,该方法不能重写. 3.    final修饰类的成员变量,该变量的值不能改变, 4. ...
  • fath_kevin
  • fath_kevin
  • 2017年10月26日 17:18
  • 70

JAVA 多态、final关键字、抽象类和方法、 day10

1、继承的弊端:打破了封装性。使用final关键字规避此问题 2、final关键字 特点:final修饰的类不能被继承,即没有子类(public final class A)             ...
  • Aimee_Li
  • Aimee_Li
  • 2017年07月26日 11:33
  • 110

Java中 关键字final,抽象类abstract, 接口interface ,多态

final,抽象abstract,接口interface,多态
  • SYL100252
  • SYL100252
  • 2015年12月21日 20:51
  • 369

黑马程序员——Java基础:继承、final关键字、抽象、接口、多态

一、面向对象之继承——extends 子类和父类:多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。多个类可以称为子类,单 独这个类...
  • u012770105
  • u012770105
  • 2015年06月20日 18:40
  • 497

java中内部类 、object类 、final关键字、修饰符、多态

继承两种方式: Has—a: 类中有另一个类的应用 Is—a:extends 多态: 1. 基本数据类型:自动转换 强制转换 2. 引用数据类型:向上转型向下转型(必须先...
  • u010296640
  • u010296640
  • 2016年10月13日 20:28
  • 123
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java final关键字与多态全解析
举报原因:
原因补充:

(最多只允许输入30个字)