JAVA 复习(Think In Java, 4th) -- Inner Classes - Part2

Anonymous Inner Class

一般耒说，我们先实现接口，实现了以後，我们再从事相关的数据运算，如：

public class AInner {    public interface Inner {        public String getMsg();    }    public class MyInner implements Inner {        private String msg;        public MyInner() {            msg = "I am anonymous innner class!";        }        public String getMsg() {return msg;}    }    public Inner inner() {        return new MyInner();    }    public static void main(String[] args) {        AInner ai = new AInner();        Inner c = ai.inner();        System.out.println(c.getMsg());    }}

但是 AnonyMous Inner Class 可以让我们直接返回一个匿名类的对象，而不用宣告一个类，并实现该接口，它的意思也就是说

「创建一个继承该 Interface的对象」，代码如下，它的意义其实和上面的代码是一样的：

public class AInner {    public interface Inner {        public String getMsg();    }    public Inner inner() {        return new Inner() {            private String msg = "I am anonymous innner class!";            public String getMsg(){return msg;}        };    }    public static void main(String[] args) {        AInner ai = new AInner();        Inner c = ai.inner();        System.out.println(c.getMsg());    }}

其实这就像是 Android 的 View.OnClickListener() 的实现

// 看看 OnClickListener, 其实是个 interface    /**     * Interface definition for a callback to be invoked when a view is clicked.     */    public interface OnClickListener {        /**         * Called when a view has been clicked.         *         * @param v The view that was clicked.         */        void onClick(View v);    }// 而我们有时也就这麽用：...blablabla...mView.setOnClickListener(new OnClickListener() {    @Override    public void onClick(View v) {        ....blablabla....    }});... blablabla...

而我们工作时一般尽量不用这种匿名类方式实现，拿个例子耒说：

...mViewA.setOnClickListener(new OnClickListener() {    @Override    public void onClick(View v) {        処理方式A();    }});mViewB.setOnClickListener(new OnClickListener() {    @Override    public void onClick(View v) {        処理方式B();    }});mViewC.setOnClickListener(new OnClickListener() {    @Override    public void onClick(View v) {        処理方式C();    }});... 依此类推...

按上面这种实现方式的话，如果有 N 个可被点击的 View，那可能最多会有 N 个匿名类对象，而这些对象在程序运行时，都是占系统资源的，因此我们一般尽量这麽做

public class xxx extends ooo implements View.OnClickListener {...    @Override    public void onClick(View v) {        final int vid = v.getId();        switch(vid) {            case R.id.buttona:                処理事件A();                break;            case R.id.buttonb:                処理事件B();                break;            ....            default:break;        }    }...}

或是宣告一个 View.OnClickListener　的对象，然後让多个 View 引用。不同的処发事件，则使用覆写不同的 OnClick() 方法，以解决不同的需求，这便是典型的 Template Design Pattern。 

回到 Inner Classes的复习～我在练习的过程中，想试著放一些参数给 Anonymous Inner Class，但是就如下面看到的，Anonymous Class 的实现接口是不能放参数的（因为 Inner这个接口本身的Constructor就没有能放参数的），因为它是使用类的缺省(default) Constructor。

//: innerclasses/Parcel7.java// Returning an instance of an anonymous inner class.public class Parcel7 {  public Contents contents(final String name) {    return new Contents(name) { // Insert a class definition      private String mName = name;      private int i = 11;      public int value() { return i; }      public String getName(){ return mName;}    }; // Semicolon required in this case  }  public static void main(String[] args) {    Parcel7 p = new Parcel7();    Contents c = p.contents();    System.out.println(""+c.getName());  }} ///:~

我们如果要放参数的话，也是可以的，就直接另外定义一个实现该接口的类，同时让它的建构子

能放我们需要的参数就行了，如下：

public class AInner {    public interface Inner {        public String getMsg();    }    public class MyInner implements Inner {        private String mMsg;        public MyInner(String msg) {            mMsg = msg;        }        public String getMsg(){            return mMsg;        }    }    public Inner inner(final String msg) {        return new MyInner(msg);    }    public static void main(String[] args) {        AInner ai = new AInner();        Inner c = ai.inner("hi");        System.out.println(c.getMsg());    }}

虽然实现了，但这样就不是匿名类的做法了（有了 MyInner类），匿名类的做法，是在宣告一个 abstract class，

并且在该 abstract class实现构造函数，达到初始化的目的，如下：

public class AInnerPrac {    public abstract class People {        public People(String name) { // 把 Constructor 该做的事实现在这里            System.out.println("new fighter: " + name);        }        public abstract void run();     }    public People getPeople(final String name) {        return new People(name) {            @Override            public void run() {                System.out.println(name + " is running and fighting!");            }        };     }      public static void main(String[] args) {        AInnerPrac ap = new AInnerPrac();        People p = ap.getPeople("Shanwu");        p.run();        }}

public class AInnerPrac {    public abstract class People {        private String mName;　　　　　　　　// 多了这个就不用 getPeople(final String name)　了        public People(String name) {　　　　            mName = name;            System.out.println("new fighter: " + mName);        }        public abstract void run();         public String getName() { return mName; }　　// 直接把参数传进这个类    }    public People getPeople(String name) {        return new People(name) {          @Override            public void run() {                System.out.println(getName() + " is running and fighting!");            }        };     }      public static void main(String[] args) {        AInnerPrac ap = new AInnerPrac();        People p = ap.getPeople("Shanwu");        p.run();        }}

有了以上匿名类的基础知识後，我们可以改写一下JAVA 复习(Think In Java, 4th) -- Interface文中工厂方法

(Factory Method)模式的代码：

