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

          
	

          

          
	
					


          
	
	內(nèi)部類，使用內(nèi)部類使編程更有層次，結(jié)構(gòu)更清晰，但一切能用內(nèi)部類解決的問題，外部類都能解決，只是編碼是否繁瑣的問題。

          內(nèi)部類，是作為外部類的成員。

          內(nèi)部類，修飾符可以為private protected static

          四種內(nèi)部類

          成員內(nèi)部類   局部內(nèi)部類   靜態(tài)內(nèi)部類   匿名內(nèi)部類

          1.成員內(nèi)部類，可以作為外部類的成員。

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

          

          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);//內(nèi)部類當前對象的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();
              }
              
          }

          成員內(nèi)部類對象依附于外部類對象。

          所以，如果一個外部類繼承另外一個類的內(nèi)部類，那么這個類的構(gòu)造函數(shù)必須需要一個那個內(nèi)部類的外部類對象作為參數(shù)傳入，才能成功構(gòu)造該類對象。

          

          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);
            }
          }


          局部內(nèi)部類

          

          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的。

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

          局部內(nèi)部類對于外部類是透明的。


          靜態(tài)內(nèi)部類

          

          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();

              }
              
          }

          靜態(tài)內(nèi)部類只能訪問外部類的靜態(tài)成員（屬性，方法）
          創(chuàng)建對象，不依賴于外部類對象，是一個頂級類。

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

          內(nèi)部類重要用途，接口配合內(nèi)部類實現(xiàn)完全的C++多繼承功能。

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

          public void run(){}//跑

          }

          interface Machine{

          void run(){}//運行

          }

          子類的run方法無法實現(xiàn)。類與接口的命名沖突，需要借助內(nèi)部類。

          

          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();
          

          匿名內(nèi)部類*
          

          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(          "匿名內(nèi)部類");
                          }                          
                  }          );
              }
              
          }

          interface IA{    
                        void run();
          }
          


          構(gòu)造函數(shù)參數(shù)傳入時，直接生成一個實現(xiàn)IA接口的匿名內(nèi)部類的對象。調(diào)用run方法時，多態(tài)會找到這個不知道叫什么名字的類的覆蓋方法。

          實現(xiàn)接口或者類

          1在new后面使用，隱含著實現(xiàn)接口或者類，父類類型。
          2 其他遵循局部內(nèi)部類的規(guī)則
          3無構(gòu)造函數(shù)。無名嘛

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

          Exception

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

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

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

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

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

          所以是編程避免。


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

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

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

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

          Java是在網(wǎng)絡(luò)上傳輸字節(jié)碼。所以不會讓程序中出現(xiàn)永遠運行不到的語句，就是不能有廢話。不能存在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
              }
          }
          

          應(yīng)用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無論如何都會被執(zhí)行，即使catch塊中有return語句，除非有System.exit(0);不會走finally塊。

          finally塊中，主要放置釋放資源，斷開網(wǎng)絡(luò)連接的代碼。
          

              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;
                  }
              }
          

          一定要執(zhí)行finally塊語句，所以傳入?yún)?shù)為2時，try計算完1，不能馬上執(zhí)行return，而是執(zhí)行finally，最后執(zhí)行finally塊中的return。


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

          開發(fā)一般規(guī)律：

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

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

          聯(lián)想：一個人要辦一件事，他需要一個中介來辦理，那么他將材料給了代理人，代理將材料提交給執(zhí)行機構(gòu)，辦理過程中，執(zhí)行機構(gòu)發(fā)現(xiàn)材料不全，告知代理人，代理是沒有能力來處理這件事的，只得再告知辦理人，由辦理人再行辦理。


          自定義例外

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

          ==>throw new MyException("");


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

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

          








           


          



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

          







          
	    
    




          








          

				

          







    







          
        
	




主站蜘蛛池模板：
兰州市|
公主岭市|
清徐县|
孝昌县|
怀安县|
西昌市|
荥经县|
郁南县|
怀化市|
杭锦后旗|
保山市|
临江市|
东乡|
广昌县|
阿鲁科尔沁旗|
兴海县|
仪陇县|
繁峙县|
茂名市|
中西区|
尚义县|
连城县|
泌阳县|
内江市|
靖远县|
孝义市|
荥阳市|
蒲江县|
道孚县|
永川市|
桂阳县|
遂宁市|
元江|
罗平县|
文登市|
襄樊市|
镇江市|
昌吉市|
石台县|
故城县|
神农架林区|