Java基础之内部类

该项目源码地址：https://github.com/ggb2312/JavaNotes/tree/master/java-basic

1. 简介

可以将一个类的定义放在另一个类的定义内部，这就是内部类。

一般格式为：

public class Zoo{
    ...
    class Panda{
    }
}

内部类是一种非常有用的特性，它允许你把一些逻辑相关的类组织在一起，并控制位于内部的类的可见性。内部类与组合是完全不同的概念。

内部类提供一种代码隐藏机制：“将类置于其他类的内部”，同时内部类也了解外部类，并能与之通信。

2. 内部类实例

内部类有以下四种形式

  1. 成员内部类
  2. 局部内部类
  3. 静态内部类
  4. 匿名内部类

成员内部类和静态内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。

下面我们通过几个实例来看看内部类具体长什么样。

2.1 成员内部类

成员内部类和成员变量一样，属于类的全局成员。
成员内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。

一般格式：

public class OuterClass { //外部类
     int id; // 成员变量
     class InnerClass { //成员内部类
     }
}

实例：

一个类作为另一个类的成员（不是作为成员变量，作为成员变量的话就成组合模式了），同时成员内部类可以无条件的使用外部类的一切静态变量、成员变量、静态方法、成员方法，用于内部类和外部类通信。

public class OuterClass {
    private String name;

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

    // 成员内部类，类比对象的成员变量
    private class InnerClass {
        int innerPrice;

        public InnerClass(int innerPrice) {
            System.out.println("成员内部类~类比对象的成员变量");
            this.innerPrice = innerPrice;
        }

        public void print() {
            helloInnerClass();
            System.out.println("出售：" + name + " 单价:" + innerPrice);
        }
    }

    public void helloInnerClass() {
        System.out.println("我是外部类的helloInnerClass方法，内部类你可以调用我");
    }

    public static void main(String[] args) {
        OuterClass sample = new OuterClass("香蕉");
        InnerClass inner = sample.new InnerClass(20);
        inner.print();
    }
}

运行结果：

成员内部类~类比对象的成员变量
我是外部类，内部类你可以调用我
出售：香蕉 单价:20

2.2 局部内部类

局部内部类和局部变量一样，都是在方法内定义的，其有效范围只在方法内有效。

一般格式：

public class OuterClass { //外部类
    public void print(){ // print方法
         class InnerClass { //局部内部类
         }
    }
}

实例：

局部内部类可以无条件的使用外部类的一切静态变量、成员变量、静态方法、成员方法，用于内部类和外部类通信。

public class OuterClass {

    private String name;

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

    public void helloInnerClass() {
        System.out.println("我是外部类的helloInnerClass方法，内部类你可以调用我");
    }

    public void print(int price) {
        // 局部内部类，类比方法内的局部变量
        class InnerClass {
            int innerPrice;

            public InnerClass(int innerPrice) {
                System.out.println("局部内部类~类比方法内的局部变量");
                this.innerPrice = innerPrice;
            }

            public void sell() {
                helloInnerClass();
                System.out.println("出售：" + name + " 单价:" + innerPrice);
            }
        }
        InnerClass apple = new InnerClass(price);
        apple.sell();
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass("苹果");
        outerClass.print(10);
    }
}

运行结果：

局部内部类~类比方法内的局部变量
我是外部类的helloInnerClass方法，内部类你可以调用我
出售：苹果 单价:10

2.3 静态内部类

静态内部类和静态变量类似，它都是使用static关键字修饰。
静态内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。

一般格式：

public class OuterClass { //外部类
   class InnerClass { //静态内部类
   }     
}

实例：

静态内部类只能使用外部类的一切成员变量、成员方法，用于内部类和外部类通信。

public class OuterClass {
    private static String name="静态内部类";

    // 静态内部类，类比类的静态变量
    private static class InnerClass {
        public void print() {
            System.out.println(name+"~类比类的的静态变量");
        }
    }

    public static void main(String[] args) {
        OuterClass.InnerClass sample = new OuterClass.InnerClass();
        sample.print();
    }
}

运行结果：

静态内部类~类比类的的静态变量

2.4 匿名内部类

匿名内部类就是没有名字的内部类，其名称由Java编译器给出，一般是形如：“外部类名称+$+匿名类顺序”，没有名称也就是其他地方就不能引用。其必须要实现一个接口或者继承一个父类，主要是用来简化代码，常常用于Swing程序设计中的事件监听处理。

一般格式：

