<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 ::
首頁 ::
新隨筆 ::
聯(lián)系 ::
聚合
 ::
管理


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


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

    

    

    

    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就叫做內(nèi)部類 
    
內(nèi)部類了解外圍類，并能與之通信(后面詳細講) 
    

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

    

    

    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. 

    

    


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

    
3、使用關(guān)鍵字.this與.new 
    
  內(nèi)部類中得到當(dāng)前外圍類對象的引用，可以使用.this關(guān)鍵字，注意與new的區(qū)別 
    
  
    

    

    

    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. 

    

    


    
  輸出結(jié)果為5 0 
    
  使用.this后，得到時創(chuàng)建該內(nèi)部類時使用的外圍類對象的引用，new則是創(chuàng)建了一個新的引用。 
    

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

    

    

    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來創(chuàng)建一個內(nèi)部類的對象 
    
  而且需要注意的是，在創(chuàng)建外圍類對象之前，不可能創(chuàng)建內(nèi)部類的對象(嵌套類除外)。 
    
4、內(nèi)部類與向上轉(zhuǎn)型 
    
  將內(nèi)部類向上轉(zhuǎn)型為基類型，尤其是接口時，內(nèi)部類就有了用武之地。 
    
  
    

    

    

    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. 

    

    


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

    
5、方法內(nèi)的類 
    
  可以在方法內(nèi)創(chuàng)建一個類。 
    
  
    

    

    

    Java代碼 
    

    

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

    

    


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

    
6、匿名內(nèi)部類 
    
  
    

    

    

    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. 

    

    


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

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

    

    

    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的構(gòu)造方法傳入一個參數(shù)。在匿名內(nèi)部類中，并沒有使用到這個參數(shù)。 
    
  如果使用到了這個參數(shù)，那么這個參數(shù)就必須是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的，編譯器就會提示出錯。 
    
  另外，還可以在匿名內(nèi)部類里定義屬性 
    
  由于類是匿名的，自然沒有構(gòu)造器，如果想模仿構(gòu)造器，可以采用實例初始化({}) 
    
  
    

    

    

    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. 

    

    


    
  匿名內(nèi)部類通過實例初始化，可以達到類似構(gòu)造器的效果~ 
    

    
另外可以通過匿名內(nèi)部類來改造工廠方法。 
    

    

    

    

    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中匿名內(nèi)部類用在字段初始化地方。 
    
這樣定義的工廠方法，代碼上看起來是不是優(yōu)雅一些？ 
    

    
7、嵌套類 
    
static的內(nèi)部類就叫做嵌套類 
    
前面提到了很多次，嵌套類是個例外 
    
使用嵌套類時有兩點需要注意： 
    
   a、創(chuàng)建嵌套類對象時，不需要外圍類 
    
   b、在嵌套類中，不能像普通內(nèi)部類一樣訪問外圍類的非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來創(chuàng)建嵌套類對象  
      14. 
    
    14.     StaticClass.StaticInnerClass inner = new StaticClass.StaticInnerClass();  
      15. 
    
    15.     inner.getNum();  
      16. 
    
    16. }  
      17. 
    
    17.   }  
      18. 

    

    


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

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

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

    

    

    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.    //兩個接口，用普通類就可實現(xiàn)多重繼承  
      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.    //兩個抽象類，使用普通類無法實現(xiàn)多重繼承  
      24. 
    
    24.      
      25. 
    
    25.    //使用內(nèi)部類可以實現(xiàn)  
      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. 

    

    


    
  另外，還有好多地方可以使用內(nèi)部類。讀過hibernate源代碼的同學(xué)，應(yīng)該可以發(fā)現(xiàn)，里面有好多內(nèi)部類。 
    
  最常見的內(nèi)部類，應(yīng)該是Map.Entry了，可以看看源代碼~  
    

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

    
	
    
	


    
	    
    

    

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




    





    


    

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


    

		    		
		
    
		
    			
		
		
		
		
    
		
    
		
		
    
		
    
			網(wǎng)站導(dǎo)航:
		
		
    
		
    
			
		
    	
		
    
			 
		
    
		
    
			
		
    
		
    
			
				
		
    		
	
    	

    



    

				
			
    
		    		
	
    
	
    
		
			


		
	
    

    


    







    
        
	



主站蜘蛛池模板：
亚洲专区中文字幕|
久久精品国产亚洲av影院|
自拍偷自拍亚洲精品第1页|
亚洲精品乱码久久久久久自慰|
亚洲国产精品成人精品无码区
|
亚洲人成图片网站|
精品国产亚洲一区二区三区在线观看
|
久久久青草青青国产亚洲免观|
国产AV无码专区亚洲精品|
亚洲日本在线观看网址|
亚洲欧洲无码AV不卡在线|
视频免费1区二区三区|
99精品视频在线观看免费专区|
成年美女黄网站色大免费视频|
免费大片在线观看网站|
亚洲AV综合色区无码另类小说|
亚洲av永久无码嘿嘿嘿|
成人一级免费视频|
久久精品无码专区免费东京热|
永久免费无码网站在线观看|
亚洲综合国产一区二区三区|
亚洲乱人伦精品图片|
四虎影视在线看免费观看|
在线观看的免费网站无遮挡|
日本一区免费电影|
久久精品国产亚洲香蕉|
亚洲精品国产综合久久久久紧|
国产免费一区二区三区免费视频|
free哆啪啪免费永久|
亚洲成年看片在线观看|
亚洲欧洲日本天天堂在线观看|
国产成人+综合亚洲+天堂|
精品无码国产污污污免费网站|
国产精品成人无码免费|
亚洲国产第一页www|
美女露隐私全部免费直播|
91精品手机国产免费|
亚洲国产成人VA在线观看|
亚洲欧洲精品国产区|
成av免费大片黄在线观看
|
亚欧色视频在线观看免费|