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

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

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

    
    

    




    







												


        

    
	

    
	
    
		
    
			
				
    eric-1001c
    
				
    
			    		
		
    
	
    

    

    
	
    
		
    
			
 
BlogJava ::
首頁 ::
新隨筆 ::
聯系 ::
聚合
 ::
管理 ::


			
			
				

    
	
    
		
    
			
			
			
				 
				3 
				隨筆 ::
				45 文章
				::
				12 評論
				::
				0 Trackbacks
			
		
    
	
    

    

			    		
		
    
	
    

    


    


    
	
					

    
	
	
	
    
		
     
    

    class Egg{
            private Yolk y;
            protected class Yolk{
                public Yolk(){
                System.out.println(    "Egg.Yolk()");
            }
        }
            public Egg(){
            System.out.println(    "new Egg()");
            y     = new Yolk();
        }
    }
    //bigegg extend egg, and try "override" the yolk
    public class BigEgg extends Egg{
            public class Yolk{
                public Yolk(){
                System.out.println(    "BigEgg.Ylok()");    
            }
        }
            public static void main(String[] args) {
                new BigEgg();
        }
    }
    

    內部類是一種非常有用的機制，它允許你把一些邏輯相關的類組織在一起，并控制位于內部類的可視性（進入修飾符和其它普通類元素沒有區別）。同時內部類能夠與外部類通信。利用內部類的特性可以使得寫出的代碼優雅而清雅。

    1）內部類可以在內部進行使用，更典型的情況是在外部類設置一個方法返回一個指向內部類的引用
    2）如果想從外部類的非靜態方法之外的任意位置創建某個內部類的對象（這個內部類必須是public），必須具體指明這個對象的類型：OuterClassName.InnerClassName；在new表達式中提供對其它外部類對象的引用，需要使用.new語法。
    


    OutClass oc     = new OutClass();
    OutClass.InnerClass ocic     = oc.new InnerClass();
    

    這個例子也告訴我們，必須使用外部類的對象來創建內部類對象，不能直接創建內部類對象，因為它們之前必須建立一個聯系（當然除了嵌套類－－靜態內部類）

    3）內部類和制造它的外圍對象之間有一種聯系（對象創建一個內部類對象時，內部類對象會捕獲一個指向那個外圍類對象的引用），這種聯系使得它能訪問外圍對象的所有成員，而不要任何特殊條件。此外，內部類還擁有其外圍類的所有元素的訪問權。（是不是可以把內部類看成外部類的一個元素，一個“特殊”的“類元素”）
    如果需要生成對外部類對象的引用，可以使用外部類的名字后面緊跟圓點和this“.this”:
    

    public class Outer{

           public class Inner{
       
              public Outer getOuter(){
                 return Outer.this;
          }

    }
    

    4) 當將內部類向上轉型為其基類，尤其是轉型為一個接口的時候，內部類就有了用武之地。這是因為內部類－－某個接口的實現－－能夠完全不可見，并且不可用（將內部類進入修飾符設置為private或protected就可以了）。所得到的只是指向基類或接口的引用，所以能夠很方便地隱藏實現細節，也完全阻止任何依賴于類型的編碼
    

    package chapter10;

    interface Destination{
        String readLabel();
    }
    interface Contents{
            int value();
    }
    class OuterInner{
            //inner class1
        private class PDestination implements Destination{
                private String label;
                private PDestination (String whereto){
                label     = whereto;
            }
                public String readLabel() {
                    return label;
            }
        }    ;
            //inner class2
        protected class PContents implements Contents{
                private int i = 11;
                public int value() {
                    return i;
            }
        }    ;
        
            //method to ge the reference of the inner class pdestination and pcontent
    //    notice that we return a interface instead of the implements of the interface
        public Destination getDestination(String s){
                return new PDestination(s);
        }
            public Contents getContents(){
                return new PContents();
        }
    }

    public class InnerUpcast {

            /**
         *     @param args
             */
            public static void main(String[] args) {
            OuterInner oi     = new OuterInner();
    //        we also use the interface as the type of the class instead of the inner class type
            Contents c =oi.getContents();
            Destination d     = oi.getDestination("Hello");
        }
    

    5) 同樣的我們可以在任意一個方法中或作用域內創建一個內部類，除了要注意它（內部類）的使用作用域外，其它用法和在類的內部類用法無異。
    6）匿名內部類：沒有名字的，不能有構造器的類
    

    interface Contents{
            int value();
    }
    abstract class Base{
            public abstract void f();
    }
    //use anonymous inner class as the vaule of return
    //play your attendtion on that the value of return not only is a inner class
    //but also it will be casted up as a interface, that's the amazing place
    class OuterInner{
    //  use interface as anonymous inner class
        public Contents getContents(){
                return new Contents(){
                    private int i = 11;
                    public int value() {
                        return i;
                }
            }    ;
        }
    //    use abstract class as anonymous inner class
        public Base getBase(){
                return new Base(){
                    public void f(){
                        //do something here
                }
            }    ;
        }
    }

    public class AnonymousInner {
            public static void main(String[] args) {
            OuterInner oi     = new OuterInner();
            Contents c     =oi.getContents();
            Base b     = oi.getBase();
        }
    }
    