public class OuterClass { //外部类
   public void print(){ // print方法
         new InnerClass(){
           ...  
         };
    }     
}

实例：

匿名内部类只能使用外部类的一切成员变量、成员方法，用于内部类和外部类通信。

定义一个接口

public interface InnerClass {
    // 接口方法默认public
    void print();
}

定义一个外部类

public class OuterClass {

    public static void print(InnerClass innerClass) {
        innerClass.print();
    }

    public static void main(String[] args) {
        OuterClass.print(new InnerClass() {
            @Override
            public void print() {
                System.out.println("匿名内部类~由于没有引用，每次新创建的，在Minor GC时被清除");
            }
        });
    }
}

运行结果：

匿名内部类~由于没有引用，每次新创建的，在Minor GC时被清除

匿名内部类的名称：外部类名称+$+匿名类顺序

匿名内部类的名称

使用JDK8提供的lambda表示替换匿名内部类

public class OuterClass {

    public static void print(InnerClass innerClass) {
        innerClass.print();
    }

    public static void main(String[] args) {
        OuterClass.print(() -> System.out.println("匿名内部类~由于没有引用，每次新创建的，在Minor GC时被清除"));
    }
}

匿名内部类在Swing中的实例：

import javax.swing.*;
import java.awt.*;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
public class test extends JFrame{
    JPasswordField passwordField;
    JTextField textField;
        test(){
            super();
            setTitle("QQ");
            setBounds(100, 100, 380, 280); 
            getContentPane().setLayout(null); 
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             
            textField = new JTextField("密码");
            textField.setBounds(100, 155, 120, 21);
            getContentPane().add(textField);
            // new MouseAdapter()使用匿名内部类
            textField.addMouseListener(new MouseAdapter(){
                @Override
                public void mouseClicked(MouseEvent e) {
                    getContentPane().remove(textField);
                    passwordField = new JPasswordField();
                    passwordField.setBounds(100, 155, 120, 21); 
                    getContentPane().add(passwordField);
                }
            });
             
        }
        public static void main(String[] args) {
            new test().setVisible(true);;
        }
}

在给textField添加鼠标监听事件的时候，使用了new MouseAdapter(){}匿名内部类作为方法的参数。

3. 深入理解内部类

1. 为什么成员内部类可以无条件访问外部类的成员和类属性？
成员内部类可以无条件访问外部类的成员变量、static变量、成员函数和static函数。

public class Outter {
    private static int b = 2;
    private int a = 1;

    protected class Inner {
        public Inner() {
            System.out.println(a);//成员变量
            System.out.println(b);//static变量
            print();//成员函数
            staticPrint();//static函数
        }
    }
    private void print() {
    }

    private static void staticPrint() {
    }
}

我们通过反编译字节码文件看看究竟是如何实现的。在编译时，会将内部类单独编译成一个字节码文件。

字节码文件

Outter.class是外部类的字节码文件，Outter$Inner.class才是成员内部类的字节码文件。

反编译Outter$Inner.class文件

javap -v Outter$Inner.class

得到一个关键信息

final cn.lastwhisper.javabasic.InnerClass.member.Outter this$0;

这是一个指向外部类对象的指针。也就是说编译器会默认为成员内部类添加了一个指向外部类对象的引用，那么这个引用是如何赋初值的呢？下面接着看内部类的构造器：

public cn.lastwhisper.javabasic.InnerClass.member.Outter$Inner(cn.lastwhisper.javabasic.InnerClass.member.Outter);

从这里可以看出，虽然我们在定义的内部类的构造器是无参构造器，编译器还是会默认添加一个参数，该参数的类型为指向外部类对象的一个引用，所以成员内部类中的Outter this&0 指针便指向了外部类对象，因此可以在成员内部类中随意访问外部类的成员。从这里也间接说明了成员内部类是依赖于外部类的，如果没有创建外部类的对象，则无法对Outter this&0引用进行初始化赋值，也就无法创建成员内部类的对象了。

2. 为什么静态内部类只能访问外部类的成员属性？
静态内部类只能访问外部类的static变量和static函数。

public class Outter {
    private static int b = 2;
    private int a = 1;

    protected static class Inner {
        public Inner() {
            //System.out.println(a);//成员变量 会报错“Non-static field 'a' cannot be referenced from a static context”
            System.out.println(b);//static变量
            //print();//成员函数 会报错“Non-static field 'a' cannot be referenced from a static context”
            staticPrint();//static函数
        }
    }

