工厂模式
//抽象的产品
public abstract class Product {
public abstract void method();
}
//定义一个具体的产品 (可以定义多个具体的产品)
class ProductA extends Product {
@Override
public void method() {} //具体的执行逻辑
}
//抽象的工厂
abstract class Factory<T> {
abstract Product createProduct(Class<T> c);
}
//具体的工厂可以生产出相应的产品
class FactoryA extends Factory {
@Override
Product createProduct(Class c) {
Product product = (Product) Class.forName(c.getName()).newInstance();
return product;
}
}
策略模式
//定义一个策略接口
public interface Strategy {
void strategyImplementation();
}
//具体的策略实现(可以定义多个具体的策略实现)
public class StrategyA implements Strategy {
@Override
public void strategyImplementation() {
System.out.println("正在执行策略A");
}
}
//封装策略，屏蔽高层模块对策略、算法的直接访问，屏蔽可能存在的策略变化
public class Context {
private Strategy strategy = null;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void doStrategy() {
strategy.strategyImplementation();
}
}
状态模式
//定义一个抽象的状态类
public abstract class State {
Context context;
public void setContext(Context context) {
this.context = context;
}
public abstract void handle1();
public abstract void handle2();
}
//定义状态A
public class ConcreteStateA extends State {
@Override
public void handle1() {} //本状态下必须要处理的事情
@Override
public void handle2() {
super.context.setCurrentState(Context.contreteStateB); //切换到状态B
super.context.handle2(); //执行状态B的任务
}
}
//定义状态B
public class ConcreteStateB extends State {
@Override
public void handle2() {} //本状态下必须要处理的事情，...
@Override
public void handle1() {
super.context.setCurrentState(Context.contreteStateA); //切换到状态A
super.context.handle1(); //执行状态A的任务
}
}
//定义一个上下文管理环境
public class Context {
public final static ConcreteStateA contreteStateA = new ConcreteStateA();
public final static ConcreteStateB contreteStateB = new ConcreteStateB();
private State CurrentState;
public State getCurrentState() {return CurrentState;}
public void setCurrentState(State currentState) {
this.CurrentState = currentState;
this.CurrentState.setContext(this);
}
public void handle1() {this.CurrentState.handle1();}
public void handle2() {this.CurrentState.handle2();}
}
//定义client执行
public class client {
public static void main(String[] args) {
Context context = new Context();
context.setCurrentState(new ContreteStateA());
context.handle1();
context.handle2();
}
}
责任链模式
//定义一个抽象的handle
public abstract class Handler {
private Handler nextHandler; //指向下一个处理者
private int level; //处理者能够处理的级别
public Handler(int level) {
this.level = level;
}
public void setNextHandler(Handler handler) {
this.nextHandler = handler;
}
// 处理请求传递，注意final，子类不可重写
public final void handleMessage(Request request) {
if (level == request.getRequstLevel()) {
this.echo(request);
} else {
if (this.nextHandler != null) {
this.nextHandler.handleMessage(request);
} else {
System.out.println("已经到最尽头了");
}
}
}
// 抽象方法，子类实现
public abstract void echo(Request request);
}
// 定义一个具体的handleA
public class HandleRuleA extends Handler {
public HandleRuleA(int level) {
super(level);
}
@Override
public void echo(Request request) {
System.out.println("我是处理者1,我正在处理A规则");
}
}
//定义一个具体的handleB
public class HandleRuleB extends Handler {} //...
//客户端实现
class Client {
public static void main(String[] args) {
HandleRuleA handleRuleA = new HandleRuleA(1);
HandleRuleB handleRuleB = new HandleRuleB(2);
handleRuleA.setNextHandler(handleRuleB); //这是重点，将handleA和handleB串起来
handleRuleA.echo(new Request());
}
}
代理模式
单例模式
适配器模式
设计模式原则
面向对象的设计模式有七大基本原则：
-
开闭原则（Open Closed Principle，OCP）
-
单一职责原则（Single Responsibility Principle, SRP）
-
里氏代换原则（Liskov Substitution Principle，LSP）
-
依赖倒转原则（Dependency Inversion Principle，DIP）
-
接口隔离原则（Interface Segregation Principle，ISP）
-
合成/聚合复用原则（Composite/Aggregate Reuse Principle，CARP）
-
最少知识原则（Least Knowledge Principle，LKP）或者迪米特法则（Law of Demeter，LOD）
简单理解就是：开闭原则是总纲，它指导我们要对扩展开放，对修改关闭；单一职责原则指导我们实现类要职责单一；里氏替换原则指导我们不要破坏继承体系；依赖倒置原则指导我们要面向接口编程；接口隔离原则指导我们在设计接口的时候要精简单一；迪米特法则指导我们要降低耦合。
当然，设计模式只是软件开发领域内多年来的经验总结，任何一个或简单或复杂的设计模式都会遵循上述的七大设计原则，只要大家真正理解了七大设计原则，设计模式对我们来说应该就不再是一件难事。但是，使用设计模式也不是要求我们循规蹈矩，只要我们的代码模型设计遵循了上述的七大原则，我们会发现原来我们的设计中就已经使用了某种设计模式。
网友评论