2. 程式人生 > >淺析Java內部類在GUI設計中的作用(2)

淺析Java內部類在GUI設計中的作用(2)

阿新 • • 發佈：2019-01-28

四、方法內部類

方法內部類只在該方法內部可見，方法內部類可以定義在方法中的任何位置。

  1. /**   
  2. * 內部類實現介面   
  3. *   
  4. * @author leizhimin 2009-7-17 14:57:50   
  5. */
  6. public class  Test2 {   
  7. public static void  main(String[] args) {   
  8.                 Outer outer =  new  Outer();   
  9.                 Foo f = outer.genFoo();   
  10.                 Bar b = outer.genBar();   
  11.                 f.say();   
  12.                 b.readme();   
  13.         }   
  14. }   
  15. class  Outer {   
  16. public  Foo genFoo() {   
  17. //方法內的內部類 
  18. class  FooImpl  implements  Foo {   
  19. public void  say() {   
  20.                                 System.out.println( "say foo!" );   
  21.                         }   
  22.                 }   
  23. return new  FooImpl();   
  24.         }   
  25. public  Bar genBar() {   
  26.                 Bar b =  null ;   
  27. if  ( true ) {   
  28. //任意位置的內部類 
  29. class  BarImpl  implements  Bar {   
  30. public void  readme() {   
  31.                                         System.out.println( "say bar!"
    );   
  32.                                 }   
  33.                         }   
  34.                         b =  new  BarImpl();   
  35.                 }   
  36. return  b;   
  37.         }   
  38. }  

執行結果：

say foo!

say bar!

Process finished with exit code 0

五、匿名類

匿名類不給出類名，直接定義一個類，通常這個類實現了某種介面或者抽象。匿名類的訪問許可權更沒有討論價值了，看個例子就行了。

在一些多執行緒程式中比較常見，有點變態，呵呵。

  1. /**   
  2. * 匿名類.   
  3. *   
  4. * @author leizhimin 2009-7-17 15:56:17   
  5. */
  6. public class  Test3 {   
  7. public  Foo f =  new  Foo() {   
  8. public void  say() {   
  9.                         System.out.println( "O(∩_∩)O哈哈~!" );   
  10.                 }   
  11.         };   
  12. public  Foo test() {   
  13. return new  Foo() {   
  14. public void  say() {   
  15.                                 System.out.println( "say foo!" );   
  16.                         }   
  17.                 };   
  18.         }   
  19. public static void  main(String[] args) {   
  20.                 Test3 t =  new  Test3();   
  21.                 t.f.say();   
  22.                 t.test().say();   
  23.         }   
  24. }   
  25. interface  Foo {   
  26. void  say();   
  27. }  

執行結果：

say foo!

  1. Process finished with exit code  0
  2. /**   
  3. * 普通類的匿名初始化   
  4. *   
  5. * @author leizhimin 2009-7-17 16:13:31   
  6. */
  7. public class  Fk {   
  8. private  String x;   
  9. public  Fk(String x) {   
  10. this .x = x;   
  11.         }   
  12. @Override
  13. public  String toString() {   
  14. return "Fk{"  +   
  15. "x='"  + x + '/ ''  +   
  16. '}' ;   
  17.         }   
  18. }   
  19. class  Test4 {   
  20. public  Fk hehe() {   
  21. //把後面的一對大括號去掉呢，呵呵 
  22. return new  Fk( "fk" ) {   
  23.                 };   
  24.         }   
  25. public static void  main(String[] args) {   
  26.                 Test4 t =  new  Test4();   
  27.                 Fk f = t.hehe();   
  28.                 System.out.println(f);   
  29.         }   
  30. }  

執行結果：

Fk{x='fk'}

Process finished with exit code 0

