23种设计模式

设计模式的定义

设计模式是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案

设计模式的分类

根据范围可分为类模式和对象模式 根据目的可分为创建型模式、结构型模式、行为型模式

创建型模式：将对象的创建和使用分离，降低系统耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。就像我们去商场购买商品时，不需要知道商品是怎么生产出来一样，因为它们由专门的厂商生产。

结构型模式：用来描述如何将类或对象按某种布局组成更大的结构，类结构型模式采用继承机制来组织接口和类，对象结构型模式采用组合或聚合来组织对象。

行为型模式：用来描述多个类或对象之间怎么相互协作共同完成单个对象无法完成的任务，类行为模式采用继承机制在类间分配行为，对象行为型模式采用组合或聚合在对象间分配行为。

面向对象七大原则

开闭原则

当应用的需求改变时，在不修改软件实体的源代码或者二进制代码的前提下，可以扩展模块的功能，使其满足新的需求。

里式替换原则

子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。

依赖倒置原则

要面向接口编程，不要面向实现编程。

单一职责原则

规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分。

接口隔离原则

一个类对另一个类的依赖应该建立在最小的接口上。

迪米特法则

又叫最少知识原则，如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。

合成复用原则

要求在软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

创建型模式

单例模式

定义

一个类只有一个实例，该类能自己创建该类的一个实例。

特点

• 单例类只有一个实例对象。

• 单例对象必须有该类自己创建。

• 单例类对外提供一个访问该单例的全局访问点。

实现方式

 // 懒汉模式：加载类的时候没有生成单例模式，调用生成实例对象的方法的时候创建单例。
public class LazySingleton {
​
    //保证lazySingleton在线程中同步
    private static volatile LazySingleton lazySingleton = null;
    //保证类不在别的地方被实例化
    private LazySingleton() {
    }
    //synchronize保证线程安全
    public static synchronized LazySingleton getInstance() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}
​
​
// 饿汉模式：类一旦加载就创建一个单例。创建的这个对象之后就不会再改变，所以是线程安全的。
public class HungrySingleton {
    private static final HungrySingleton hungrySingleton = new HungrySingleton();
    private HungrySingleton() {
    }
    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }
}
​
​

工厂模式

定义

对象的实际创建工作推迟到子类当中。

特点

• 用户只需要知道工厂的名称，则可得到对应的产品，无需知道产品的创建过程。

• 系统增加产品时只需添加具体产品类和对应的具体工厂类，无需对原工厂进行修改。

• 每增加一个产品就得增加一个具体产品类和和一个对应的具体工厂类。

实现方式

// 提供产品的接口
public interface Product {
    public void show();
}
​
// 具体产品1实现产品接口
public class ProductImpl1 implements Product {
    @Override
    public void show() {
        System.out.println("我生产了1");
    }
}
​
// 具体产品2实现产品接口
public class ProductImpl2 implements Product {
    @Override
    public void show() {
        System.out.println("我生产了2");
    }
}
​
// 抽象工厂，提供生成产品的方法
public interface AbstractFactory {
    public Product getInstance();
}
​
// 实现产品生成
public class FactoryTest {
    public static void main(String[] args) {
        CreateFactory1 createFactory1 = new CreateFactory1();
        createFactory1.getInstance();
        CreateFactory2 createFactory2 = new CreateFactory2();
        createFactory2.getInstance();
    }
    static class CreateFactory1 implements AbstractFactory {
        @Override
        public Product getInstance() {
            System.out.println("工厂1生产产品");
            ProductImpl1 productImpl1 = new ProductImpl1();
            productImpl1.show();
            return productImpl1;
        }
    }
    static class CreateFactory2 implements AbstractFactory {
        @Override
        public Product getInstance() {
            System.out.println("工厂2生产产品");
            ProductImpl2 productImpl2 = new ProductImpl2();
            productImpl2.show();
            return productImpl2;
        }
    }
}
​

抽象工厂模式

定义

是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

特点

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。

• 当增加一个新的产品族时不需要修改原代码。

实现方式

// 形状类以及具体的图形
public interface Shape {
    /**
     * 画形状
     */
    void draw();
}
public class Rectangle implements Shape {
​
    public static final String SHAPE = "rectangle";
​
    @Override
    public void draw() {
        System.out.println("我是长方形");
    }
}
public class Square implements Shape {
    
    public static final String SHAPE = "square";
​
    @Override
    public void draw() {
        System.out.println("我是矩形");
    }
}
​
// 颜色以及具体的颜色
public interface Color {
    /**
     * 填充颜色
     */
    void fill();
}
public class Green implements Color {
    
    public static final String COLOR = "green";
​
    @Override
    public void fill() {
        System.out.println("填充绿色");
    }
}
public class Red implements Color {
​
    public static final String COLOR = "red";
​
    @Override
    public void fill() {
        System.out.println("填充红色");
    }
}
​
// 得到颜色和形状的抽象工厂
public abstract class AbstractFactory {
​
    public abstract Color getColor(String color);
    public abstract Shape getShape(String shape);
​
}
​
// 得到具体颜色、具体形状的方法
public class ColorFactory extends AbstractFactory {
​
    public static final String TYPE = "color";
​
    @Override
    public Color getColor(String color) {
        if (color == null) {
            return null;
        } else if (Red.COLOR.equalsIgnoreCase(color)) {
            return new Red();
        } else if (Green.COLOR.equalsIgnoreCase(color)) {
            return new Green();
        }
        return null;
    }
​
    @Override
    public Shape getShape(String shape) {
        return null;
    }
}
public class ShapeFactory extends AbstractFactory {
​
    public static final String TYPE = "shape";
​
    @Override
    public Color getColor(String color) {
        return null;
    }
​
    @Override
    public Shape getShape(String shape) {
        if (shape == null) {
            return null;
        }
        if (Rectangle.SHAPE.equalsIgnoreCase(shape)) {
            return new Rectangle();
        } else if (Square.SHAPE.equalsIgnoreCase(shape)) {
            return new Square();
        }
        return null;
    }
}
​
// 得到颜色或者形状的工厂
public class FactoryProducer {
​
    /**
     * 获取工厂实例
     *
     * @param type 工厂类型
     * @return AbstractFactory
     */
    public static AbstractFactory getFactoryInstance(String type) {
        if (ShapeFactory.TYPE.equalsIgnoreCase(type)) {
            return new ShapeFactory();
        } else if (ColorFactory.TYPE.equalsIgnoreCase(type)) {
            return new ColorFactory();
        }
        return null;
    }
}
​
// 根据传入的东西判断得到具体的形状或者具体的颜色
public static void main(String[] args) {
    //获取形状工厂
    AbstractFactory shape = FactoryProducer.getFactoryInstance("shape");
​
    Shape rectangle = Objects.requireNonNull(shape).getShape("rectangle");
    rectangle.draw();
​
    Shape square = shape.getShape("square");
    square.draw();
​
    // 获取颜色工厂
    AbstractFactory colorFactory = FactoryProducer.getFactoryInstance("COLOR");
    Color color1 = Objects.requireNonNull(colorFactory).getColor("RED");
    color1.fill();
}
​
​
​
​
​
​
​
​
​