2019-05-28 java设计模式

来源设计模式之禅---作者-秦小波

import java.util.ArrayList;
import java.util.Vector;

public class T {
}


////1.单例模式
//
//class Sigleton {
//    private static final Sigleton  sigleton = new Sigleton();
//    //限制产生多个对象
//    private Sigleton(){
//
//    }
//
//    public static Sigleton getSigleton(){
//        return sigleton;
//    }
//
//    public static void doSomething(){
//
//    }
//}
//
//
////2.工厂方法
//
//abstract class Product{
//    //产品类的公共方法
//    public void method1(){
//
//    }
//    //抽象方法
//    public abstract void method2();
//}
//
//class ConcreteProduct1 extends Product {
//
//    @Override
//    public void method2() {
//        //业务处理逻辑
//    }
//}
//
//class ConcreteProduct2 extends Product{
//
//    @Override
//    public void method2() {
//        //业务处理逻辑
//    }
//}
//
//abstract class Creator{
//    //创建一个产品
//    public abstract <T extends Product> T createProduct(Class<T> c);
//}
//
//class ConcreteCreator extends Creator {
//
//    @Override
//    public <T extends Product> T createProduct(Class<T> c) {
//        Product product = null;
//        try {
//            product = (Product)Class.forName(c.getName()).newInstance();
//        }catch (Exception e){
//            //异常处理
//        }
//        return (T)product;
//    }
//}
//
////场景类（main）
//class client{
//    public static void main(){
//        Creator creator = new ConcreteCreator();
//        Product product = creator.createProduct(ConcreteProduct1.class);
//        //继续业务
//    }
//}
//
//
////3.抽象工厂模式
//abstract class AbstractProductA{
//    //每个产品共用的方法
//    public void shareMethod(){
//
//    }
//    //每个产品相同方法不同实现
//    public abstract void doSomething();
//}
//
//class ProductA extends AbstractProductA {
//
//    @Override
//    public void doSomething() {
//        System.out.println("产品A1的实现方法");
//    }
//}
//
//class ProductB extends AbstractProductA{
//
//    @Override
//    public void doSomething() {
//        System.out.println("产品A2的实现方式");
//    }
//}
//
//abstract class AbstractCreator{
//    //创建A产品家族
//    public abstract AbstractProductA createProductA();
//}
//
//class Creator1 extends AbstractCreator {
//
//    @Override
//    public AbstractProductA createProductA() {
//        return new ProductA();
//    }
//}
//
//class Creator2 extends AbstractCreator {
//
//    @Override
//    public AbstractProductA createProductA() {
//        return new ProductB();
//    }
//}
//
////4.模板方法模式
//
//abstract class AbstractClass {
//    //基本方法
//    protected abstract void doSomething();
//    //基本方法
//    protected abstract void doAnyThing();
//    //模板方法  为了防止恶意操作，一般模板方法都加上final关键字，不允许被覆写
//    public final void templeteMethod(){
//        //调用基本方法完成相关的逻辑
//        this.doAnyThing();
//        this.doSomething();
//    }
//}
//
//class ConcreteClass1 extends AbstractClass {
//
//    @Override
//    protected void doSomething() {
//        //业务逻辑处理
//    }
//
//    @Override
//    protected void doAnyThing() {
//        //业务逻辑处理
//    }
//}
//class ConcreteClass2 extends AbstractClass {
//
//    @Override
//    protected void doSomething() {
//        //业务逻辑处理
//    }
//
//    @Override
//    protected void doAnyThing() {
//        //业务逻辑处理
//    }
//}
//class client4 {
//    public static void main(String[] args){
//        AbstractClass class1 = new ConcreteClass1();
//        AbstractClass class2 = new ConcreteClass2();
//        //调用模板方法
//        class1.templeteMethod();
//        class2.templeteMethod();
//    }
//}

//*******************分割线分割线分割线分割线分割线分割线分割线分割线***************************//

