Java基础-面向对象-内部类-CFANZ编程社区

Java工程师知识树 / Java基础

Java内部类

概念：

Java 类中不仅可以定义变量和方法，还可以定义类，这样定义在类内部的类就被称为内部类。

内部类的实现过程

通过反编译内部类的字节码，分析之后主要是通过以下几步做到的：

编译器自动为内部类添加一个成员变量，这个成员变量的类型和外部类的类型相同，这个成员变量就是指向外部类对象的引用；
编译器自动为内部类的构造方法添加一个参数，参数的类型是外部类的类型，在构造方法内部使用这个参数为1中添加的成员变量赋值；
在调用内部类的构造函数初始化内部类对象时，会默认传入外部类的引用。

public class Outer {
    private int m = 1;
    public class Inner {
        private void test() {
            //访问外部类private成员
            System.out.println(m);
        }
    }
}
//编译，会发现会在编译目标目录生成两个.class文件：Outer.class和Outer$Inner.class。
//将Outer$Inner.class放入IDEA中打开，会自动反编译，查看结果：
public class Outer$Inner {
    public Outer$Inner(Outer this$0) {
        this.this$0 = this$0;
    }

    private void test() {
        System.out.println(Outer.access$000(this.this$0));
    }
}

为什么需要内部类

其主要原因有以下几点：

内部类方法可以访问该类定义所在的作用域的数据，包括私有的数据
内部类可以对同一个包中的其他类隐藏起来,一般的非内部类，是不允许有 private 与protected权限的，但内部类可以可是实现多重继承
当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷。

使用内部类最吸引人的原因是：

每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。大家都知道Java只能继承一个类，它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。

内部类的类型

根据定义的方式不同，内部类分为静态内部类，成员内部类，局部内部类，匿名内部类四种。

静态内部类:

定义在类内部的静态类，就是静态内部类。 用static修饰的成员内部类又称为嵌套类。

public class Out {
    private static int a;
    private int b;

    public static class Inner {
        public void print() {
            System.out.println(a);
        }
    }
}

解释：

静态内部类可以访问外部类所有的静态变量和方法，即使是 private 的也一样。
静态内部类和一般类一致，可以定义静态变量、方法，构造方法等。
其它类使用静态内部类需要使用"外部类.静态内部类"方式，如下所示：
```
Out.Inner inner = new Out.Inner();
inner.print(); 
```

Java集合类HashMap内部就有一个静态内部类Entry。Entry是HashMap存放元素的抽象， HashMap 内部维护 Entry 数组用了存放元素，但是 Entry 对使用者是透明的。像这种和外部类关系密切的，且不依赖外部类实例的，都可以使用静态内部类。

成员内部类

定义在类内部的非静态类，就是成员内部类。

成员内部类不能定义静态方法和变量（final 修饰的除外）。这是因为成员内部类是非静态的，类初始化的时候先初始化静态成员，如果允许成员内部类定义静态变量，那么成员内部类的静态变量初始化顺序是有歧义的。

public class Out {
    private static int a;
    private int b;

    public class Inner {
        public void print() {
            System.out.println(a);
            System.out.println(b);
        }
    }
}

局部内部类（定义在方法中的类）

定义在方法中的类，就是局部类。

如果一个类只在某个方法中使用，则可以考虑使用局部类。

public class Out {
    private static int a;
    private int b;

    public void test(final int c) {
        final int d = 1;
        class Inner {
            public void print() {
                System.out.println(c);
            }
        }
    }
}

匿名内部类（要继承一个父类或者实现一个接口、直接使用 new 来生成一个对象的引用）

匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。

同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。

public abstract class Bird {

    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    Bird(String name) {
        this.name = name;
    }
    public abstract int fly();
}
public class Test {
    
    public void test(Bird bird) {
        System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.test(new Bird("大雁") {
            public int fly() {
                return 10000;
            }
        });
        test.test(new Bird("麻雀") {
            public int fly() {
                return 1000;
            }
        });
    }
}

