设计模式之工厂方法模式

 工厂方法模式定义

Define an interface for creating an object,but let subclasses decide which class to instantite.Factory Method lets a class defer instantation to subclass.

工厂方法模式的一般类图

工厂方法模式的通用源码

1.抽象产品类

package FactoryMethod;

public abstract class Product {
	public void method1(){
		System.out.println("这是产品类的业务逻辑处理方法");
	}
	
	public abstract void method2();
}

2.具体的产品类

package FactoryMethod;

public class ConcreteProduct1 extends Product {
    @Override
    public void method2() {
        System.out.println("这是产品一的业务逻辑处理方法");
    }
}

package FactoryMethod;

public class ConcreteProduct2 extends Product {
	@Override
	public void method2() {
		System.out.println("这是产品二的业务逻辑处理方法");
	}
}

3.抽象工厂类

package FactoryMethod;

public abstract class Creator {
	public abstract <T extends Product> T createProduct(Class<T> c);
}

4.具体工厂类

package FactoryMethod;

public class ConcreteCreator extends Creator {
	public <T extends Product> T createProduct(Class<T> c) {
		Product product = null;
		try {
			product = (Product)Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return (T)product;
	}
}

5.客户端代码

package FactoryMethod;

public class Client {
	/**
	 * @author ZhangH
	 */
	public static void main(String[] args) {
		Creator creator = new ConcreteCreator();
		Product product1 = creator.createProduct(ConcreteProduct1.class);
		Product product2 = creator.createProduct(ConcreteProduct2.class);
		
		product1.method1();
		product1.method2();
	
		product2.method1();
		product2.method2();
	}
}

工厂方法模式的优点

优点：

    1. 良好的封装性，降低模块间的耦合；

    2. 面向产品接口，屏蔽产品类。

    3. 典型的解耦框架。高层模块只需要知道产品的抽象类。

    4. 符合迪米特法则、依赖倒置原则、里氏替换原则。

开放-封闭原则

       针对扩展是开放的，针对修改是封闭的。详细介绍可以见百度百科，开放-封闭原则是面向对象设计的核心所在，遵循这个原则可以带来巨大好处，可扩展、可维护、可复用。再来说简单工厂方法模式，我需要增加一种运算时，需要增加一个新的运算类，这没有错，但是还需要修改工厂方法，增加分支，这就违背了开放-封闭原则，工厂方法模式就是基于其上的遵循开放-封闭原则的解决方案，针对工厂的变化，抽象出来工厂接口，将静态工厂中的每个分支判断都抽成单独的工厂类，这也是前文提到过的将if…else分支判断转成单独的类，使代码结构更清晰。

里氏代换原则

       Liskov Substitution Principle，简称LSP。子类型必须能替换掉他们的父类型。换句话说，在软件里面，把使用父类的地方，都换成子类，程序的行为是没有变化的。这是面向对象语言继承的基础，如果没有里氏代换原则，也就谈不上开放-关闭原则了，比如：

动物 animal = new 动物(); animal.吃(); animal.喝(); animal.叫();

       根据里氏代换原则，将动物对象换成狗、牛、骆驼，其它地方不变，是完全可以执行的。

依赖倒置原则

       也叫依赖倒转原则，Dependence Inversion Principle，对抽象进行编程，不要对实现进行编程。面相对象设计将就高内聚、低耦合，高内聚指功能相关性很强的紧密的结合在一起，遵守单一职责原则；耦合是指不同模块或不同层次代码的联系程度，耦合性越低，模块独立性越强，耦合性越高，模块独立性越弱，高耦合的软件，往往修改一处地方，都会牵一发而动全身，这就是设计不当。举个硬件的例子，内存条和主板是通过金手指和主板内存槽连接的，主板定义好插内存条的接口，各个内存条厂商都根据这个标准接口去制作自己的内存条，假如内存条坏了，不能开机了，我不需要去换主板，到中关村买个新的内存条插上即可(话说显卡什么时候能这样做啊，所谓的“独显”都不是真正的独显)。

参考链接：http://my.oschina.net/u/1470003/blog/222163