什么是设计模式
目录
1.设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
2.设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性
抽象工厂模式
抽象类 PcFactory
public abstract class PcFactory {
//制作方法
public abstract Mouse makeMouse();
public abstract Keyboard makeKeyboard();
//为得到具体的工厂的方法服务
private static HpFactory hpFactory = new HpFactory();
private static LogicFactory logicFactory = new LogicFactory();
//为得到具体的工厂的方法服务
public final static int PC_TYPE_HP = 1;
public final static int PC_TYPE_LG = 2;
/**
* 得到具体的工厂的方法
* @param pcType传入表示电脑类型的常数
* @return 返回PcFactory抽象类:面向抽象编程代替面向具体编程
*/
public static PcFactory getPcFactory(int pcType) {
switch (pcType){
case 1:
return hpFactory;
case 2 :
return logicFactory;
default:
return null;
}
}
}
惠普工厂 HpFactory
public class HpFactory extends PcFactory {
//返回抽象类:面向抽象编程代替面向具体编程
@Override
public Mouse makeMouse() {
return new HpMouse();
}
@Override
public Keyboard makeKeyboard() {
return new HpKeyboard();
}
}
罗技工厂 LogicFactory
public class LogicFactory extends PcFactory {
@Override
public Mouse makeMouse() {
return new LogicMouse();
}
@Override
public Keyboard makeKeyboard() {
return new LogicKeyboard();
}
}
键盘抽象类 Keyboard
public abstract class Keyboard {
abstract String getInfo();
}
惠普键盘类 HpKeyboard
public class HpKeyboard extends Keyboard {
@Override
String getInfo() {
return "HP keyboard";
}
}
罗技键盘类 LogicKeyboard
public class LogicKeyboard extends Keyboard {
@Override
String getInfo() {
return "logic keyboard";
}
}
鼠标抽象类 Mouse
public abstract class Mouse {
abstract String getInfo();
}
惠普鼠标类 HpMouse
public class HpMouse extends Mouse {
@Override
String getInfo() {
return "HP mouse";
}
}
罗技鼠标类 LogicMouse
public class LogicMouse extends Mouse {
@Override
String getInfo() {
return "logic mouse";
}
}
测试类
public class Main {
public static void main(String[] args) {
//通过抽象PcFactory父类得到HP电脑制作工厂
PcFactory HpFactory = PcFactory.getPcFactory(PcFactory.PC_TYPE_HP);
//得到HP制作键盘的方法
Keyboard keyboard = HpFactory.makeKeyboard();
//得到HP制作鼠标的方法
Mouse mouse = HpFactory.makeMouse();
System.out.println(keyboard.getInfo());
System.out.println(mouse.getInfo());
}
}
责任链模式
责任链模式是一个对象的行为模式,很多对象之间形成一条链条,处理请求在这个链条上进行传递,直到责任链的上的某个对象决定处理请求(也可扩展为几个对象处理),这个过程对于用户来说是透明的,也就是说用户并不需要知道是责任链上的哪个对象处理的请求,对请求是否处理由链条上的对象自己决定。
可以想象一下击鼓传花的游戏。
责任链模式也可以说是行为模式(而抽象工厂叫做建造模式):拥有相同行为的类共同实现一个接口
Filter 接口
/**
* Filter接口,实际上是对变化的抽象
* 这种方式会逐个的运行Filter,但不能
* 指定是否需要继续执行后面的Filter。
* 比如:当发现违法了特殊符号的Filter时
* 其后的过滤链没有必要执行
*/
public interface Filter {
void doFilter(Message message);
}
ChackSyntaxFilter类
public class ChackSyntaxFilter implements Filter {
@Override
public void doFilter(Message message) {
String content = message.getContent();
content = content.replace("<", "#");
content = content.replace(">", "#");
message.setContent(content);
}
}
WordFilter类
public class WordFilter implements Filter {
@Override
public void doFilter(Message message) {
String content = message.getContent();
content = content.replace("牛", "***");
content = content.replace("马", "*****");
message.setContent(content);
}
}
FilterChain过滤器链
/**
* 将Filter组织成一个链条
*/
public class FilterChain {
private FilterChain(){}
private static List<Filter> filters = new ArrayList<>();
private static FilterChain instance = new FilterChain();
public static FilterChain getInstance(){
return instance;
}
public FilterChain add(Filter filter) {
filters.add(filter);
return this;
}
public Message dofilters(final Message message) {
for (Filter f : filters) {
f.doFilter(message);
}
return message;
}
}
测试
public class Main {
public static void main(String[] args) {
Message msg = new Message();
msg.setContent("hello, <abc>, 牛xx马, 哈哈哈");
FilterChain fc = FilterChain.getInstance();
fc.add(new ChackSyntaxFilter())
.add(new WordFilter())
.dofilters(msg);
System.out.println(msg.getContent());
}
}
观察者模式
观察者模式是对象的行为模式,有时也称为“发布/订阅模式”或者“监听器模式”。
观察者模式定义了被观察者和观察者之间的一对多的关系,让多个观察者对象可以响应一个被观察者对象。
Observer接口
public interface Observer {
void bell(BellEvent event);
}
Nurse类
public class Nurse implements Observer {
@Override
public void bell(BellEvent event) {
System.out.println("I am nurse, Can I help you?");
}
}
Wife类
public class Wife implements Observer {
@Override
public void bell(BellEvent event) {
System.out.println("baby, I am here, Don't worry !");
}
}
Doctor类
public class Docter implements Observer {
@Override
public void bell(BellEvent event) {
System.out.println("I am docter, Can I help you?");
}
}
Event抽象类
public abstract class Event {
protected Object source;
public Object getSource() {
return this.source;
}
}
BellEvent类
public class BellEvent extends Event {
long timestamp;
public BellEvent(Object source) {
this.timestamp = System.currentTimeMillis();
this.source = source;
}
}
病人实体类
public class Patient {
private List<Observer> observers = new ArrayList<>();
public void addObserver(Observer observer) {
observers.add(observer);
}
public void ringBell() {
BellEvent event = new BellEvent(this);
for (Observer observer: observers) {
observer.bell(event);
}
}
}
测试
public class Main {
public static void main(String[] args) {
Patient patient = new Patient();
patient.addObserver(new Docter());
patient.addObserver(new Nurse());
patient.addObserver(new Wife());
patient.ringBell();
}
}