research papers $5000up# Joke - 肚皮舞运动
g*y
1 楼
原帖见：http://www.mitbbs.com/article_t/JobHunting/32015883.html
说实在，那个主函数是一个很糟糕的写法，没有错误，但是awfully done。
现代软件工程的核心就是：代码易读易改。要做到这点，你的写法就不能违反直觉。
sneaker.Decorate(Alice); trouser.Decorate(sneaker); 就是这一段看不明白!!!!!
tshirt.Decorate(trouser); 虚函数+覆写函数 咋有递归的感觉
tshirt.Show(); code里用了英文单词，但是表达的完全不是那个意思，那就是对后来维护的人一种折磨。
Decorator的核心就是一个operation, 经过一条链来处理。这条链是可以动态增加的。
从结果看，你希望达到的效果就是：
decoratedObj.act()会依次call链上的每一个decorator的act()
要达到这种效果，那每个decorator需要知道前一个object, 这个可以通过creation来
实现(也可以象原code那样call Decorate()传进去)；然后需要返回自己，这样下一个
decorator才链接上。
为了实现以上的目的，我们需要给这些decorator定义一个公用的parent class, 简单
地说，
public class Decotorator {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
public void act() {
this.component.act();
}
}
啰嗦完，把那个code稍微改一下就是：
public class Person {
private String name;
public Person() {}
public Person(String name) {
this.name = name;
}
public void show() {
System.out.print("Decorated person is " + this.name + ".");
}
public static void main(String[] args) {
Person p = new Person("Alice");
Finery decorated = new TShirt(new BigTrouser(new Sneakers(p)));
decorated.show();
}
}
class Finery extends Person {
protected Person caller;
public Finery(Person caller) {
this.caller = caller;
}
public void show() {
caller.show();
}
}
class TShirt extends Finery {
public TShirt(Person caller) {
super(caller);
}
public void show() {
System.out.print("TShirt ");
caller.show();
}
}
class BigTrouser extends Finery {
public BigTrouser(Person caller) {
super(caller);
}
public void show() {
System.out.print("BigTrouser ");
caller.show();
}
}
class Sneakers extends Finery {
public Sneakers(Person caller) {
super(caller);
}
public void show() {
System.out.print("Sneakers ");
caller.show();
}
}
最后的主函数就是三句：
Person p = new Person("Alice");
Finery decorated = new TShirt(new BigTrouser(new Sneakers(p)));
decorated.show();
翻译成大白话：给人穿衣，穿裤，穿鞋，然后：
奔！
说实在，那个主函数是一个很糟糕的写法，没有错误，但是awfully done。
现代软件工程的核心就是：代码易读易改。要做到这点，你的写法就不能违反直觉。
sneaker.Decorate(Alice); trouser.Decorate(sneaker); 就是这一段看不明白!!!!!
tshirt.Decorate(trouser); 虚函数+覆写函数 咋有递归的感觉
tshirt.Show(); code里用了英文单词，但是表达的完全不是那个意思，那就是对后来维护的人一种折磨。
Decorator的核心就是一个operation, 经过一条链来处理。这条链是可以动态增加的。
从结果看，你希望达到的效果就是：
decoratedObj.act()会依次call链上的每一个decorator的act()
要达到这种效果，那每个decorator需要知道前一个object, 这个可以通过creation来
实现(也可以象原code那样call Decorate()传进去)；然后需要返回自己，这样下一个
decorator才链接上。
为了实现以上的目的，我们需要给这些decorator定义一个公用的parent class, 简单
地说，
public class Decotorator {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
public void act() {
this.component.act();
}
}
啰嗦完，把那个code稍微改一下就是：
public class Person {
private String name;
public Person() {}
public Person(String name) {
this.name = name;
}
public void show() {
System.out.print("Decorated person is " + this.name + ".");
}
public static void main(String[] args) {
Person p = new Person("Alice");
Finery decorated = new TShirt(new BigTrouser(new Sneakers(p)));
decorated.show();
}
}
class Finery extends Person {
protected Person caller;
public Finery(Person caller) {
this.caller = caller;
}
public void show() {
caller.show();
}
}
class TShirt extends Finery {
public TShirt(Person caller) {
super(caller);
}
public void show() {
System.out.print("TShirt ");
caller.show();
}
}
class BigTrouser extends Finery {
public BigTrouser(Person caller) {
super(caller);
}
public void show() {
System.out.print("BigTrouser ");
caller.show();
}
}
class Sneakers extends Finery {
public Sneakers(Person caller) {
super(caller);
}
public void show() {
System.out.print("Sneakers ");
caller.show();
}
}
最后的主函数就是三句：
Person p = new Person("Alice");
Finery decorated = new TShirt(new BigTrouser(new Sneakers(p)));
decorated.show();
翻译成大白话：给人穿衣，穿裤，穿鞋，然后：
奔！
