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

　　四方法內部類

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

　　/**

　　* 內部類實現接口

　　*

　　* @author leizhimin ::

　　*/

　　public class Test {

　　public static void main(String[] args) {

　　Outer outer = new Outer();

　　Foo f = outergenFoo();

　　Bar b = outergenBar();

　　fsay();

　　breadme();

　　}

　　}

　　class Outer {

　　public Foo genFoo() {

　　//方法內的內部類

　　class FooImpl implements Foo {

　　public void say() {

　　Systemoutprintln(say foo!);

　　}

　　}

　　return new FooImpl();

　　}

　　public Bar genBar() {

　　Bar b = null;

　　if (true) {

　　//任意位置的內部類

　　class BarImpl implements Bar {

　　public void readme() {

　　Systemoutprintln(say bar!);

　　}

　　}

　　b = new BarImpl();

　　}

　　return b;

　　}

　　}

　　運行結果

　　say foo!

　　say bar!

　　Process finished with exit code

　　五匿名類

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

　　在一些多線程程序中比較常見有點變態呵呵

　　/**

　　* 匿名類

　　*

　　* @author leizhimin ::

　　*/

　　public class Test {

　　public Foo f = new Foo() {

　　public void say() {

　　Systemoutprintln(O(∩_∩)O哈哈~!);

　　}

　　};

　　public Foo test() {

　　return new Foo() {

　　public void say() {

　　Systemoutprintln(say foo!);

　　}

　　};

　　}

　　public static void main(String[] args) {

　　Test t = new Test();

　　tfsay();

　　ttest()say();

　　}

　　}

　　interface Foo {

　　void say();

　　}

　　運行結果

　　say foo!

　　Process finished with exit code

　　/**

　　* 普通類的匿名初始化

　　*

　　* @author leizhimin ::

　　*/

　　public class Fk {

　　private String x;

　　public Fk(String x) {

　　thisx = x;

　　}

　　@Override

　　public String toString() {

　　return Fk{ +

　　x= + x + \ +

　　};

　　}

　　}

　　class Test {

　　public Fk hehe() {

　　//把後面的一對大括號去掉呢呵呵

　　return new Fk(fk) {

　　};

　　}

　　public static void main(String[] args) {

　　Test t = new Test();

　　Fk f = thehe();

　　Systemoutprintln(f);

　　}

　　}

　　運行結果

　　Fk{x=fk}

　　Process finished with exit code

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

　　interface Service {

　　void method();

　　void method();

　　}

　　interface ServiceFactory {

　　Service getService();

　　}

　　class Implementation implements Service {

　　private Implementation() {}

　　public void method() {Systemoutprintln(Implementation method);}

　　public void method() {Systemoutprintln(Implementation method);}

　　public static ServiceFactory factory = new ServiceFactory() {

　　public Service getService() {

　　return new Implementation();

　　}

　　};

　　}

　　class Implementation implements Service {

　　private Implementation() {}

　　public void method() {Systemoutprintln(Implementation method);}

　　public void method() {Systemoutprintln(Implementation method);}

　　public static ServiceFactory factory = new ServiceFactory() {

　　public Service getService() {

　　return new Implementation();

　　}

　　};

　　}

　　public class Factories {

　　public static void serviceConsumer(ServiceFactory fact) {

　　Service s = factgetService();

　　thod();

　　thod();

　　}

　　public static void main(String[] args) {

　　serviceConsumer(Implementationfactory);

　　serviceConsumer(Implementationfactory);

　　}

　　}

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

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

　　六靜態內部類

　　靜態內部類是static class型的內部類這種內部類特點是它不能訪問外部類的非靜態成員要創建靜態內部類對象時候也不需要外部類對象了直接可以

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

　　來創建給個例子

　　/**

　　* 靜態內部類

　　*

　　* @author leizhimin ::

　　*/

　　public class Outer {

　　public static int i =;

　　protected static class Inner {

　　int i =;

　　String name;

　　Inner(String name) {

　　thisname = name;

　　}

　　void sayHello() {

　　Systemoutprintln(Hello + name);

　　Outeri++;

　　}

　　}

　　public Inner genInner(String name) {

　　return new Inner(name);

　　}

　　}

　　class Test {

　　public static void main(String[] args) {

　　OuterInner in = new OuterInner();

　　insayHello();

　　Systemoutprintln(Outeri);

　　OuterInner in = new Outer()genInner();

　　insayHello();

　　Systemoutprintln(Outeri);

　　}

　　}

　　運行結果

　　Hello

　　

　　Hello

　　

　　Process finished with exit code

　　七接口內部類

　　接口內部類自動都是public static的相當於為接口定義了一種變量類型這在java的設計中就有使用比如在HashMap中就有

　　static class Entry implements MapEntry

　　下面我給個例子

　　/**

　　* 接口內部類

　　*

　　* @author leizhimin ::

　　*/

　　public interface AInterface {

　　void readme();

　　class Inner implements AInterface {

　　public void readme() {

　　Systemoutprintln(我是一個接口內部類);

　　}

　　}

　　}

　　class Main {

　　public static void main(String[] args) {

　　AInterfaceInner in = new AInterfaceInner();

　　inreadme();

　　}

　　}

　　八內部的類的嵌套

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

　　/**

　　* 嵌套內部類

　　*

　　* @author leizhimin ::

　　*/

　　public class Outer {

　　private void f() {

　　Systemoutprintln(f);

　　}

　　class A {

　　private void a() {

　　f();

　　Systemoutprintln(a);

　　}

　　class B {

　　protected void b() {

　　a();

　　Systemoutprintln(b);

　　}

　　}

　　}

　　}

　　class Test{

　　public static void main(String[] args) {

　　Outer o = new Outer();

　　OuterA    a =     onew A();

　　OuterAB b = anew B();

　　bb();

　　}

　　}

　　運行結果

　　f

　　a

　　b

　　Process finished with exit code

　　八內部類的繼承

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

　　/**

　　* 內部類的繼承可以繼承內部類也可以繼承外部類

　　*

　　* @author leizhimin ::

　　*/

　　public class Outer {

　　class Inner {

　　void doSomething() {

　　Systemoutprintln(Inner doing );

　　}

　　}

　　class Inner extends Inner {

　　void doSomething() {

　　Systemoutprintln(Inner doing );

　　}

　　void readme() {

　　Systemoutprintln(HeHe!);

　　}

　　}

　　}

　　class Test {

　　public static void main(String[] args) {

　　Outer outer = new Outer();

　　OuterInner in = outernew Inner();

　　OuterInner in = outernew Inner();

　　indoSomething();

　　indoSomething();

　　inreadme();

　　}

　　}

　　運行結果

　　Inner doing

　　Inner doing

　　HeHe!

　　Process finished with exit code

　　總結

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

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

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

From:http://tw.wingwit.com/Article/program/Java/hx/201311/26666.html