還有一個不得不提的經典例項，來自thining in java，有改動：

  1. interface  Service {   
  2. void  method1();   
  3. void  method2();   
  4. }   
  5. interface  ServiceFactory {   
  6.     Service getService();   
  7. }   
  8. class  Implementation1  implements  Service {   
  9. private  Implementation1() {}   
  10. public void  method1() {System.out.println( "Implementation1 method1" );}   
  11. public void  method2() {System.out.println( "Implementation1 method2" );}   
  12. public static  ServiceFactory factory =  new  ServiceFactory() {   
  13. public  Service getService() {   
  14. return new  Implementation1();   
  15.             }   
  16.         };   
  17. }   
  18. class  Implementation2  implements  Service {   
  19. private  Implementation2() {}   
  20. public void  method1() {System.out.println( "Implementation2 method1" );}   
  21. public void  method2() {System.out.println( "Implementation2 method2" );}   
  22. public static  ServiceFactory factory =  new  ServiceFactory() {   
  23. public  Service getService() {   
  24. return new  Implementation2();   
  25.             }   
  26.         };   
  27. }   
  28. public class  Factories {   
  29. public static void  serviceConsumer(ServiceFactory fact) {   
  30.         Service s = fact.getService();   
  31.         s.method1();   
  32.         s.method2();   
  33.     }   
  34. public static void  main(String[] args) {   
  35.         serviceConsumer(Implementation1.factory);   
  36.         serviceConsumer(Implementation2.factory);   
  37.     }   
  38. }  

這個應用給了我們很多思考，我就不說了，不同人看了會有不同的感受。

內部類的巧妙使用會讓你的程式碼很牛，如果要形容下，那就是：沒看懂的時候感覺神出鬼沒，看懂後感覺鬼斧神工。不過這些程式碼多了，別人想看懂都難，想 看懂你思路就難上加難了。呵呵！

六、靜態內部類

靜態內部類是static class型的內部類，這種內部類特點是：它不能訪問外部類的非靜態成員。要建立靜態內部類物件時候，也不需要外部類物件了，直接可以：

new 外部類名.內部類構造方法

來建立，給個例子：

  1. /**   
  2. * 靜態內部類   
  3. *   
  4. * @author leizhimin 2009-7-17 16:53:05   
  5. */
  6. public class  Outer {   
  7. public static int  i = 500 ;   
  8. protected static class  Inner {   
  9. int  i = 100 ;   
  10.                 String name;   
  11.                 Inner(String name) {   
  12. this .name = name;   
  13.                 }   
  14. void  sayHello() {   
  15.                         System.out.println( "Hello "  + name);   
  16.                         Outer.i++;   
  17.                 }   
  18.         }   
  19. public  Inner genInner(String name) {   
  20. return new  Inner(name);   
  21.         }   
  22. }   
  23. class  Test {   
  24. public static void  main(String[] args) {   
  25.                 Outer.Inner in1 =  new  Outer.Inner( "1111" );   
  26.                 in1.sayHello();   
  27.                 System.out.println(Outer.i);   
  28.                 Outer.Inner in2 =  new  Outer().genInner( "2222" );   
  29.                 in2.sayHello();   
  30.                 System.out.println(Outer.i);   
  31.         }   
  32. }  

執行結果：

Hello 1111

501

Hello 2222

502

Process finished with exit code 0

七、介面內部類

介面內部類自動都是public static的，相當於為介面定義了一種變數型別，這在java的設計中就有使用，比如在HashMap中，就有：

static class Entry<K,V> implements Map.Entry<K,V>

下面我給個例子，

  1. /**   
  2. * 介面內部類   
  3. *   
  4. * @author leizhimin 2009-7-17 17:20:28   
  5. */
  6. public interface  AInterface {   
  7. void  readme();   
  8. class  Inner1  implements  AInterface {   
  9. public void  readme() {   
  10.                         System.out.println( "我是一個介面內部類" );   
  11.                 }   
  12.         }   
  13. }   
  14. class  Main {   
  15. public static void  main(String[] args) {   
  16.                 AInterface.Inner1 in1 =  new  AInterface.Inner1();   
  17.                 in1.readme();   
  18.         }   
  19. }  

八、內部的類的巢狀

所謂內部類巢狀，就是內部類裡面再定義內部類。其實這種用法還真沒見過，試試寫個簡單例子看看吧：

  1. /**   
  2. * 巢狀內部類   
  3. *   
  4. * @author leizhimin 2009-7-17 17:33:48   
  5. */
  6. public class  Outer {   
  7. private void  f0() {   
  8.                 System.out.println( "f0" );   
  9.         }   
  10. class  A {   
  11. private void  a() {   
  12.                         f0();   
  13.                         System.out.println( "a" );   
  14.                 }   
  15. class  B {   
  16. protected void  b() {   
  17.                                 a();   
  18.                                 System.out.println( "b" );   
  19.                         }   
  20.                 }   
  21.         }   
  22. }   
  23. class  Test{   
  24. public static void  main(String[] args) {   
  25.                 Outer o =  new  Outer();   
  26.                 Outer.A    a =     o. new  A();   
  27.                 Outer.A.B b = a. new  B();   
  28.                 b.b();   
  29.         }   
  30. }  

