atwood-pan

 

03-设计模式——工厂模式

设计模式——工厂模式

模式定义：

定义一个用于创建对象的接口，让子类决定实例化哪一个类

Factory Method 使得一个类的实例化延迟到子类

应用场景

  1. 当你不知道该使用对象的确切类型的时候
  2. 当你希望为库或框架提供拓展内部组件的方法时

主要优点：

  • 将具体产品和创建者解耦
  • 符合单一职责原则
  • 符合开闭原则

源码中的应用：

// 静态工厂方法
NumberFormat
ResourceBundle.getBundle()
// 工厂方法
    //流协议通用处理
java.net.URLStreamHandlerFactory
javax.xml.bind.JAXBContext.createMarshaller

简单工厂模式

Simple Factory

在创建一个对象时不向客户暴露内部细节，并提供一个创建对象的通用接口

Class Diagram

简单工厂把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。

这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。客户类往往有多个，如果不使用简单工厂，那么所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。
在这里插入图片描述

/**
 * @program: DesignPatterns
 * @description: 工厂模式
 * @author: Coder_Pan
 * @create: 2022-04-13 06:41
 **/
public class FactoryMethod {

    public static void main(String[] args) {
        System.out.println("简单工厂模式.....");
        Application application = new Application();
        // 这里根据传入的type参数，即可生成指定的对象
        Product product = application.getObject("0");
        product.method1();
    }
}
interface Product{
    /**
     * 产品接口
     */
    public void method1();
}

class ProductA implements Product{
    /**
     * 假设稳定部分   =>   定义接口
     *
     * read()
     * close()
     * 重写父类中的方法
     */
    @Override
    public void method1(){
        System.out.println("ProductA.method executed. ");
    }
}

class ProductB implements Product{
    /**
     * 假设稳定部分   =>   定义接口
     *
     * read()
     * close()
     * 重写父类中的方法
     */
    @Override
    public void method1(){
        System.out.println("ProductB.method executed. ");
    }
}


/**
 * 定义简单工厂
 * 封装实例化过程
 */
class SimpleFactory {

    public static Product createProduct(String type){
        String equals0 = "0";
        String equals1 = "1";
        if (equals0.equals(type)){
            return new ProductA();
        }else if (equals1.equals(type)) {
            return new ProductB();
        }else {
            return null;
        }
    }
}
/**
 * 重构，面向实现
 */
class Application {
    /**
     * 创建对象是稳定部分
     * @param type
     * @return
     */
    private Product createProduct(String type) {
        //创建ProductA实例
        /**
         * 通过SimpleFactory生成对象返回
         */
        return SimpleFactory.createProduct(type);
    }

    /**
     *
     * @return 返回接口实例
     */
    Product getObject(String type) {
        Product product = createProduct(type);
        //....
        return product;
    }
}

工厂方法模式

Factory Method

定义了一个创建对象的接口，但由子类决定要实例化哪个类

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

Class Diagram

在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。

下图中，Factory 有一个 doSomething() 方法，这个方法需要用到一个产品对象，这个产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。

Lugfw8.png

/**
 * @program: DesignPatterns
 * @description: 工厂模式
 * @author: Coder_Pan
 * @create: 2022-04-13 06:41
 **/
public class FactoryMethod {

    public static void main(String[] args) {
//        System.out.println("简单工厂模式.....");
//        Application application = new Application();
//        Product product = application.getObject("0");
//        product.method1();
        System.out.println("工厂方法模式.....");
        Application concreateProductA = new ConcreateProductA();
        Product productA = concreateProductA.getObject();
        productA.method1();
        /**
         * 无需修改其他代码
         * 只需重新new一个实现类即可
         */
        Application concreateProductB = new ConcreateProductB();
        Product productB = concreateProductB.getObject();
        productB.method1();
    }
}
interface Product{
    /**
     * 产品接口
     */
    public void method1();
}

class ProductA implements Product{
    /**
     * 假设稳定部分   =>   定义接口
     *
     * read()
     * close()
     * 重写父类中的方法
     */
    @Override
    public void method1(){
        System.out.println("ProductA.method executed. ");
    }
}

class ProductB implements Product{
    /**
     * 假设稳定部分   =>   定义接口
     *
     * read()
     * close()
     * 重写父类中的方法
     */
    @Override
    public void method1(){
        System.out.println("ProductB.method executed. ");
    }
}

/**
 * 重构，面向实现
 * 工厂方法模式  ==  通过实现抽象类声明实例
 */
abstract class Application {
    /**
     * 创建对象是稳定部分
     * @param
     * @return
     * 子类是变化的
     * 通过该方法，使得一个类的实例化延迟到子类
     */
    abstract Product createProduct();

    /**
     *
     * @return 返回接口实例
     */
    Product getObject() {
        Product product = createProduct();
        //....
        return product;
    }
}

/**
 * 不稳定部分  =》 各个实现类，会发生变化
 */
class ConcreateProductA extends Application {

    @Override
    Product createProduct() {
        return new ProductA();
    }
}

class ConcreateProductB extends Application {

    @Override
    Product createProduct() {
        return new ProductB();
    }
}

posted on 2022-04-13 09:05  JavaCoderPan  阅读(9)  评论(0)  编辑  收藏  举报  来源

导航