<rt id="bn8ez"></rt>
<label id="bn8ez"></label>
  • 

    • <span id="bn8ez"></span>
    

    <label id="bn8ez"><meter id="bn8ez"></meter></label>
    

    
    

    




    







												


        



    
	
    
		
			


    
	
    

    posts - 12, comments - 8, trackbacks - 0, articles - 5
    
	
 
BlogJava ::
首頁 ::
新隨筆 ::
聯系 ::
聚合
 ::
管理


    
		    		
	
    
	
    
		
			
    
			
    
		    		
		
			
    
				
					
	
    
		
    
			
    
				java內部類詳解
			
    
 			Posted on 2010-11-25 16:27 楊羅羅 閱讀(5034) 評論(1)  編輯  收藏  所屬分類: java.syntax 
			
			


		
    
		
    內部類詳解 
    
1、定義 
    
  一個類的定義放在另一個類的內部，這個類就叫做內部類。 
    

    

    

    

    Java代碼 
    

    

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

    

    


    
像這樣的，Contents就叫做內部類 
    
內部類了解外圍類，并能與之通信(后面詳細講) 
    

    
2、鏈接到外圍類 
    
  創建了內部類對象時，它會與創造它的外圍對象有了某種聯系，于是能訪問外圍類的所有成員，不需任何特殊條件。 
    
  
    

    

    

    Java代碼 
    

    

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

    

    


    
  在內部類Contents中，可以使用外圍類First的字段str。 
    
  那么，它是如何實現的呢？ 
    
  是這樣的，用外圍類創建內部類對象時，此內部類對象會秘密的捕獲一個指向外圍類的引用，于是，可以通過這個引用來訪問外圍類的成員。 
    
  通常，這些都是編譯器來處理，我們看不到，也不用關心這個。 
    
  正是因為如此，我們創建內部類對象時，必須與外圍類對象相關聯。 
    
  注：嵌套類(后面會講到)除外。 
    

    
3、使用關鍵字.this與.new 
    
  內部類中得到當前外圍類對象的引用，可以使用.this關鍵字，注意與new的區別 
    
  
    

    

    

    Java代碼 
    

    

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

    

    


    
  輸出結果為5 0 
    
  使用.this后，得到時創建該內部類時使用的外圍類對象的引用，new則是創建了一個新的引用。 
    

    
  .new關鍵字 
    
  如果想直接創建一個內部類對象，而不是通過外圍類對象的方法來得到，可以使用.new關鍵字 
    
  形式是這樣的： 
    
  
    

    

    

    Java代碼 
    

    

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

    

    


    
  必須是外圍類對象.new，而不能是外圍類.new 
    
  
    

    

    

    Java代碼 
    

    

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

    

    


    
  必須通過外圍類First的對象first來創建一個內部類的對象 
    
  而且需要注意的是，在創建外圍類對象之前，不可能創建內部類的對象(嵌套類除外)。 
    
4、內部類與向上轉型 
    
  將內部類向上轉型為基類型，尤其是接口時，內部類就有了用武之地。 
    
  
    

    

    

    Java代碼 
    

    

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

    

    


    
  此時，內部類是private的，可以它的外圍類Painter以外，沒人能訪問。 
    
  這樣,private內部類給累的設計者提供了一種途徑，通過這種方式可以完全阻止任何依賴于類型的編碼，并完全隱藏實現的細節。 
    

    
