工厂设计模式和单例设计模式

工厂设计模式

定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。这满足创建型模式中所要求的“创建与使用相分离”的特点。

简单工厂模式

又称 静态工厂模式

• 创建一个接口
• 多个实现类实现这个接口
• 创建简单工厂
• client通过调用静态方法根据内置的匹配机制返回接口的实现类

public class Lamborghini implements Car{
    @Override
    public void name() {
        System.out.println("兰博基尼");
    }
}
public class Porsche implements Car{
    @Override
    public void name() {
        System.out.println("保时捷");
    }
}
//工厂类
public class CarFactory {
    //创建产品的方法
    public static Car getCar(String car){
        if ("保时捷".equals(car)){
           return new Porsche();
        }else if ("兰博基尼".equals(car)){
           return new Lamborghini();
        }else {
            return null;
        }
    }
public class Consumer {
    public static void main(String[] args) {

        //直接调用工厂类创建产品的方法，不需要知道具体的细节，只需要知道产品名就行
        Car car = CarFactory.getCar("兰博基尼");
        Car car1 = CarFactory.getCar("保时捷");

        car.name();//兰博基尼
        car1.name();//保时捷
    }
}

工厂方法模式

• 创建一个接口
• 多个实现类实现接口
• 创建工厂接口
• 多个工厂实现类实现工厂接口
• 调用方法 Car car = new LamborghiniFactory().getCar();

public interface Car {
    void name();
}
public class Lamborghini implements Car{
    @Override
    public void name() {
        System.out.println("兰博基尼");
    }
}
public class Porsche implements Car{
    @Override
    public void name() {
        System.out.println("保时捷");
    }
}
//抽象工厂
public interface CarFactory {
    Car getCar();
}
//具体工厂
public class LamborghiniFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Lamborghini();
    }
}
//具体工厂
public class PorscheFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Porsche();
    }
}
public class Consumer {
    public static void main(String[] args) {
        //调用具体工厂，由具体工厂实现
        Car car = new LamborghiniFactory().getCar();
        Car car1 = new PorscheFactory().getCar();

        car.name();//兰博基尼
        car1.name();//保时捷

    }
}

抽象工厂设计模式

抽象工厂模式同工厂方法模式相同，由抽象工厂，具体工厂，抽象产品和具体产品四个要素组成，但是该模式下的抽象产品数量为多个

• 创建多个抽象产品接口
• 创建抽象工厂，提供了创建产品的接口
• 略

单例设计模式

该模式下只能有一个实例，必须通过自己创建自己的唯一实例，单例类必须给其他对象提供这一实例

懒单汉设计模式

//懒汉式单例类.在第一次调用的时候实例化自己 
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;
    }
}