设计模式(行为型)

发表于 | 分类于 |
字数统计: 493 | 阅读时长 ≈ 2

[TOC]

观察者模式

观察者

1
2
3
public interface Observer {
    void update(float temp);
}

主题

1
2
3
4
5
public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObserver();
}

现在的

1
2
3
4
5
6
7
8
9
10
11
public class CurrentConditionsDisplay implements Observer {
    public CurrentConditionsDisplay(Subject weatherData) {
        weatherData.registerObserver(this);
    }


    @Override
    public void update(float temp) {
        System.out.println("Current temp: "+temp);
    }
}
1
2
3
4
5
6
7
8
9
10
11
public class StatisticsDisplay implements Observer {
    public StatisticsDisplay(Subject weatherData) {
        weatherData.registerObserver(this);
    }


    @Override
    public void update(float temp) {
        System.out.println("Statistics temp: "+temp);
    }
}

数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class WeatherData implements Subject {
    private List<Observer> observers;
    private float temperature;
    public WeatherData() {
        observers = new ArrayList<>();
    }
    public void setMeasurements(float temperature) {
        this.temperature = temperature;
        notifyObserver();
    }
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }
    @Override
    public void removeObserver(Observer o) {
        int i = observers.indexOf(o);
        if (i >= 0) {
            observers.remove(i);
        }
    }
    @Override
    public void notifyObserver() {
        for (Observer o : observers) {
            o.update(temperature);
        }
    }
}

实例化

1
2
3
4
5
6
7
8
9
10
public class WeatherStation {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay currentConditionsDisplay = new
                CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
        weatherData.setMeasurements(0);
        weatherData.setMeasurements(1);
    }
}

模板模式

通过模板方法，子类可以重新定义算法的某些步骤，而不用改变算法的结构。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public abstract class CaffeOrTea
{
    final void prepare()
    {
        boil();
        brew();
        pour();
        
    }
    abstract void brew();
    abstract void pour();
    void boil()
    {
        System.out.println("boil");
    }
}
public class Coffee extends CaffeOrTea{
    @Override
    void brew()
    {
        System.out.println("Coffee.brew");
    }
}
public class Tea extends CaffeOrTea{
    @Override
    void brew()
    {
        System.out.println("Tea.brew");
    }
}
public class test
{
    public static void main(String[] args)
    {
        CaffeeOrTea c=new Coffee();
        c.prepare();
    }
}

策略模式

定义一系列算法，封装每个算法，并使它们可以互换。

设计一个鸭子，它可以动态地改变叫声。这里的算法族是鸭子的叫声行为。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public interface QuackBehavior{
    void quack();
}
public class Quack implements QuackBehavior{
    @Override
    public void quack()
    {
        System.out.println("Quack!");
    }
}
public class Gaga implements QuackBehavior{
    @Override
    public void quack()
    {
        System.out.println("Gaga!");
    }
}
public class Duck {
  private QuackBehavior quackBehavior;
  public void performQuack() {
  if (quackBehavior != null) {
  quackBehavior.quack();
  }
}
public void setQuackBehavior(QuackBehavior quackBehavior) {
  this.quackBehavior = quackBehavior;
 }
}
public class test
{
 public static void main(String[] args) {
    Duck duck = new Duck();
    duck.setQuackBehavior(new Squeak());
    duck.performQuack();
    duck.setQuackBehavior(new Quack());
    duck.performQuack();
 }
}