5、方法內的類 
    
  可以在方法內創建一個類。 
    
  
    

    

    

    Java代碼 
    

    

      
    
    1. public void test(){  
      2. 
    
    2. ass Inner{  
      3. 
    
    3.  public void method(){  
      4. 
    
    4. ystem.out.println("在方法內創建的類");  
      5. 
    
    5.  }  
      6. 
    
    6.   
      7. 
    
    7. }  
      8. 

    

    


    
  值得注意的是：方法內創建的類，不能加訪問修飾符。 
    
  另外，方法內部的類也不是在調用方法時才會創建的，它們一樣也被編譯了(怎么知道的？后面會有講解)。 
    

    
6、匿名內部類 
    
  
    

    

    

    Java代碼 
    

    

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

    

    


    
  注意，匿名內部類后面的分號不可缺少！ 
    
   匿名類，顧名思義，就是沒有名稱。 
    
  getShape（）方法里，就使用了匿名內部類。 
    
  看上去很奇怪，不符合傳統的寫法？ 
    
  第一眼看上去確實是這樣的。 
    

    
  這樣寫，意思是創建了一個實現了Shape的匿名類的對象。 
    
  匿名類可以創建，接口，抽象類，與普通類的對象。創建接口時，必須實現接口中所有方法。 
    
  
    
  這是無參的，如果需要參數呢？ 
    
  可以直接傳。 
    
  
    

    

    

    Java代碼 
    

    

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

    

    


    
  Ok，在這個例子中，可以為A的構造方法傳入一個參數。在匿名內部類中，并沒有使用到這個參數。 
    
  如果使用到了這個參數，那么這個參數就必須是final的。 
    
  
    

    

    

    Java代碼 
    

    

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

    

    


    
  如果不是final的，編譯器就會提示出錯。 
    
  另外，還可以在匿名內部類里定義屬性 
    
  由于類是匿名的，自然沒有構造器，如果想模仿構造器，可以采用實例初始化({}) 
    
  
    

    

    

    Java代碼 
    

    

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

    

    


    
  匿名內部類通過實例初始化，可以達到類似構造器的效果~ 
    

    
另外可以通過匿名內部類來改造工廠方法。 
    

    

    

    

    Java代碼 
    

    

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

    

    


    
在Implemention1和2中匿名內部類用在字段初始化地方。 
    
這樣定義的工廠方法，代碼上看起來是不是優雅一些？ 
    

    
7、嵌套類 
    
static的內部類就叫做嵌套類 
    
前面提到了很多次，嵌套類是個例外 
    
使用嵌套類時有兩點需要注意： 
    
   a、創建嵌套類對象時，不需要外圍類 
    
   b、在嵌套類中，不能像普通內部類一樣訪問外圍類的非static成員 
    

    

    

    

    Java代碼 
    

    

      
    
    1.   public class StaticClass {  
      2. 
    
    2. private int num;  
      3. 
    
    3. private static int sum = 2;  
      4. 
    
    4. private static class StaticInnerClass{  
      5. 
    
    5.     public int getNum(){  
      6. 
    
    6.     //只能訪問sum，不能訪問num  
      7. 
    
    7.                return sum;  
      8. 
    
    8.     }  
      9. 
    
    9. }  
      10. 
    
    10.   }  
      11. 
    
    11.   public class Test {  
      12. 
    
    12. public static void main(String [] args){  
      13. 
    
    13.                //可以直接通過new來創建嵌套類對象  
      14. 
    
    14.     StaticClass.StaticInnerClass inner = new StaticClass.StaticInnerClass();  
      15. 
    
    15.     inner.getNum();  
      16. 
    
    16. }  
      17. 
    
    17.   }  
      18. 

    

    


    
  另外，嵌套類還有特殊之處，就是嵌套類中可以有static方法，static字段與嵌套類，而普通內部類中不能有這些。 
    

    
  8、內部類標識符 
    
  我們知道每個類會產生一個.class文件，文件名即為類名 
    
  同樣，內部類也會產生這么一個.class文件，但是它的名稱卻不是內部類的類名，而是有著嚴格的限制：外圍類的名字，加上$,再加上內部類名字。 
    
  前面說到得定義在方法內的內部類，不是在調用方法時生成，而是與外圍類一同編譯，就可以通過查看.class文件的方式來證明。 
    

    
  9、為何要內部類？ 
    
    a、內部類提供了某種進入外圍類的窗戶。 
    
    b、也是最吸引人的原因，每個內部類都能獨立地繼承一個接口，而無論外圍類是否已經繼承了某個接口。 
    
  因此，內部類使多重繼承的解決方案變得更加完整。 
    
  在項目中，需要多重繼承，如果是兩個接口，那么好辦，接口支持多重繼承。 
    
  如果是兩個類呢？這時只有使用內部類了。 
    
  
    

    

    

    Java代碼 
    

    

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

    

    


    
  另外，還有好多地方可以使用內部類。讀過hibernate源代碼的同學，應該可以發現，里面有好多內部類。 
    
  最常見的內部類，應該是Map.Entry了，可以看看源代碼~  
    

    
總結： 
    
  內部類的特性大致就是上述了，特性很直觀，了解了之后，使用也很簡單。 
    
  但是，何時使用我說的并不是很明確，因為本人知識有限，使用內部類也不是很多。項目中很少用，好像就是ActiveMQ那里用了一些。 
    
  不過，相信大家在了解了內部類的特性之后，再隨著時間的推移，慢慢積累經驗，應該會做出自己的判斷，會在何時使用內部類，怎樣應用了
    

    
	
    
	


    
	    
    

    

    評論
    
	
			
    
				
    
					
    
						# re: java內部類詳解[未登錄]  回復  更多評論
						  
					
    
					2014-07-14 13:58 by aaa
				
    
				
    總結的很好，部分代碼有點不完整...
    
			
    
		




    





    


    

	
    
		
    
				
		
	
		
    
		
		
    只有注冊用戶登錄后才能發表評論。
    
		
    
			
		
    
			
		
    
		
		
    
		


    

		    		
		
    
		
    			
		
		
		
		
    
		
    
		
		
    
		
    
			網站導航:
		
		
    
		
    
			
		
    	
		
    
			 
		
    
		
    
			
		
    
		
    
			
				
		
    		
	
    	

    



    

				
			
    
		    		
	
    
	
    
		
			


		
	
    

    


    







    
        
	



主站蜘蛛池模板：
最近中文字幕免费2019|
久久久久亚洲精品美女|
亚洲视频在线免费看|
国产97视频人人做人人爱免费|
在线a亚洲老鸭窝天堂av高清|
亚洲国产精品嫩草影院在线观看|
亚洲国产精品视频|
在线观看免费国产视频|
免费无码AV电影在线观看|
30岁的女人韩剧免费观看|
APP在线免费观看视频|
国产三级在线免费观看|
色多多A级毛片免费看|
国产AV无码专区亚洲AV蜜芽
|
99亚洲乱人伦aⅴ精品|
亚洲高清中文字幕免费|
亚洲国产人成在线观看|
亚洲视频在线一区二区三区|
久久亚洲精品AB无码播放|
亚洲色精品88色婷婷七月丁香|
亚洲视频在线免费|
亚洲国产成人精品女人久久久|
国产高清在线精品免费软件|
免费看美女让人桶尿口|
24小时免费直播在线观看|
毛片免费观看视频|
蜜桃视频在线观看免费网址入口|
国产成在线观看免费视频|
国产无人区码卡二卡三卡免费|
午夜福利不卡片在线播放免费|
AV无码免费永久在线观看|
最近免费中文字幕大全高清大全1
最近免费中文字幕mv在线电影
|
亚洲精品在线播放|
亚洲女人影院想要爱|
亚洲精品二三区伊人久久|
亚洲三级高清免费|
国产精品亚洲av色欲三区|
免费很黄无遮挡的视频毛片|
黄床大片免费30分钟国产精品|
中文字幕一区二区免费|
久久香蕉国产线看免费|