设计模式原则：多使用接口、抽象类，从而增加代码的可扩展性，降低模块之间的依赖和联系
在这里插入图片描述
@TOC
单例模式：
定义及使用场合：只有一个对象被创建 建议采用饿汉模式创建，线程安全、容易实现。
public class SingleObject {
//创建 SingleObject 的一个对象
private static SingleObject instance = new SingleObject();
//让构造函数为 private，这样该类就不会被实例化
private SingleObject(){}
//获取唯一可用的对象
public static SingleObject getInstance(){
return instance;
}
}
观察者模式：
定义及使用场合：一个对象（subject）被其它多个对象（observer）所依赖，则当一个对象变化时发出通知，其它依赖该对象的对象都会收到通知，并且随之改变【获取资料】
定义观察者 接收通知后操作方法
public interface Observer {
public void update();
}
定义观察者Observer1 实现接收通知后操作方法
public class Observer1 implements Observer {
@Override
public void update() {
System.out.println("observer1 has received!");
}
}
定义观察者Observer2 实现接收通知后操作方法
public class Observer2 implements Observer {
@Override
public void update() {
System.out.println("observer2 has received!");
}
}
定义主题接口 定义基本方法
public interface Subject {
/*增加观察者*/
public void add(Observer observer);
/*删除观察者*/
public void del(Observer observer);
/*通知所有的观察者*/
public void notifyObservers();
//加入Java开发交流君样：484138291一起吹水聊天
/*自身的操作*/
public void operation();
}
定义主题接口抽象实现 实现基本方法
public abstract class AbstractSubject implements Subject {
private Vector<Observer> vector = new Vector<Observer>();
@Override
public void add(Observer observer) {
vector.add(observer);
}
@Override
public void del(Observer observer) {
vector.remove(observer);
}
@Override
public void notifyObservers() {
Enumeration<Observer> enumo = vector.elements();
while(enumo.hasMoreElements()){
enumo.nextElement().update();
} }}
定义主题实现类 重写发出通知方法
public class MySubject extends AbstractSubject {
@Override
public void operation() {
System.out.println("update self!");
notifyObservers();
}
}
测试类
public class ObserverTest {
public static void main(String[] args) {
Subject sub = new MySubject();
sub.add(new Observer1()); //订阅这个对象
sub.add(new Observer2());
//加入Java开发交流君样：484138291一起吹水聊天
sub.operation(); //发出改变的一个通知
}
}
抽象工厂模式：
定义与使用场景：多个对象具有共同的特征，则不需要具体创建各个对象，而是创建对象工厂类即可【获取资料】
例如：同上，将创建对象的工厂类分离，如果需要增加新的发送消息业务，则只需新增一个消息发送类和消息发送类创建工厂类
策略模式：
定义和使用场合：需要动态的在几种类似的算法中选择一种
例如：
定义操作接口
public interface Strategy {
public int doOperation(int num1, int num2);
}
定义加法操作类
public class OperationAdd implements Strategy{
@Override
public int doOperation(int num1, int num2) {
return num1 + num2;
}
}
定义减法操作类
public class OperationSubstract implements Strategy{
@Override
public int doOperation(int num1, int num2) {
return num1 - num2;
}
}
定义代理对象
public class Context {
private Strategy strategy;
public Context(Strategy strategy){
this.strategy = strategy;
}
public int executeStrategy(int num1, int num2){
return strategy.doOperation(num1, num2);
}
}
测试类
public class StrategyPatternDemo {
public static void main(String[] args) {
//实例化对象的位置在调用处
//加入Java开发交流君样：484138291一起吹水聊天
Context context = new Context(new OperationAdd());
System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
context = new Context(new OperationSubstract());
System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
context = new Context(new OperationMultiply());
System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
}
}
桥接模式：
使用场景及定义：访问多种数据库驱动，不是直接访问，而是通过DriverManger桥来访问
外观模式：
使用场景及定义：整个过程是串行的，有先后顺序
例如：电脑启动，先启动cpu，再启动memory，再启动disk （有点类似将操作封装）
public class Computer {
//是组合，而非继承。这是与工厂模式的显著区别。
//加入Java开发交流君样：484138291一起吹水聊天
private CPU cpu;
private Memory memory;
private Disk disk;
public Computer(){
cpu = new CPU();
memory = new Memory();
disk = new Disk();
}
public void startup(){
System.out.println("start the computer!");
cpu.startup();
memory.startup();
disk.startup();
System.out.println("start computer finished!");
}
public void shutdown(){
System.out.println("begin to close the computer!");
cpu.shutdown();
memory.shutdown();
disk.shutdown();
System.out.println("computer closed!");
}
}
生产者-消费者模式：
定义与使用场景：生产者将数据放在数据缓冲区，消费者从数据缓冲区获取数据
