20200803

final

final关键字代表最终，不可改变的

常见的四种用法

• 可以用来修饰一个类
• 可以用来修饰一个方法
• 可以用来修饰一个局部变量
• 可以用来修饰一个成员变量

1.当final关键字用来修饰一个类的时候，格式为：

public final class 类名称 {

    //.......

}

含义：当前这个类不能有任何的子类（太监类）

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

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

格式：

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

           //方法体

}

注意事项：对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾

3.一旦使用final用来修饰局部变量，那么这个变量就不能进行更改，“一次赋值，终生不变”

对于基本类型来说，不可变说的是变量当中的数据不可改变

对于引用类型来说，不可变说的是变量当中的地址值不可改变

4.对于成员变量来说，如果使用final关键字修饰，那么这个变量也是照样不可变

由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了

对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值，二者选其一

必须保证类当中所有重载的构造方法都最终会对final的成员变量进行赋值

四种权限修饰符

                             public    >    protected    >    (default)    >    private

同一个类               YES               YES                YES                  YES

同一个包               YES               YES                YES                  NO

不同包子类            YES               YES                NO                   NO

不同包非子类         YES               NO                  NO                   NO

注意事项：（default） 并不是关键字“default”,而是根本不写

内部类

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类

例如：身体和心脏的关系

分类：

• 成员内部类
• 局部内部类（包含匿名内部类）

成员内部类的定义格式：

修饰符  class  外部类名称 {

       修饰符  class  内部类名称 {

        //.......

     }

     //.....

}

注意：内用外，随意访问；外用内，需要内部类对象

public class Body {//外部类
    public class Heart {//成员内部类
        //内部类
        public void beat(){
            System.out.println("心脏跳动：蹦蹦蹦！");
            System.out.println("我叫：" + name);
        }

    }
    //外部类的成员变量
    private String name;

    //外部类的方法
    public void methodBody(){
        System.out.println("外部类的方法");
        new Heart().beat();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

如何使用成员内部类

间接方式：在外部类的方法当中，使用内部类，然后main只是调用外部类的方法

直接方式：公式：外部类名称.内部类名称  对象名  =  new  外部类名称（）.new 内部类名称（）；

public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body();//外部类的对象
        //通过外部类的对象调用外部类的方法，里面间接在使用内部类Heart
        body.methodBody();
        System.out.println("=============");

        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名

public class Outer {
    int num = 10;//外部类的成员变量

    public class Inner {

        int num = 20;//内部类的成员变量

        public void methodInner(){
            int num = 30;//内部类方法的局部变量
            System.out.println(num);//局部变量，就近原则
            System.out.println(this.num);//内部类的成员变量
            System.out.println(Outer.this.num);//外部类的成员变量
        }
    }
}

public class Demo02InnerClass {
    public static void main(String[] args) {
        //外部类名称.内部类名称 对象名 = new 外部类名称（）.new 内部类名称（）；
        Outer.Inner obj = new Outer().new Inner();
        obj.methodInner();//30
                          //20
                          //10
    }
}