设计模式学习笔记(二)之观察者模式、装饰者模式

观察者模式的简单理解：

多个观察者时刻关注主题的动态，主题一旦有变化及时反馈。

实现：

抽象观察者：

抽象类声明一个方法：对主题的变化做出反馈。

public abstract class Observer {

    public abstract void Update();
    
}

抽象主题：

一个字段：抽象观察者的集合。一个主题对应多个观察者，是一对多的一种体现。

三个方法：addObserver(添加观察者)，delObserver(删除观察者)。

Notify(唤醒观察者)：提醒观察者已经发生变化。遍历集合里的所有观察者，使每个观察者做出反馈。

public abstract class Subject {

    private List<Observer> list=new ArrayList<Observer>();
    
    public void addObserver(Observer observer){
        list.add(observer);
    }
    public void delObserver(Observer observer){
        list.remove(observer);
    }
    public void Notify(){
        for(Observer o:list){
            
            o.Update();
        }    
    }
}

具体主题：

一个字段：主题的当前状态。

public class ConcreteSubject extends Subject {

    private String subjectState;
    
    public void setSubjectState(String subjectState){
        
        this.subjectState=subjectState;
    }
    public String getSubjectState(){
        return subjectState;
    }
}

具体观察者：

Update方法：对主题的变化做出反馈的具体实现。

public class ConcreteObserver extends Observer{

    private String observerState;
    private String name;
    private ConcreteSubject subject;
    
    public ConcreteObserver(ConcreteSubject subject,String name){
        this.subject=subject;
        this.name=name;
    }
    
    public ConcreteSubject getSubject() {
        return subject;
    }

    public void setSubject(ConcreteSubject subject) {
        this.subject = subject;
    }
    
    @Override
    public void Update() {
        // TODO Auto-generated method stub
        observerState=subject.getSubjectState();
        System.out.println("The observer's state of "+name+" is "+ observerState);

    }

}

测试类：

public class Test {
    public static void main(String[] args) {
        ConcreteSubject subject=new ConcreteSubject();
        subject.addObserver(new ConcreteObserver(subject, "Observer A"));
        subject.addObserver(new ConcreteObserver(subject, "Observer B"));
        subject.addObserver(new ConcreteObserver(subject, "Observer C"));
        

        subject.setSubjectState("Ready");
        subject.Notify();
        
        
        subject.setSubjectState("Start");
        subject.Notify();
    }

}

 输出：

The observer's state of Observer A is Ready
The observer's state of Observer B is Ready
The observer's state of Observer C is Ready
The observer's state of Observer A is Start
The observer's state of Observer B is Start
The observer's state of Observer C is Start

装饰者模式的简单理解：

动态的给一个对象增加一些装饰，使其拥有更多功能或属性。

实现：

抽象类Girl：被装饰者的父类，拥有Girl的属性和一个描述Girl的方法。

public abstract class Girl {

    public String description="no particular";
    
    public String getDescription(){
        
        
        return description;
    }
    
    
}

被装饰者：中国Girl,美国Girl.为Girl添加属性，定义特定类型Girl。

public class ChineseGirl extends Girl {

    public ChineseGirl(){
        super.description="Chinese Girl";
    }
}

public class AmericanGirl extends Girl{

    public AmericanGirl(){
        
        super.description="American Girl";
        
    }
}

装饰者(抽象)：继承Girl类的描述方法，并把该方法承接给自己的子类(装饰者)。

装饰者与被装饰者拥有共同的超类(Girl)

public abstract class GirlDecorator extends Girl {

    public abstract String getDescription();

}

装饰者：为特定类型Girl添加描述。

public class Art extends GirlDecorator{
    private Girl girl;
    public Art(Girl girl){
        this.girl=girl;
    }        
    @Override
    public String getDescription() {
        // TODO Auto-generated method stub
        return this.girl.getDescription()+"+like Art";
    }
    public void draw(){
        System.out.println("draw pictures!");
    }    
}


public class Music extends GirlDecorator{
    private Girl girl;    
    public Music(Girl girl){
        this.girl=girl;
    }    
    @Override
    public String getDescription() {
        // TODO Auto-generated method stub
        return this.girl.getDescription()+"+like Music";
    }
    public void Singing(){
        System.out.println("Singing Music");
    }
}

测试类：

public class Test {

    public static void main(String[] args) {
        
        Girl g1=new AmericanGirl();
        
        System.out.println(g1.getDescription());
        
        Art g2=new Art(g1);        
        System.out.println(g2.getDescription());
        
        Music g3=new Music(g2);
        System.out.println(g3.getDescription());
        
    }
}

输出：

American Girl
American Girl+like Art
American Girl+like Art+like Music