它也叫做静态工厂模式，其实是不属于23种设计模式的。

他的实现主要就是
定义一个类，该类根据传入的参数，动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接口)的实例，其实就是将一个具体类的实例化交给一个类的静态方法来执行，（体现的是创建者和调用者分离）该类被称为工厂类，静态方法被称为静态工厂方法。

首先以买车为例 创建一个大家都熟悉的流程
先创建一个接口：

public interface Car {
    //有一个名字的属性
    String name();
}

然后创建两个实体类：

Tesla

public class Tesla implements Car{
    @Override
    public String name() {
        return "特斯拉";
    }
}

Wuling

public class WuLing implements Car{
    @Override
    public String name() {
        return "五菱";
    }
}

创建消费者购买这两类车

public class Customer {
    public static void main(String[] args) {
        //然后作为消费者 需要买一辆五菱 买一辆特斯拉的话
        //需要创建这两个实例对象
        Car car1=new WuLing();
        Car car2=new Tesla();
        System.out.println(car1.name());
        System.out.println(car2.name());
    }
}

但是这种基本模式下 有很大的缺点，就是实例化对象的时候都需要new一个，就好比买车的时候 就需要自己new一个想要的车，所以需要有工厂类的出现
模式图

简单工厂模式：

CarFactory

public class CarFactory{
    //简单静态工厂类 在这个地方进行new
    //在这个类里面 写一个静态方法 可以直接调用的
    public static  Car getCar(String name){
        //但是我不知道是不是 异常 就是如果输入的车名是不一样的
        if(name.equals("特斯拉")){
            //那就创建特斯拉的车
            return  new Tesla();
        }else if(name.equals("五菱")){
            return new WuLing();
        }
        //这里是防止出现一些没有名字的新车
        return new Car() {
            @Override
            public String name() {
                return "无名";
            }
        };
    }
}

FactoryCustomer

public class FactoryCustomer {
    public static void main(String[] args) {
        //这里就是调用那个工厂了
        //先创建这个工厂类
        Car car1=CarFactory.getCar("特斯拉");
        Car car2=CarFactory.getCar("五菱");
        Car car3=CarFactory.getCar("无名氏");
        System.out.println(car1.name());
        System.out.println(car2.name());
        System.out.println(car3.name());

    }
}

但是这个简单工厂模式是不符合开闭原则的，也就是让我们又出现一辆新的车的时候，就需要在这个CarFactory这边进行对应增加if判断，所以简单工厂模式也算是静态工厂模式。不适合动态的增加

模型图：

工厂方法模式：

其实简单来说 就是定义一个工厂接口，然后对每种车都进行实现工厂接口，变成专属自己的车工厂
先创建Car接口:

public interface Car {
    //有一个名字的属性
    String name();
}

Tesla和WuLing两个实现类：

public class Tesla implements Car {
    @Override
    public String name() {
        return "特斯拉";
    }
}

public class WuLing implements Car {
    @Override
    public String name() {
        return "五菱";
    }
}

CarFactoryu接口

public interface CarFactory {
    //这个接口有一个方法
    Car getCar();
}

Tesla工厂接口和WuLing工厂接口：

public class WuLingFactory  implements CarFactory{
    @Override
    public Car getCar() {
        return new WuLing();
    }
}

public class TeslaFactory implements CarFactory{
    @Override
    public Car getCar() {
        //实现这个工厂接口 并创建一个对应的类
        return new Tesla();
    }
}

最后是customer类

public class Customer {
    public static void main(String[] args) {
        //所以是需要和对应的工厂对接？ 反正目的就是不需要new?
        //那这样子是不是 没必要呢
        //但是这样new可以姑且理解为 new 一个车等于要造一个车，但是new一个工厂就是相当于找到一个4s店。。。
        TeslaFactory teslaFactory=new TeslaFactory();
        WuLingFactory wuLingFactory=new WuLingFactory();
        Car car1=teslaFactory.getCar();
        Car car2=wuLingFactory.getCar();


        System.out.println(car1.name());
        System.out.println(car2.name());

    }
}

这样的好处在于，满足了开闭原则，不需要再修改。但是需要每次进行添加：