欢迎大家来到IT世界,在知识的湖畔探索吧!

1 设计模式简介

1.1 什么是设计模式？

指在软件开发中，经过验证的，用于解决在特定环境下、重复出现的、特定问题的解决方案。这就是 设计模式（Design Patterns）。

简单的理解就是经过前辈们的经验，遇到了各种编程问题后，为了解决这些问题而提出来的一种编程设计思想。

1.2 设计模式分类

在编程中设计模式可以分为3大类23小类，下面我们详细了解一下这些设计模式。

设计模式三大类：创建型模式、结构型模式、行为型模式。

创建型模式（5种）：

● 工厂（Factory Pattern）

定义一个接口，子类继承它，由子类来决定生产什么。
很好理解，比如创建一个厂，但是没有定这个厂具体生产什么，其子类来决定生产什么。

欢迎大家来到IT世界,在知识的湖畔探索吧!

● 抽象工厂（Abstract Factory Pattern）

欢迎大家来到IT世界,在知识的湖畔探索吧!创建一个生产某一类型的产品接口，其子类可以生产相关产品。
也很好理解，比如创建一个食品厂，其子类只能生产食品类型的产品。

● 单例（Singleton Pattern）

只能生成类的一个实例，其他类通过该类的全局访问获取其实例。

● 原型（Prototype Pattern）

欢迎大家来到IT世界,在知识的湖畔探索吧!把某对象作为原型模板，需要的时候来克隆出和原型相似的新实例。

● 建造者（Builder Pattern）

将一个复杂对象分解成多个部分，分别按需创建它们，最后构建成该复杂对象。

结构型模式（7种）：

● 适配器（Adapter Pattern）

把一个类的接口转换成你希望的其他接口，这样接口就兼容了，因接口兼容导致的那些类能正常工作。

● 装饰器（Decorator Pattern）

动态的给对象增加一些额外的功能。

● 代理（Proxy Pattern）

为某对象提供一种代理以控制对该对象的访问。
例如：A想买某东西，A就让B代理A去买一个道理。Java中的动态代理、静态代理就是代理模式实现的。

● 外观（Facade Pattern）

如果你的系统有很多复杂的子系统，那么久可以用外观模式，这样其子系统就很容易被访问了。

● 桥接（Bridge Pattern）

把抽象与实现分离，使它们可以独立变化。

● 组合（Composite Pattern）

把对象组合成树状层次结构，这样这些对象就有了一致的访问性。

● 享元（Flyweight Pattern）

运用共享技术来有效地支持大量细粒度对象的复用。

行为型模式（11种）：

● 策略（Strategy Pattern）

定义了一系列算法并封装起来，让这些算法能相互替换。

● 模板方法（Template Pattern）

定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

● 观察者（Observer Pattern）

当对象有了一对多情况，其中一个对象改变会通知其他对象，从而来影响其他对象的行为。

● 迭代器（Iterator Pattern）

提供一种方法来顺序访问聚合对象中的一系列数据。

● 责任链（Chain of Responsibility Pattern）

在整个链中，请求由上一个对象传给下一个对象，直到请求响应结束。

● 命令（Command Pattern）

把请求封装到对象中，从而把发起请求和执行请求的责任分开。

● 备忘录（Memento Pattern）

获取并保存对象的内部状态（不能破坏其封装性），便于后期恢复该对象。

● 状态（State Pattern）

允许对象在其内部状态改变化时，改变该对象的行为能力。

● 访问者（Visitor Pattern）

为集合中的每个元素提供多个访问对象访问（不能改变集合元素）。

● 中介者（Mediator Pattern）

创建中介对象降低系统中对象间的耦合度，以及简化原有对象间的交互，这样原来对象之间不需要相互了解。

● 解释器（Interpreter Pattern）

提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。

2 为什么要使用设计模式？

使用设计模式后，你的代码具有高内聚、低耦合的特性。也可以提高程序的可维护性、可复用性、可扩展性及灵活性。

3 设计模式的六大原则

知道设计模式的六大设计原则，这样才能更好的使用设计模式。设计模式六大原则如下：

● 接口隔离原则（Interface Segregation Principle）

● 迪米特法则（ Law of Demeter）

● 单一职责原则（Single Responsibility Principle）

● 里氏代换原则（Liskov Substitution Principle）

● 开闭原则（Open Close Principle）

● 依赖倒置原则（Dependence Inversion Principle）

设计模式的六大原则详细解释如下图：

4 Java代码实现设计模式

● 工厂（Factory Pattern）

package cn.xiuxiucartoonadmin.common.channel.vo;

/**
 * 抽象工厂
 */
public interface CarFactory {
    Car manufacture();
}
 
 
 
/**
 * 抽象汽车
 */
public interface Car {
    void show();
}
 
 
 
/**
 * 具体工厂A
 */
public class FactoryA implements CarFactory{
    @Override
    public CarA manufacture() {
        System.out.println("具体工厂A");
        return new ProductA();
    }
}
 
 
 
/**
 * 具体工厂B
 */
public class FactoryB implements CarFactory{
    @Override
    public Car manufacture() {
        System.out.println("具体工厂B");
        return new CarB();
    }
}
 
 
 
 
/**
 * 具体产品A
 */
