简单工厂模式

最新推荐文章于 2024-10-16 16:34:42 发布

Chuancey717

最新推荐文章于 2024-10-16 16:34:42 发布

阅读量148

点赞数 1

文章标签： java 设计模式

本文链接：https://blog.csdn.net/m0_51658696/article/details/119927971

版权

本文介绍了工厂方法模式在实际开发中的应用，包括简单工厂模式和延迟加载工厂模式。简单工厂模式通过静态方法创建汽车对象，而延迟加载工厂则使用Map缓存对象，提高效率。示例代码展示了如何创建和使用这两种工厂，以及它们在实际项目中的实用性。

摘要由CSDN通过智能技术生成

工厂方法模式使用的频率非常高，在我们日常的开发中总能见到它的身影。其定义为:

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

简单工厂

定义一个汽车接口，其中包含一些获取汽车属性的抽象

public interface Car {
    void getColor();

    void getName();
}

奔驰车实现类
public class BenzCar implements Car {
    @Override
    public void getColor() {
        System.out.println("我是黑色的");
    }

    @Override
    public void getName() {
        System.out.println("奔驰");
    }
}



宝马车实现类
public class BWMCar implements Car {
    @Override
    public void getColor() {
        System.out.println("我是白色的！");
    }

    @Override
    public void getName() {
        System.out.println("宝马！");
    }
}

构建汽车工厂（通过泛型控制了构造的汽车都是实现Car接口的子类，利用反射传入想要构造的汽车）

//创建一个构造汽车类的简单工厂
public class EasyCarFactory {
    public static <T extends Car> T createCar(Class<T> c) {
        //定义一辆汽车（还不知道要造什么车）
        Car car = null;
        try {
            //通过反射得到boss想造什么车
            car = (Car) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("造车失败！");
        }
        return (T) car;
    }
}

public static void main(String[] args) {
        //知道宝马的类名就可以造宝马
        BWMCar bwm = EasyCarFactory.createCar(BWMCar.class);
        bwm.getName();
        bwm.getColor();
        System.out.println("=============================");
        //知道奔驰的类名就可以造奔驰
        BenzCar benz = EasyCarFactory.createCar(BenzCar.class);
        benz.getName();
        benz.getColor();

    }

输出：
宝马！
我是白色的！
=============================
奔驰
我是黑色的

该模式是工厂方法模式的弱化，因为简单，所以称为简单工厂模式(Simple Factory Pattern)，也叫做静态工厂模式。在实际项目中，采用该方法的案例还是比较多的，其缺点是工厂类的扩展比较困难，不符合开闭原则，但它仍然是一个非常实用的设计模式。

延迟加载工厂

工厂类：

public class LazyFactory {
    //用一个map容器来装工厂创建的对象，有就返回，没有就创建，返回并装入；
    private static final Map<String, Car> map = new HashMap<>();


    public static synchronized Car createCar(String name){
        //先创建一个车对象
        Car car = null;
        //如果存在这个车，直接返回，不存在装入并返回
        if (map.containsKey(name)){
            car = map.get(name);
        }else {
            if("bmw".equals(name)){
                car = new BWMCar();
            }else if("benz".equals(name)){
                car = new BenzCar();
            }
            map.put(name,car);
        }
        return car;
    }
}

利用工厂创建对象：

public static void main(String[] args) {
        Car bmw = LazyFactory.createCar("bmw");
        bmw.getName();
        bmw.getColor();
        Car benz = LazyFactory.createCar("benz");
        benz.getName();
        benz.getColor();
        //创建第二个宝马车，可以看到创建的两个宝马车是同一个对象，Spring中单例的缓存与此思想类似
        Car bmw1 = LazyFactory.createCar("bmw");
        bmw1.getName();
        bmw1.getColor();
    }

输出：
宝马！1554874502
我是白色的！
==========================
奔驰
我是黑色的
==========================
宝马！1554874502
我是白色的！