【Java编程的逻辑】内部类的本质

最新推荐文章于 2023-04-10 08:59:51 发布

whyalwaysmea

最新推荐文章于 2023-04-10 08:59:51 发布

阅读量364

点赞数

分类专栏： Java基础文章标签： Java基础内部类

本文链接：https://blog.csdn.net/u013435893/article/details/79579344

版权

Java基础专栏收录该内容

28 篇文章 0 订阅

订阅专栏

之前我们所说的类都对应于一个独立的Java源文件，但一个类还可以放在另一个类的内部，称之为内部类。
内部类可以实现对外部完全隐藏，可以有更好的封装性，代码实现上往往更加简洁。
不过，内部类只是Java编译器的概念，对于Java虚拟机而言，它是不知道内部类这回事的，每个内部类最后都会被编译成为一个独立的类。

静态内部类

静态内部类和静态变量、静态方法类似，同样是使用static关键字，只是定义一个类而已

public class Outer {
    private static int shared = 1000;
    public static class StaticInner {
        public void innerMethod() {
            System.out.println("inner: " + shared);
        }
    }
    public void test() {
        StaticInner inner = new StaticInner();
        inner.innerMethod();
    }
}

外部类为Outer，静态内部类为StaticInner。
静态内部类可以访问外部类的静态变量和方法，但不可以访问实例变量和方法。

静态内部类可以被外部调用：

Outer.StaticInner inner = new Outer.StaticInner();
inner.innerMethod();

静态内部类的实现：
我们在Outer.java的文件目录下，对该Java源文件进行编译：

javac Outer.java

在该目录下可以得到两个.class文件，分别是：
Outer.class 和 Outer$StaticInner.class

这就是真正编译后的代码了。我们来查看一下.class中的代码，当然这里需要用到反编译的工具，这里从这里下载使用

// Outer.class
public class Outer {
    private static int share = 1000;
    public void test() {
        Outer$StaticInner inner = new Outer$StaticInner();
        inner.innerMethod();
    }
    static int access$0() {
        return share;
    }
}
// Outer$Inner.class
public class Outer$StaticInner {
    public void innerMethod() {
        System.out.println("inner: " + Outer.access$0());
    }
}

内部类访问了外部类的一个私有静态变量share，我们都知道私有变量是不能被类外部访问的，这里的做法是：Outer中生成了一个非私有访问方法access$0()，它返回了这个私有静态变量share。

成员内部类

与静态内部类相比，成员内部类没有static修饰符。

public class Outer {
    private int a = 100;
    public class Inner {
        public void innerMethod() {
            System.out.println("outer a " + a);
            action();
            // Outer.this.action();
        }
    }
    private void action() {
        System.out.println("action");
    }
    public void test() {
        Inner inner = new Inner();
        inner.innerMethod();
    }
}

Inner就是成员内部类，它除了静态变量和方法，还可以直接访问外部类的实例和方法。
成员内部类可以通过“外部类.this.方法名”调用外部类的实例变量和方法。如果没有重名，那么可以直接通过方法名调用

在外部使用成员内部类:

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.innerMethod();

可以这么理解：成员内部类对象总是与一个外部类对象相连的

与静态内部类不同，成员内部类中不能定义静态变量和方法（final变量例外，它等同于常量），方法内部类和匿名内部类也都不可以。
为什么？这些内部类是与外部实例相连的，不应独立使用，而静态变量和方法作为类型的属性和方法，一般都是独立使用的，在内部类中意义不大。

成员内部类的实现

public class Outer {
    private int a = 100;
    private void action() {
        System.out.println("action");
    }
    public void test() {
        Outer$Inner inner = new Outer$Inner(this);
        inner.innerMethod();
    }
    static int access$0(Outer outer) {
        return outer.a;
    }
    static void access$1(Outer outer) {
        outer.action();
    }
}

public class Outer$Inner {
    final Outer outer;
    public Outer$Inner(Outer outer) {
        this.outer = outer;
    }
    public void innerMethod() {
        System.out.println("outer a " + Outer.access$0(outer));
        Outer.access$1(outer);
    }
}

Outer$Inner类有个实例变量outer指向外部类的对象，它在构造方法中被初始化。

方法内部类

内部类还可以定义在一个方法体中

public class Outer{
    private int a = 100;
    public void test(final int param) {
        final String str = "hello";
        class Inner {
            public void innerMethod() {
                System.out.println("outer a: " + a);
                System.out.println("param : " + param);
                System.out.println("local var: " + str);
            }
        }
        Inner inner = new Inner();
        inner.innerMethod();
    }
}

方法内部类只能在定义的方法内被使用。
如果方法是实例方法，则除了静态变量和方法，内部类还可以直接访问外部类的实例变量和方法。
如果方法是静态方法，则方法内部类只能访问外部类的静态变量和方法。
方法内部类还可以直接访问方法的参数和方法中的局部变量，不过，这些变量必须被声明为final。Java 8之后可以不用声明final，但是在方法内部类中不能修改它们的值。

方法内部类的实现

public class Outer {
    private int a = 100;
    public void test(final int param) {
        final String str = "hello";
        OuterInner inner = new OuterInner(this, param);
        inner.innerMethod();
    }
    static int access$0(Outer outer){
        return outer.a;
    }
}

public class OuterInner {
    Outer outer;
    int param;    
    OuterInner(Outer outer, int param){
        this.outer = outer;
        this.param = param;
    }    
    public void innerMethod() {
        System.out.println("outer a " + Outer.access$0(this.outer));
        System.out.println("param " + param);
        System.out.println("local var " + "hello");
    }
}

与成员内部类类似，OuterInner类也有一个实例变量outer指向外部对象，在构造方法中被初始化，对外部私有实例变量的访问也是通过Outer添加的方法access$0来进行的。

方法内部类可以访问方法中的参数和局部变量，这是通过在构造方法中传递参数来实现的，如OuterInner构造方法中有参数int param，在新建OuterInner对象时，Outer类将方法中的参数传递给了内部类，如OuterInner inner = new OuterInner(this, param);。在上面代码中，String str并没有被作为参数传递，这是因为它被定义为了常量，在生成的代码中，可以直接使用它的值。

这也解释了，为什么方法内部类访问外部方法中的参数和局部变量时，这些变量必须被声明为final，因为实际上，方法内部类操作的并不是外部的变量，而是它自己的实例变量，只是这些变量的值和外部一样，对这些变量赋值，并不会改变外部的值，为避免混淆，所以干脆强制规定必须声明为final。

匿名内部类

匿名内部类是与new关联的，在创建对象的时候定义类，new后面是父类或者父接口，然后是圆括号()，里面可以是传递给父类构造方法的参数，最后是大括号{}，里面是类的定义。

public class Outer {
    public void test(final int x, final int y){
        Point p = new Point(2,3){                                                               
            @Override                              
            public double distance() {             
                return distance(new Point(x,y));     
            }                                      
        };                                                                                        
        System.out.println(p.distance());        
    }
}