    interface provideCoffee {          String getCoffeeType();          void makeCoffee();      }            class VanillaCoffee implements provideCoffee {          @Override          public String getCoffeeType() {              return "Vanilla--Flavor Coffee";          }          @Override          public void makeCoffee() {              String action = "make "+getCoffeeType()+" coffee";              System.out.println(action);          }      }            class ChocolateCoffee implements provideCoffee {          @Override          public String getCoffeeType() {              return "Chocolate--Flavor Coffee";          }          @Override          public void makeCoffee() {              String action = "make "+getCoffeeType()+" coffee";              System.out.println(action);          }      }                  class Customer {          void getServed(provideCoffee coffee) {              coffee.makeCoffee();              String action = "Customer drinks "+ coffee.getCoffeeType();              System.out.println(action);          }            }      public class StarBucks {          public static void main(String[] args) {             Customer a = new Customer();             a.getServed(new VanillaCoffee());             a.getServed(new ChocolateCoffee());          }                 }  

修改後：

    interface provideCoffee {          String getCoffeeType();          void makeCoffee();      }           interface CoffeeMaker {        provideCoffee readyForCoffee();     }     class VanillaCoffee implements provideCoffee {          @Override          public String getCoffeeType() {              return "Vanilla--Flavor Coffee";          }          @Override          public void makeCoffee() {              String action = "make "+getCoffeeType()+" coffee";              System.out.println(action);          }                 public static CoffeeMaker coffeeMaker = new CoffeeMaker() {            @Override            public provideCoffee readyForCoffee() {                return new VanillaCoffee();            }        };    }            class ChocolateCoffee implements provideCoffee {          @Override          public String getCoffeeType() {              return "Chocolate--Flavor Coffee";          }          @Override          public void makeCoffee() {              String action = "make "+getCoffeeType()+" coffee";              System.out.println(action);          }        public static CoffeeMaker coffeeMaker = new CoffeeMaker() {            @Override            public provideCoffee readyForCoffee() {                return new ChocolateCoffee();            }        };    }            class Customer {          void getServed(CoffeeMaker cmaker) {            provideCoffee coffee = cmaker.readyForCoffee();            coffee.makeCoffee();              String action = "Customer drinks "+ coffee.getCoffeeType();              System.out.println(action);          }      }      public class StarBucks {        public static void main(String[] args) {             Customer a = new Customer();             a.getServed(VanillaCoffee.coffeeMaker);             a.getServed(ChocolateCoffee.coffeeMaker);          }           }

Nested Classes

当你的内部类对象和其所在的外部类对象没有什麽关系的时候，可以考据把你的内部类加上 static 属性，

加上 static 後的内部类又叫 nested class, 当你这麽做的时候，代表二件事：

一、内部类对象不用再依靠创建外部类对象以後再创建内部类对象。

二、内部类对象不能再存取外部类的 non-static 类成员(因为内部类有了 static 属性)

练习的时候发现假如在nested class 里再宣告一个 nested class，用下面的方式就会出错：

public class NestedClassPrac {    public static class Nested {        public void sayHello() { System.out.println("First nested class~");}        public static class LittleNested {            public void sayHello() { System.out.println("this is why we are nested class");}        }    }    public static void main(String[] args) {        Nested a = new Nested();        a.sayHello();        LittleNested b = new Nested();        b.sayHello();        }}

其实应该用下面这种方式来做：

public class NestedClassPrac {    public static class Nested {        public void sayHello() { System.out.println("First nested class~");}        public static class LittleNested {            public void sayHello() { System.out.println("this is why we are nested class");}        }    }    public static void main(String[] args) {        Nested a = new Nested();        a.sayHello();        Nested.LittleNested b = new Nested.LittleNested();         b.sayHello();         }}

Closures & callbacks

Closure 指的是一个自产生到结束的过程都存在，并持有资讯数据的可呼叫物件。

而在这一章，我们可以发现 Inner Class 便是个物件导向的 Closure。

从下面的代码可以看到，mOnClickListener 透过 setOnClickListener()而和外界得已接触，外界可自行实现一个接口传入，从而

有不同的 Click 事件的処理。而在本例 OnClickListener 所触发的事件已被　JavaClosure　类实现，我们可以创一个内部类，

另外实现一个方法。

interface OnClickListener {    void onClick();}public class JavaClosure implements OnClickListener {    private OnClickListener mOnClickListener;    public void setOnClickListener(OnClickListener l) {        mOnClickListener = l;    }    public void click() {        System.out.println("clicked");        if(mOnClickListener!=null) {            mOnClickListener.onClick();        }    }    @Override    public void onClick() {        System.out.println("hello! I am listener!!");    }    public OnClickListener getType2ClickEvent() {        return new Type2ClickListener();    }    private static class Type2ClickListener implements OnClickListener {        @Override        public void onClick() {            System.out.println("hello! I am type 2 listener!!");        }    }    public static void main(String[] args) {        JavaClosure jcbtn = new JavaClosure();        jcbtn.setOnClickListener(jcbtn);        jcbtn.click();        jcbtn.setOnClickListener(jcbtn.getType2ClickEvent());        jcbtn.click();    }}

其它：

http://stackoverflow.com/questions/26029272/nested-class-as-testing-method-in-java