    private void print() {
    }

    private static void staticPrint() {
    }
}

如果静态内部类使用外部类的成员变量，就会报错“Non-static field 'a' cannot be referenced from a static context”，从字面意思很好理解，非static字段不能被static上下文所引用。静态内部类使用外部类的成员函数情况也类似。

类比着上一个问题，通过反编译字节码文件，发现编译器在编译时并没有添加外部类的引用，所以静态内部类也无法使用外部类的成员变量和成员函数。

public cn.lastwhisper.javabasic.InnerClass.Static.Outter$Inner();

3. 为什么匿名内部类只能访问final修饰的局部变量？

在JDK8以前匿名内部类只能访问final修饰的局部变量，在JDK8以后匿名内部类可以访问非final修饰的局部变量

想必这个问题也曾经困扰过很多人，在讨论这个问题之前，先看下面这段代码：

public class FinalTest {
    public void test(final int b) {
        final int a = 100;
        new Thread() {
            public void run() {
                System.out.println(a);
                System.out.println(b);
            }
        }.start();
    }
}

这段代码会被编译成两个class文件：FinalTest$1.class和FinalTest.class

匿名内部类字节码文件

默认情况下，编译器会为匿名内部类起名为“外部类名称+$+匿名类顺序”

即test方法里面的匿名内部类为：FinalTest$1.class

上段代码中，如果把变量a和b前面的任一个final去掉，这段代码都编译不过。我们先考虑这样一个问题：

当test方法执行完毕之后，局部变量a的生命周期就结束了，而此时Thread对象的生命周期很可能还没有结束，那么在Thread的run方法中继续访问test方法的局部变量a就变成不可能了，但是又要实现这样的效果，怎么办呢？Java采用了 复制 的手段来解决这个问题。将这段代码的字节码反编译可以得到下面的内容：

反编译FinalTest$1.class

得到的信息很多，我们分成两个部分。
第一部分run方法

run方法

我们看到在run方法中有一条指令：

bipush 100

这条指令表示将操作数100压栈，表示使用的是一个本地局部变量。这个过程是在编译期间由编译器默认进行，如果这个变量的值在编译期间可以确定，则编译器默认会在匿名内部类的常量池中添加一个内容相等的字面量或者直接将相应的字节码嵌入到执行字节码中。

这样一来，匿名内部类方法中引用的变量其实并不是外部类方法中的局部变量，而是引用编译器在匿名内部类的常量池中添加的一个内容相等的字面量。即匿名内部类run方法中使用的a并不是test方法中的a，而是FinalTest$1常量池中的a=100。

第二部分匿名内部类的构造函数

匿名内部类的构造函数

我们看到匿名内部类FinalTest$1的构造器含有两个参数，一个是指向外部类对象的引用，一个是int型变量，很显然，这里是将变量test方法中的形参b以参数的形式传进来对匿名内部类中的拷贝（变量b的复制）进行赋值初始化。

也就说如果局部变量的值在编译期间就可以确定，则直接在匿名内部里面创建一个拷贝。如果局部变量的值无法在编译期间确定，则通过构造器传参的方式来对拷贝进行初始化赋值。

这样一来就解决了前面所说的生命周期不一致的问题。但是新的问题又来了，既然在run方法中访问的变量a和test方法中的变量a不是同一个变量，当在run方法中改变变量a的值的话，会出现什么情况？

对，会造成数据不一致性，这样就达不到原本的意图和要求。为了解决这个问题，java编译器就限定必须将变量a限制为final变量，不允许对变量a进行更改（对于引用类型的变量，是不允许指向新的对象），这样数据不一致性的问题就得以解决了。

至此我们可以回答“为什么匿名内部类只能访问final修饰的局部变量？”了。

1. Java为了避免数据不一致性的问题，做出了匿名内部类只可以访问final的局部变量的限制。

2. 补充：Java为了局部变量与匿名内部类生命周期不一致的问题，将匿名内部类使用到的外部类方法局部变量复制到自己的常量池中一份，操作时只使用自己常量池中的数据。

4. 为什么需要内部类

至此我们已经看到了许多描述内部类的语法和语义，但是这并不能回答“为什么需要内部类” 这个问题。

一般说来，内部类继承自某个类或实现某个接口，内部类的代码操作创建它的外围类的对象。所以可以认为内部类提供了某种进入其外围类的窗口。

