标签：
Seven：装饰模式
装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例，下图是类与类之间的关系。
但是这个类图并没有表现出不同的装饰风格时候要如何应对，比如一个女人，她需要的装饰肯定不会只有一种，这个时候这个类图的缺点就显示出来了，太过简洁。补救的方法也很简单，对Decorator类进行扩展，对method()方法进行覆盖，就可以达到多种多样的装饰风格的目的。
下面是一个文本框，对其进行不同的修饰，一个为其装上滚动条，一个为其画上边框。
被装饰类
<span style="font-size:14px;">package com.zcl.design.decorator;
public class TextView extends VisualComponent {
@Override
public void draw() {
System.out.println("在窗口显示正文");
}
}</span>
共同的父类package com.zcl.design.decorator;
public abstract class VisualComponent {
public abstract void draw();
}装饰类package com.zcl.design.decorator;
public class Decorator extends VisualComponent {
//要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例
private VisualComponent textview;
public Decorator(VisualComponent component) {
this.textview=component;
}
@Override
public void draw() {
System.out.println("在Dectorator类中对textview进行装饰");
textview.draw();//被装饰的draw方法
}
}
装饰类的子类（分别担当不同的装饰风格）package com.zcl.design.decorator;
public class ScrollDecorator extends Decorator {
private boolean mscroll;
private void scrollTo(boolean mscroll) {
if (mscroll) {
System.out.println("为TextView加上滚动条");
} else {
System.out.println("不为TextView加上滚动条");
}
}
public ScrollDecorator(VisualComponent component,boolean scroll) {
super(component);
this.mscroll=scroll;
}
public void draw() {
super.draw();//父类的
scrollTo(mscroll);
}
}
加上边框package com.zcl.design.decorator;
public class BorderDecorator extends Decorator {
private int mborderWidth;
private void drawBorder(int borderWidth){
System.out.println("为TextView画上"+borderWidth+"cm的边框");
}
public BorderDecorator(VisualComponent component,int borderWidth) {
super(component);
this.mborderWidth= borderWidth;
}
public void draw() {
super.draw();
drawBorder(mborderWidth);
}
}
测试类package com.zcl.design.decorator;
public class Client {
public static void main(String[] args) {
VisualComponent textView = new TextView();//被装饰者对象
BorderDecorator borderDecorator = new BorderDecorator(textView,5);//装饰者子类对象1
borderDecorator.draw();
ScrollDecorator scrollDecorator=new ScrollDecorator(textView, true);//装饰者子类对象2
scrollDecorator.draw();
}
}
装饰器模式是装饰者在自身的相同函数内内通过被装饰者对象调用其相应函数的形式在自身内完成调用，并且完成其他的内容完成对被装饰者的装饰作用。外观模式是一种很简单的模式，其作用也很简单，是为了降低类与类之间的耦合
例如：你要打开门才能打开灯，煮饭，睡觉等一系列动作。这样这个门就是他们的外观，一切的动作都要先进门然后你可以对里面的任何一种动作进行实施。
Light
package com.zcl.design.Facade;
public class Light {
public void openLight() {
System.out.println("打开灯");
}
}
Bedpackage com.zcl.design.Facade;
public class Bed {
public void sleep() {
System.out.println("在床上睡觉");
}
}
Foodpackage com.zcl.design.Facade;
public class Food {
public void EatFood() {
System.out.println("吃东西");
}
}然后就是重头类了我们的Door类
Door
package com.zcl.design.Facade;
public class Door {
private Food food = new Food();
private Bed bed = new Bed();
private Light light = new Light();
public Door() {
System.out.println("进了门");
}
public void foodmethod() {
this.food.EatFood();
}
public void bedmethod() {
this.bed.sleep();
}
public void lightmenthod() {
this.light.openLight();
}
}
测试类Clientpackage com.zcl.design.Facade;
public class Client {
public static void main(String[] args) {
Door door = new Door();
door.bedmethod();
door.foodmethod();
door.lightmenthod();
}
}
点评:这个模式只是将其他类封装到一个“袋子里”，而只留一个口来进行跟外界的交互。这样这些类都依赖于这一个类，总体上降低了类与类之间的耦合。但是各个类都跟这一个类有交互，这个类会很庞大，而且很复杂，是这个模式的一个缺点。
这里面我贴上一个Demo的代码，大家可以品一品。
package com.zcl.design.bridge.pen;
public interface Color {
public void bepaint(String penType, String name);
}
package com.zcl.design.bridge.pen;
public class Blue implements Color {
public void bepaint(String penType, String name) {
System.out.println(penType + " 蓝色的" + name + ".");
}
}
package com.zcl.design.bridge.pen;
public abstract class Pen {
protected Color color;
public void setColor(Color color) {
this.color = color;
}
public abstract void draw(String name);
}package com.zcl.design.bridge.pen;
public class BigPen extends Pen {
public void draw(String name) {
String penType = " 大号毛笔绘制";
this.color.bepaint(penType, name);
}
}
测试类：
package com.zcl.design.bridge.pen;
public class Client {
public static void main(String[] args) {
Color color=new Blue();
Pen pen = new BigPen();
pen.setColor(color);
pen.draw(" 鲜花");
}
}
Ten：策略模式package com.zcl.design.celue;
/**
* @author zcl
*
*/
public class Person {
private TravelStrategy strategy;
public void setStrategy(TravelStrategy strategy) {
this.strategy = strategy;
}
public void travel() {
strategy.travel();
}
}
package com.zcl.design.celue;
/**
* @author zcl
*
*/
public abstract class TravelStrategy {
public abstract void travel();
}package com.zcl.design.celue;
/**
* @author zcl
*
*/
public class AirplaneStrategy extends TravelStrategy {
@Override
public void travel() {
System.out.println("The Customer choose the AirplaneStrategy");
}
}package com.zcl.design.celue;
/**
* @author zcl
*
*/
public class BicycleStrategy extends TravelStrategy {
@Override
public void travel() {
System.out.println("The Customer choose the BicycleStrategy");
}
}package com.zcl.design.celue;
/**
* @author zcl
*
*/
public class TrainStrategy extends TravelStrategy {
@Override
public void travel() {
System.out.println("The Customer choose the TrainStrategy");
}
}
测试类Clientpackage com.zcl.design.celue;
public class Test {
public static void main(String[] args) {
Person person = new Person();
TravelStrategy airplaneStrategy = new AirplaneStrategy();
TravelStrategy bicycleStrategy = new BicycleStrategy();
TravelStrategy trainStrategy = new TrainStrategy();
person.setStrategy(airplaneStrategy);
person.travel();
person.setStrategy(bicycleStrategy);
person.travel();
person.setStrategy(trainStrategy);
person.travel();
}
}
Eleven:观察者模式package com.zcl.design.observer;
import java.util.*;
public abstract class MySubject {
protected ArrayList observers = new ArrayList();
// 注册方法
public void attach(MyObserver observer) {
observers.add(observer);
}
// 注销方法
public void detach(MyObserver observer) {
observers.remove(observer);
}
// 抽象通知方法
public abstract void rain();
}package com.zcl.design.observer;
public class Rain extends MySubject {
//通知方法，通知观察者
public void rain() {
System.out.println("下雨了");
System.out.println("----------------------------");
for (Object obs : observers) {
((MyObserver) obs).response();
}
}
}上面是被观察者package com.zcl.design.observer;
public interface MyObserver {
//抽象响应方法
public void response();
}
package com.zcl.design.observer;
public class Woman implements MyObserver {
//响应方法
@Override
public void response() {
System.out.println("起来收衣服");
}
}
package com.zcl.design.observer;
public class Man implements MyObserver {
//响应方法
@Override
public void response() {
System.out.println("继续看电视，下雨跟我没什么关系");
}
}上面是观察者
测试类Client
package com.zcl.design.observer;
public class Client {
public static void main(String a[]) {
MySubject subject = new Rain();
MyObserver obs1 = new Man();
MyObserver obs2 = new Woman();
subject.attach(obs1);
subject.attach(obs2);
subject.rain();
}
}
<textarea class="goog-textarea short_text" id="source-is" name="text-is" disabled="disabled" dir="ltr" style="overflow-y:hidden; overflow-x:auto; padding-bottom:32px; height:69px; padding-right:20px"></textarea>
标签：
原文地址：http://blog.csdn.net/zcl1359205840/article/details/51889767
