隨筆-159 
評論-114 
文章-7 
trackbacks-0

          
	

          

          
	
					


          
	
	內部類，使用內部類使編程更有層次，結構更清晰，但一切能用內部類解決的問題，外部類都能解決，只是編碼是否繁瑣的問題。

          內部類，是作為外部類的成員。

          內部類，修飾符可以為private protected static

          四種內部類

          成員內部類   局部內部類   靜態內部類   匿名內部類

          1.成員內部類，可以作為外部類的成員。

          既然作為成員，那么四種訪問修飾符適用。
          優點：1任意訪問外部類私有成員（屬性，方法）
                      2 定義比private還要小的訪問控制權限（對于外部類） 
                      3 成員內部類，不能有靜態屬性。

          

          public class Outer {
                        private int index = 100;
              
                        /** Creates a new instance of Outer */
                        public Outer() {
              }
              
                        class Inner
                        {
                            private int index = 50;
                            void print()
                            {
                                int index = 30;
                      System.out.println(index);          //局部變量30
                      System.out.println(this.index);//內部類當前對象的index
                      System.out.println(Outer.this.index);//引用外部類對象index
                  }
              }
              
                        public static void main(String[] args)
                        {
                  Outer outer           = new Outer();
                  Outer.Inner oi           = outer.new Inner();
                  oi.print();
              }
              
          }

          成員內部類對象依附于外部類對象。

          所以，如果一個外部類繼承另外一個類的內部類，那么這個類的構造函數必須需要一個那個內部類的外部類對象作為參數傳入，才能成功構造該類對象。

          

          class WithInner {
                      class Inner {}
          }
          public class InheritInner extends WithInner.Inner {
                      //! InheritInner() {} // Won't compile
            InheritInner(WithInner wi) {
              wi.          super();
            }
                      public static void main(String[] args) {
              WithInner wi           = new WithInner();
              InheritInner ii           = new InheritInner(wi);
            }
          }


          局部內部類

          

          public class Outer {
                        private int index = 100;
              
                        /** Creates a new instance of Outer */
                        public Outer() {
              }

                        void fn(final int a)
                        {
                            final int b = 0;
                            class Inner
                            {
                                int index = 50;
                                void print()
                                {
                                    int index = 30;
                          System.out.println(          this.index);
                          System.out.println(Outer.          this.index);
                          System.out.println(a);
                          System.out.println(b);
                      }
                  }
                  Inner in           = new Inner();
                  in.print();
              }

                        public static void main(String[] args)
                        {
                  Outer outer           = new Outer();
                  outer.fn(          10000);
              }             
          }

          可以訪問實例變量，通過外部類當前對象。Outer.this
          可以使用局部變量，但這些變量必須是final的。

          局部內部類前沒有訪問控制修飾符，因為作用域就是在方法內部，指定無意義。

          局部內部類對于外部類是透明的。


          靜態內部類

          

          public class Outer {
                        private int index = 100;
              
                        private static int index_static = 100;

                         /** Creates a new instance of Outer */
                        public Outer() {
              }

                        static class StaticInner{
                            private int index = 50;
                            void print()
                            {
                                int index = 30;
                      System.out.print(index);
                      System.out.print(          this.index);
                      System.out.print(Outer.index_static);
                  }
                  
              }

                        public static void main(String[] args)
                        {
                  Outer.StaticInner st           = new Outer.StaticInner();
                  st.print();

              }
              
          }

          靜態內部類只能訪問外部類的靜態成員（屬性，方法）
          創建對象，不依賴于外部類對象，是一個頂級類。

          Outer.Inner in = new Outer.Inner();
          in.***();

          內部類重要用途，接口配合內部類實現完全的C++多繼承功能。

          接口不能完全實現多繼承，簡單例子，就是如果一個機器人Robet，父類People，機器Machine。
          class People{

          public void run(){}//跑

          }

          interface Machine{

          void run(){}//運行

          }

          子類的run方法無法實現。類與接口的命名沖突，需要借助內部類。

          

          public class Robot extends People{
              
                        /** Creates a new instance of Robot */
                        public Robot() {
              }
              
                        public void run(){
                  System.out.println(          "機器人跑");
              }
              
                        class Heart implements Machine{
                            public void run()
                            {
                      System.out.println(          "心臟跳動");
                  }
              }
          }

          abstract class People{    
                        abstract public void run();    
          }

          interface Machine{
                        void run();
          }
          

          r = new Robet();r.run();
          

          Robet.Heart h = r.new Heart();
          

          h.run();
          

          匿名內部類*
          

          public class OuterNoName {
              
                        /** Creates a new instance of OuterNoName */
                        public OuterNoName() {
              }
              
                        public OuterNoName(IA impl)
                        {
                  impl.run();
              }
              
                        public static void main(String[] args)
                        {
                  OuterNoName onn           = new OuterNoName(new IA(){
                                    public void run(){
                              System.out.println(          "匿名內部類");
                          }                          
                  }          );
              }
              
          }

          interface IA{    
                        void run();
          }
          


          構造函數參數傳入時，直接生成一個實現IA接口的匿名內部類的對象。調用run方法時，多態會找到這個不知道叫什么名字的類的覆蓋方法。

          實現接口或者類

          1在new后面使用，隱含著實現接口或者類，父類類型。
          2 其他遵循局部內部類的規則
          3無構造函數。無名嘛

          ===============================================

          Exception

          java.lang.Throwable是java.lang.Error和java.lang.Exception的父類。

          java.lang.Error是指底層的，低級的，嚴重的，不可恢復的錯誤，例如內存不足等。
          程序一定會退出。

          java.lang.Exception是程序員關注的重點，例外又分為RunTime Exception未檢查例外和已檢查例外。

          未檢查例外是由于程序的大意，沒有相應的檢查，而出的例外。此類異常是可以避免的。
          此類問題應提前提供應對策略，是可能出現的錯誤提前應對。

          例如除0，數組越界，強制類型轉換錯誤ClassCastException，等。java.lang.RuntimeException的子類都是未檢查錯誤，去查API。

          所以是編程避免。


          已檢查例外是需要程序處理的。

          兩種方式：
          1.方法throws Exception 
          2.
          try{
          ...
          }catch(Exception ex)
          {
          ...
          }
          finally
          {
          ...
          }

          第一種是一種消極的處理方式，第二種是一種積極的處理方式。

          如果不處理，程序非正常退出，影響出現其他代碼正常運行，盡管他們沒有關系。

          Java是在網絡上傳輸字節碼。所以不會讓程序中出現永遠運行不到的語句，就是不能有廢話。不能存在unreachable statement。
          

          public class TestException {
              
                        /** Creates a new instance of TestException */
                        public TestException() {
              }
              
                        public static void main(String[] args) throws Exception
                        {
                  System.out.println(          "main1");
                  System.out.println(          "main2");
                  print();
                  System.out.println(          "main3");
              }
              
                        public static void print() throws Exception{
                  System.out.println(          "print1");
                  System.out.println(          "print2");
                  subPrint();
                  System.out.println(          "print3");
              }
              
                        public static void subPrint() throws Exception{
                  System.out.println(          "subprint1");
                  System.out.println(          "subprint2");
                            throw new Exception();
                            //System.out.println("subprint3");        unreachable statement
              }
          }
          

          應用try...catch...finally處理異常，保證程序正常退出。
          

              public static void main(String[] args)
                        {
                  System.out.println(          "main1");
                  System.out.println(          "main2");
                            try{
                  print();
                  }
                            catch(IOException e){}
                            catch(Exception ex){}
                            finally{
                      System.out.println(          "Run me whatever!");
                  }
                  System.out.println(          "main3");
              }
          


          catch可以有多個，但一個異常只能匹配一個，而且catch的Exception從上到下，是子類到父類的順序，不可顛倒。

          try塊中，有語句可能運行不到，finally無論如何都會被執行，即使catch塊中有return語句，除非有System.exit(0);不會走finally塊。

          finally塊中，主要放置釋放資源，斷開網絡連接的代碼。
          

              public static void main(String[] args)
                        {
                  System.out.println(cal(          0));
                  System.out.println(cal(          1));
                  System.out.println(cal(          2));
              }
                        public int cal(int n)
                        {
                            try{
                                int r = (int)(2/n);
                                return r;
                  }
                            catch(Exception ex){return 1;}
                            finally{
                                if(n == 2) return 0;
                  }
              }
          

          一定要執行finally塊語句，所以傳入參數為2時，try計算完1，不能馬上執行return，而是執行finally，最后執行finally塊中的return。


          ex.getMessage() ------>Exception(String message)，注意需要構造對象時采用有參構造方法
          ex.printStackTrace(),打印堆棧信息，最早出現位置，途經哪個方法。

          開發一般規律：

          1.try范圍控制確定
          寫程序，聯動操作，如果第一件事與第二件事無關，不要放置于同一個try塊中。
          如果第一件事影響到第二件事，放在一起。

          2.try...catch，這種積極的處理方式，放置于最有能力處理的地方，否則采用throws方式，將例外拋給調用者。

          聯想：一個人要辦一件事，他需要一個中介來辦理，那么他將材料給了代理人，代理將材料提交給執行機構，辦理過程中，執行機構發現材料不全，告知代理人，代理是沒有能力來處理這件事的，只得再告知辦理人，由辦理人再行辦理。


          自定義例外

          class MyException extends Exception{
             public MyException(String message)
             {
                super(message);
             }
          }
          

          ==>throw new MyException("");


          覆蓋方法時，覆蓋方法的例外拋出類型和數量有限制，類型相等，或者是被覆蓋方法例外類型的字類型，數量只能更少。

          try必須和catch或者finally配套出現。任何代碼塊中都可以再次嵌套try...catch...finally。

          








           


          



          
                                
                                
                                
          
	
          posted on 2005-12-03 19:59 北國狼人的BloG 閱讀(434) 評論(0)  編輯  收藏  所屬分類: 達內學習總結 
          

          







          
	    
    




          








          

				

          







    







          
        
	




主站蜘蛛池模板：
武邑县|
云南省|
富锦市|
汕尾市|
海门市|
夹江县|
铁岭市|
兴城市|
丰镇市|
鄂托克旗|
淮北市|
临清市|
辽源市|
汽车|
万盛区|
林口县|
三原县|
四子王旗|
上虞市|
新龙县|
娱乐|
郸城县|
芦山县|
基隆市|
海宁市|
福泉市|
疏附县|
张掖市|
集安市|
武川县|
神农架林区|
临江市|
林西县|
英超|
密山市|
赞皇县|
右玉县|
万荣县|
凉山|
定安县|
来凤县|