執行結果：

f0

a

b

Process finished with exit code 0

八、內部類的繼承

內部類的繼承，可以繼承內部類，也可以繼承外部類。

  1. /**   
  2. * 內部類的繼承，可以繼承內部類，也可以繼承外部類   
  3. *   
  4. * @author leizhimin 2009-7-22 13:50:01   
  5. */
  6. public class  Outer {   
  7. class  Inner {   
  8. void  doSomething() {   
  9.                         System.out.println( "Inner doing ..." );   
  10.                 }   
  11.         }   
  12. class  Inner2  extends  Inner {   
  13. void  doSomething() {   
  14.                         System.out.println( "Inner2 doing ..." );   
  15.                 }   
  16. void  readme() {   
  17.                         System.out.println( "HeHe!" );   
  18.                 }   
  19.         }   
  20. }   
  21. class  Test {   
  22. public static void  main(String[] args) {   
  23.                 Outer outer =  new  Outer();   
  24.                 Outer.Inner in = outer. new  Inner();   
  25.                 Outer.Inner2 in2 = outer. new  Inner2();   
  26.                 in.doSomething();   
  27.                 in2.doSomething();   
  28.                 in2.readme();   
  29.         }   
  30. }  

執行結果：

Inner doing ...

Inner2 doing ...

HeHe!

Process finished with exit code 0

總結 ：

內部類是Java中最複雜深奧的概念之一，而且內部類在訪問控制，修飾符，繼承，實現，抽象，序列化等等很多方面都是一個很讓人迷惑的問題，在實際 中，這些問題也許永遠沒機會沒時間搞清，但是一般說來，懂得以上的內部類的知識就足夠用了。

內部類的設計也許是彌補Java語言本身的先天不足吧，作為語言來說，這個特性太變態了點，難道就沒別的法了？

以上的總結完全是建立在實踐基礎上的，所列舉的例子也許偏頗，不能全面反映問題的本質，希望有興趣的博友多多發表自己的看法與觀點。

本文轉自 http://developer.51cto.com/art/201002/183375_1.htm

希望對有需要的朋友有幫助

相關推薦

淺析Java內部類在GUI設計中的作用(2)

四、方法內部類 方法內部類只在該方法內部可見，方法內部類可以定義在方法中的任何位置。 /**    * 內部類實現介面    *    * @author leizhimin 2009-7-17 14:57:50    */ public clas

為什麼Java內部類要設計成靜態和非靜態兩種

作者：Paranoid 連結：https://www.zhihu.com/question/28197253/answer/365692360 來源：知乎 著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。   首先，我們需要明白，為什麼要設計Java內部

JAVA中區域性內部類和匿名內部類的特點和作用?

