设计模式

理解每种设计模式的思想,以及使用场景.

设计模式就是基于面向对象,对一类具备相同特性的问题,总结出的处理方式;

面向对象七大原则:

1.开闭原则(OCP):对扩展开放,对修改关闭;

2.里氏替换原则:继承必须确保超类所拥有的性质在子类中仍然成立;

3.依赖导致原则:要面向接口编程,不要面向实现编程;

4.单一职责原则:一个方法只做一件事,解耦合,提升内聚

5.接口隔离原则:各个类需要专用接口

6.迪米特法则:只与朋友交谈

7.合成复用原则:能组合尽量用组合;has A ,继承.is A

一.工厂模式

作用:实现了创建者和调用者分离

核心本质:实例化对象不用new ,统一管理控制创建对象,实现创建对象的过程与调用者解耦;

public interface Car {
    void name();
}

public class CarFactory {
    //静态工厂模式
    //方法一(没有满足开闭原则,当添加车种类时需要修改Factory)
    public static Car getCar(String carName){
        if(carName.equals("五菱宏光")){
            return new WuLing();
        }else if(carName.equals("奔驰")){
            return new BenChi();
        }else{
            return null;
        }
    }
    public static Car getWuLing(){
        return new WuLing();
    }
    public static Car getBenChi(){
        return new BenChi();
    }

}

工厂方法:

public interface FactoryCar {
    Car getCar();
}

//工厂方法
public class WulingFactory implements FactoryCar{
    @Override
    public Car getCar() {
        return new WuLing();
    }

    public static void main(String[] args) {
        Car car = new WulingFactory().getCar();
        car.name();
    }
}

对比:结构复杂度:简单工厂

　　代码复杂度:简单工厂

　　编程复杂度:简单工厂

　　管理上的复杂度:简单工厂

　　//根据设计原则:工厂方法;

　　//实际业务:简单工厂;

抽象工厂模式:

当需要生产的产品比较复杂,时将工厂变成接口,构建他的实现类

例如:不同的厂商,回生产很多不同的产品;用工厂控制不同的厂商,接口内的方法控制产品种类

 

二.建造者模式

将对象的构建 和使用分离,使用者不用考虑对象的创建过程;

指挥者,负责管理建造流程;

建造者:负责具体的创建;

1.先有建造者,后又对象

 

指挥者是一个抽象类,组合一个建造者,通过实现不同的build方法来构建不同的对象;

建造者内部创建对象,提供给对象赋值的方法;但是不调用,提供一个获取对象的方法;

创建指挥者实现类,组合建造者,在build中调用建造者的方法给对象赋值;最后返回一个对象;

 

 

优点:便于代码重复利用;创建建造模板(也就是指挥者)直接获得对象

2.先有建造者,对象通过建造者来创建;

我们在使用时充当指挥者;

创建一个builder,我们来指挥builder.

优点:更加灵活

三.原型模式

clone()

tk.mybatis中Example 中建造者模式的使用

Example是一个查询模板,下面时构造方法;通过建造者来构建

private Example(Builder builder) {
        this.exists = builder.exists;
        this.notNull = builder.notNull;
        this.distinct = builder.distinct;
        this.entityClass = builder.entityClass;
        this.propertyMap = builder.propertyMap;
        this.selectColumns = builder.selectColumns;
        this.excludeColumns = builder.excludeColumns;
        this.oredCriteria = builder.exampleCriterias;
        this.forUpdate = builder.forUpdate;
        this.tableName = builder.tableName;

        if (!StringUtil.isEmpty(builder.orderByClause.toString())) {
            this.orderByClause = builder.orderByClause.toString();
        }

    }

public Example build() {
            this.exampleCriterias = new ArrayList<Criteria>();
            for (Sqls.Criteria criteria : sqlsCriteria) {
                Example.Criteria exampleCriteria = new Example.Criteria(this.propertyMap, this.exists, this.notNull);
                exampleCriteria.setAndOr(criteria.getAndOr());
                for (Sqls.Criterion criterion : criteria.getCriterions()) {
                    String condition = criterion.getCondition();
                    String andOr = criterion.getAndOr();
                    String property = criterion.getProperty();
                    Object[] values = criterion.getValues();
                    transformCriterion(exampleCriteria, condition, property, values, andOr);
                }
                exampleCriterias.add(exampleCriteria);
            }

            if (this.orderByClause.length() > 0) {
                this.orderByClause = new StringBuilder(this.orderByClause.substring(1, this.orderByClause.length()));
            }

            return new Example(this);
        }

以上时Bulder 中的build方法

通过builer收集属性值,再通过Example的构造方法构建对象;

 

 

 

结构型模式

从程序结构上实现松耦合,从而可以扩大整体的类结构,用来解决更大的问题;

一.适配器模式

//1.继承被适配的类(属于类适配器)
//2.组合被适配的对象(对象适配器)
public class AdapterImpl extends Adapter implements NetToUsb{
    @Override
    public void requestHander() {
        super.request();
    }
    public static void main(String[] args) {
        AdapterImpl adapterInst = new AdapterImpl();
        Computer computer = new Computer(adapterInst);
        computer.net();
    }
}

//要被适配的类:网线
public class Adapter {
    public void request(){
        System.out.println("连接网线上网");
    }

}

//不能直接连接网线的电脑
public class Computer {
    NetToUsb abapter;

    public Computer(NetToUsb abapter) {
        this.abapter = abapter;
    }

    public void net(){
        abapter.requestHander();
    }
}

//抽象的转换器
public interface NetToUsb {
    void requestHander();
}

-

public class PingGou implements brand{
    @Override
    public void info() {
        System.out.print("苹果");
    }
}

 

 

 二.桥接模式

将抽象部分与它的实现部分分离,是他们都可以独立的变化.

抽象 好比品牌  实现好比品牌;

一个类有两个不维度的特性; 

public class Ts extends Computer {
    public Ts(brand b) {
        super(b);
    }

    @Override
    public void info() {
        super.info();
        System.out.println("台式");
    }
    public static void main(String[] args) {
        LianXiang lianXiang = new LianXiang();
        Ts ts = new Ts(lianXiang);
        ts.info();
    }
}

public class LianXiang implements brand{
    @Override
    public void info() {
        System.out.print("联想");
    }
}

public abstract class Computer {
    protected brand b;

    public Computer(brand b) {
        this.b = b;
    }
    public void info(){
        b.info();
    };
}

public interface brand {
    void info();
}

public class Bjb extends Computer{
    public Bjb(brand b) {
        super(b);
    }

    @Override
    public void info() {
        super.info();
        System.out.println("笔记本");
    }
}