[会写代码的健身爱好者成长史]之设计模式

1.工厂模式

工厂模式分为3种：简单工厂模式，工厂方法模式，抽象工厂模式

1.简单工厂模式

01.概念：

简单工厂模式属于创建型模式，又称静态工厂方法，由一个工厂对象决定创建出现哪一种产品类的实例，对新增的产品，需要在已有的代码上面做添加更改，所以简单工厂模式也是工厂模式中最简单实用的

02.代码举例

模拟消费者买车，首先要去对应车品牌的工厂买，工厂这边去制造（new）一个车

创建一个车接口 

/**
 * 创建一个 车 接口
 */
public interface Car {
    void name();
}

 bwm牌车，去实现car接口

/**
 * bwm牌车，去实现car接口
 */
public class BWM implements Car{
    @Override
    public void name() {
        System.out.println("BWM");
    }
}

tesla牌车，实现car接口 

/**
 * tesla牌车，实现car接口
 */
public class Tesla implements Car{

    @Override
    public void name() {
        System.out.println("tesla");
    }
}

 简单工厂模式,创建所有的对象都在这里判断完成
 根据消费者的需求,到底要哪一种车,去制作（new）消费者需要的车

/**
 * 简单工厂模式,创建所有的对象都在这里判断完成
 * 根据消费者的需求,到底要哪一种车,去制作（new）消费者需要的车
 */
public class CarFactory{
    public static Car getCar(String name){
        if (name.equals("BWM")){
            return new BWM();
        }else if (name.equals("tesla")){
            return new Tesla();
        }else {
            return null;
        }
    }
}

 调用carFactory工厂,根据消费者需要的车品牌去制造（new）车

/**
 * 调用carFactory工厂,根据消费者需要的车品牌去制造（new）车
 */
public class Consumer {
    public static void main(String[] args) {
        Car bwm = CarFactory.getCar("BWM");
        bwm.name();

        Car tesla = CarFactory.getCar("tesla");
        tesla.name();
    }
}

2.工厂方法模式

01.概念

工厂方法模式又称多态工厂模式，每添加一个具体的对象，都需要添加一个对应的具体工厂对象，支持增加任意产品，而不需要更改工厂的代码，原有工厂不需要做任何修改，很好的符合了 开放关闭 原则

 02.代码举例

创建一个car工厂 

/**
 * 工厂方法模式
 */
public interface CarFactory {
    Car getCar();
}

tesla品牌工厂去实现这个car工厂 

/**
 * 车品牌工厂去实现这个car工厂
 */
public class TeslaFactory implements CarFactory{

    @Override
    public Car getCar() {
        return new Tesla();
    }
}

bwm车实现car工厂 

/**
 * bwm车实现car工厂
 */
public class BWMFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new BWM();
    }
}

消费者去工厂获得车 

public class MethodConsumer {
    public static void main(String[] args) {
        Car car = new BWMFactory().getCar();
        car.name();
        Car car1 = new TeslaFactory().getCar();
        car1.name();
    }
}

2.单例模式

概念：单例模式就是在运行时只能有一个实例化对象

为什么需要单例模式？

因为有的类的实例对象的创建和销毁对资源的消耗不大，有的类的创建和消耗对资源消耗大，并且这些对象还是可以复用的，那么会造成一些不必要的性能浪费

1.饿汉式

比较常用的，也是线程安全的单例模式，但是类加载时就初始化，浪费内存，没有加锁所以效率比较高

/**
 * 饿汉式
 */
public class Singleton {
    
    //创建一个SingleObject对象
    private static Singleton singleton = new Singleton();
    
    //让构造函数为private,这样该类就不会被实例化
    private Singleton(){}
    
    //获取唯一可用的对象
    private Singleton getSingleton(){
        return singleton;
    }

}

2.懒汉式

如果不加synchronized，线程不安全，加了线程安全，但是执行效率低

/**
 * 懒汉式
 */
public class Singleton {

    private static Singleton singleton;

    private Singleton(){}
    //如果不加synchronized是线程不安全的，多线程下会出问题
    public static synchronized Singleton getInstance(){
        if (singleton==null){
            singleton = new Singleton();
        }
        return singleton;
    }

}

3.双重校验锁

双锁机制，安全且在多线程的情况下保持高性能

/**
 * 双重校验锁
 */
public class Singleton {
    //使用volatile可以阻止作用在getInstance指令上jvm为了性能重新排列的问题,该问题可能会导致线程不安全
    private volatile static Singleton singleton;

    private Singleton(){}
    
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    //在指令层面不是原子操作,分为3步:
                    //1.分配内存  2.初始化对象  3.对象指向内存地址
                    //在真正执行时,jvm虚拟机为了效率可能会对其进行重新排列,可能会出问题，
                    //所以要在刚开始的时候加个volatile关键字（private volatile static                
                    //Singleton singleton）
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}