java 内部类

1. 简介

在 Java 中可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：

成员内部类、局部内部类、匿名内部类和静态内部类。

 

2. 优点

在程序设计中有时会存在一些使用接口很难解决的问题，此时可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决。

可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。

使用内部类可以使程序拥有以下特性：

1）内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立；

2）在单个外部类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类；

3）创建内部类对象的时刻并不依赖于外部类对象的创建；

4）内部类并没有令人迷惑的“is-a”关系，它就是一个独立的实体；

5）内部类提供了更好的封装，除了该外部类，其他类都不能访问；

 

3. 示例

3.1 成员内部类

3.1.1 成员内部类的修饰符和实例化

成员内部类可以看作是外部类的一个成员，它有以下注意点：

1）成员内部类不能使用static关键字；

2）成员内部类的实例化：成员内部类依赖于外部类，因此必须在外部类实例化后内部类才能实例化。

注：上述条件说明在外部类的非静态方法中可以实例化内部类（要访问外部类的实例方法，先要有外部类对象，满足上述条件）；

或者在外部类的静态方法中先实例化外部类，再实例化内部类。

public class OuterClass1 {

    class InnerClass{
        //private static int innerVar = 1;         // 成员内部类不能使用静态成员变量
        //private static void innerMethod(){ }     // 成员内部类不能使用静态方法
    }

    public void outMethod(){
        InnerClass in = new InnerClass();      // 在外部类的非静态方法中直接实例化内部类
    }

    public static void main(String[] args){
        //InnerClass in = new InnerClass();       // 在外部类的静态方法中不能直接实例化内部类

        // 先创建外部类对象后才能创建内部类对象
        OuterClass1 out = new OuterClass1();
        OuterClass1.InnerClass in = out.new InnerClass();
        // 外部类的非静态方法之所以可以创建内部类对象，是由于要访问外部类的非静态方法，必须通过外部类的对象访问，
        // 此时已经创建了外部类对象，满足了先外部对象，再内部对象的条件
        out.outMethod();
    }
}

3.1.2 成员内部类访问外部类

 成员内部类在访问外部类时，它有以下注意事项：

1）成员内部类访问外部类的非同名成员变量和方法：直接调用即可；

2）成员内部类访问外部类的同名成员变量和方法：外部类.this.成员变量 / 外部类.this.成员方法；

注：无论外部类的成员变量和方法是否使用private修饰，皆可访问。

public class OuterClass2 {
    private String outVar1 = "outVar1";
    private static String outVar2 = "outVar2";
    private String outVar3 = "outVar3";

    private void outerMethod(){
        System.out.println("outerMethod with same name of OuterClass");
    }

    private void outerMethod1(){
        System.out.println("outerMethod of OuterClass");
    }

    private static void outerMethod2(){
        System.out.println("static outerMethod of OuterClass");
    }

    class InnerClass{
        private String outVar3 = "innerVar3";

        private void outerMethod(){
            System.out.println("outerMethod with same name of InnerClass");
            System.out.println(outVar1);                      // 访问外部类成员变量
            System.out.println(outVar2);                      // 访问外部类静态成员变量
            System.out.println(OuterClass2.this.outVar3);     // 访问外部类同名成员变量
        }

        public void innerMethod(){
            outerMethod();                       // 访问自身的同名方法
            OuterClass2.this.outerMethod();      // 访问外部类的同名方法
            outerMethod1();                      // 访问外部类的实例方法
            outerMethod2();                      // 访问外部类的静态方法
        }
    }

    public static void main(String[] args){
        OuterClass2 out = new OuterClass2();
        OuterClass2.InnerClass in = out.new InnerClass();
        in.innerMethod();
    }
}

运行结果如下：

outerMethod with same name of InnerClass
outVar1
outVar2
outVar3
outerMethod with same name of OuterClass
outerMethod of OuterClass
static outerMethod of OuterClass

3.1.3 外部类访问成员内部类

外部类在访问成员内部类时，它有以下注意事项：

1）外部类访问成员内部类时必须通过内部类的对象访问；

public class OuterClass3 {

    class InnerClass{
        private String innerVar1 = "innerVar1";

        private void outerMethod1(){
            System.out.println("outerMethod with same name of InnerClass");
        }
    }

    private void outerMethod1(){
        System.out.println("outerMethod with same name of OuterClass");
        InnerClass in = new InnerClass();      // 通过内部类对象访问内部类的成员变量和方法
        System.out.println(in.innerVar1);
        in.outerMethod1();
    }

    private static void outerMethod2(){
        System.out.println("static method with same name of OuterClass");
       // InnerClass in = new InnerClass();      // error
        OuterClass3 out = new OuterClass3();     // 通过内部类对象访问内部类的成员变量和方法
        OuterClass3.InnerClass in = out.new InnerClass();
        in.outerMethod1();
    }

    public static void main(String[] args){
        OuterClass3 out = new OuterClass3();
        out.outerMethod1();
        outerMethod2();
    }
}

运行结果如下：

outerMethod with same name of OuterClass
innerVar1
outerMethod with same name of InnerClass
static method with same name of OuterClass
outerMethod with same name of InnerClass

 

3.2 静态内部类

3.2.1 静态内部类的说明和使用

静态内部类指使用static关键字修饰的内部类。非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外部类，

静态内部类却没有该引用，这是因为静态内部类是类级别的属性，不需要对象的引用（this）来调用。