怎么正确的使用内部类

1.注意内存泄露

《Effective Java》第二十四小节明确提出过。优先使用静态内部类。这是为什么呢？
由上面的分析我们可以知道，除了嵌套类，其他的内部类都隐式包含了外部类对象。这便是Java内存泄露的源头。看代码：

定义Outer：

public class Outer{

    public  List getList(String item) {

        return new ArrayList() {
            {
                add(item);
            }
        };
    }
}

使用Outer:

public class Test{

   public static List getOutersList(){

    Outer outer=new Outer();
    //do something
    List list=outer.getList("test");

    return list;    
   }
   public static void main(String[] args){
       List list=getOutersList();


      //do something with list
   }

}

相信这样的代码一定有同学写出来，这涉及到一个习惯的问题：

不涉及到类成员方法和成员变量的方法，最好定义为static

我们先研究上面的代码，最大的问题便是带来的内存泄露：

在使用过程中，我们定义Outer对象完成一系列的动作

使用outer得到了一个ArraList对象
将ArrayList作为结果返回出去。

正常来说，在getOutersList方法中，我们new出来了两个对象：outer和list，而在离开此方法时，我们只将list对象的引用传递出去,outer的引用随着方法栈的退出而被销毁。按道理来说，outer对象此时应该没有作用了，也应该在下一次内存回收中被销毁。

然而,事实并不是这样。按上面所说的，新建的list对象是默认包含对outer对象的引用的，因此只要list不被销毁，outer对象将会一直存在，然而我们并不需要outer对象，这便是内存泄露。

怎么避免这种情况呢？

很简单：不涉及到类成员方法和成员变量的方法，最好定义为static

public class Outer{

    public static List getList(String item) {

        return new ArrayList() {
            {
                add(item);
            }
        };
    }
}

这样定义出来的类便是嵌套类+继承，并不包含对外部类的引用。

2.应用于只实现一个接口的实现类

优雅工厂方法模式

我们可以看到，在工厂方法模式中，每个实现都会需要实现一个Fractory来实现产生对象的接口，而这样接口其实和原本的类关联性很大的，因此我们可以将Fractory定义在具体的类中，作为内部类存在

简单的实现接口

       new Thread(new Runnable() {
           @Override
           public void run() {
               System.out.println("test");
           }
       }

       ).start();
    }

同时实现多个接口

public class imple{

    public static Eat getDogEat(){
        return new EatDog();
    }

    public static Eat getCatEat(){
        return new EatCat();
    }

    private static class EatDog implements Eat {
        @Override
        public void eat() {
            System.out.println("dog eat");
        }
    }
    private static class EatCat implements Eat{
        @Override
        public void eat() {
            System.out.println("cat eat");
        }
    }
}

3.优雅的单例类

public class Imple {

    public static Imple getInstance(){
        return ImpleHolder.INSTANCE;
    }


    private static class ImpleHolder{
        private static final Imple INSTANCE=new Imple();
    }
}

4.反序列化JSON接受的JavaBean

有时候需要反序列化嵌套JSON

{
    "student":{
        "name":"",
        "age":""
    }
}

类似这种。我们可以直接定义嵌套类进行反序列化

public JsonStr{

    private Student student;

    public static Student{
        private String name;
        private String age;

        //getter & setter
    }

    //getter & setter
}

但是注意，这里应该使用嵌套类，因为我们不需要和外部类进行数据交换。

核心思想：

嵌套类能够访问外部类的构造函数
将第一次访问内部类放在方法中，这样只有调用这个方法的时候才会第一次访问内部类，实现了懒加载

总结

内部类的理解可以按照方法来理解，但是内部类很多特性都必须剥开语法糖和明白为什么需要这么做才能完全理解，明白内部类的所有特性才能更好使用内部类，在内部类的使用过程中，一定记住：能使用嵌套类就使用嵌套类，如果内部类需要和外部类联系，才使用内部类。最后不涉及到类成员方法和成员变量的方法，最好定义为static可以防止内部类内存泄露。