设计模式2,3-工厂模式

在说工厂模式前,首先说明下设计模式是为了解决什么问题:

简单的来说就是:

在出了问题的时候,有什么新需求的时候,更新换代的时候...好改代码.

要怎么做到好改代码呢?

先设想一个情况:

public static class SimpleFactory {
	public static Product getProduct(String type) {
		switch (type) {
		case "A":
			return new ProductA();
		case "B":
			return new ProductB();
		case "C":
			return new ProductC();		
		}
		return null;
	}
}
interface Product{
	void method();
}
class ProductA implements Product{
	@Override
	public void method() {
		System.out.println("ProductA");	
	}
}
class ProductB implements Product{
	@Override
	public void method() {
		System.out.println("ProductB");
	}
}
class ProductC implements Product{
	@Override
	public void method() {
		System.out.println("ProductC");	
	}
}

这样在需要获取ABC的时候,传入对应的值就行,而且直接造型为接口: 

Product a=SimpleFactory.getProduct("A")

interface IFactory{
	Product getProduct();
}
class FactoryA implements IFactory {
	@Override
	public Product getProduct() {
		return new ProductA();
	}
}
class FactoryB implements IFactory {
	@Override
	public Product getProduct() {
		return new ProductB();
	}
}
class FactoryC implements IFactory {
	@Override
	public Product getProduct() {
		return new ProductC();
	}
}
interface Product{
	void method();
}
class ProductA implements Product{
	@Override
	public void method() {
		System.out.println("ProductA");	
	}
}
class ProductB implements Product{
	@Override
	public void method() {
		System.out.println("ProductB");
	}
}
class ProductC implements Product{
	@Override
	public void method() {
		System.out.println("ProductC");	
	}
}

使用的时候: 

IFactory f=new FactoryA();f.getProduct();

评价:工厂方法,每一个具体产品,对应一个工厂.然后把工厂的选择抛给了用户.这种设计模式仅仅相当于一个中介,用于创建对象,当对象创建简单的时候毫无作用,并且凭空的增加了系统的复杂度.除非创建对象的过程真的非常复杂,不然不建议使用.

public class AbstractFactory {
	public static void main(String[] args) {
		AFactory apple=new FactoryAppleSerise();
		apple.getOpenWin().win();
		apple.getCloseWin().closeWin();
		AFactory windows=new FactoryWindowsSerise();
		windows.getOpenWin().win();
		windows.getCloseWin().closeWin();
	}
}


interface AFactory{
	OpenWinow getOpenWin();
	CloseWindow getCloseWin();
}
class FactoryAppleSerise implements AFactory{
	@Override
	public OpenWinow getOpenWin() {
		return new WinInApple();
	}
	@Override
	public CloseWindow getCloseWin() {
		return new CloseWinInApple();
	}	
}
class FactoryWindowsSerise implements AFactory{
	@Override
	public OpenWinow getOpenWin() {
		return new WinInWindows();
	}
	@Override
	public CloseWindow getCloseWin() {
		return new CloseWinInWindows();
	}	
}


interface OpenWinow{
	void win();
}
class WinInWindows implements OpenWinow{
	@Override
	public void win() {
		System.out.println("打开windows窗口");
	}
}
class WinInApple implements OpenWinow{
	@Override
	public void win() {
		System.out.println("打开Apple窗口");
	}
}
interface CloseWindow{
	void closeWin();
}
class CloseWinInWindows implements CloseWindow{
	@Override
	public void closeWin() {
		System.out.println("关闭windows窗口");
	}
}
class CloseWinInApple implements CloseWindow{
	@Override
	public void closeWin() {
		System.out.println("关闭Apple窗口");
	}
}

输出结果: