设计模式--工厂方法模式

1.定义：定义一个用于创建对象的接口让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到其子类。

2.代码部分


----------------------------------------------------------------

//工厂方法所创建的对象的接口
public interface Product{
	
}
//具体的Product对象
public class ConcreteProduct implements Product{
	
}
//创建器，声明工厂方法
public abstract class Creator{


	//创建Product的工厂方法，一般不对外开放
	protected abstract Product factoryMethod();


	//实例方法，提供给外部使用的方法，客户端一般使用Creator提供的这些方法来完成所需要的功能
	public void someOperation(){
		//在这里使用了工厂方法
		Product product = factoryMethod();
	}
}


//具体的创建器实现对象
public class ConcreteCreator extends Creator{
	protected Product factoryMethod(){
		return new ConcreteProduct();
	}
}

-----------------------------------------------------------

public interface ExportFileApi{
	public boolean export(String data);
}


//导出成文本文件格式的对象
public class ExportTxtFile implements ExportFileApi{
	public boolean export(String data){
		System.out.println("导出数据"+data+"到文本文件");
		return true;
	}
}


//导出成数据库备份文件形式的对象
public class ExportDB implements ExportFileApi{
	public boolean export(String data){
		System.out.println("导出数据"+data+"到数据库备份文件");
		return true;
	}
}


//实现导出数据的业务功能对象
public abstract class ExportOperate{
	public boolean export(String data){
		//使用工厂方法
		ExportFileApi api = factoryMethod();
		return api.export(data);
	}


	protected abstract ExportFileApi factoryMethod();
}


//具体的创造器实现对象，实现创建导出文本文件格式的对象
public class ExportTxtFileOperate extends ExportOperate{
	protected ExportFileApi factoryMethod(){
		return new ExportTxtFile();
	}
}


public class ExportDBOperate extends ExportOperate{
	protected ExportFileApi facoryMethod(){
		return new ExportDB();
	}
}


public class Client{
	public static void main(String[] args){
		ExportOperate operate = new ExportDBOperate();
		operate.export("测试数据");
	}
}

3.工厂方法模式的功能是让父类在不知道具体实现的情况下，完成自身的功能调用，而具体的实现延迟到子类来实现。
  工厂方法的实现中，通常父类会是一个抽象类，里面包含创建所需要对象的抽象方法，这些抽象方法就是工厂方法。
  这里要注意一个问题，子类在实现这些抽象方法的时候，通常并不是真正地由子类来实现具体的功能，而是在子类的

  方法里面做选择，选择具体的产品实现对象。

4.工厂方法的本质---延迟到子类来选择实现。
    工厂方法模式很好地体现了“依赖倒置原则”。要依赖抽象，不要依赖于具体类。简单点说就是：
    不能让高层组件依赖于低层组件，而且不管高层组件还是低层组件，都应该依赖于抽象。