【第三章】面向对象——内部类

1.内部类

1.1 概念

在Java中，允许在一个类的内部定义类，这样的类称作内部类，内部类所在的类称作外部类。

在实际开发中，根据内部类的位置、修饰符和定义方式的不同，内部类可分为4种，分别是成员内部类、局部内部类、静态内部类、匿名内部类。

1.1 成员内部类

在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。成员内部类可以访问外部类的所有成员。

接下来通过一个案例学习如何定义成员内部类。

1 class Outer {
2    int m = 0; 		// 定义类的成员变量
3   // 下面的代码定义了一个成员方法，方法中访问内部类
4    void test1() {
5       System.out.println("外部类成员方法");
6    }
7    // 下面的代码定义了一个成员内部类
8    class Inner {
9        int n = 1;
10        void show1() {
11           // 在成员内部类的方法中访问外部类的成员变量
12           System.out.println("外部成员变量m = " + m);
13       }
14 void show2() {
15            // 在成员内部类的方法中访问外部类的成员变量
16           System.out.println("内部成员方法");
17       }
18    }
19    void test2() {
20        Inner inner = new Inner();
21        System.out.println("内部成员变量n = " + inner.n);
22        inner.show2();
23    }
24 }
25 public class Example20 {
26    public static void main(String[] args) {
27        Outer outer = new Outer();
28        Outer.Inner inner = outer.new Inner();
29        inner.show1();
30       outer.test2();
31    }
32 }

上述代码中，第1~24行代码定义了一个Outer类，Outer类就是一个外部类。第8~23行代码是在Outer类内部定义了Inner类，Inner类就是Outer类的成员内部类。Outer类中定义了test1()和test2()两个方法。Inner类定义了一个show()方法，在show()方法中访问外部类的成员变量num；test2()方法中创建了内部类Inner的实例对象，并通过该对象调用show()方法，将num值输出。从运行结果可以看出，内部类可以在外部类中使用，并能访问外部类的成员。

如果想通过外部类访问内部类，则需要通过外部类创建内部类对象，创建内部类对象的具体语法格式如下：

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

1.2 局部内部类

局部内部类，也叫作方法内部类，是指定义在某个局部范围中的类，它和局部变量一样，都是在方法中定义的，有效范围只限于方法内部。

在局部内部类中，局部内部类可以访问外部类的所有成员变量和方法，而局部内部类中变量和方法却只能在所属方法中访问。

接下来通过一个案例学习局部内部类的定义和使用。

1 class Outer {
2     int m = 0;  		// 定义类的成员变量
3    // 下面的代码定义了一个成员方法，方法中访问内部类
4     void test1() {
5        System.out.println("外部类成员方法");
6    }
7 void test2() {
8        // 下面的代码定义了一个成员内部类
9        class Inner {
10            int n = 1;
11            void show() {
12                // 在成员内部类的方法中访问外部类的成员变量
13                System.out.println("外部成员变量m = " + m);
14                test1();
15           }
16        }
17        Inner inner = new Inner();
18        System.out.println("局部内部类变量n = " + inner.n);
19        inner.show();
20  }
21}
22 public class Example21 {
23    public static void main(String[] args) {
24        Outer outer = new Outer();
25        outer.test2();
26    }
27 }

在上述代码中，第1~21行代码定义了一个外部类Outer，并在该类中定义了成员变量m、成员方法test1()和test2()。第9~15行代码是在外部类的成员方法test2()中定义了一个局部内部类Inner；然后在局部内部类Inner中，编写了show()方法。第13~14行代码是对外部类变量和方法的调用；第17~19行代码是在test2()方法中创建了局部内部类Inner对象，并调用局部内部类的方法和变量。

2.3 静态内部类

所谓静态内部类，就是使用static关键字修饰的成员内部类。与成员内部类相比，在形式上，静态内部类只是在内部类前增加了static关键字，但在功能上，静态内部类只能访问外部类的静态成员，通过外部类访问静态内部类成员时，可以跳过外部类直接访问静态内部类。

创建静态内部类对象的基本语法格式如下：

外部类名.静态内部类名 变量名 = new 外部类名().静态内部类名();

接下来通过一个案例学习静态内部类的定义和使用。

1 class Outer {
2    static int m = 0; // 定义类的成员变量
3    // 下面的代码定义了一个静态内部类
4    static class Inner {
5         int n = 1;
6         void show() {
7             // 在静态内部类的方法中访问外部类的成员变量
8             System.out.println("外部静态变量m = " + m);
9           }
10     }
11  }
12 public class Example22 {
13    public static void main(String[] args) {
14        Outer.Inner inner = new Outer.Inner();
15        inner.show();
16    }
17 }
12 public class Example22 {
13    public static void main(String[] args) {
14        Outer.Inner inner = new Outer.Inner();
15        inner.show();
16    }
17 }

上述代码中，第1~11行代码定义了一个外部类Outer，其中第2~10行代码是在Outer类中定义了静态成员变量和静态内部类Inner。然后在静态内部类Inner中，编写了一个show()方法，在show()方法中打印了外部静态变量m，第14~15行代码是声明了一个内部类对象inner，并使用inner对象调用show()方法测试对外部类静态变量m的调用。

2.4 匿名内部类

匿名内部类是没有名称的内部类。

在Java中调用某个方法时，如果该方法的参数是接口类型，除了可以传入一个接口实现类，还可以使用实现接口的匿名内部类作为参数，在匿名内部类中直接完成方法的实现。

创建匿名内部类的基本语法格式如下：

new 父接口(){

   //匿名内部类实现部分

}

1 interface Animal{
2   void shout();
3 }
4 public class Example23{
5    public static void main(String[] args){
6        String name = "小花";
7        animalShout(new Animal(){
8           @Override
9            public void shout() {
10                System.out.println(name+"喵喵...");
11            }
12       });
13   }
14   public static void animalShout(Animal an){
15       an.shout();
16    }
17 }

第1~3行代码创建了Animal接口；第7~12行代码是调用animalShout()方法，将实现Animal接口的匿名内部类作为animalShout()方法的参数，并在匿名内部类中重写了Animal接口的show()方法。

在上述代码中的匿名内部类中访问了局部变量name，而局部变量name并没有使用final修饰符修饰，程序也没有报错。这是JDK 8的新增特性，允许在局部内部类、匿名内部类中访问非final修饰的局部变量，而在JDK 8之前，局部变量前必须加final修饰符，否则程序编译时报错。

匿名类的编写步骤：

（1）在调用animalShout()方法时，在方法的参数位置写上new Animal(){}，这相当于创建了一个实例对象，并将对象作为参数传给animalShout()方法。在new Animal()后面有一对大括号，表示创建的对象为Animal的子类实例，该子类是匿名的。具体代码如下所示：

animalShout(new Animal(){});

（2）在大括号中编写匿名子类的实现代码，具体如下所示：

animalShout(new Animal() {

  public void shout() {

  System.out.println("喵喵……");

  }

});