zoukankan      html  css  js  c++  java
  • 工厂模式

    1. 简单工厂(Simple Factory)

    Intent

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

    Class Diagram

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

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

    Implementation

    public interface Product {
    }
    public class ConcreteProduct implements Product {
    }
    public class ConcreteProduct1 implements Product {
    }
    public class ConcreteProduct2 implements Product {
    }

    以下的 Client 类包含了实例化的代码,这是一种错误的实现。如果在客户类中存在这种实例化代码,就需要考虑将代码放到简单工厂中。

    public class Client {
    
        public static void main(String[] args) {
            int type = 1;
            Product product;
            if (type == 1) {
                product = new ConcreteProduct1();
            } else if (type == 2) {
                product = new ConcreteProduct2();
            } else {
                product = new ConcreteProduct();
            }
            // do something with the product
        }
    }

    以下的 SimpleFactory 是简单工厂实现,它被所有需要进行实例化的客户类调用。

    public class SimpleFactory {
    
        public Product createProduct(int type) {
            if (type == 1) {
                return new ConcreteProduct1();
            } else if (type == 2) {
                return new ConcreteProduct2();
            }
            return new ConcreteProduct();
        }
    }
    public class Client {
    
        public static void main(String[] args) {
            SimpleFactory simpleFactory = new SimpleFactory();
            Product product = simpleFactory.createProduct(1);
            // do something with the product
        }
    }

    2. 工厂方法(Factory Method)

    Intent

    定义了一个创建对象的接口,但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类。

    Class Diagram

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

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

    Implementation

    public abstract class Factory {
        abstract public Product factoryMethod();
        public void doSomething() {
            Product product = factoryMethod();
            // do something with the product
        }
    }
    public class ConcreteFactory extends Factory {
        public Product factoryMethod() {
            return new ConcreteProduct();
        }
    }
    public class ConcreteFactory1 extends Factory {
        public Product factoryMethod() {
            return new ConcreteProduct1();
        }
    }
    public class ConcreteFactory2 extends Factory {
        public Product factoryMethod() {
            return new ConcreteProduct2();
        }
    }

    JDK

    • java.util.Calendar
    • java.util.ResourceBundle
    • java.text.NumberFormat
    • java.nio.charset.Charset
    • java.net.URLStreamHandlerFactory
    • java.util.EnumSet
    • javax.xml.bind.JAXBContext

    3. 抽象工厂(Abstract Factory)

    Intent

    提供一个接口,用于创建 相关的对象家族 。

    Class Diagram

    抽象工厂模式创建的是对象家族,也就是很多对象而不是一个对象,并且这些对象是相关的,也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象,这和抽象工厂模式有很大不同。

    抽象工厂模式用到了工厂方法模式来创建单一对象,AbstractFactory 中的 createProductA() 和 createProductB() 方法都是让子类来实现,这两个方法单独来看就是在创建一个对象,这符合工厂方法模式的定义。

    至于创建对象的家族这一概念是在 Client 体现,Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象,在这里这两个对象就有很大的相关性,Client 需要同时创建出这两个对象。

    从高层次来看,抽象工厂使用了组合,即 Cilent 组合了 AbstractFactory,而工厂方法模式使用了继承。

    Implementation

    public class AbstractProductA {
    }
    public class AbstractProductB {
    }
    public class ProductA1 extends AbstractProductA {
    }
    public class ProductA2 extends AbstractProductA {
    }
    public class ProductB1 extends AbstractProductB {
    }
    public class ProductB2 extends AbstractProductB {
    }
    public abstract class AbstractFactory {
        abstract AbstractProductA createProductA();
        abstract AbstractProductB createProductB();
    }
    public class ConcreteFactory1 extends AbstractFactory {
        AbstractProductA createProductA() {
            return new ProductA1();
        }
    
        AbstractProductB createProductB() {
            return new ProductB1();
        }
    }
    public class ConcreteFactory2 extends AbstractFactory {
        AbstractProductA createProductA() {
            return new ProductA2();
        }
    
        AbstractProductB createProductB() {
            return new ProductB2();
        }
    }
    public class Client {
        public static void main(String[] args) {
            AbstractFactory abstractFactory = new ConcreteFactory1();
            AbstractProductA productA = abstractFactory.createProductA();
            AbstractProductB productB = abstractFactory.createProductB();
            // do something with productA and productB
        }
    }

    JDK

    • javax.xml.parsers.DocumentBuilderFactory
    • javax.xml.transform.TransformerFactory
    • javax.xml.xpath.XPathFactory
  • 相关阅读:
    CSU 1333 Funny Car Racing
    FZU 2195 检查站点
    FZU 2193 So Hard
    ZOJ 1655 FZU 1125 Transport Goods
    zoj 2750 Idiomatic Phrases Game
    hdu 1874 畅通工程续
    hdu 2489 Minimal Ratio Tree
    hdu 3398 String
    洛谷 P2158 [SDOI2008]仪仗队 解题报告
    POJ 1958 Strange Towers of Hanoi 解题报告
  • 原文地址:https://www.cnblogs.com/AnXinliang/p/9955434.html
Copyright © 2011-2022 走看看