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