一天一种设计模式之六-----工厂方法模式

一.工厂方法模式

1. 工厂方法模式属于建立型模式。

2. 工厂方法模式定义：定义一个用于建立对象的借口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到了他的子类。

3. 通常工厂类会有一个工厂的接口，实现类也有一个实现的接口。工厂接口负责定义一个建立实现接口的方法，而工厂类负责建立具体的实现类。

4. 工厂模式根据抽象程度的不一样分为三种：简单工厂模式（也叫静态工厂模式），工厂方法模式以及抽象工厂模式。工厂模式是编程中常常会遇到的一种模式。

5. 工厂方法模式的优势有：

1. 使代码结构清晰，有效的封装变化。在编程中，产品类的实例化有时候是复杂多变的，经过工厂模式将产品的实例化封装起来，是的调用者无需关心实例化过程只需依赖工厂便可获得本身想要的产品。

2. 对调用者屏蔽具体的产品类。若是使用工厂模式，调用者只须要关心产品的接口就能够了，即便变动了具体的实现，对调用这来讲没有任何影响。

6. 工厂方法模式符合开放封闭原则，迪米特法则，依赖倒置原则。
   

   二.测试代码

7. 测试代码以下（实现一个计算器）下属模式中，若是新增了其余的计算类，只须要新建一个计算类实现，和相应的计算类工厂就能够了。
   

8. public class GongChangMethodTest {
   	public static void main(String[] args) {
   		IFactory factory = new SumFactory();
   		Jisuan jisuan = factory.createJisuan();
   		jisuan.setNum1(12);
   		jisuan.setNum2(44);
   		;
   		System.out.println(jisuan.getResult());
   	}
   }
   
   interface IFactory {
   	Jisuan createJisuan();
   }
   
   class SumFactory implements IFactory {
   
   	@Override
   	public Jisuan createJisuan() {
   		return new SumJisuan();
   	}
   
   }
   
   class SubFactory implements IFactory {
   	@Override
   	public Jisuan createJisuan() {
   		return new SubJisuan();
   	}
   }
   
   class MulFactory implements IFactory {
   	@Override
   	public Jisuan createJisuan() {
   		return new MulJisuan();
   	}
   }
   
   class DevFactory implements IFactory {
   	@Override
   	public Jisuan createJisuan() {
   		return new DevJisuan();
   	}
   }
   
   abstract class Jisuan {
   	private int num1;
   	private int num2;
   
   	public Jisuan() {
   	}
   
   	public Jisuan(int num1, int num2) {
   		this.num1 = num1;
   		this.num2 = num2;
   	}
   
   	public abstract int getResult();
   
   	public int getNum1() {
   		return num1;
   	}
   
   	public void setNum1(int num1) {
   		this.num1 = num1;
   	}
   
   	public int getNum2() {
   		return num2;
   	}
   
   	public void setNum2(int num2) {
   		this.num2 = num2;
   	}
   }
   
   class SumJisuan extends Jisuan {
   
   	@Override
   	public int getResult() {
   		return getNum1() + getNum2();
   	}
   
   }
   
   class SubJisuan extends Jisuan {
   
   	@Override
   	public int getResult() {
   		return getNum1() - getNum2();
   	}
   }
   
   class MulJisuan extends Jisuan {
   
   	@Override
   	public int getResult() {
   		return getNum1() * getNum2();
   	}
   }
   
   class DevJisuan extends Jisuan {
   
   	@Override
   	public int getResult() {
   		int result = 0;
   		if (getNum2() != 0) {
   			result = getNum1() / getNum2();
   		}
   		return result;
   	}
   }

9. 企业级应用中，咱们对数据库的实现就能够采用上述模式
   实际上，咱们再加上其余表，IFactory中再增长createXXXFactory就成了抽象工厂模式了，抽象工厂只是比工厂方法多了一个纬度而已
   

public class GongChangMethodTest {

	public static void main(String[] args) {
		IFactory factory=new MysqlUserFactory();
		IUserService service=factory.createUserService();
		service.insert();
	}
}	
interface IUserService{
	void insert();
}
class UserService implements IUserService{
	@Override
	public void insert() {
		System.out.println("insert 方法");
	}
}
interface IFactory{
	public IUserService createUserService();
}	
abstract class MysqlFactory implements IFactory{
	//这里能够作一些初始化mysql链接的事情
}
abstract class SqlServerFactory implements IFactory{
	//这里能够作一些初始化mysql链接的事情
}
//若是想换成sqlserver，只须要加一个SqlserverUserFactory就能够了
class MysqlUserFactory extends MysqlFactory{
	@Override
	public IUserService createUserService() {
		return new UserService();
	}
	
}