//class Product {
//    public void doSomething(){
//        //独立业务处理
//    }
//}
//
//abstract class Builder{
//    //设置产品的不同部分，以获得不同的产品
//    public abstract void setPart();
//    //建造产品
//    public abstract Product buildProduct();
//}
//
////注意：有多少个产品类就有几个具体的构建者
//class ConcreteProduct extends Builder {
//    private Product product = new Product();
//    @Override
//    public void setPart() {
//        //产品类内的逻辑处理
//    }
//
//    //组建一个产品
//    @Override
//    public Product buildProduct() {
//        return product;
//    }
//}
//
////导演者,起到封装的作用，避免高层模块深入到建造者内部的实现类。
//class Director {
//    private Builder builder = new ConcreteProduct();
//    //构建不同的产品
//    public Product getAproduct(){
//        builder.buildProduct();
//        //设置不同的零件，产生不同的产品
//        return builder.buildProduct();
//    }
//}
//
////6.代理模式
//interface Subject {
//    //定义一个方法
//    void request();
//}
//class RealSubject implements Subject {
//
//    @Override
//    public void request() {
//        //业务逻辑处理
//    }
//}
//
//class Proxy implements Subject {
//    //要代理哪个实现类
//    private Subject subject = null;
//    //默认被代理者
//    public Proxy(){
//        this.subject=new Proxy();
//    }
//    public Proxy(Object ...objects){
//    }
//    public Proxy(Subject subject){
//        this.subject = subject;
//    }
//
//    @Override
//    public void request() {
//        this.before();
//        this.subject.request();
//        this.after();
//    }
//
//    //预处理
//    private void before(){
//
//    }
//    //善后处理
//    private void after(){
//
//    }
//}
//
////7.原型模式
//
//class PrototypeClass implements Cloneable{
//
//    //覆写父类Object方法
//    @Override
//    protected Object clone()  {
//        PrototypeClass prototypeClass = null;
//        try {
//            prototypeClass = (PrototypeClass) super.clone();
//        }catch (CloneNotSupportedException e){
//
//        }
//        return prototypeClass;
//    }
//}
//
////8.中介者模式
//
////抽象中介者模式
//abstract class Mediator {
//    //定义同事类
//    protected ConcreteColleague1 c1;
//    protected ConcreteColleague2 c2;
//    //通过getter和setter把同事类注入进来;
//    public ConcreteColleague1 getC1(){
//        return c1;
//    }
//    public void setC1(ConcreteColleague1 c1){
//        this.c1 = c1;
//    }
//    public ConcreteColleague2 getC2() {
//        return c2;
//    }
//
//    public void setC2(ConcreteColleague2 c2){
//        this.c2 = c2;
//    }
//
//    //中介者模式的业务;
//    public abstract void doSomething1();
//    public abstract void doSomething2();
//
//}
//
//
//class ConcreteMediator extends Mediator{
//
//    @Override
//    public void doSomething1() {
//        //调用同事的方法只要是public都可以调用
//        super.c1.selfMethod();
//        super.c2.selfMethod();
//    }
//
//    @Override
//    public void doSomething2() {
//        super.c1.selfMethod();
//        super.c2.selfMethod();
//    }
//}
//
//
////抽象同事类
//abstract class Colleague {
//    protected Mediator mediator;
//    public Colleague(Mediator mediator){
//        this.mediator = mediator;
//    }
//}
//
//class ConcreteColleague1 extends Colleague {
//
//    public ConcreteColleague1(Mediator mediator) {
//        super(mediator);
//    }
//    public void selfMethod(){
//        //处理自己的业务逻辑
//    }
//    public void depMethod1(){
//        //处理自己的业务逻辑
//        //自己不能处理的委托给中介者处理
//        super.mediator.doSomething1();
//    }
//
//}
//
//class ConcreteColleague2 extends Colleague {
//
//    public ConcreteColleague2(Mediator mediator) {
//        super(mediator);
//    }
//
//    public void selfMethod(){
//        //处理自己的业务逻辑
//    }
//    public void depMethod1(){
//        //处理自己的业务逻辑
//        //自己不能处理的委托给中介者处理
//        super.mediator.doSomething2();
//    }
//}
//
//
////9.命令模式
//abstract class Receiver {
//    //抽象接收者，定义每个接收者都必须完成的业务
//    public abstract void doSomething();
//}
//
//class CurrentReceiver1 extends Receiver{
//    //每个接收者必须处理一定的业务
//    @Override
//    public void doSomething() {
//
//    }
//}
//class CurrentReceiver2 extends Receiver {
//    //每个接收者必须处理一定的业务
//    @Override
//    public void doSomething() {
//
//    }
//}
//abstract class Command{
//    //每个命令类都必须有一个执行的事
//    public abstract void execute();
//}
//class ConcreteCommand1 extends Command {
//    private Receiver receiver;
//
//    public ConcreteCommand1(Receiver receiver){
//        this.receiver = receiver;
//    }
//    @Override
//    public void execute() {
//        this.receiver.doSomething();
//    }
//}
//
//class ConcreteCommand2 extends Command {
//    private Receiver receiver;
//
//    public ConcreteCommand2(Receiver receiver){
//        this.receiver = receiver;
//    }
//    @Override
//    public void execute() {
//        this.receiver.doSomething();
//    }
//}
//
//class Invoker {
//    private Command command;
//    //受气包，接收命令
//    public void  setCommand(Command command){
//        this.command = command;
//    }
//    //执行命令
//    public void action(){
//        this.command.execute();
//    }
//}
//class Client9 {
//    public static void main(String[] args){
//        //首先声明调用者Invoker
//        Invoker invoker = new Invoker();
//        //定义接收者
//        Receiver receiver = new CurrentReceiver1();
//        //定义一个发送给接收者的命令
//        Command command = new ConcreteCommand1(receiver);
//        invoker.setCommand(command);
//        invoker.action();
//    }
//}
//
////10.责任链模式
//abstract class Handler {
//    private Handler nextHandler;
//    //设置下一个处理者是谁
//    public void setNext(Handler handler){
//        this.nextHandler = handler;
//    }
//    protected abstract Level getHandlerLevel();
//    //每个处理者都必须要处理任务
//    protected abstract Response echo(Request request);
//    //每个处理者都必须对请求做出处理
//    public final Response handleMessage(Request request){
//        Response response = null;
//        if(this.getHandlerLevel().equals(request.getRequestLevel())){
//            response = this.echo(request);
//        }
//        if(this.nextHandler != null){
//            response = this.nextHandler.handleMessage(request);
//        }else {
//            //没有适当的处理者，业务自行处理
//        }
//        return response;
//
//    }
//}
//class Level{
//    //定义一个请求和处理等级
//}
//class Request{
//    //请求的等级
//    public Level getRequestLevel(){
//        return null;
//    }
//}
//class Response {
//    //处理者返回的数据
//}
//
//class ConcreteHandler1 extends Handler {
//
//    @Override
//    protected Level getHandlerLevel() {
//        return null;
//    }
//
//    @Override
//    protected Response echo(Request request) {
//        return null;
//    }
//}
//class ConcreteHandler2 extends Handler {
//
//    @Override
//    protected Level getHandlerLevel() {
//        return null;
//    }
//
//    @Override
//    protected Response echo(Request request) {
//        return null;
//    }
//}
//
//class ConcreteHandler3 extends Handler {
//
//    @Override
//    protected Level getHandlerLevel() {
//        return null;
//    }
//
//    @Override
//    protected Response echo(Request request) {
//        return null;
//    }
//}
//
//class client10{
//    public static void main(String[] args){
//        Handler handler1 = new ConcreteHandler1();
//        Handler handler2 = new ConcreteHandler2();
//        Handler handler3 = new ConcreteHandler3();
//        handler1.setNext(handler2);
//        handler2.setNext(handler3);
//        Response response = handler1.handleMessage(new Request());
//    }
//}


