工厂模式（Factory Pattern）

将创建对象的事交给工厂，不用自己new对象，需要对象从工厂里面拿。

1、简单工厂

public interface ICar {
    String getCarName();
}

public class WulingCar implements ICar {
    @Override
    public String getCarName() {
        return "五菱车型";
    }
}

public class YeMaCar implements ICar {
    @Override
    public String getCarName() {
        return "野马车型";
    }
}



public class CarFactory {
    /**
     * 根据不同车名称创建不同的车
     */
    public static ICar createCar(String carName){
        if("五菱".equals(carName))
            return new WulingCar();
        else if("野马".equals(carName))
            return new YeMaCar();
        else
            return null;
    }
}

public class ClientTest {

    public static void main(String[] args) {
        ICar car = CarFactory.createCar("五菱");
        if(car==null){
            return;
        }
        System.out.println(car.getCarName());
    }
}
// 输出结果：五菱车型

2、工厂方法

工厂方法把实例化操作推迟到子类

// 工厂不直接实现，给子类实现，其实就是定义一个标准
public interface  CarFactory {
    ICar createCar();
}

public class WulingCarFactory implements CarFactory {
    @Override
    public ICar createCar() {
        return new WulingCar();
    }
}

public class YeMaCarFactory implements CarFactory {
    @Override
    public ICar createCar() {
        return new YeMaCar();
    }
}

public class ClientTest {
    public static void main(String[] args) {
        /**
         * 通过各自的工厂去创建各自的车，创建车的事交个工厂
         * 新增加一个车时，不需要动原来的代码，新增类型车继承车进行组装，再创建相应的工厂创建该车即可
         */
        CarFactory factory1 = new WulingCarFactory();
        ICar car1 = factory1.createCar();
        System.out.println(car1.getCarName());

        CarFactory factory2 = new YeMaCarFactory();
        ICar car2 = factory2.createCar();
        System.out.println(car2.getCarName());
    }
}
/**
 * 输出结果：
 * 五菱车型
 * 野马车型
 **/

3、抽象工厂

工厂方法和抽象工厂的区别：

• 工厂方法模式：工厂方法模式只是用于创建一个对象。
• 抽象工厂模式：抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象。

// 定义一个工厂标准，这个标准为工厂能生产手机和wifi发射器
public interface IFactory {
    IPhone createPhoneProduct();

    IWifi createWifiProduct();
}

// 小米就建这种工厂，生产小米的手机和wifi发射器
public class XiaoMiFactory implements IFactory{
    @Override
    public IPhone createPhoneProduct() {
        return new XiaoMiPhone();
    }

    @Override
    public IWifi createWifiProduct() {
        return new XiaoMiWifi();
    }
}

// 华为也建这种工厂，生产华为的手机和wifi发射器
public class HuaWeiFactory implements IFactory{
    @Override
    public IPhone createPhoneProduct() {
        return new HuaWeiPhone();
    }

    @Override
    public IWifi createWifiProduct() {
        return new HuaWeiWifi();
    }
}

// 任意一个工厂实现，都会有手机和wifi发射器
public class ClientTest {
    public static void main(String[] args) {
        XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
        IPhone phoneProduct = xiaoMiFactory.createPhoneProduct();
        phoneProduct.callPhone();

        IWifi wifiProduct = xiaoMiFactory.createWifiProduct();
        wifiProduct.openWifi();
    }
}
/**
 * 输出结果：
 * 小米打电话
 * 小米开wifi
 **/

补充：对于手机和wifi产品而言，也算是一个抽象工厂模式，定义标准，不同的产品去实现功能，一对多。

public interface IPhone {
    // 打电话
    void callPhone();
    // 发送短信
    void sendMsg();
}

public interface IWifi {
    // 开启wifi
    void openWifi();
    // 关闭wifi
    void closeWifi();
}

public class XiaoMiPhone implements IPhone{
    @Override
    public void callPhone() {
        System.out.println("小米打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("小米发短信");
    }
}

public class XiaoMiWifi implements IWifi {
    @Override
    public void openWifi() {
        System.out.println("小米开wifi");
    }

    @Override
    public void closeWifi() {
        System.out.println("小米关wifi");
    }
}

public class HuaWeiPhone implements IPhone{

    @Override
    public void callPhone() {
        System.out.println("华为打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("华为发短信");
    }
}

public class HuaWeiWifi implements IWifi{
    @Override
    public void openWifi() {
        System.out.println("华为开wifi");
    }

    @Override
    public void closeWifi() {
        System.out.println("华为关wifi");
    }
}