【每日一记】设计模式——工厂模式

概述

工厂模式属于创建型模式，是非常常见的设计模式

• 作用：屏蔽对象创建的细节，降低类之间的耦合

实现

工厂模式可分为简单工厂、工厂方法、抽象工厂

简单工厂

简单工厂由一个工厂类根据传入的参量决定创建出哪一种产品类的实例，虽然降低了客户端对于产品类的依赖，但是所有的逻辑都集中在工厂类中，每当要增加一种新产品时就要修改工厂类的代码，违反了“开闭原则”，扩展性不强。

// 产品
public interface IProduct {
    void use();
}

class ProductA implements IProduct {
    @Override
    public void use() {
        System.out.println("ProductA");
    }
}

class ProductB implements IProduct {
    @Override
    public void use() {
        System.out.println("ProductB");
    }
}

// 简单工厂
public class SimpleFactory {
    public IProduct produce(String name) {
        if("A".equals(name)) {
            return new ProductA();
        } else if("B".equals(name)) {
            return new ProductB();
        }
        return null;
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        IProduct pa = factory.produce("A");
        IProduct pb = factory.produce("B");
        pa.use();
        pb.use();
    }
}

工厂方法

工厂方法通过一个接口将具体实例化的工作延迟到子类，工厂类不再负责所有产品的创建。当增加新产品时只需添加对应的工厂即可，做到了“对修改关闭，对扩展开放”，但是当产品种类非常多时，会出现大量的与之对应的工厂对象。

// 产品
public interface IProduct {
    void use();
}

class ProductA implements IProduct {
    @Override
    public void use() {
        System.out.println("ProductA");
    }
}

class ProductB implements IProduct {
    @Override
    public void use() {
        System.out.println("ProductB");
    }
}

// 工厂
public interface IFactory {
    IProduct produce();
}

class FactoryA implements IFactory {
    @Override
    public IProduct produce() {
        return new ProductA();
    }
}

class FactoryB implements IFactory {
    @Override
    public IProduct produce() {
        return new ProductB();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        IFactory fa = new FactoryA();
        IProduct pa = fa.produce();
        pa.use();

        IFactory fb = new FactoryB();
        IProduct pb = fb.produce();
        pb.use();
    }
}

抽象工厂

与工厂方法生产单个产品不同，抽象工厂模式通常用于创一族产品，并且这族产品分不同的等级。对于增加产品族只需要简单的添加相应的产品族工厂即可，但是要想添加一种新产品，抽象工厂模式无能为力，因为这要修改所有的产品族工厂。

// CPU等级的产品，分为Intel族和AMD族
public interface CPU {
    void use();
}

class CPU_Intel implements CPU {
    @Override
    public void use() {
        System.out.println("Intel CPU");
    }
}

class CPU_AMD implements CPU {
    @Override
    public void use() {
        System.out.println("AMD CPU");
    }
}

// 主板等级的产品，分为Intel族和AMD族
public interface Board {
    void use();
}

class Board_Intel implements Board {
    @Override
    public void use() {
        System.out.println("Board Intel");
    }
}

class Board_AMD implements Board {
    @Override
    public void use() {
        System.out.println("Board AMD");
    }
}

// 工厂接口
public interface IFactory {
    CPU produceCPU();
    Board produceBoard();
}
// Intel产品族的工厂
class IntelFactory implements IFactory {
    @Override
    public CPU produceCPU() {
        return new CPU_Intel();
    }

    @Override
    public Board produceBoard() {
        return new Board_Intel();
    }
}
// AMD产品族的工厂
class AMDFactory implements IFactory {
    @Override
    public CPU produceCPU() {
        return new CPU_AMD();
    }

    @Override
    public Board produceBoard() {
        return new Board_AMD();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        IFactory f1 = new IntelFactory();
        f1.produceCPU().use();
        f1.produceBoard().use();

        IFactory f2 = new AMDFactory();
        f2.produceCPU().use();
        f2.produceBoard().use();
    }
}

区别

• 简单工厂：用来生产同一等级结构中的任意产品；对于增加新的产品无能为力
• 工厂方法：用来生产同一等级结构中的固定产品；支持增加任意产品
• 抽象工厂：用来生产不同产品族的全部产品；对于增加新的产品无能为力；支持增加产品族

实际应用

SAXParserFactory.newInstance();
Proxy.newProxyInstance()
Class.forName()