设计模式——工厂模式

工厂模式

一、基本思想

工厂模式是对简单工厂模式的进一步抽象化。好处是使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

二、应用场景

1. 客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
2. 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
3. 客户不关心创建产品的细节，只关心产品的品牌。

三、结构图

四、代码

//抽象产品
 public interface Product {
        void show();
 }
 
//具体产品：ProductA
static class ConcreteProduct1 implements Product {
	public void show() {
		System.out.println("具体产品1显示...");
	}
}
//具体产品：ProductB
static class ConcreteProduct2 implements Product {
	public void show() {
		System.out.println("具体产品2显示...");
	}
}

//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    public Product newProduct();
}

//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
	public Product newProduct() {
		System.out.println("具体工厂1生成-->具体产品1...");
		return new ConcreteProduct1();
    }
}

//具体工厂2：实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory {
	public Product newProduct() {
        System.out.println("具体工厂2生成-->具体产品2...");
        return new ConcreteProduct2();
    }
}

public static void main(String[] args) {
	try {
		Product a;
		AbstractFactory af;
		af = (AbstractFactory) ReadXML1.getObject();
		a = af.newProduct();
		a.show();
	} catch (Exception e) {
		System.out.println(e.getMessage());
	}
}

class ReadXML1 {
    //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
	public static Object getObject() {
		try {
            //创建文档对象
		DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
		DocumentBuilder builder = dFactory.newDocumentBuilder();
		Document doc;
		doc = builder.parse(new File("src/FactoryMethod/config1.xml"));
		//获取包含类名的文本节点
		NodeList nl = doc.getElementsByTagName("className");
		Node classNode = nl.item(0).getFirstChild();
		String cName = "FactoryMethod." + classNode.getNodeValue();
		//System.out.println("新类名："+cName);
		//通过类名生成实例对象并将其返回
        Class<?> c = Class.forName(cName);
        Object obj = c.newInstance();
        return obj;
		} catch (Exception e) {
			e.printStackTrace();
        return null;
		} 
	}
}

五、优点

1. 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
2. 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
3. 典型的解耦框架。
4. 高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

六、缺点

1. 类的个数容易过多，增加复杂度
2. 增加了系统的抽象性和理解难度
3. 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决

七、示例

//课程工厂
public interface ICourseFactory{
	ICourse create();
}

//课程顶层接口
public interface ICourse{
	void record();
}

//Java课程工厂
public class JavaCourseFactory implements ICourseFactory {
	public ICourse create() {
		//实例化课程过程
		return new JavaCourse();
	}
}
//Python课程工厂
public class PythonCourseFactory implements ICourseFactory {
	public ICourse create() {
		return new PythonCourse();
	}
}

//调用
public static void main(String args[]){
	ICourseFactory factory = new JavaCourseFactory();
	ICourse course = factory.create();
	course.record();
}