Java内部クラスのGUI設計における役割を浅く分析する(2)

32704 ワード

四、方法内部クラス
メソッド内部クラスは、メソッド内でのみ表示され、メソッド内部クラスはメソッド内の任意の場所を定義できます.

  
  
  
  
  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.  
  16. class  Outer {   
  17.          public  Foo genFoo() {   
  18.                  //    
  19.                  class  FooImpl  implements  Foo {   
  20.                          public   void  say() {   
  21.                                 System.out.println( "say foo!" );   
  22.                         }   
  23.                 }   
  24.                  return   new  FooImpl();   
  25.         }   
  26.  
  27.          public  Bar genBar() {   
  28.                 Bar b =  null ;   
  29.                  if  ( true ) {   
  30.                          //    
  31.                          class  BarImpl  implements  Bar {   
  32.                                  public   void  readme() {   
  33.                                         System.out.println( "say bar!" );   
  34.                                 }   
  35.                         }   
  36.                         b =  new  BarImpl();   
  37.                 }   
  38.                  return  b;   
  39.         }   
  40. }  

実行結果:
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.  
  13.          public  Foo test() {   
  14.                  return   new  Foo() {   
  15.                          public   void  say() {   
  16.                                 System.out.println( "say foo!" );   
  17.                         }   
  18.                 };   
  19.         }   
  20.  
  21.          public   static   void  main(String[] args) {   
  22.                 Test3 t =  new  Test3();   
  23.                 t.f.say();   
  24.                 t.test().say();   
  25.         }   
  26. }   
  27.  
  28. interface  Foo {   
  29.          void  say();   
  30. }  

実行結果:
say foo!

  
  
  
  
  1. Process finished with exit code  0    
  2.  
  3. /**   
  4. *     
  5.  
  6. * @author leizhimin 2009-7-17 16:13:31   
  7. */    
  8. public   class  Fk {   
  9.          private  String x;   
  10.  
  11.          public  Fk(String x) {   
  12.                  this .x = x;   
  13.         }   
  14.  
  15.          @Override    
  16.          public  String toString() {   
  17.                  return   "Fk{"  +   
  18.                                  "x='"  + x + '/ ''  +   
  19.                                  '}' ;   
  20.         }   
  21. }   
  22.  
  23. class  Test4 {   
  24.          public  Fk hehe() {   
  25.                  // ,    
  26.                  return   new  Fk( "fk" ) {   
  27.                 };   
  28.         }   
  29.  
  30.          public   static   void  main(String[] args) {   
  31.                 Test4 t =  new  Test4();   
  32.                 Fk f = t.hehe();   
  33.                 System.out.println(f);   
  34.         }   
  35. }  

実行結果:
Fk{x='fk'}
Process finished with exit code 0
もう一つの古典的な例はthining in javaから来て、変更があります.

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

この応用は私たちに多くの思考を与えて、私は言わないで、異なる人が見て異なる感じがします.
内部類の巧みな使用はあなたのコードをとても牛にすることができて、もし形容するならば、それは:理解していない時に神が幽霊を出したと感じて、理解してから鬼斧神工を感じます.しかし、これらのコードが多くなって、他の人が理解したいのは難しいです.あなたの考えを理解したいのは難しいです.ほほほ!
六、静的内部クラス
静的内部クラスはstatic class型の内部クラスで、外部クラスの非静的メンバーにアクセスできないことを特徴としています.静的内部クラスオブジェクトを作成する場合は、外部クラスオブジェクトも必要ありません.
新外部クラス名内部クラス構築方法
で行ないます.

  
  
  
  
  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.  
  12.                 Inner(String name) {   
  13.                          this .name = name;   
  14.                 }   
  15.  
  16.                  void  sayHello() {   
  17.                         System.out.println( "Hello "  + name);   
  18.                         Outer.i++;   
  19.                 }   
  20.         }   
  21.  
  22.          public  Inner genInner(String name) {   
  23.                  return   new  Inner(name);   
  24.         }   
  25. }   
  26.  
  27. class  Test {   
  28.          public   static   void  main(String[] args) {   
  29.                 Outer.Inner in1 =  new  Outer.Inner( "1111" );   
  30.                 in1.sayHello();   
  31.                 System.out.println(Outer.i);   
  32.  
  33.                 Outer.Inner in2 =  new  Outer().genInner( "2222" );   
  34.                 in2.sayHello();   
  35.                 System.out.println(Outer.i);   
  36.         }   
  37. }  

実行結果:
Hello 1111
501
Hello 2222
502
Process finished with exit code 0
七、インタフェース内部クラス
インタフェースの内部クラスは自動的にpublic staticであり、インタフェースに変数タイプを定義することに相当します.これはjavaの設計で使用されています.例えば、HashMapでは、次のようなものがあります.
static class Entry implements Map.Entry
次に例を示します

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

八、内部のクラスのネスト
内部クラスネストとは,内部クラスに内部クラスを再定義することである.実はこの使い方は見たことがないので、簡単な例を書いてみましょう.

  
  
  
  
  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.  
  11.          class  A {   
  12.                  private   void  a() {   
  13.                         f0();   
  14.                         System.out.println( "a" );   
  15.                 }   
  16.  
  17.                  class  B {   
  18.                          protected   void  b() {   
  19.                                 a();   
  20.                                 System.out.println( "b" );   
  21.                         }   
  22.                 }   
  23.         }   
  24. }   
  25. class  Test{   
  26.          public   static   void  main(String[] args) {   
  27.                 Outer o =  new  Outer();   
  28.                 Outer.A    a =     o. new  A();   
  29.                 Outer.A.B b = a. new  B();   
  30.                 b.b();   
  31.         }   
  32. }  

実行結果:
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.  
  13.          class  Inner2  extends  Inner {   
  14.                  void  doSomething() {   
  15.                         System.out.println( "Inner2 doing ..." );   
  16.                 }   
  17.  
  18.                  void  readme() {   
  19.                         System.out.println( "HeHe!" );   
  20.                 }   
  21.         }   
  22. }   
  23.  
  24. class  Test {   
  25.          public   static   void  main(String[] args) {   
  26.                 Outer outer =  new  Outer();   
  27.                 Outer.Inner in = outer. new  Inner();   
  28.                 Outer.Inner2 in2 = outer. new  Inner2();   
  29.                 in.doSomething();   
  30.                 in2.doSomething();   
  31.                 in2.readme();   
  32.         }   
  33. }  

実行結果:
Inner doing ...
Inner2 doing ...
HeHe!
Process finished with exit code 0
まとめ:
内部クラスはJavaの中で最も複雑で奥深い概念の一つであり、内部クラスはアクセス制御、修飾子、継承、実現、抽象、シーケンス化など多くの面で迷っている問題であり、実際には、これらの問題は永遠に明らかにする機会がないかもしれないが、一般的には、以上の内部クラスの知識を知っていれば十分だ.
内部クラスのデザインはJava言語そのものの先天的な不足を補うのかもしれませんが、言語としては、この特性が変態すぎる点は、他に方法がないのではないでしょうか.
以上の総括は完全に実践の基礎の上で創立して、列挙した例は偏っているかもしれなくて、全面的に問題の本質を反映することができなくて、興味のある博友がもっと自分の見方と観点を発表することを望みます.
 
この文書はhttp://developer.51cto.com/art/201002/183375_1.htm
必要な友达に役に立つことを望んでいます.