匿名內部類既可以擴展類（抽象類），也可以實現接口，但不能兩者兼備。如果匿名內部類要使用在其外部定義的對象，則要求該參數引用為final

    7）要創建嵌套類（靜態內部類）意味著：并不需要其外圍類的對象；不能從嵌套類的對象中訪問非靜態的外圍類對象。嵌套類與普通內部類還有一個區別：普通內部類的字段與方法只能放在類的外部層次上，所以普通的內部類不能有static數據和static字段，也不能包含嵌套類。但是嵌套類可以包含所有這些東西。
    8）一個內部類被嵌套多少層并不重要，它能透明地訪問所有它所嵌入的外圍類的所有成員
    9）“每個內部類都能獨立地繼承自一個（接口的）實現，所以無論外圍類是否已經繼承了某個（接口的）實現，對于內部類都沒有影響”，這樣的內部類特性使得其很多解決“多重繼承”：
           a. 內部類可以有多個實例，每個實例都有自己的狀態信息，并且與其外圍類對象的信息相互獨立（通過匿名內部類實現）
           b. 在單個外圍類中，可以讓多個內部類以不同的方式實現同一個接口，或繼承同一個類（通過匿名內部類實現）
           c. 創建內部類對象的時候并不依賴于外圍類對象的創建，并沒有令人迷惑的“is-a”關系，它就是一個獨立的實體

    

    class PetSequence{
        String[] str     =new String[]{"Rat","Manx","Cymric","Mutt","Pug"};
            protected ArrayList<String> pets = new ArrayList<String>(
                Arrays.asList(str));
    }

    public class NonClollectionSequence extends PetSequence{
    //    我們在這創建了3個方法，返回類型都是Iterable接口。但不同方法對Iterable接口的實現是不同的
    //    使用匿名內部類很好的以不同的方式實現同一個接口，而且并不依賴于外圍對象
        public Iterable<String> Iterator(){
                return new Iterable<String>(){
                    public Iterator<String> iterator(){
                        return new Iterator<String>(){
                            private int index = 0;
                            public boolean hasNext(){
                                return index< pets.size();
                        }
                            public String next(){return pets.get(index++);}
                            public void remove(){
                                throw new UnsupportedOperationException();
                        }
                    }    ;
                }
            }    ;
        }
        
            public Iterable<String> reversed(){
                return new Iterable<String>(){
                    public Iterator<String> iterator(){
                        return new Iterator<String>(){
                            private int index = pets.size()-1;
                            public boolean hasNext(){
                                return index< pets.size();
                        }
                            public String next(){
                                return pets.get(index--);
                        }
                            public void remove(){
                                throw new UnsupportedOperationException();
                        }
                    }    ;
                }
            }    ;
        }
        
            public Iterable<String> randomized(){
                return new Iterable<String>(){
                    public Iterator<String> iterator(){
                    List    <String> shuffed = new ArrayList<String>(Arrays.asList(str));
                    Collections.shuffle(shuffed,     new Random(47));
                        return shuffed.iterator();
                }
            }    ;
        }

            public static void main(String[] args) {
            NonClollectionSequence s     = new NonClollectionSequence();
                for(String string: s.reversed())
                System.out.println(string);
            System.out.println();
                for(String string2: s.randomized())
                System.out.println(string2);
        }
    }
    

    10)如果創建一個繼承具有內部類的外圍類的新類，并在新類中試圖覆蓋內部類，會發生什么呢？

    當繼承了某個外圍類的時候，內部類并沒有發生什么特別的神奇的變化。這兩個內部類是完全獨立的兩個實體，各自在自己的命名空間內
    11）內部類的標識符：外圍類的名字，加上‘$’，再加上內部類的名字，比如OuterClass$InnerClass；對了匿名內部類，編譯器會簡單地產生一個數字作為其標識符，比如OuterClass$1
    12)局部內部類VS匿名內部類
          a. 局部內部類可以提供一個構造器，方便重載構造器，而匿名內部類只能用于實例初始化
          b. 局部內部類可以被使用多次，然而匿名內部類只能實例化一次

	
    
	
	
    
		posted on 2007-07-17 11:18 Eric-1001c 閱讀(229) 評論(0)  編輯  收藏  所屬分類: ThinkingInJava 
	
    

    







    
	    
    




    








    

				

    




    







    
        
	



主站蜘蛛池模板：
蜜芽亚洲av无码一区二区三区|
好男人视频在线观看免费看片|
国产精品亚洲专区在线播放|
亚洲精品国产专区91在线|
亚洲国产精品人人做人人爱|
国产免费av片在线看|
亚洲精品国产字幕久久不卡|
成人免费无毒在线观看网站|
在线免费观看你懂的|
免费观看一区二区三区|
男人免费视频一区二区在线观看|
国产成人精品日本亚洲11|
色播亚洲视频在线观看|
国产成A人亚洲精V品无码性色
|
亚洲AV永久无码精品一福利
|
四虎永久在线观看免费网站网址|
免费无码H肉动漫在线观看麻豆|
美女裸免费观看网站|
亚洲国产成人久久综合|
香蕉大伊亚洲人在线观看|
亚洲成年人电影在线观看|
亚洲欧洲国产精品你懂的|
亚洲av无码国产精品夜色午夜
|
99精品免费观看|
99久久精品毛片免费播放|
二区久久国产乱子伦免费精品|
人体大胆做受免费视频|
青青草国产免费国产是公开|
久久精品国产亚洲av天美18|
色五月五月丁香亚洲综合网|
欧美日韩亚洲精品|
亚洲av日韩av永久无码电影|
亚洲Av无码国产一区二区|
337P日本欧洲亚洲大胆精品|
色综合久久精品亚洲国产|
国产成人+综合亚洲+天堂|
国产亚洲视频在线播放大全|
曰批免费视频播放在线看片二|
日日躁狠狠躁狠狠爱免费视频|
草久免费在线观看网站|
在线视频网址免费播放|