内部类

2020-06-08 约 5082 字预计阅读 11 分钟次阅读

概述

把类定义在另一个类的内部，该类就被称为内部类。

举例：把类Inner定义在类Outer中，类Inner就被称为内部类。

1
2
3
4


  class Outer {
      class Inner {
      }
  }

内部类的访问规则

可以直接访问外部类的成员，包括私有
外部类要想访问内部类成员，必须创建内部类对象

内部类的分类

成员内部类

成员内部类：就是位于外部类成员位置的类特点：可以使用外部类中所有的成员变量和成员方法（包括private的）

格式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package com.eh.ftd.inner;

public class InnerDemo {
    public static void main(String[] args) {
        // 成员内部类是非静态的演示
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

class Outer {
    private int age = 20;

    // 成员位置
    class Inner {
        public void show() {
            System.out.println(age);
        }
    }
}

对象创建

1
2
3
4
5


//成员内部类不是静态的：
外部类名.内部类名 对象名 = new 外部类名.new 内部类名();

//成员内部类是静态的：
外部类名.内部类名 对象名 = new 外部类名.内部类名();    

内部类常见修饰符

private

如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这样我们就无法通过创建对象的方法来访问，想要访问只需要在外部类中定义一个public修饰的方法，间接调用。这样做的好处就是，我们可以在这个public方法中增加一些判断语句，起到数据安全的作用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class Outer {
      private class Inner {
          public void show() {
              System.out.println(“密码备份文件”);
          }
      }
      //使用getXxx()获取成员内部类，可以增加校验语句（文中省略）
      public Inner getInner() {
          return new Inner();
      }
      
      public static void main(String[] args) {
          Outer outer = new Outer();
          Outer.Inner inner = outer.getInner();
          inner.show();
      }
  }

static

这种被 static 所修饰的内部类，按位置分，属于成员内部类，但也可以称作静态内部类，也常叫做嵌套内部类。具体内容我们在下面详细讲解。

成员内部类经典题

请在三个println 后括号中填空使得输出25,20,18

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Outer {
      public int age = 18;    
      class Inner {
          public int age = 20;    
          public viod showAge() {
              int age  = 25;
              System.out.println(age);//空1
              System.out.println(this.age);//空2
            // 当和外部类属性名重叠时，可通过外部类名.this.属性名
              System.out.println(Outer.this.age);//空3
          }
      }
  }

小结

可以是任何的访问修饰符。
内部类的内部不能有静态信息。
内部类也是类,该继承继承，该重写重写，该重载重载，this和super随便用。
外部类如何访问内部类信息，必须new之后打点访问。
内部类可以直接使用外部类的任何信息，如果属性或者方法发生冲突，调用外部类.this.属性或者方法。
其它类如何访问内部类：

1
2
3
4


Outer outer=new Outer();
//创造内部类对象
Outer.Inner inner=outer.new Inner();
inner.inner_show();

静态内部类

我们所知道static是不能用来修饰类的,但是成员内部类可以看做外部类中的一个成员,所以可以用static修饰,这种用static修饰的内部类我们称作静态内部类,也称作嵌套内部类. 特点：不能使用外部类的非static成员变量和成员方法

非静态内部类编译后会默认的保存一个指向外部类的引用，而静态类却没有。

即使没有外部类对象，也可以创建静态内部类对象，而外部类的非static成员必须依赖于对象的调用，静态成员则可以直接使用类调用，不必依赖于外部类的对象，所以静态内部类只能访问静态的外部属性和方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77


/**
 * 外部类、内部类定义
 */
public class Outer {

    private int outerVariable = 1;

    /**
     * 外部类定义的属性(重名)
     */
    private int commonVariable = 2;
    
    private static int outerStaticVariable = 3;

    static {
        System.out.println("Outer的静态块被执行了……");
    }

    /**
     * 成员方法
     */
    public void outerMothod() {
        System.out.println("我是外部类的outerMethod方法");
    }

    /*
    *	静态方法
    */
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }


    /**
     * 静态内部类
     */
    public static class Inner {
        /**
         * 成员信息
         */
        private int innerVariable = 10;
        private int commonVariable = 20;

        static {
            System.out.println("Outer.Inner的静态块执行了……");
        }

        private static int innerStaticVariable = 30;

        /**
         * 成员方法
         */
        public void innerShow() {
            System.out.println("innerVariable:" + innerVariable);
            System.out.println("内部的commonVariable:" + commonVariable);
            System.out.println("outerStaticVariable:"+outerStaticVariable);
            outerStaticMethod();
        }

        /**
         * 静态方法
         */
        public static void innerStaticShow() {
        	//被调用时会先加载Outer类
            outerStaticMethod();
            System.out.println("outerStaticVariable"+outerStaticVariable);
        }
    }

    /**
     * 外部类的内部如何和内部类打交道
     */
    public static void callInner() {
        System.out.println(Inner.innerStaticVariable);
        Inner.innerStaticShow();
    }
}

访问

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class Other {

    public static void main(String[] args) {
        //访问静态内部类的静态方法，Inner类被加载,此时外部类未被加载，独立存在，不依赖于外围类。
        Outer.Inner.innerStaticShow();
        //访问静态内部类的成员方法
        Outer.Inner oi = new Outer.Inner();
        oi.innerShow();
    }
}

加载

静态内部类的变量被调用时，我们可以看出外部类进行了加载（注：外部类中的静态代码块中的代码执行了），但是并没有被初始化（注：外部类的构造方法并没有执行，没有new对象肯定不会执行构造方法），且静态内部类也完成了加载。

因为调用静态内部类的变量，很有可能在静态内部内初始化时会调用外部静态变量，所以之前需要将外部内进行加载。

静态内部类和非静态内部类一样，都不会因为外部内的加载而加载，同时静态内部类的加载不需要依附外部类，在使用时才加载，不过在加载静态内部类的过程中也会加载外部类

小结

和成员内部类对比理解（区别异同）

内部可以包含任意的信息。
静态内部类的方法只能访问外部类的static关联的信息。
利用外部类.内部类引用=new 外部类.内部类(); 然后利用引用.成员信息(属性、方法)调用。
访问内部类的静态信息，直接外部类.内部类.静态信息就可以了。
静态内部类可以独立存在，不依赖于其他外围类。

局部内部类

局部内部类：就是定义在一个方法或者一个作用域里面的类特点：主要是作用域发生了变化，只能在自身所在方法和属性中被使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77


/**
 *	外部类、内部类
 */
public class Outer {
    /**
     * 属性和方法
     */
    private int outerVariable = 1;
    /**
     * 外部类定义的属性
     */
    private int commonVariable = 2;
    /**
     * 静态的信息
     */
    private static int outerStaticVariable = 3;