内部类必须要回答的一个问题是：如果只是需要一个对接口的引用，为什么不通过外围类实现那个接口呢？答案是：“如果这能满足需求，那么就应该这样做。” 那么内部类实现一个接口与外围类实现这个接口有什么区别呢？答案是：后者不是总能享用到接口带来的方便， 有时需要用到接口的实现。所以，使用内部类最吸引人的原因是 ：

每个内部类都能独立地继承自一个(接口的)实现，所以无论外围类是否已经继承了某个(接口的)实现，对于内部类都没有影响。

内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了 “多重继承” 。 也就是说，内部类允许继承多个非接口类型(类或抽象类)。

实例：

使用一个类继承两个抽象类，模拟“多继承问题”

abstract class MyClass1 { }
abstract class MyClass2 { }

/**
 * 成员内部类实例
 * @author lastwhisper
 */
public class OuterClass extends MyClass1 {
    private String name;

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

    // 成员内部类，类比对象的成员变量
    class InnerClass extends MyClass2 {
        int innerPrice;

        public InnerClass(int innerPrice) {
            System.out.println("成员内部类~类比对象的成员变量");
            this.innerPrice = innerPrice;
        }

        public void print() {
            helloInnerClass();
            System.out.println("出售：" + name + " 单价:" + innerPrice);
        }
    }

    public void helloInnerClass() {
        System.out.println("我是外部类的helloInnerClass方法，内部类你可以调用我");
    }

    public static void main(String[] args) {
        OuterClass sample = new OuterClass("香蕉");
        InnerClass inner = sample.new InnerClass(20);
        inner.print();
    }
}

如果不需要解决“多重继承” 的问题，那么自然可以用别的方式编码，而不需要使用内部类。但如果使用内部类，还可以获得其他一些特性：

  1. 内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立。
  2. 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类。
  3. 创建内部类对象的时刻并不依赖于外围类对象的创建。
  4. 内部类并没有令人迷惑的“is-a”关系； 它就是一个独立的实体 。

5. 总结

访问权限：

  1. 成员内部类和静态内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。
  2. 如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。
  3. 这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。

资源使用：

  1. 成员内部类可以无条件的使用外部类的一切静态变量、成员变量、静态方法、成员方法，用于内部类和外部类通信。
  2. 局部内部类可以无条件的使用外部类的一切静态变量、成员变量、静态方法、成员方法，用于内部类和外部类通信。
  3. 静态内部类只能使用外部类的一切成员变量、成员方法，用于内部类和外部类通信。
  4. 匿名内部类只能使用外部类的一切成员变量、成员方法，用于内部类和外部类通信。

使用内部类的好处：

  1. 可以解决“多继承问题”
  2. 内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立。
  3. 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类。
  4. 创建内部类对象的时刻并不依赖于外围类对象的创建。
  5. 内部类并没有令人迷惑的“is-a”关系； 它就是一个独立的实体 。

参考

《Java编程思想》
https://www.cnblogs.com/dolphin0520/p/3811445.html
https://www.cnblogs.com/cuipengfei/p/3150542.html#3901831

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,772评论 6赞 477
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,458评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,610评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,640评论 1赞 276
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,657评论 5赞 365
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,590评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,962评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,631评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,870评论 1赞 297
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,611评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,704评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,386评论 4赞 319
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,969评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,944评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,179评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 44,742评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,440评论 2赞 342

推荐阅读更多精彩内容

  • Java基础之内部类（InnerClass）
    一、内部类介绍 内部类：将一个类的定义放在另一个类的定义内部。 内部类是个编译时的概念，一旦编译成功后，它就与外围...
    代码米虫阅读 497评论 0赞 0
  • Java基础之内部类
    1、内部类分类： 成员内部类 局部内部类 匿名内部类 静态内部类 2、成员内部类 1.概念： 定义在一个类内部的类...
    M_JCs阅读 900评论 0赞 9
  • Java基础之内部类
    什么是内部类？为什么要使用内部类？  内部类是指在类的内部可以定义另一个类。内部类可以申明成public或priv...
    小任务大梦想阅读 290评论 0赞 0
  • java基础之内部类
    内部类:类里面再声明类 1》默认内部类 class Outer{ private int a = 12; clas...
    沈默的头号狗腿阅读 97评论 0赞 0
  • 感情的十字路口
    今年的4月5日，清明节，我和L走到了一起。 她算我的第二个女朋友。 今天我和她分开，整整六个月的时间。 决绝之后，...
    名再道号直行阅读 435评论 0赞 1