Java：内部类与final关键字解析

final关键字概念

final关键字：代表最终的、不可改变的。
常见的四种用法：

• 1.可以用来修饰一个类
• 2.可以用来修饰一个方法
• 3.可以用来修饰一个局部变量
• 4.可以用来修饰一个成员变量

如果final修饰一个类，那么格式：

• public final class 类名称 {

•   //...
  

• }
• 含义：当前这个类不能有任何的子类。
• 注意事项：一个类如果是被final关键字修饰后，那么所有的成员方法都无法被重写。

如果final修饰一个方法，格式：

• public final void 方法名(){}
• 含义：当方法被final修饰时，这个方法就是最终方法，不能被覆盖重写。
• 注意事项：
• 对于类、方法来说，abstract关键字和final关键字不能同时使用，因为相互矛盾。

final修饰局部变量赋值后，变量不可再次改变

final修饰成员变量后，这个变量也是不可变的。

• 1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
• 2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。
• 3.必须保证类中的所有重载的构造方法，语句都对final的成员变量进行赋值。

public class Demo01 {
   public static void main(String[] args) {
       int num1 = 10;
       num1 = 20;
       System.out.println(num1);
       final int num2 = 100;//final修饰局部变量赋值后，不可再次改变
//        num2 = 200;
       //对于基本类型来说，不可变是指变量的数据不可改变
       //对于引用类型来说，不可变是指变量的地址值不可改变。
       final Student stu = new Student("小白");
//        stu = new Student("小黑");地址值不能改变
       //但是值可以改变
       System.out.println(stu.getName());
       stu.setName("小黑");
       System.out.println(stu.getName());
   }
}
package demo;

public class Student {
   private String name;

   public Student() {
   }

   public Student(String name) {
       this.name = name;
   }

   public String getName() {
       return name;
   }

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

内部类

一个事物包含另一个事物，那么这就是一个类内部包含另一个类。
例如身体和心脏的关系。
内部类分为：
1.成员内部类
2.局部内部类(包含匿名内部类)

成员内部类

一个事物包含另一个事物，那么这就是一个类内部包含另一个类。
例如身体和心脏的关系。
内部类分为：
1.成员内部类
2.局部内部类(包含匿名内部类)

成员内部类的定义格式：
修饰符 class 外部类名{
修饰符 class 内部类名{
//…
}
//…
}
注意：内用外，随意访问，外用内，需要使用内部对象。
成员内部类的两种使用方法：
1.间接方式：在外部类的方法中使用内部类(创建对象调用),然后在main中只创建外部类的对象并调用
2.直接方式：外部类名.内部类名 对象名 = new 外部类名().new内部类名();
对于成员内部类与外部类中的成员变量名重复的情况
在内部类方法中引用System.out.println(Outer.this.num);
Outer关键字

成员内部类的两种使用方法
public class Demo01InClass {
    public static void main(String[] args) {
        Body body = new Body();
        body.bodyMethod();
        Body.Heart jj = new Body().new Heart();
        jj.heartMethod();
    }
}
package demo02;
public class Body {
    public class Heart{
        public void heartMethod(){
            System.out.println("内部类方法执行");
            System.out.println(num);//可以从内部类中访问到外部类中的成员变量。
        }
    }
    //外部类成员变量
    private int num = 10;
    //外部类方法
    public void bodyMethod(){
        System.out.println("外部类方法执行");
        Heart heart = new Heart();
        heart.heartMethod();
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
}
package demo02;
内部类中的变量重名现象
public class Outer {
    int num = 10;
    public class Inter{
        int num = 20;
        public void method(){
            int num = 30;
            System.out.println(num);//30
            System.out.println(this.num);//20
            //内部类取外部类的同名成员变量值
            System.out.println(Outer.this.num);//10
        }
    }
}

局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
定义格式：

• 修饰符 class 外部类名称{

•   修饰符 返回值 外部类方法名(){
  

•       class 局部内部类名称{
  

•   }
  

• }
• }

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是(有效final的)
备注：从java8开始，只要局部变量事实不变，那么final关键字可以省略。
原因：

• 1.new出来的对象在堆内存当中。
• 2.局部变量是跟着方法走的，在栈内存中。
• 3.方法运行结束之后，立刻出栈，局部变量就会立刻消失。
• 4.但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

public class Out {
    public void outMethod(){
        class In{
            int num = 20;
            public void inMethod(){
                System.out.println(num);
            }
        }
        In in = new In();
        in.inMethod();
    }
}

匿名内部类(常用于接口)

如若接口的实现类(或者定义类的子类)只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用(匿名内部类).
匿名内部类的定义格式：
接口名称 对象名 = new 接口名(){
//覆盖重写所有抽象方法
};
对格式"new 接口名(){…}"进行解析：

• 1.new代表创建对象的动作
• 2.接口名称就是匿名内部类需要实现哪个接口
• 3.{…}这才是匿名内部类的内容
  另外还要注意几点问题：
• 1.匿名内部类，在【创建对象时】，只能使用唯一一次
  如果需要多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
• 2.匿名对象，在【调用方法时】，只能调用唯一一次。
  如果希望同一个对象，多次调用方法，那么必须给对象起个名字。
• 3.匿名内部类是省略了【实现类/子类名】，但是匿名对象是省略了【对象名称】