码迷，mamicode.com
首页 > 其他好文 > 详细

内部类详解

时间：2014-06-21 00:59:23      阅读：285      评论：0      收藏：0      [点我收藏+]

标签：class   java   http   ext   com   get   

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

Java代码 
  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代码 
  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代码 
  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代码 
  1. OutClass.InnerClass obj = outClassInstance.new InnerClass();  


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

Java代码 
  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代码 
  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代码 
  1. public void test(){  
  2. ass Inner{  
  3.  public void method(){  
  4. ystem.out.println("在方法内创建的类");  
  5.  }  
  6.   
  7. }  


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

6、匿名内部类 
 

Java代码 
  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代码 
  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代码 
  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代码 
  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代码 
  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中匿名内部类用在字段初始化地方。 
这样定义的工厂方法，代码上看起来是不是优雅一些？bubuko.com,布布扣 

7、嵌套类 
static的内部类就叫做嵌套类 
前面提到了很多次，嵌套类是个例外 
使用嵌套类时有两点需要注意： 
   a、创建嵌套类对象时，不需要外围类 
   b、在嵌套类中，不能像普通内部类一样访问外围类的非static成员 

Java代码 
  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代码 
  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了，可以看看源代码~  

总结： 
  内部类的特性大致就是上述了，特性很直观，了解了之后，使用也很简单。 
  但是，何时使用我说的并不是很明确，因为本人知识有限，使用内部类也不是很多。项目中很少用，好像就是ActiveMQ那里用了一些。 
  不过，相信大家在了解了内部类的特性之后，再随着时间的推移，慢慢积累经验，应该会做出自己的判断，会在何时使用内部类，怎样应用了

内部类详解,布布扣,bubuko.com

内部类详解

标签：class   java   http   ext   com   get   

原文地址：http://www.cnblogs.com/isoftware/p/3795487.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！