工厂设计模式是一种创建型设计模式，用于创建对象的过程中封装对象的创建逻辑。
它提供了一种创建对象的最佳方式，不需要在每个使用该对象的地方直接实例化对象。工厂模式通过定义一个公共的接口来创建对象，然后由子类来实现这个接口以提供具体的对象实例化逻辑
核心本质：
- 实例化对象不使用new，用工厂方法代替
- 选择实现类，创建对象统一管理和控制，从而将调用者跟我们的实现类解耦
工厂设计模式主要有三种形式：简单工厂模式、工厂方法模式和抽象工厂模式。
-
简单工厂模式（Simple Factory Pattern）：简单工厂模式通过一个工厂类来负责创建所有的产品类的实例，客户端只需要提供工厂类所需的参数，即可获取所需的产品实例。
-
工厂方法模式（Factory Method Pattern）：工厂方法模式将工厂抽象成一个接口或抽象类，每个具体的工厂类负责创建一种产品，客户端通过调用工厂方法来获取产品实例。
-
抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式提供一个接口，用于创建一系列相关或依赖对象，而不需要指定具体的类。客户端通过调用工厂接口来获取不同产品的实例。
工厂模式的优点包括：封装了对象的创建逻辑，降低了客户端和具体产品类之间的耦合度，提高了代码的可维护性和扩展性。缺点是如果产品类的种类过多，会导致工厂类代码变得复杂，维护困难。
创建一个接口，定义了我们要实现的基本功能
public interface Car {
void name();
}创建这个接口的实现类
public class TSLa implements Car {
@Override
public void name() {
System.out.println("特斯拉");
}
}
public class WuLing implements Car {
@Override
public void name() {
System.out.println("五菱宏光");
}
}简单工厂模式
创建一个CarFactory类，在这个类中提供创建类的实例的静态方法，所以简单工厂也称为静态工厂。
public class CarFactory {
//方式1
//简单工厂模式/静态工厂模式
//缺点：如果需要增加新的产品，需要修改代码，不符合开闭原则
public static Car getCar(String name)
{
if(name.equals("特斯拉"))
{
return new TSLa();
}
else if(name.equals("五菱"))
{
return new WuLing();
}
else
{
return null;
}
}
//方式2
public static Car getTSCar(){
return new TSLa();
}
public static Car getWLCar(){
return new WuLing();
}
}消费者在创建对应的对象的时候调用工厂类。提供对应的参数即可
public class test {
public static void main(String[] args) {
//传统的方式创建对象
Car wuli=new WuLing();
Car TS=new TSLa();
wuli.name();
TS.name();
//使用简单工厂创建对象
Car car = CarFactory.getCar("五菱");
Car car2 = CarFactory.getCar("特斯拉");
car.name();
car2.name();
}
}简单工厂模式的缺点：如果我们要新增加一个类，我们就需要对CarFactory类中的代码进行修改。这违反了开闭原则。
工厂方法模式
就是给每一种汽车类都封装对应的工厂
创建一个CarFactory的接口
public interface CarFactory {
Car getCar();
}不同的类创造不同的工厂对象来继承这个CarFactory接口
public class TSLFactory implements CarFactory{
@Override
public Car getCar() {
return new TSLa();
}
}public class WLFactory implements CarFactory{
@Override
public Car getCar() {
return new WuLing();
}
}然后在消费者中通过不同的工厂得到对应的对象
public class test {
public static void main(String[] args) {
Car car1 = new TSLFactory().getCar();
Car car2 = new WLFactory().getCar();
car1.name();
car2.name();
}
}如果我们需要添加一个其他的汽车类，就需要创建一个对应的汽车工厂类来创建这个汽车类的对象
如果我们的汽车类特别多，我们创建的java文件数量就会很多。
抽象工厂模式
定义：抽象工厂提供了一个创建一系列相关或者相互依赖对象的接口，无虚指定它们具体的类
适用场景：
- 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
- 强调一系列相关的产品对象（属于统一产品族）一起使用创建对象需要大量的重复代码
- 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现
优点：
- 具体产品在应用层的代码隔离，无需关心创建的细节
- 将一系列的产品统一到一起创建
缺点：
- 规定了所有可能被创建的产品集合，产品族中扩展性的产品困难
- 增加了系统的抽象性和理解难度
举例：现在有一个大的抽象工厂：IProductFactory，用来创建手机和路由器，手机、路由器的种类有小米和华为。
//抽象产品工厂
public interface IProductFactory {
IPhoneProduct getPhoneProduct();
RouterProduct getRouterProduct();
}//华为生产工厂
public class HuaWeiFactory implements IProductFactory{
@Override
public IPhoneProduct getPhoneProduct() {
return new HuaWeiPhone();
}
@Override
public RouterProduct getRouterProduct() {
return new HuaWeiRouter();
}
}//小米生产工厂
public class XiaoMiFactory implements IProductFactory{
@Override
public IPhoneProduct getPhoneProduct() {
return new XiaoMiPhone();
}
@Override
public RouterProduct getRouterProduct() {
return new XiaoMiRouter();
}
}//手机产品接口
public interface IPhoneProduct {
void start();
void shutdown();
void callup();
void sendSMS();
//路由器产品接口
public interface RouterProduct {
void start();
void shutdown();
void openWifi();
void setting();
}//华为手机实现类
public class HuaWeiPhone implements IPhoneProduct{
@Override
public void start() {
System.out.println("华为手机开机");
}
@Override
public void shutdown() {
System.out.println("华为手机关机");
}
@Override
public void callup() {
System.out.println("华为手机打电话");
}
@Override
public void sendSMS() {
System.out.println("华为手机发短信");
}
}//华为路由器实现类
public class HuaWeiRouter implements RouterProduct{
@Override
public void start() {
System.out.println("华为路由器开机");
}
@Override
public void shutdown() {
System.out.println("华为路由器关机");
}
@Override
public void openWifi() {
System.out.println("华为路由器打开wifi");
}
@Override
public void setting() {
System.out.println("华为路由器设置");
}
}//小米手机实现类
public class XiaoMiPhone implements IPhoneProduct{
@Override
public void start() {
System.out.println("小米手机开机");
}
@Override
public void shutdown() {
System.out.println("小米手机关机");
}
@Override
public void callup() {
System.out.println("小米手机打电话");
}
@Override
public void sendSMS() {
System.out.println("小米手机发短信");
}
}//小米路由器实现类
public class XiaoMiRouter implements RouterProduct{
@Override
public void start() {
System.out.println("小米路由器开机");
}
@Override
public void shutdown() {
System.out.println("小米路由器关机");
}
@Override
public void openWifi() {
System.out.println("小米路由器打开WIFI");
}
@Override
public void setting() {
System.out.println("小米路由器设置");
}
}客户端使用
public class client {
public static void main(String[] args) {
System.out.println("========小米=======");
XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
IPhoneProduct xiaomiPhone = xiaoMiFactory.getPhoneProduct();
xiaomiPhone.start();
xiaomiPhone.sendSMS();
RouterProduct xiaomiRouter = xiaoMiFactory.getRouterProduct();
xiaomiRouter.start();
xiaomiRouter.openWifi();
System.out.println("========华为=======");
HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
IPhoneProduct huaweiPhone = huaWeiFactory.getPhoneProduct();
huaweiPhone.start();
huaweiPhone.sendSMS();
RouterProduct huaweiRouter = huaWeiFactory.getRouterProduct();
huaweiRouter.start();
huaweiRouter.openWifi();
}
}
关系图
总结
简单工厂模式（静态工厂模式）
- 虽然不符合设计原则，但是使用方便，实际使用最多
工厂方法模式
- 不修改已有类的前提下，通过增加新的工厂类实现扩展
抽象工厂模式
- 不可以增加产品，但可以增加产品族
应用场景
- JDK中Calendar的getInstance方法
- JDBC中的Connection对象的获取
- Spring中IOC容器创建管理的bean方法
- 反射中Class对象的newInstance方法
扫一扫
1606
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
