内部类详解

我会带着你远行 2022-07-12 17:41 111阅读 0赞

内部类详解  
1、定义  
  一个类的定义放在另一个类的内部，这个类就叫做内部类。

Java代码   ![收藏代码][icon_star.png]

1.  public class First \{  
2.  public class Contents\{  
3.      public void f()\{  
4.      System.out.println("In Class First's inner Class Contents method f()");  
5.      \}  
6.  \}  
7.   \}

像这样的，Contents就叫做内部类  
内部类了解外围类，并能与之通信(后面详细讲)  
  
2、链接到外围类  
  创建了内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件。

Java代码   ![收藏代码][icon_star.png]

1.     public class First \{  
2.  public class Contents\{  
3.           public void getStr()\{  
4.          System.out.println("First.str="\+str);  
5.       \}  
6.  \}  
7.  private String str;  
8.      \}  
9.

在内部类Contents中，可以使用外围类First的字段str。  
  那么，它是如何实现的呢？  
  是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用，于是，可以通过这个引用来访问外围类的成员。  
  通常，这些都是编译器来处理，我们看不到，也不用关心这个。  
  正是因为如此，我们创建内部类对象时，必须与外围类对象相关联。  
  注：嵌套类(后面会讲到)除外。  
  
3、使用关键字.this与.new  
  内部类中得到当前外围类对象的引用，可以使用.this关键字，注意与new的区别

Java代码   ![收藏代码][icon_star.png]

1.      private int num ;  
2.  public Test2()\{  
3.        
4.  \}  
5.    
6.  public Test2(int num)\{  
7.      this.num = num;  
8.  \}  
9.    
10. private class Inner\{  
11.     public Test2 getTest2()\{  
12.         return Test2.this;  
13.     \}  
14.       
15.     public Test2 newTest2()\{  
16.         return new Test2();  
17.     \}  
18. \}  
19.   
20. public static void main(String \[\] args)\{  
21.     Test2 test = new Test2(5);  
22.     Test2.Inner inner = test.new Inner();  
23.     Test2 test2 = inner.getTest2();  
24.     Test2 test3 = inner.newTest2();  
25.     System.out.println(test2.num);  
26.     System.out.println(test3.num);  
27. \}  
28.

输出结果为5 0  
  使用.this后，得到时创建该内部类时使用的外围类对象的引用，new则是创建了一个新的引用。  
  
  .new关键字  
  如果想直接创建一个内部类对象，而不是通过外围类对象的方法来得到，可以使用.new关键字  
  形式是这样的：

Java代码   ![收藏代码][icon_star.png]

1.  OutClass.InnerClass obj = outClassInstance.new InnerClass();

必须是外围类对象.new，而不能是外围类.new

Java代码   ![收藏代码][icon_star.png]

1.     public class First \{  
2.  public class Contents\{  
3.      public void f()\{  
4.          System.out.println("In Class First's inner Class Contents method f()");  
5.      \}  
6.      public void getStr()\{  
7.          System.out.println("First.str="\+str);  
8.      \}  
9.  \}  
10.   
11. public static void main(String \[\] args)\{  
12.     First first = new First();  
13.     First.Contents contents = first.new Contents();  
14.     contents.f();  
15. \}  
16.     \}  
17.

必须通过外围类First的对象first来创建一个内部类的对象  
  而且需要注意的是，在创建外围类对象之前，不可能创建内部类的对象(嵌套类除外)。  
4、内部类与向上转型  
  将内部类向上转型为基类型，尤其是接口时，内部类就有了用武之地。

Java代码   ![收藏代码][icon_star.png]

1.      public interface Shape \{  
2.  public void paint();  
3.      \}  
4.      public class Painter \{  
5.        
6.         private class InnerShape implements Shape\{  
7.      public void paint()\{  
8.          System.out.println("painter paint() method");  
9.      \}  
10. \}  
11.   
12. public Shape getShape()\{  
13.     return new InnerShape();  
14. \}     
15.       
16.        public static void main(String \[\]args)\{  
17.     Painter painter = new Painter();  
18.     Shape shape = painter. getShape();  
19.     shape.paint();  
20. \}  
21.     \}  
22.

