【工厂模式】工厂方法模式、抽象工厂模式-简单例子

简单工厂模式，请跳转到我的另一篇博客【工厂模式】简单工厂模式-简单例子-CSDN博客

四、工厂方法模式

（1）这部分还是不变，创建一个Car接口，和两个实现类。

public interface Car {void name();
}public class WuLing implements Car{@Overridepublic void name() {System.out.println("五菱");}
}public class Tesla implements Car{@Overridepublic void name() {System.out.println("特斯拉");}
}

（2）把车工厂提取成一个接口，

public interface CarFactory {Car getCar();
}public class TeslaFactory implements CarFactory{@Overridepublic Car getCar() {return new Tesla();}
}public class WuLingFactory implements CarFactory{@Overridepublic Car getCar(){return new WuLing();}
}

（3）这样的话，我再新增一种新车的时候就很方便了。

public class Mobai implements Car {@Overridepublic void name(){System.out.println("mobai");}
}public class MobaiFactory implements CarFactory{@Overridepublic Car getCar() {return new Mobai();}
}

（4）创建一个Customer类，

public class Customer {public static void main(String[] args) {Car car1 = new WuLingFactory().getCar();Car car2 = new TeslaFactory().getCar();car1.name();car2.name();Car car3 = new MobaiFactory().getCar();car3.name();}
}

这样的话，原来的类我们是没有动的，并且随时可以动态扩展，满足开闭原则。

但是实现起来反而是非常麻烦的，因为从下图的目录结构中我们也可以看出，需要创建的类变多了。

画个流程图分析一下，

总结

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它通过定义一个用于创建对象的接口，但是让子类决定实例化哪个类。这样，工厂方法模式允许一个类的实例化延迟到其子类。

在工厂方法模式中，通常会有一个抽象的工厂类，该工厂类定义了一个抽象的方法，用于创建产品对象。具体的产品创建逻辑由子类实现，每个子类负责实例化特定类型的产品。这样，客户端代码可以通过调用工厂方法来创建所需的产品，而无需关心具体的实现细节。

工厂方法模式通常包括以下角色：

抽象工厂类（Abstract Factory Class）：定义了一个抽象的工厂方法，用于创建产品对象。通常是一个接口或抽象类。
具体工厂类（Concrete Factory Class）：实现了抽象工厂类，负责实际创建产品对象的逻辑。每个具体工厂类对应一种产品类型。
抽象产品类（Abstract Product Class）：定义了产品对象的接口或抽象类，描述了产品的公共属性和方法。
具体产品类（Concrete Product Class）：实现了抽象产品类定义的接口或抽象类，是真正被创建的产品对象。

工厂方法模式的优点在于可以将对象的创建逻辑移到子类中，使得主要的工厂类更加通用，而具体的产品实现则可以灵活地扩展和变化。同时，它也遵循了开闭原则，对扩展开放，对修改关闭。

总的来说，工厂方法模式提供了一种更加灵活的对象创建方式，适用于需要根据不同情况创建不同类型对象的场景。

简单工厂模式和工厂方法模式的对比

简单工厂模式（Simple Factory Pattern）和工厂方法模式（Factory Method Pattern）是两种不同的创建型设计模式，它们在对象创建的方式和角色分配上有一些不同之处。

角色定义：
- 简单工厂模式通常只涉及一个工厂类，该工厂类负责根据客户端的请求创建具体的产品对象。
- 工厂方法模式引入了抽象工厂类和具体工厂类，使得对象的创建逻辑更加灵活。抽象工厂类定义了一个抽象的工厂方法，而具体的产品创建逻辑则由具体工厂类实现。
创建逻辑：
- 在简单工厂模式中，工厂类通常包含一个静态方法，根据不同的参数或条件返回不同类型的产品对象。
- 而在工厂方法模式中，每个具体的产品都有对应的具体工厂类，该类负责创建特定类型的产品对象。这样，对象的创建逻辑被分散到了多个具体工厂类中。
扩展性：
- 简单工厂模式的扩展性相对较差，如果需要添加新的产品类型，则需要修改工厂类的代码，违反了开闭原则。
- 工厂方法模式遵循了开闭原则，因为具体的产品创建逻辑在具体工厂类中，所以可以通过添加新的具体工厂类来扩展系统，而不需要修改已有的代码。
复杂度：
- 简单工厂模式相对于工厂方法模式来说，实现起来较为简单，适用于简单的场景。
- 工厂方法模式的实现相对复杂一些，但提供了更高的灵活性和可扩展性，适用于需要根据不同情况创建不同类型对象的复杂场景。

总的来说，简单工厂模式适用于简单的对象创建场景，而工厂方法模式更适用于复杂的场景，需要更高的灵活性和可扩展性。

五、抽象工厂模式

（1）创建一个产品接口类，和两个实现类。

public interface PhoneProduct {void start();void shutdown();void call();void sendMes();
}public class XiaomiPhone implements PhoneProduct{@Overridepublic void start() {System.out.println("小米手机开机");}@Overridepublic void shutdown() {System.out.println("小米手机关机");}@Overridepublic void call() {System.out.println("小米手机打电话");}@Overridepublic void sendMes() {System.out.println("小米手机发短信");}
}public class HuaWeiPhone implements PhoneProduct{@Overridepublic void start() {System.out.println("华为手机开机");}@Overridepublic void shutdown() {System.out.println("华为手机关机");}@Overridepublic void call() {System.out.println("华为手机打电话");}@Overridepublic void sendMes() {System.out.println("华为手机发短信");}
}

（2）创建一个路由器接口类，和两个实现类。

public interface RouteProduct {void start();void shutdown();void setting();void openWife();
}public class XiaomiRoute implements RouteProduct{@Overridepublic void start() {System.out.println("小米路由器开机");}@Overridepublic void shutdown() {System.out.println("小米路由器关机");}@Overridepublic void setting() {System.out.println("小米路由器设置");}@Overridepublic void openWife() {System.out.println("小米路由器打开wife");}
}public class HuaWeiRoute implements RouteProduct{@Overridepublic void start() {System.out.println("华为路由器开机");}@Overridepublic void shutdown() {System.out.println("华为路由器关机");}@Overridepublic void setting() {System.out.println("华为路由器设置");}@Overridepublic void openWife() {System.out.println("华为路由器打开wife");}
}

（3）创建一个抽象工厂接口，已经两个系列产品的实现类。

public interface ProductFactory {PhoneProduct phoneProduct();RouteProduct routeProduct();
}public class HuaWeiFactory implements ProductFactory{@Overridepublic PhoneProduct phoneProduct() {return new HuaWeiPhone();}@Overridepublic RouteProduct routeProduct() {return new HuaWeiRoute();}
}public class XiaomiFactory implements ProductFactory{@Overridepublic PhoneProduct phoneProduct() {return new XiaomiPhone();}@Overridepublic RouteProduct routeProduct() {return new XiaomiRoute();}
}

（4）创建一个Client类，

public class Client {public static void main(String[] args) {System.out.println("----小米产品----");XiaomiFactory xiaomiFactory = new XiaomiFactory();PhoneProduct phoneProduct = xiaomiFactory.phoneProduct();RouteProduct routeProduct = xiaomiFactory.routeProduct();phoneProduct.call();routeProduct.openWife();System.out.println("----华为产品----");HuaWeiFactory huaWeiFactory = new HuaWeiFactory();PhoneProduct phoneProduct1 = huaWeiFactory.phoneProduct();RouteProduct routeProduct1 = huaWeiFactory.routeProduct();phoneProduct1.call();routeProduct1.openWife();}
}