public class ProductA implements Car{
    @Override
    public void show() {
        System.out.println("具体产品A");
    }
}
 
 
 
/**
 * 具体产品B
 */
public class CarB implements Car{
    @Override
    public void show() {
        System.out.println("具体产品B");
    }
}
 
 
 
public class Client {
    public static void main(String[] args) {
        CarFactory factoryA = new FactoryA();
        Car carA = factoryA.manufacture();
        carA.show();
 
        CarFactory factoryB = new FactoryB();
        Car carB = factoryB.manufacture();
        carB.show();
    }
}

● 抽象工厂（Abstract Factory Pattern）

//产品工厂接口
public interface IProductFactory {
 
    //生产手机
    IPhoneProduct phoneProduct();
 
    //生成路由器
    IRouterProduct routerProduct();
}

package cn.xiuxiucartoonadmin.common.channel.vo;

//A工厂实现类
public class AFactory implements IProductFactory {
 
    @Override
    public IPhoneProduct phoneProduct() {
	return new APhone();
    }
 
    @Override
    public IRouterProduct routerProduct() {
	return new ARouter();
    }
}
 
//B工厂实现类
public class BFactory implements IProductFactory {
 
    @Override
    public IPhoneProduct phoneProduct() {
    	return new BPhone();
    }
 
    @Override
    public IRouterProduct routerProduct() {
	return new BRouter();
    }
}

● 单例（Singleton Pattern）

//懒汉模式
public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法 
    public static Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
    }
}

//饿汉模式
public class Singleton1 {
    private Singleton1() {}
    private static final Singleton1 single = new Singleton1();
    //静态工厂方法 
    public static Singleton1 getInstance() {
        return single;
    }
}

● 原型（Prototype Pattern）

public interface IPrototype<T> {
    T clone();
}

public class ConcretePrototype implements IPrototype {
 
    private int age;
    private String name;
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public ConcretePrototype clone() {
        ConcretePrototype concretePrototype = new ConcretePrototype();
        concretePrototype.setAge(this.age);
        concretePrototype.setName(this.name);
        return concretePrototype;
    }
 
    @Override
    public String toString() {
        return "ConcretePrototype{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

public class Client {
 
    public static void main(String[] args) {
        //创建原型对象
        ConcretePrototype prototype = new ConcretePrototype();
        prototype.setAge(18);
        prototype.setName("Tom");
        System.out.println(prototype);
 
        //拷贝原型对象
        ConcretePrototype cloneType = prototype.clone();
        System.out.println(cloneType);
 
    }
}

● 建造者（Builder Pattern）

package cn.xiuxiucartoonadmin.common.channel.vo;

//自行车类
public class Bike {
    private String frame;
    private String seat;

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }

    public String getSeat() {
        return seat;
    }

    public void setSeat(String seat) {
        this.seat = seat;
    }
}

// 抽象 builder 类
public abstract class Builder {

    protected Bike mBike = new Bike();

    public abstract void buildFrame();
    public abstract void buildSeat();
    public abstract Bike createBike();
}

//A单车Builder类
public class ABuilder extends Builder {

    @Override
    public void buildFrame() {
        mBike.setFrame("铝合金车架");
    }

    @Override
    public void buildSeat() {
        mBike.setSeat("真空车轮");
    }

    @Override
    public Bike createBike() {
        return mBike;
    }
}

//B单车Builder类
public class BBuilder extends Builder {

    @Override
    public void buildFrame() {
        mBike.setFrame("铁车架");
    }

    @Override
    public void buildSeat() {
        mBike.setSeat("橡胶车轮");
    }

    @Override
    public Bike createBike() {
        return mBike;
    }
}

//指挥者类
public class Director {
    private Builder mBuilder;

    public Director(Builder builder) {
        mBuilder = builder;
    }

    public Bike construct() {
        mBuilder.buildFrame();
        mBuilder.buildSeat();
        return mBuilder.createBike();
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        showBike(new BBuilder());
        showBike(new ABuilder());
    }
    private static void showBike(Builder builder) {
        Director director = new Director(builder);
        Bike bike = director.construct();
        System.out.println(bike.getFrame());
        System.out.println(bike.getSeat());
    }
}

结构型模式（7种）：

● 适配器（Adapter Pattern）

package cn.xiuxiucartoonadmin.common.channel.vo;

public class AC{
 
    public int outputAC() {
        int output = 120;
        System.out.println("输出" + output + "V");
        return output;
    }
}

package cn.xiuxiucartoonadmin.common.channel.vo;

public interface DC5 {
    int output5V();
}
 
//创建Adapter角色电源适配器PowerAdapter类：
public class PowerAdapter extends AC implements DC5 {
    public int output5V() {
        int adapterInput = super.outputAC();
        int adapterOutput = adapterInput / 44;
        System.out.println("使用Adapter输入AC" + adapterInput + "V,输出DC" + adapterOutput + "V");
        return adapterOutput;
    }
}

public class Test {
     public static void main(String[] args) {
        DC5 adapter = new PowerAdapter();
        adapter.output5V();
    }
}

其他的这里就不一一举例了，其实主要是知道设计模式的原理以及种类，了解他们的作用。这样就能更好的设计我们的程序了。