目录

内部类

转载自:java内部类有什么作用?

概述

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

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

1
2
3
4
  class Outer {
      class Inner {
      }
  }

内部类的访问规则

  1. 可以直接访问外部类的成员,包括私有

  2. 外部类要想访问内部类成员,必须创建内部类对象

内部类的分类

成员内部类

成员内部类:就是位于外部类成员位置的类 特点:可以使用外部类中所有的成员变量和成员方法(包括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
          }
      }
  }

小结

  1. 可以是任何的访问修饰符。
  2. 内部类的内部不能有静态信息。
  3. 内部类也是类,该继承继承,该重写重写,该重载重载,this和super随便用。
  4. 外部类如何访问内部类信息,必须new之后打点访问。
  5. 内部类可以直接使用外部类的任何信息,如果属性或者方法发生冲突,调用外部类.this.属性或者方法。
  6. 其它类如何访问内部类:
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对象肯定不会执行构造方法),且静态内部类也完成了加载。

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

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

小结

和成员内部类对比理解(区别异同)

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

局部内部类

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

 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();
    }
}

小结

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

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

匿名内部类

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

格式

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。

小结

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

使用内部类的原因

封装性

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

如果我们的内部类不想轻易被任何人访问,可以选择使用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方法