Java设计模式--（1）

设计模式

24大设计模式和7个设计原则

7个原则

1. 单一职责原则：一个类负责一项职责
2. 里氏替换原则：继承与派生的原则
3. 依赖倒置原则：高层模块不应该依赖底层模块，两者都应该依赖其抽象；抽象不应该依赖细节；细节依赖抽象。
4. 接口隔离原则：建立单一接口，尽量细化接口
5. 迪米特法则：低耦合，高内聚
6. 开闭原则：一个软件实体应该对扩展开放，对修改关闭
7. 聚合复用原则：尽量使用组合和聚合，少使用继承的关系来达到复用的原则

创建型设计模式

单例模式-双重校验锁-线程安全

singleton实例化一次，之后就可以使用，双重判定所先判断是否已经执行过实例化，没有执行过，进行加锁实例化操作。

public class Singleton {
    private volatile static Singleton singleton;
    public static Singleton getSingleton(){
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

责任链设计模式

通过责任链模式，可以为某个请求创建一个对象链，每个对象按照链式检查请求，对其进行处理或者传递给下一个对象。

首先顶一个一个Handle类，定义处理请求的接口，并且实现后继链

package com.wlh.designPattern.chain;


public abstract class Handler {
    protected Handler successor;
    public Handler(Handler successor){
        this.successor = successor;
    }
    protected abstract void handleRequest(Request request);
}

package com.wlh.designPattern.chain;


public class ConcreteHandler1 extends Handler{

    public ConcreteHandler1(Handler successor) {
        super(successor);
    }

    @Override
    protected void handleRequest(Request request) {
        if (request.getRequestType() == RequestType.type1){
            System.out.println(request.getName() + "handle");
            return;
        }
        if (successor != null){
            successor.handleRequest(request);
        }
    }
}

package com.wlh.designPattern.chain;

public class ConcreteHandler2 extends Handler{

    public ConcreteHandler2(Handler successor) {
        super(successor);
    }

    @Override
    protected void handleRequest(Request request) {
        if (request.getRequestType() == RequestType.type2){
            System.out.println(request.getName() + " handle");
            return;
        }
        if (successor != null){
            successor.handleRequest(request);
        }
    }
}

package com.wlh.designPattern.chain;

public enum RequestType {
    type1,
    type2
}

package com.wlh.designPattern.chain;

public class Request {
    private RequestType requestType;
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public RequestType getRequestType() {
        return requestType;
    }

    public void setRequestType(RequestType requestType) {
        this.requestType = requestType;
    }

    public Request(RequestType requestType, String name){
        this.requestType = requestType;
        this.name = name;
    }

}

简单工厂

简单工厂就是把实例化的操作单独的放到一个类中，这个类就是简单工厂类。由简单工厂类来决定由哪些具体的子类来进行实例化，实现客户类和具体子类的解耦。

public interface Product {

}
class ConcreteProduct implements Product {
}
class ConcreteProduct1 implements Product {
}
class ConcreteProduct2 implements Product {
}

package com.wlh.designPattern.simpleFactory;

public class SimpleFactory {
    public Product createProduct(int type){
        
        
        
       
        if (type == 1){
            return new ConcreteProduct1();
        }else if (type == 2){
            return new ConcreteProduct2();
        }
        return new ConcreteProduct();
    }
}