6.3 内部类-CSDN博客

本文链接：https://blog.csdn.net/StarPlatinum2/article/details/144107519

内部类(inner class)是定义在另一个类中的类。
使用内部类的原因 :

内部类可以对同一个包中的其他类隐藏。
内部类方法可以访问定义在这个类的作用域中的数据，包括原本私有的数据。
在Java中内部类的对象有一个隐式的引用，指向实例化这个类的外部对象。通过这个指针它可以访问外部类的全部状态。
但静态内部类没有附加这个指针。

6.3.1 使用内部类访问对象状态

可以使用内部类访问外部类的字段及方法

package innerClass;  
  
  
public class Test02 {  
    private int age = 10;  
    public void h() {  
        System.out.println("haha");  
    }  
    public class Inner {  
        public void m() {  
	        // Test02.this 得到外部类的引用
            System.out.println(Test02.this.age);  
            Test02.this.h();  
        }  
    }  
    public static void main(String[] args) {  
        Test02 test02 = new Test02();  
        Inner inner = test02.new Inner();  
        inner.m();  
    }  
}

6.3.2 内部类的特殊语法规则

在内部类中使用外部类引用 : OuterClass.this

在Java中，当你创建一个外部类的对象时，内部类的对象并不会自动创建。外部类和内部类是独立的实体，它们的生命周期和创建方式是分开的。

通过外部类创建一个内部类 : new OutClass().new InnerClass()
静态内部类可以脱离外部类直接创建 : new OutClass.InnerClass()

6.3.3 内部类是否有用，必要和安全

内部类是一个编译器现象，与虚拟机无关。编译器将内部类转换为常规的类文件，用$分隔外部类名与内部类名，而虚拟机对此一无所知。

6.3.4 局部内部类

局部内部类被定义在方法的内部。
声明局部内部类时不能有访问修饰符(public或private)。
局部类的作用域被限定在声明这个局部类的块中。

6.3.5 由外部方法访问变量

局部类不仅能够访问外部变量，也能访问局部变量，但那些局部变量必须是实际最终变量(effectively final)。

package innerClass;  
  
public class OutClass02 {  
    public void f() {  
        String text = "hello";  
        class InnerClass02 {  
            public void m() {  
                System.out.println(text);  
            }  
        }  
        InnerClass02 class02 = new InnerClass02();  
        class02.m();  
    }  
    public static void main(String[] args) {  
        new OutClass02().f();  
    }  
}

6.3.6 匿名内部类

如果只是想创建一个类甚至不需要给这个类取名字，这种类叫匿名内部类(anonymous inner class)，匿名内部类通常与接口一起使用。

由于构造器名必须和类名保持一致，但匿名内部类没有类名，所以匿名内部类没有构造器，但它当扩展一个类时还是可以调用父类的构造器。

虽然匿名内部类没有构造器，但他可以有对象初始化块。

这里还有一个小技巧，用于初始化数组或列表

package anonymousInnerClass;  
  
import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.List;  
  
public class Test01 {  
  
    public static void f(List<String> list) {  
        list.stream().forEach(System.out::println);  
    }  
  
    public static void main(String[] args) {  
        List<String> list = Arrays.asList("abc", "efg");  
        f(list);  
		 // 双括号初始化 (double brace initialization)
		f(new ArrayList<String>() {{  
            add("abc");  
            add("efg");
        }});  
    }  
}

在匿名内部类中获得外部类

package anonymousInnerClass;  
  
import java.util.ArrayList;  
  
public class Test02 {  
    public static void main(String[] args) {  
        System.out.println(new ArrayList() {  
        }.getClass().getEnclosingClass().getName());  
    }  
}

6.3.7 静态内部类

有时候使用内部类只是想把类隐藏在另一个类的内部，并不需要内部类有外部类的引用，此时可以将类声明成static，这样就不会产生那个引用了。

package anonymousInnerClass;  
  
import innerClass.Test02;  
  
import java.util.Arrays;  
  
public class Test03 {  
    public static class Pair {  
        private int first;  
        private int second;  
  
        public Pair(int first, int second) {  
            this.first = first;  
            this.second = second;  
        }  
  
        public int getFirst() {  
            return first;  
        }  
  
        public int getSecond() {  
            return second;  
        }  
    }  
  
    public static Pair find(int ...numbers) {  
        int max, min;  
        max = min = numbers[0];  
        for (int i = 1; i < numbers.length; i++) {  
            max = Math.max(max, numbers[i]);  
            min = Math.min(min, numbers[i]);  
        }  
        return new Pair(max, min);  
    }  
  
    public static void main(String[] args) {  
        Test03.Pair pair = find(1, 2, 4);  
        System.out.println(pair.getFirst());  
        System.out.println(pair.getSecond());  
    }  
}