    /**
     * 成员外部方法
     */
    public void outerMethod() {
        System.out.println("我是外部类的outerMethod方法");
    }

    /**
     * 静态外部方法
     */
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }

    /**
     * 程序的入口
     */
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerCreatMethod(100);
    }

    /**
     * 成员方法，内部定义局部内部类
     */
    public void outerCreatMethod(int value) {
        /**
         * 女性
         */
        boolean sex = false;

        /**
         * 局部内部类，类前不能有访问修饰符
         */
        class Inner {

            private int innerVariable = 10;
            private int commonVariable = 20;
			/**
			*	局部内部类方法
			*/
            public void innerShow() {
                System.out.println("innerVariable:" + innerVariable);
                //局部变量
                System.out.println("是否男性:" + sex);
                System.out.println("参数value:" + value);
                //调用外部类的信息
                System.out.println("outerVariable:" + outerVariable);
                System.out.println("内部的commonVariable:" + commonVariable);
                System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
                System.out.println("outerStaticVariable:" + outerStaticVariable);
                outerMethod();
                outerStaticMethod();
            }
        }
        //局部内部类只能在方法内使用
        Inner inner = new Inner();
        inner.innerShow();
    }
}

小结

局部内有很多局限，应注意作用域

类前不能有访问修饰符。
仅在此方法内使用。
无法创造静态信息。
可以直接访问方法内的局部变量和参数（只能是final类型的，不能更改）
可以随意的访问外部类的任何信息。

匿名内部类

一个没有名字的类，是内部类的简化写法

格式

1
2
3


new 类名或者接口名() {
      重写方法();
}

本质：其实是继承该类或者实现接口的子类匿名对象，这也就是下例中，可以直接使用 new Inner() {}.show(); 的原因 == 子类对象.show();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


interface Inner {
      public abstract void show();
  }

  class Outer {
      public void method(){
          new Inner() {
              public void show() {
                  System.out.println("HelloWorld");
              }
          }.show();
      }
  }

  class Test {
      public static void main(String[] args)  {
          Outer o = new Outer();
          o.method();
      }
  }

如果匿名内部类中有多个方法又该如何调用呢？

1
2
3
4
5


Inter i = new Inner() {  //多态，因为new Inner(){}代表的是接口的子类对象
      public void show() {
      System.out.println("HelloWorld");
      }
  };

我们在开发的时候，会看到抽象类，或者接口作为参数。而这个时候，实际需要的是一个子类对象。如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

又比如常见的HashMap初始化写法

1
2
3
4
5
6


Map<String, Object> map = new HashMap<String, Object>() {
    　　{
        　　put("name", "June");  
       　　 put("age", 12);  
    　　}
　　};

