分类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式
1、简单工厂模式：就是建立一个工厂类，对实现同一接口的子类或者继承同一父类的子类，进行实例创建。
public class Test { public static void main(String[] args) { Operation oper; oper = OperationFactory.createOperation(2); oper.numberA = 1; oper.numberB = 2; System.out.println(oper.getResult()); } } //运算类 class Operation { public double numberA = 0; public double numberB = 0; public double getNumberA() { return numberA; } public void setNumberA(double numberA) { this.numberA = numberA; } public double getNumberB() { return numberB; } public void setNumberB(double numberB) { this.numberB = numberB; } public double getResult() { return 0; } } //加法类继承运算类 class OperationAdd extends Operation { public double getResult() { return numberA + numberB; } } //减法类继承运算类 class OperationSub extends Operation { public double getResult() { return numberA - numberB; } } //工厂类 class OperationFactory { public static Operation createOperation(int operate) { Operation oper = null; switch (operate) { case 1: oper = new OperationAdd(); break; case 2: oper = new OperationSub(); break; } return oper; } }
2、策略模式： 定义了一系列算法，并将每个封装起来，使他们可以互相替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列的实现类提供统一的方法，多个实现类实现该接口。
收银系统，结算界面的功能。结算时有活动：1、打折，可以8折，9折，5折，折扣可以抽象出一个算法 2、满减，满300减100，满1000减400等，抽象出一个。关键点在于封装其变化点
package strategy;
public class Context {
Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
//上下文接口
public void ContextInterface() {
//根据具体的策略对象调用方法
strategy.AlgorithmInterface();
}
}
package strategy;
public class ConcreteStrategyA extends Strategy {
@Override
public void AlgorithmInterface() {
System.out.println("算法A实现");
}
}
package strategy;
public class ConcreteStrategyB extends Strategy {
@Override
public void AlgorithmInterface() {
System.out.println("算法B实现");
}
}
package strategy;
public class ConcreteStrategyC extends Strategy {
@Override
public void AlgorithmInterface() {
System.out.println("算法C实现");
}
}
package strategy;
public class Context {
Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
//上下文接口
public void ContextInterface() {
//根据具体的策略对象调用方法
strategy.AlgorithmInterface();
}
}
package strategy;
public class test {
public static void main(String[] args) {
Context context;
context = new Context(new ConcreteStrategyA());
context.ContextInterface();
context = new Context(new ConcreteStrategyB());
context.ContextInterface();
context = new Context(new ConcreteStrategyB());
context.ContextInterface();
}
}
3、装饰者模式：装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。
package decorator;
//定义一个对象接口，可以给这些对象动态添加职责
public abstract class Component {
public abstract void Operation();
}
package decorator;
public class ConcreteComponent extends Component {
@Override
public void Operation() {
System.out.println("被装饰的对象！！！");
}
}
package decorator;
public abstract class Decorator extends Component {
public Component component;
public void setComponent(Component component) {
this.component = component;
}
@Override
public void Operation() {
if(component != null){
component.Operation();
}
}
}
package decorator;
public class ConcreteDecoratorA extends Decorator {
@Override
public void Operation() {
super.Operation();
System.out.println("具体装饰对象A的操作！！");
}
public void setComponent(Component component) {
this.component = component;
}
}
package decorator;
public class ConcreteDecoratorB extends Decorator {
@Override
public void Operation() {
super.Operation();
AddedBehavior();
System.out.println("具体装饰对象B的操作！！");
}
private void AddedBehavior() {
}
}
package decorator;
public class test {
public static void main(String[] args) {
ConcreteComponent c = new ConcreteComponent();
ConcreteDecoratorA d1 = new ConcreteDecoratorA();
ConcreteDecoratorB d2 = new ConcreteDecoratorB();
d1.setComponent(c);
d2.setComponent(d1);
d2.Operation();
}
}
结果：
被装饰的对象！！！
具体装饰对象A的操作！！
具体装饰对象B的操作！！
4、代理模式（Proxy）：代理模式就是多一个代理类出来，替原对象进行一些操作。
package proxy;
public interface Subject {
public abstract void request();
}
package proxy;
public class RealSubject implements Subject{
@Override
public void request() {
System.out.println("真实的请求！！！");
}
}
package proxy;
public class Proxy implements Subject{
RealSubject realSubject;
@Override
public void request() {
if(realSubject == null){
realSubject = new RealSubject();
}
realSubject.request();
}
}
package proxy;
public class test {
public static void main(String[] args) {
Proxy p = new Proxy();
p.request();
}
}
5、工厂方法模式：
6、原型模式：
7、模板方法模式：
8、外观模式：
9、建造者模式：主要是用于创建一些复杂的对象，这些对象内部构建的建造顺序通常是稳定的，但是对象内部的构建通常面临着复杂的变化。
10、观察者模式：