设计模式-工厂模式

主目录：https://blog.csdn.net/qq_52681418/article/details/114828850

设计模式-工厂模式

调用者在调用某个类时无需主要new的是哪个对象，而是通过工厂来构建对象。违背开闭原则。

正常情况下用代码实现需要创建华为类、小米类，创建哪个new哪个，这样就会导致调用类和华为类、小米类耦合在一起。

举例：

假设你需要生产小米和华为手机，你创建一个手机接口或抽象类，然后创建实现类：

手机接口：

public interface Phone {
    void sun();
}

华为手机

public class HuaWeiPhone implements Phone {
   public void sun(){
       System.out.println("---华为手机---");
   }
}

小米手机

public class XiaoMiPhone implements Phone {
   public void sun(){
       System.out.println("---小米手机---");
   }

}

接下来我们通过不同模式来创建这些手机。

我们不使用工厂模式：

public class Main {
    public static void main(String[] args) {
        Phone phone1=new HuaWeiPhone();
        Phone phone2=new XiaoMiPhone();
        phone1.sun();
        phone2.sun();
    }
}

可以发现：创建手机时需要依赖华为类、小米类。如果添加新品牌，需要修改调用者。

1.简单工厂模式

为了减轻依赖，我们可以添加一个工厂，调用者依赖于工厂，由工厂来决定生产哪个手机。

手机工厂

public class PhoneFactory {

    public Phone createPhone(String phoneName){
        if (phoneName.equals("HuaWei")){
            return new HuaWeiPhone();
        }
        if(phoneName.equals("XiaoMi")){
            return new XiaoMiPhone();
        }
        return null;
    }

}

调用工厂来生产

public class Main {
    public static void main(String[] args) {
        PhoneFactory phoneFactory = new PhoneFactory();    //创建手机工厂
        Phone phone1=phoneFactory.createPhone("HuaWei");   //工厂制造华为手机
        Phone phone2=phoneFactory.createPhone("XiaoMi");   //工厂制造小米手机
        phone1.sun();
        phone2.sun();
    }
}

可以发现：将调用者对手机的依赖转移给了工厂，只需要调用工厂即可。每次添加新品牌手机时，修改工厂即可。

我们还可以将createPhone()方法设为静态方法，这样调用者就无需new工厂，而是直接使用( 静态工厂)。

Phone phone1=PhoneFactory.createPhone("HuaWei");   //工厂制造华为手机
Phone phone2=PhoneFactory.createPhone("XiaoMi");   //工厂制造小米手机

工厂模式虽然降低了调用者和手机的耦合，但出现了手机和工厂的新耦合：

工厂和手机 的耦合是可以去除的，将手机信息存放在配置文件，工厂去读配置文件来读取有哪些手机，每次添加新品牌时修改配置文件即可。

2.工厂方法模式

创建一个抽象的工厂，然后实现多个工厂，类似于总厂-分厂，比如手机总厂衍生出华为分厂、小米分厂。这样一来我们添加新手机的时候就只需为其添加一个新分厂即可，无需修改其它代码。

修改我们的工厂：

工厂接口(总厂)

public interface PhoneFactory {
   Phone createPhone();
}

华为分厂：

public class HuaWeiPhoneFactory implements PhoneFactory {
   public Phone createPhone() {
       return new HuaWeiPhone();
   }
}

小米分厂

public class XiaoMiPhoneFactory implements PhoneFactory {
   public Phone createPhone() {
       return new XiaoMiPhone();
   }
}

创建好了分厂，我们制造手机 (焦点是手机和调用者解耦)

public class Main {
    public static void main(String[] args) {
        PhoneFactory phoneFactory1=new HuaWeiPhoneFactory();//华为工厂
        PhoneFactory phoneFactory2=new XiaoMiPhoneFactory();//小米工厂
        Phone phone1 = phoneFactory1.createPhone();//华为工厂制造华为手机
        Phone phone2 = phoneFactory2.createPhone();//小米工厂制造小米手机
        phone1.sun();
        phone2.sun();
    }
}

这样一来，我们每次添加新产品时，为新产品添加一个工厂即可。

缺点：每个产品一个分工厂，虽然实现了解耦，但是产品过多导致类爆炸。(假如此时再做小米、华为电脑，就会产生类爆炸)。