第三周学习总结 ---- 几种设计模式的练习

 关注
发布于: 2020 年 06 月 24 日
     第二周课的时候通过一个拨打电话号码的Case老师讲解了几种常用的设计模式，当时对于几种设计模式 体会不是很深有些地方也没太弄明白，然后本周老师又拿其他同学的作业给大家参考讲解了一下，在此我也参考优秀同学的作业，自己总结一下：
原始UML类图设计：
UML类图对应的代码：
public class Button{
  
	public final static int SEND_BUTTON = -99;
  private Dialer dialer;
  private int token;
  
  public Button(int token, Dialer dialer){
  	this.token = token;
    this.dialer = dialer;
  }
  
  public void press(){
  	switch(token){
      case 0: case 1: case 2: case 3: case 4:
      case 5: case 6: case 7: case 8: case 9:
        dialer.entreDigit(token);
        break;
      case SEND_BUTTON:
        dialer.dial();
        break;
      default:
        thor new UnsupportedOperationException("unknow button pressed: token=" + token);
       
    }
  }
}
﻿
public class Dialer{
	public void enterDigit(int digit){
  	scree.display(digit);
    speaker.beep(digit);
  }
  
  public void dial(){
  	screen.display("dialing...");
    radio.connect();
  }
}
以上设计存在的问题：
改进方法一：使用继承多态的方式
Button类：
public class Button{ 
  
    public void press(){}
  
}
DigitButton类：
public class DigitButton extends Button {
    
    private int token;
    Dailer dailer;
    public DigitButton (int token,Dailer dailer) {
        this. token = token;
        this.dailer = dailer ;
    }
    @Override
    public void press() {
        dailer.enterDigit(token);
    }
}
SendButton类：
public class SendButton extends Button {
    Dailer dailer;
    public SendButton (Dailer dailer) {
        this.dailer = dailer ;
    }
    @Override
    public void press() {
        super.press();
        dailer.dial();
    }
}
Dailer类：
public class Dailer {
    public void enterDigit (int digit) {
        System.out.println("展示这个数字"+digit);
        System.out.println("声音"+digit);
    }
    public void dial () {
        System.out.println("展示输入数字串");
        System.out.println("无限传播连接");
    }
}
改进方法二：策略模式
﻿
策略模式把对象本身和运算规则区分开来，因此我们整个模式也分为三个部分。
环境类(Context):用来操作策略的上下文环境，也就是 按键。
抽象策略类(Strategy):策略的抽象，
按键的抽象具体策略类(ConcreteStrategy):具体的策略实现，每一个按键的具体实现。
第一步：定义抽象策略接口 ButtonServer
public interface ButtonServer {
    public void buttonPress(int token) ;
  
}
第二步：具体策略类 Dailer类：
public class Dailer implements ButtonServer {
    List<Integer> buttonList = new LinkedList<>();
    public void enterDigit(int digit) {
        System.out.println("展示这个数字"+digit);
        System.out.println("声音"+digit);
    }
    public void dial() {
        for (Integer token : buttonList) {
            System.out.print(token);
        }
        System.out.println("无限传播 connect");
    }
    @Override
    public void buttonPress(int token) {
        if(token > 0 && token < 9){
            buttonList.add(token);
            enterDigit(token);
        }
        if(token == 99){
            dial();
        }
    }
}
第三步：环境类实现Button类：
﻿
public class Button {
    private int token;
    private  ButtonServer buttonServer;
    public Button(int token, ButtonServer buttonServer) {
        this.token = token;
        this.buttonServer = buttonServer;
    }
    public void press(){
        buttonServer.buttonPress(token);
    }
  
  public static void main(String[] args){
  	Button button1 = new Button(1, new Dailer);
    Button button2 = new Button(2, new Dailer);
    Button sendButton = new Button(99, new Dailer);
    
    button1.press();
    button2.press();
    sendButton.press();
  }
}
﻿
方法三：适配器模式 （Adapter Pattern）
﻿
 Button 类调用 ButtonServer