此时，内部类是private的，可以它的外围类Painter以外，没人能访问。  
  这样,private内部类给累的设计者提供了一种途径，通过这种方式可以完全阻止任何依赖于类型的编码，并完全隐藏实现的细节。  
  
5、方法内的类  
  可以在方法内创建一个类。

Java代码   ![收藏代码][icon_star.png]

1.  public void test()\{  
2.  ass Inner\{  
3.   public void method()\{  
4.  ystem.out.println("在方法内创建的类");  
5.   \}  
6.    
7.  \}

值得注意的是：方法内创建的类，不能加访问修饰符。  
  另外，方法内部的类也不是在调用方法时才会创建的，它们一样也被编译了(怎么知道的？后面会有讲解)。  
  
6、匿名内部类

Java代码   ![收藏代码][icon_star.png]

1.    public class Painter \{  
2.  ublic Shape getShape()\{  
3.  return new Shape()\{  
4.      public void paint()\{  
5.          System.out.println("painter paint() method");  
6.      \}  
7.  \};  
8.    
9.        public static void main(String \[\] args)\{  
10.             Painter painter = new Painter();  
11.             Shape shape = painter.getShape();  
12.             shape.paint();  
13.       \}  
14.   \}  
15.   public interface Shape \{  
16. ublic void paint();  
17.   \}

注意，匿名内部类后面的分号不可缺少！  
   匿名类，顾名思义，就是没有名称。  
  getShape（）方法里，就使用了匿名内部类。  
  看上去很奇怪，不符合传统的写法？  
  第一眼看上去确实是这样的。  
  
  这样写，意思是创建了一个实现了Shape的匿名类的对象。  
  匿名类可以创建，接口，抽象类，与普通类的对象。创建接口时，必须实现接口中所有方法。  
   
  这是无参的，如果需要参数呢？  
  可以直接传。

Java代码   ![收藏代码][icon_star.png]

1.     public class B \{  
2.  public A getA(int num)\{  
3.      return new A(num)\{  
4.            
5.      \};  
6.  \}  
7.     \}  
8.     public class A \{  
9.  private int num;  
10. public A(int num)\{  
11.     this.num = num;  
12. \}  
13. public A()\{  
14.       
15. \}  
16.    \}  
17.

Ok，在这个例子中，可以为A的构造方法传入一个参数。在匿名内部类中，并没有使用到这个参数。  
  如果使用到了这个参数，那么这个参数就必须是final的。

Java代码   ![收藏代码][icon_star.png]

1.     public class B \{  
2.  public A getA(final int num)\{  
3.      return new A(num)\{  
4.         public int getNum()\{  
5.                       return num;  
6.                    \}  
7.      \};  
8.  \}  
9.     \}  
10.    public class A \{  
11. private int num;  
12. public A(int num)\{  
13.     this.num = num;  
14. \}  
15. public A()\{  
16.       
17. \}  
18.    \}  
19.

如果不是final的，编译器就会提示出错。  
  另外，还可以在匿名内部类里定义属性  
  由于类是匿名的，自然没有构造器，如果想模仿构造器，可以采用实例初始化(\{\})

Java代码   ![收藏代码][icon_star.png]

1.     public A getA()\{  
2.  return new A()\{  
3.      int num = 0;  
4.      String str;  
5.      \{  
6.          str = "javaeye";  
7.          System.out.println("hello robbin");  
8.      \}  
9.  \};  
10.    \}  
11.

匿名内部类通过实例初始化，可以达到类似构造器的效果~  
  
另外可以通过匿名内部类来改造工厂方法。

Java代码   ![收藏代码][icon_star.png]

1.    public interface Service \{  
2.  public void method1();  
3.    \}  
4.    public interface ServiceFactory \{  
5.  Service getService();  
6.    \}  
7.    public class Implemention1 implements Service\{  
8.  public void method1()\{  
9.      System.out.println("In Implemention1 method method1()");  
10. \}  
11.   
12. public static ServiceFactory factory = new ServiceFactory()\{  
13.     public Service getService()\{  
14.         return new Implemention1();  
15.     \}  
16. \};  
17.   \}  
18.   public class Implemention2 implements Service \{  
19. public void method1()\{  
20.     System.out.println("in Implemention2 method method1()");  
21. \}  
22.   
23. public static ServiceFactory factory = new ServiceFactory()\{  
24.     public Service getService()\{  
25.         return new Implemention2();  
26.     \}  
27. \};  
28.   
29.   \}  
30.   public class Test \{  
31. public static void main(String \[\]args)\{  
32.     service(Implemention1.factory);  
33.     service(Implemention2.factory);  
34.       
35.     ServiceFactory factory1 = Implemention1.factory;  
36.     Service service1 = factory1.getService();  
37.     service1.method1();  
38.       
39.     ServiceFactory factory2 = Implemention1.factory;  
40.     Service service2 = factory2.getService();  
41.     service2.method1();  
42. \}  
43.   \}

在Implemention1和2中匿名内部类用在字段初始化地方。  
这样定义的工厂方法，代码上看起来是不是优雅一些？ ![icon_redface.gif][]  
  
7、嵌套类  
static的内部类就叫做嵌套类  
前面提到了很多次，嵌套类是个例外  
使用嵌套类时有两点需要注意：  
   a、创建嵌套类对象时，不需要外围类  
   b、在嵌套类中，不能像普通内部类一样访问外围类的非static成员

Java代码   ![收藏代码][icon_star.png]

1.    public class StaticClass \{  
2.  private int num;  
3.  private static int sum = 2;  
4.  private static class StaticInnerClass\{  
5.      public int getNum()\{  
6.      //只能访问sum，不能访问num  
7.                 return sum;  
8.      \}  
9.  \}  
10.   \}  
11.   public class Test \{  
12. public static void main(String \[\] args)\{  
13.                //可以直接通过new来创建嵌套类对象  
14.     StaticClass.StaticInnerClass inner = new StaticClass.StaticInnerClass();  
15.     inner.getNum();  
16. \}  
17.   \}

另外，嵌套类还有特殊之处，就是嵌套类中可以有static方法，static字段与嵌套类，而普通内部类中不能有这些。  
  
  8、内部类标识符  
  我们知道每个类会产生一个.class文件，文件名即为类名  
  同样，内部类也会产生这么一个.class文件，但是它的名称却不是内部类的类名，而是有着严格的限制：外围类的名字，加上$,再加上内部类名字。  
  前面说到得定义在方法内的内部类，不是在调用方法时生成，而是与外围类一同编译，就可以通过查看.class文件的方式来证明。  
  
  9、为何要内部类？  
    a、内部类提供了某种进入外围类的窗户。  
    b、也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外围类是否已经继承了某个接口。  
  因此，内部类使多重继承的解决方案变得更加完整。  
  在项目中，需要多重继承，如果是两个接口，那么好办，接口支持多重继承。  
  如果是两个类呢？这时只有使用内部类了。

Java代码   ![收藏代码][icon_star.png]

1.     public interface One \{  
2.  public void inOne();  
3.     \}  
4.     public interface Two \{  
5.  public void inTwo();  
6.     \}  
7.     //两个接口，用普通类就可实现多重继承  
8.     public class CommonClass implements One,Two \{  
9.  public void inOne()\{  
10.     System.out.println("CommonClass inOne() method");  
11. \}  
12.   
13. public void inTwo()\{  
14.     System.out.println("CommonClass inTwo() method");  
15. \}  
16.    \}  
17.    public abstract class Three \{  
18. public abstract void inThree();  
19.    \}  
20.    public abstract class Four \{  
21. public abstract void inFour();  
22.    \}  
23.    //两个抽象类，使用普通类无法实现多重继承  
24.      
25.    //使用内部类可以实现  
26.    public class Contents extends Three \{  
27. public void inThree()\{  
28.     System.out.println("In Contents inThress() method");  
29. \}  
30.   
31. public class InnerFour extends Four\{  
32.     public void inFour()\{  
33.         System.out.println("In Contents");  
34.     \}  
35.       
36. \}  
37.    \}  
38.

另外，还有好多地方可以使用内部类。读过hibernate源代码的同学，应该可以发现，里面有好多内部类。  
  最常见的内部类，应该是Map.Entry了，可以看看源代码~

[icon_star.png]: /images/20220709/b488d20119fd46369995ded60274a925.png
[icon_redface.gif]: /images/20220709/31b1cb67e2b7458a9c0116d246cd5611.png