第一个花括号表示一个匿名类继承了HashMap，第二个花括号是构造块的意思

然后将这个匿名内部类对象赋值给map。

小结

匿名内部类是没有访问修饰符的。
使用匿名内部类时，这个new之后的类首先是要存在的，其次我们要重写new后的类的某个或某些方法。
匿名内部类访问方法参数时也有和局部内部类同样的限制(在封闭范围中定义的局部变量必须是final的)。
匿名内部类没有构造方法。
匿名内部类的好处就在于不仅节省了定义实现类的过程，还能够自动向上转型。

使用内部类的原因

封装性

作为一个类的编写者，我们很显然需要对这个类的使用访问者的访问权限做出一定的限制，我们需要将一些我们不愿意让别人看到的操作隐藏起来，

如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这样我们就无法通过创建对象的方法来访问，想要访问只需要在外部类中定义一个public修饰的方法，间接调用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


public interface Demo {
      void show();
  }
  
  class Outer {
      private class test implements Demo {
          public void show() {
              System.out.println("密码备份文件");
          }
      }
      
      public Demo getInner() {
          return new test();
      }
      
  }

我们来看其测试

1
2
3
4
5
6
7
8


public static void main(String[] args) {
          Outer outer = new Outer();
          Demo d = outer.getInner();
          i.show();
      }

  //运行结果
  密码备份文件

这样做的好处之一就是，我们可以在这个public方法中增加一些判断语句，起到数据安全的作用。

其次呢，我们的对外可见的只是getInner()这个方法，它返回了一个Demo接口的一个实例，而我们真正的内部类的名称就被隐藏起来了

实现多继承

我们之前的学习知道，java是不可以实现多继承的，一次只能继承一个类，我们学习接口的时候，有提到可以用接口来实现多继承的效果，即一个接口有多个实现，但是这里也是有一点弊端的，那就是，一旦实现一个接口就必须实现里面的所有方法，有时候就会出现一些累赘，但是使用内部类可以很好的解决这些问题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


public class Demo1 {
      public String name() {
          return "BWH_Steven";
      }
  }
  
  public class Demo2 {
      public String email() {
          return "xxx.@163.com";
      }
  }
  
  public class MyDemo {

      private class test1 extends Demo1 {
          public String name() {
              return super.name();
          }
      }

      private class test2 extends Demo2  {
          public String email() {
              return super.email();
          }
      }

      public String name() {
          return new test1().name();
      }

      public String email() {
          return new test2().email();
      }

      public static void main(String args[]) {
          MyDemo md = new MyDemo();
          System.out.println("我的姓名:" + md.name());
          System.out.println("我的邮箱:" + md.email());
      }
  }

我们编写了两个待继承的类Demo1和Demo2，在MyDemo类中书写了两个内部类，test1和test2 两者分别继承了Demo1和Demo2类，这样MyDemo中就间接的实现了多继承

使用匿名内部类实现回调功能

我们用通俗讲解就是说在Java中，通常就是编写一个接口，然后你来实现这个接口，然后把这个接口的一个对象作以参数的形式传到另一个程序方法中，然后通过接口调用你的方法，匿名内部类就可以很好的展现了这一种回调功能

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


public interface Demo {
      void demoMethod();
  }
  
  public class MyDemo{
      public test(Demo demo){
          System.out.println("test method");
      }
      
      public static void main(String[] args) {
          MyDemo md = new MyDemo();
          //这里我们使用匿名内部类的方式将接口对象作为参数传递到test方法中去了
          md.test(new Demo){
              public void demoMethod(){
                  System.out.println("具体实现接口")
              }
          }
      }
  }

解决继承及实现接口出现同名方法的问题

编写一个接口 Demo

1
2
3


  public interface Demo {
      void test();
  }

编写一个类 MyDemo

1
2
3
4
5
6
7


  public class MyDemo {
  
      public void test() {
          System.out.println("父类的test方法");
      }
      
  }

编写一个测试类

1
2
3
4


  public class DemoTest extends MyDemo implements Demo {
      public void test() {
      }
  }

这样的话我就有点懵了，这样如何区分这个方法是接口的还是继承的，所以我们使用内部类解决这个问题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


  public class DemoTest extends MyDemo {
  
  
      private class inner implements Demo {
          public void test() {
              System.out.println("接口的test方法");
          }
      }
      
      public Demo getIn() {
          return new inner();
      }
      
      
      public static void main(String[] args) {
          //调用接口而来的test()方法
          DemoTest dt = new DemoTest();
          Demo d = dt.getIn();
          d.test();
          
          //调用继承而来的test()方法
          dt.test();
      }
  }
  
  //运行结果
  接口的test方法
  父类的test方法

目录

内部类

概述