public class Button {
    ButtonServer buttonServer;
    public Button(ButtonServer dialer) {
        this.buttonServer = dialer;
    }
    public void press(){
        buttonServer.buttonPress();
    }
}
﻿
目标接口ButtonServer 类：
public interface ButtonServer {
    public void buttonPress();
}
﻿
DigitButtonDialerAdapter类
public class DigitButtonDialerAdapter implements ButtonServer{
    private int token;
    private Dialer dialer;
    public DigitButtonDialerAdapter(int token,Dialer dialer) {
        this.token = token;
        this.dialer = dialer;
    }
    public Dialer getDialer() {
        return dialer;
    }
    public void setDialer(Dialer dialer) {
        this.dialer = dialer;
    }
    @Override
    public void buttonPress() {
        dialer.enterDigit(token);
    }
}
SendButtonDialerAdapter类
public class SendButtonDialerAdapter implements ButtonServer{
    private Dialer dialer;
    public SendButtonDialerAdapter(Dialer dialer) {
        this.dialer = dialer;
    }
    public Dialer getDialer() {
        return dialer;
    }
    public void setDialer(Dialer dialer) {
        this.dialer = dialer;
    }
    @Override
    public void buttonPress() {
        dialer.dial();
    }
}
﻿
﻿
public class Test {
    public static void main(String[] args) {
        Dialer dialer = new Dialer();
        Button button1 = new Button(new DigitButtonDialerAdapter(1,dialer));
        Button button2 = new Button(new DigitButtonDialerAdapter(2,dialer));
        Button button3 = new Button(new DigitButtonDialerAdapter(3,dialer));
﻿
        Button sendButton = new Button(new SendButtonDialerAdapter(dialer));
﻿
        button1.press();
        button2.press();
        button3.press();
﻿
        sendButton.press();
    }
}
方法四：观察者模式
Button类：
public class Button {
    private List<ButtonListener> listeners;
    public Button() {
        this.listeners = new LinkedList<ButtonListener>();
    }
    public void addListener(ButtonListener listener) {
        assert listener != null;
        listeners.add(listener);
    }
    public void press(){
        for (ButtonListener buttonListener : listeners) {
            buttonListener.buttonPressed();
        }
    }
}
ButtonListener类：
public interface ButtonListener {
    
    public void buttonPressed();
    
}
D ailer类
public class Dialer {
    public void enterDigit (int digit) {
        System.out.println("展示这个数字"+digit);
        System.out.println("声音"+digit);
    }
    public void dial () {
        System.out.println("展示输入数字串");
        System.out.println("无限传播连接");
    }
}
Phone类
public class Phone {
    private Dialer dialer;
    private Button[] digitButtons;
    private Button sendButton;
    public Phone(){
        dialer = new Dialer();
        digitButtons = new Button[10];
        for(int i = 0;i < digitButtons.length;i++){
            digitButtons[i] = new Button();
            final int digit = i;
            digitButtons[i].addListener(new ButtonListener() {
                @Override
                public void buttonPressed() {
                    dialer.enterDigit(digit);
                }
            });
        }
        sendButton = new Button();
        sendButton.addListener(new ButtonListener() {
            @Override
            public void buttonPressed() {
                dialer.dial();
            }
        });
    }
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.digitButtons[9].press();
        phone.digitButtons[1].press();
        phone.digitButtons[1].press();
        phone.sendButton.press();
    }
}
﻿
以上代码大部分拷贝了老师所讲到的那位优秀同学的代码，本人也仔细阅读分析了，只是在第四种模式上，理解的不太到位 。
　观察者模式（Observer），又叫发布-订阅模式（Publish/Subscribe），定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。
按照观察者模式的定义和UML结构图来说 即便参考云同学的代码，我也没太理解到位，后绪有时间我再找老师请教吧。
﻿
发布于: 2020 年 06 月 24 日阅读数: 30
Geek_165f3d

 关注
还未添加个人签名 2019.12.14 加入
还未添加个人简介
发布
暂无评论