////////////////*********************************分割线***************************************//////


//11.装饰者模式

///*抽象构件
//abstract class Component {
//    public abstract void operate();
//}
//
//class ConcreteComponent extends Component {
//
//    @Override
//    public void operate() {
//        System.out.println("do something");
//    }
//}
////抽象装饰者
//abstract class Decorator extends Component {
//    private Component component = null;
//    public Decorator(Component component){
//        this.component = component;
//    }
//
//    @Override
//    public void operate() {
//        this.component.operate();
//    }
//}
//
//class ConcreteDecorator1 extends Decorator {
//
//    public ConcreteDecorator1(Component component) {
//        super(component);
//    }
//
//    private void method1(){
//        System.out.println("method1修饰");
//    }
//
//    @Override
//    public void operate() {
//        this.method1();
//        super.operate();
//    }
//}
//
//class ConcreteDecorator2 extends Decorator {
//
//    public ConcreteDecorator2(Component component) {
//        super(component);
//    }
//
//    private void method1(){
//        System.out.println("method1修饰");
//    }
//
//    @Override
//    public void operate() {
//        this.method1();
//        super.operate();
//    }
//}
//
//class Client11{
//    public static void main(String[] args){
//        Component component = new ConcreteComponent();
//        component = new ConcreteDecorator1(component);
//        component = new ConcreteDecorator2(component);
//        component.operate();
//    }
//}
//
////12.策略模式
//
//interface Strategy{
//    public void doSomething();
//}
//
//class ConcreteStrategy1 implements Strategy {
//
//    @Override
//    public void doSomething() {
//        System.out.println("具体策略1的运算法则");
//    }
//}
//class ConcreteStrategy2 implements Strategy {
//
//    @Override
//    public void doSomething() {
//        System.out.println("具体策略1的运算法则");
//    }
//}
//class Context {
//    //抽象策略
//    private Strategy strategy = null;
//    public Context(Strategy strategy){
//        this.strategy = strategy;
//    }
//
//    public void doAnything(){
//        this.strategy.doSomething();
//    }
//
//}
//
//class Client12 {
//    public static void main(String[] args){
//       Strategy  strategy = new ConcreteStrategy1();
//       Context context = new Context(strategy);
//       context.doAnything();
//    }
//}
//
////13.适配器模式
//interface Target{
//    void request();
//}
//
//class ConcreteTarget implements Target {
//
//    @Override
//    public void request() {
//        System.out.println("if you need help,please call me!");
//    }
//}
//
//class Addaptee{
//    public void dosomething(){
//        System.out.println("i'm kind of busy,leave me alone ,pls");
//    }
//}
//class Adapter extends Addaptee implements Target {
//
//    @Override
//    public void request() {
//        super.dosomething();
//    }
//}
//
//class Client13 {
//    public static void main(String[] args){
//        //原有的业务逻辑
//        Target target = new ConcreteTarget();
//        target.request();
//        //现在增加了适配器角色后的逻辑
//        Target target2 = new Adapter();
//        target2.request();
//    }
//}

