JAVA的设计模式

1：设计模式作用和原则

作用：经验的传承，提高了软件复用的水平，最终达到提高软件开发效率

2：分类

1：创建型模式：都是用来帮助我们创建对象的、

2：结构性模式:关注对象和类的组织

3：行为型模式:关注系统中对象之间的相互交换，研究系统在运行时对象之间的相互通信和协作，进一步明确对象的职责

3：单例模式

作用：单例模式的核心是保证一个类只有一个实例，并且提供一个访问实例的全局访问点。

4：工厂模式

工厂模式的作用是帮助我们创建对象，我们不用自己来创建，根据需要创建的对象的复杂度我们可以把工厂模式分为简单工厂，工厂方法和抽象工厂。

1：简单工厂

简单工厂模式又称为静态工厂方法，他可以根据不同的参数而返回不同的实例，简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

/**
 * 简单工厂
 */
public class SimpleFactory {

    public static void main(String[] args) {
        // 根据对应的类型返回相关产品
        CarFactory.createCar("奥迪").run();
        CarFactory.createCar("Byd").run();
    }
}

// 定义公共的接口
interface Car{
    void run();
}

class Audi implements Car{
    @Override
    public void run() {
        System.out.println("奥迪在跑...");
    }
}

class Byd implements Car{
    @Override
    public void run() {
        System.out.println("Byd在跑...");
    }
}

// 创建对应的简单工厂类
class CarFactory{
    public static Car createCar(String type){
        if("奥迪".equals(type)){
            return new Audi();
        }else if("Byd".equals(type)){
            return new Byd();
        }else{
            throw new RuntimeException("该产品不能生产");
        }
    }
}

2:工厂方法

针对于简单工厂的短板，引出了工厂方法模式，定义一个用户创建对象的接口，让子类决定实例化哪个类，工厂方法使一个类的实例化延迟到了其子类中。

3：抽象工厂

上面的两种方式实现的工厂都是生产同一大类的产品，如果要实现生产不同类型的产品这时我们就可以用抽象工厂模式来实现。

/**
 * 抽象工厂：多个产品族
 */
public class AbstractFactory {

    public static void main(String[] args) {
        Car car = new LuxuryEngineCarFacory().createCar();
        Engine engine = new LuxuryEngineCarFacory().createEngine();
        car.run();
        engine.run();
    }

    // 抽象工厂
    public static interface AbstarctComponentFactory{
        Car createCar();
        Engine createEngine();
    }

    public static class LuxuryEngineCarFacory implements AbstarctComponentFactory{
        @Override
        public Engine createEngine() {
            return new LuxuryEngineFactory().createEngine();
        }

        @Override
        public Car createCar() {
            return new BydCarFactory().createCar();
        }
    }

    public static class LowEngineCarFacory implements AbstarctComponentFactory{
        @Override
        public Car createCar() {
            return new AudiCarFactory().createCar();
        }

        @Override
        public Engine createEngine() {
            return new LowEngineFactory().createEngine();
        }
    }

    // 汽车产品族
    public static interface  Car{
        public void run();
    }

    public static class Byd implements Car {
        @Override
        public void run() {
            System.out.println("比亚迪...");
        }
    }

    public static class Audi implements Car {
        @Override
        public void run() {
            System.out.println("奥迪...");
        }
    }

    public static interface CarFactory{
        public Car createCar();
    }

    // 扩展的工厂
    public static class AudiCarFactory implements CarFactory {
        @Override
        public Car createCar() {
            return new Audi();
        }
    }

    public static class BydCarFactory implements  CarFactory{
        @Override
        public Car createCar() {
            return new Byd();
        }
    }

    // 发动机产品族
    public static interface Engine{
        public void run();
    }

    public static class LuxuryEngine implements Engine{
        @Override
        public void run() {
            System.out.println("豪华版发动机...");
        }
    }

    public static class LowEngine implements Engine{
        @Override
        public void run() {
            System.out.println("低配版发动机...");
        }
    }

    public static interface EngineFactory{
        public Engine createEngine();
    }

    public static class LuxuryEngineFactory implements EngineFactory{
        @Override
        public Engine createEngine() {
            return new LuxuryEngine();
        }
    }

    public static class LowEngineFactory implements EngineFactory{
        @Override
        public Engine createEngine() {
            return new LowEngine();
        }
    }
}

5:建造者模式

6:原型模式

在java中我们知道通过new关键字创建的对象是非常繁琐的(类加载判断，内存分配，初始化等)，在我们需要大量对象的情况下，原型模式就是我们可以考虑实现的方式。
  原型模式我们也称为克隆模式，即一个某个对象为原型克隆出来一个一模一样的对象，该对象的属性和原型对象一模一样。而且对于原型对象没有任何影响。原型模式的克隆方式有两种：浅克隆和深度克隆.

7:代理模式

代理模式的作用是通过代理对象来增强目标对象的功能。利用的是AOP横切的思想。
代理模式的实现方式有三种：静态代理，动态代理(JDK动态代理和CGLIB动态代理)

8：适配器模式

适配器模式的作用是把两个不兼容的对象通过适配器能够连接起来工作。

以MyBatis中的日志模块为例来介绍。常见的日志框架有log4j,log4j2,slf4j,logbak等，但是每种日志框架中的日志级别都有差异。
不同的日志框架里面所定义的日志级别和对应的方法都有区别，那么我们的框架怎么来统一使用这些日志框架呢？在MyBatis中通过定义了一个日志接口，定义了日志具有的级别和方法。

那这时候我们就发现具体的日志框架和这个接口其实是没有办法直接来使用的。

这时我们就需要通过对应的适配器来处理这种情况，以Slf4J为例。

9：装饰者模式

装饰者模式又称为包装模式(Wrapper),作用是用来动态的为一个对象增加新的功能。装饰模式是一种用于代替继承的技术， 无须通过继承增加子类就能扩展对象的新功能 。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。

装饰者模式的应用场景还是非常多的，比如

• IO流中的FileInputStream，FileOutputStream等
• Spring中的各种Wrapper
• MyBatis中的缓存设计

10：组合模式

其实解决的是对象与对象之间的包含关系。也就是 部分-整体 的层次结构。
组合模式在配置文件的加载解析中其实会用的相对比较多。以SpringSecurity的配置文件为例

上面是具体的定义

11：门面模式

门面模式也称为外观模式，他隐藏了系统的复杂性，并向客户端提供了一个可以访问系统的接口。这种类型的设计模式属于结构性模式。为子系统中的一组接口提供了一个统一的访问接口，这个接口使得子系统更容易被访问或者使用。

  具体的例子比如：MyBatis中的SqlSession接口，对外提供了数据库操作的相关功能，具体的实现细节对调用者是隐藏的，这种模式在实际项目和框架中很频繁

12：桥接模式

桥接模式的出现是替代掉多层继承的问题。提高了系统的扩展性。

具体的应用比如JDBC中的DriverManager其实有用到桥接模式，不同的数据库厂商对应不同的驱动和连接

13：享元模式

这个问题相对来说比较冷门，用到的也比较少，主要是针对内存这块的节省处理，如果有很多个完全相同或相似的对象，我们可以通过享元模式，节省内存.

享元模式以共享的方式高效地支持大量细粒度对象的重用。

享元对象能做到共享的关键是区分了内部状态和外部状态。
• 内部状态 ：可以共享，不会随环境变化而改变
• 外部状态 ：不可以共享，会随环境变化而改变