Java 內部類 分四種：成員內部類、區域性內部類、靜態內部類和匿名內部類。 1、成員內部類： 即作為外部類的一個成員存在，與外部類的屬性、方法並列。 注意：成員內部類中不能定義靜態變數,但可以訪問外部類的所有成員。 public class Outer{ privat

Java內部類引用外部類中的局部變量為何必須是final問題解析

lib soft 編譯器 art http word tail ace 軟件 今天編寫一個多線程程序，發現在方法內定義內部類時，如果內部類調用了方法中的變量，那麽該變量必須申明為final類型，百思不得其解，後來想到應該是生命周期的原因，因為方法內定義的變量是局部變量，

java內部類作用

修改 private end 之一 class 需要 sta bean sid 推薦一、 定義 放在一個類的內部的類我們就叫內部類。 二、 作用 1.內部類可以很好的實現隱藏 一般的非內部類，是不允許有 private 與protected權限的，但內部類可以

Java內部類的作用

在普通類裡面在建立一個類，這個類叫做內部類。內部類大致分為4類： 成員內部類、區域性內部類、匿名內部類和靜態內部類 一、內部類分類 定義一個介面方便示例： package helloworld; /** * 介面 **/ public interface Inter

在Java內部類中使用外部類的成員方法以及成員變數

眾所周知，在定義成員方法或者成員變數的時候，可以給其加上一些許可權的修飾詞，以防止其他類的訪問。如在成員變數或者成員方法前面，加上Private關鍵字，則其他類就無法呼叫這個類中的成員方法或則和成員變數。但是，如果這個類有成員內部類，則不受這方面的限制。也就是說，在成員內

java 內部類來將執行緒 程式碼隱藏在類中

package org.rui.thread.basic; import java.util.concurrent.TimeUnit; /** * 有時通過使用內部類來將執行緒 程式碼隱藏在類中 將會很有用，就像下面這樣: * ----- * InnerThrea

Java 內部類，多執行緒中Synchronized與wait,notify的使用

工作內容： 1.成員內部類    與成員方法，屬性的訪問許可權一致 2.靜態內部類    修飾符 stactic 類名{...} 3.匿名內部類    new 類名()/介面名(重寫介面方法) 4.區域性內部類    程式碼塊中 5.執行緒Thread wait,noti

關於java內部類（Inner Class） 不斷更新中

java內部類（Inner Class）  Inner Class 即巢狀類，也即C++和C#中的Nested Class。但Java 的Inner Class 與 C++和C#最大的不同之處在於，巢狀類包含一個指向其容器類的引用，可以訪問容器類的成員。以下程式碼演示了這一點

淺談java內部類及其作用

1.1)什麼是內部類 1.2)內部類的分類： a)成員內部類【重點】 a.1)作為內部類的成員，可以直接使用外部類的所有成員和方法，包括private a.2)外部類要訪問內部類的成員變數和方法，則需

java內部類的四大作用

放在一個類的內部的類我們就叫內部類。 二、 作用 1.內部類可以很好的實現隱藏  一般的非內部類，是不允許有 private 與protected許可權的，但內部類可以 2．內部類擁有外圍類

java內部類引用外部類中的變數 必須是final

@Test//資料庫連線池DBCPpublic void testDBCP(){//建立連線池BasicDataSource ds=new BasicDataSource();//給連線池新增必要的屬性//可以將這些屬性去掉set首字母小寫，寫在.properties檔案中ds.setUsername("ro

Java內部類作用用法詳解

Java中，可以將一個類定義在另一個類裡面或者一個方法裡面，這樣的類稱為內部類。 內部類包括四種：成員內部類、區域性內部類、匿名內部類和靜態內部類。 內部類的作用： 1.Java只支援單重繼承，想擴充套件功能，去實現介面吧。很快Java的設計者就發現了他們犯了矯枉過正的

Java內部類引用外部類中的區域性變數為何必須是final問題解析

       今天編寫一個多執行緒程式，發現在方法內定義內部類時，如果內部類呼叫了方法中的變數，那麼該變數必須申明為final型別，百思不得其解，後來想到應該是生命週期的原因，因為方法內定義的變數是區域性變數，離開該方法，變數就失去了作用，也就會自動被消除，而內部類卻不會

Java內部類的四種分類以及作用

# 內部類內容解析 ### 內部類的區分 內部類分別有成員內部類、區域性內部類、匿名內部類、靜態內部類，接下來將分別介紹。 ### 成員內部類 - 就是位於外部類成員位置的類。與外部類的屬性、方法並列。 - 成員內部類作為外部類的成員，可以訪問外部類的私有成員或屬性。（即使將外部類宣告為private，但

Java內部類之匿名內部類

urn nat 看到了 math 通過 rri 內部 test mat ??我們都知道Java中可以使用內部類，將一個類的定義放在另一個類的定義的內部，這就是內部類，但是匿名內部類往往使我們摸不著頭腦，因為它並沒有特定的名稱，那麽該如何使用它呢？ 定義一個匿名內部類 pu

Java內部類基本使用

add size sel 整體 object 方法 句柄 protected 基本使用 鏈接到外部類 ??創建內部類時，那個類的對象同時擁有封裝對象(封裝內部類的外部類)的一個鏈接，所以內部類可以訪問外部類的成員。??內部類擁有對外部類所有元素的訪問權限。??看如下代碼，內

Java內部類的使用小結

提示 key 內部 效果 com where out alt 文件 轉自：http://android.blog.51cto.com/268543/384844/ 內部類是指在一個外部類的內部再定義一個類。類名不需要和文件夾相同。 *內部類可以是靜態static的，也可

JAVA 內部類 （二）

匿名內部類 獨立 button strong 知識 desc ets .get xxx 一、為什麽要使用內部類 為什麽要使用內部類？在《Think in java》中有這樣一句話：使用內部類最吸引人的原因是：每個內部類都能獨立地繼承一個（接口的）實現，所以無論外