它的特点如下：

0）加载外部类时不会直接加载静态内部类，当且仅当静态内部类的静态成员（静态域、构造器、静态方法等）被调用时才会加载；

1）静态内部类的对象创建不依赖于外部类；

2）静态内部类不能使用外部类的任何非静态成员变量和方法，只能访问静态成员变量和方法；

3）外部类可以通过类名.xx直接访问静态内部类的静态方法；

public class OuterClass4 {
    private String outVar1 = "outVar1";
    private static String outVar2 = "outVar2";
    private static String outVar3 = "outVar3";

    public void outMethod1(){
        InnerClass in = new InnerClass();
        System.out.println(in.outVar3);
    }

    private static void outMethod2(){
    }

    private static void outMethod3(){
        System.out.println(InnerClass.outVar4);          // 可以直接访问静态内部类的静态变量和方法
        InnerClass in = new InnerClass();
        in.innerMethod();
        System.out.println(in.outVar3);                  // 可以通过内部类对象访问实例变量和方法
    }

    static class InnerClass {
        private String outVar3 = "innerVar3";
        private static String outVar4 = "innerVar4";

        public InnerClass(){
//            System.out.println(outVar1);              // 不能访问外部类的非静态变量
            System.out.println(outVar2);                // 可以访问外部类的静态变量
            System.out.println(OuterClass4.outVar3);   //  可以访问外部类的同名静态变量

            //outMethod1();            // 不能访问外部类的非静态方法
            outMethod2();              // 可以访问外部类的静态方法
        }

        public void innerMethod(){
        }
    }

    public static void main(String[] args){
        InnerClass in = new InnerClass();       // 可以直接创建内部类对象
        System.out.println(in.outVar3);

        OuterClass4 out = new OuterClass4();
        out.outMethod1();
        outMethod3();
    }
}

 运行结果如下：

outVar2
outVar3
innerVar3
outVar2
outVar3
innerVar3
innerVar4
outVar2
outVar3
innerVar3

 

3.3 局部内部类

3.3.1局部内部类的说明和使用

局部内部类是定义在一个方法或者作用域中的类，它的使用仅限于其方法或者作用域内，出了方法和作用域就会失效，类似于局部变量。其特点如下：

1）局部内部类是定义在一个方法或者作用域中的类，它的访问权限仅限于其方法或者作用域内；

2）局部内部类类似方法和作用域中的局部变量，不能使用权限访问修饰符和static关键字修饰；

class Animal{ }

public class OuterClass5 {

    // 在方法中使用局部内部类
    private Animal getDog(){
        class Dog extends Animal{
        }
        return new Dog();
    }

    // 在作用域中使用局部内部类
    private Animal getCat(boolean flag){
        if(flag){
            class Cat extends Animal{
            }
            return new Cat();
        }
        return null;
    }

    public static void main(String[] args){
        OuterClass5 out = new OuterClass5();
        Animal a1 = out.getDog();
        Animal a2 = out.getCat(true);
        System.out.println(a1);
        System.out.println(a2);
    }
}

运行结果如下：

InnerClass.OuterClass5$1Dog@6d6f6e28
InnerClass.OuterClass5$1Cat@135fbaa4

 

3.4 匿名内部类

3.4.1 匿名内部类的说明

匿名内部类即是没有名称的内部类，它的使用前提和特点如下：

1）使用匿名内部类需要继承父类或者实现一个接口；

2）匿名内部类不能使用访问修饰符修饰；

3）匿名内部类不能是抽象类，因为在使用它时会直接创建该类的对象；

4）匿名内部类不能定义构造器，因为该类没有类名；

3.4.2 未在抽象类和接口上使用匿名内部类

对于一个抽象类和接口，通常需要使用一个类继承或实现它们，然后再实现其内部的方法，最后使用它。例如：

abstract class Parent{
    abstract int getNumber(int n);
}

class Child extends Parent{
    @Override
    int getNumber(int n) {
        return n;
    }
}

public class Demo {
    public static void main(String[] args){
        Parent p = new Child();
        System.out.println(p.getNumber(2));
    }
}

3.4.3 在抽象类上使用匿名内部类

对于上述抽象类Parent，我们显示地定义了一个Child类继承它，并且重写了其方法，有什么方法可以不写这个Child类呢？

这里引入匿名内部类即可，例如以下示例：

abstract class Parent {
    abstract int getNumber(int n);
}

public class Demo1 {
    public static void main(String[] args){
        Parent p = new Parent() {           // 注意，这里使用了匿名内部类 
            @Override
            public int getNumber(int n) {
                return n;
            }
        };
        System.out.println(p.getNumber(2));
    }
}

3.4.4 在接口上使用匿名内部类

interface Parent {
    int getNumber(int n);
}

public class Demo2 {
    public static void main(String[] args){
        // 直接使用
        Parent p1 = new Parent() {     // 没有出现类名
            @Override
            public int getNumber(int n) {
                return n;
            }
        };
        System.out.println(p1.getNumber(2));

        // 使用Lambda表达式
        Parent1 p2 = n -> n;
        System.out.println(p2.getNumber(2));
    }
}

 

4. 参考文献

https://www.runoob.com/w3cnote/java-inner-class-intro.html

https://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html

https://blog.csdn.net/guyuealian/article/details/51981163

https://www.cnblogs.com/chenssy/p/3388487.html

！！！