//14.迭代器模式 省略

//15.组合模式

abstract class Component {
    //个体和整体都具有的共享
    public void dosomething(){}
}

//树枝构建
class Composite extends Component {
    //构件容器
    private ArrayList<Component> componentArrayList = new ArrayList<>();
    //
    public void add(Component component){
        this.componentArrayList.add(component);
    }
    //删除一个叶子构件或树枝构件
    public void remove(Component component){
        this.componentArrayList.remove(component);
    }
    public ArrayList<Component> getChildren(){
        return this.componentArrayList;
    }
}

class Leaf extends Component{
    @Override
    public void dosomething() {
        super.dosomething();
    }
}

class Client15 {
    public static void main(String[] args){
        Composite root = new Composite();
        root.dosomething();

        Composite branch = new Composite();
        Leaf leaf = new Leaf();

        root.add(branch);
        branch.add(leaf);
    }

    //递归遍历
    public static void display(Composite root){
        for(Component item : root.getChildren()){
            if(item instanceof Leaf){
                item.dosomething();
            }else {
                display((Composite)item);
            }
        }
    }
}

//16.观察者模式
abstract class Subject {
    //定义一个观察者数组
    private Vector<Observer> obsVector = new Vector<>();
    public void addObserver(Observer o){
        obsVector.add(o);
    }
    public void delObserver(Observer o){
        obsVector.remove(o);
    }
    //通知所有观察者
    public void notifyObservers(){
        for(Observer item : obsVector){
            item.update();
        }
    }
}

class ConcreteSubject extends Subject{
    public void dosomething(){
        /**
         * do something
         */
        super.notifyObservers();
    }
}
interface Observer{
    void update();
}

class ConcreteObserver implements Observer {

    @Override
    public void update() {
        System.out.println("接收到消息，并进行处理!");
    }
}

class client{
    public static void main(String[] args){
        ConcreteSubject subject = new ConcreteSubject();
        Observer o = new ConcreteObserver();
        subject.addObserver(o);
        subject.dosomething();
    }
}

//17.门面模式
class ClassA{
    public void doSomethingA(){
        //业务逻辑
    }
}
class ClassB{
    public void doSomethingB(){}
}

class ClassC{
    public void doSomethingC(){

    }
}
class Facade{
    //被委托的对象
    private ClassA a = new ClassA();
    private ClassB b = new ClassB();
    private ClassC c = new ClassC();
    //提供给外部访问的方法
    public void doSomethingA(){
        this.a.doSomethingA();
    }
    public void doSomethingB(){
        this.b.doSomethingB();
    }
    public void doSomethingC(){
        this.c.doSomethingC();
    }

}

//18.备忘录模式
class Originator {
    //内部状态
    private String state = "";

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    //创建一个备忘录
    public Memento createMemento(){
        return new Memento(this.state);
    }
    //恢复一个备忘录
    public void restoreMemento(Memento memento){
        this.setState(memento.getState());
    }
}
class Memento{
    private String  state = "";
    public Memento(String state){
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

//备忘录管理员角色
class Caretaker {
    private Memento memento;
    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

class Client18 {
    public static void main(String[] args){
        //定义出发起人
        Originator originator = new Originator();
        //定义出备忘录管理员
        Caretaker caretaker = new Caretaker();
        //创建出一个备忘录
        caretaker.setMemento(originator.createMemento());
        originator.restoreMemento(caretaker.getMemento());
    }
}

////19.访问者模式
//
////抽象元素
//abstract class Element {
//    //定义业务逻辑
//    abstract void doSomething();
//    abstract
//}