阅读笔记常见的设计模式之四：工厂模式

先看一个例子:

抽象产品类

public abstract class Product{
//由具体的产品类去实现
 public abstract void method();
}

具体产品类A

public class ConcreteProductA extends Product{
@Override
public void method(){
syso("ConcreteProductA");
}
}

具体产品类B

public class ConcreteProductB extends Product{
@Override
public void method(){
syso("ConcreteProductB");
}
}

方式一
抽象工厂类

public abstract class Factory{
//由具体的子类去实现生产对象，返回具体的产品对象
public abstract Product createProduct(){};
}

具体工厂类A

public class ConcreteFactory extends Factory{
public Product createProduct(){
return new ConcreteProductA();
}
}

客户类

public class Client{
public static void main(String[] args){
Factory factory=new ConcreteFactory();
Product p=factory.createProduct();
p.method();
}
}

理解:
首先是定义两个抽象类：生产抽象类和工厂抽象类，前者由子类继承，实现具体子类所要生产的方法，后者由具体工厂实现，具体工厂决定自己要实现那个产品，之间的联系，是由抽象工厂类的createProduct方法建立的，这个方法返回的是Produce类型，意味着可以通过createProduct得到Product对象，从而创建产品.

这里我们得到的是ConcreteProductA的实例，如果我们想得到ConcreteProductB的实例，则只需要改一下即可：

public class ConcreteFactory extends Factory{
public Product createProduct(){
//return new ConcreteProductA();
return new ConcreteProductB();
}
}

方式二
利用反射的方式

//抽象的工厂类

Public abstract class Factory{

public abstract <T extends Product> T createProduct(Class<T> clz);

}

//具体的工厂类

public class ConcreteFactory extends Factory{
@Override
public <T extends Product> T createProduct(Class<T> clz){
try{
p=(Product)class.forName(clz.getName()).newInstance();
}
catch(Exception e){

e.printStackTrace();

}
return (T)p;
}
}

//Client的实现

public class Client{
public static void main(String[] args){
Factory factory=new ConcreteFactory();
Product p=factory.createProduct();
p.method();
}
}

来看个工厂模式的实战：

public abstract classIOHandler{

public abstract void add(String id,String name);

public abstract void remove(String id)；

public abstruct void update(String id,String name);

public abstract void query(String id);
//....

}

FileHandler

public class FileHandler extends IOHandler{
@Override
public void add(String id,String name){
}
@Override
public void remove(String id){
}
@Override
public void update(String id,String name){
}
@Override
public void query(String id){
}
//..
}

XmlHandler

public class XmlHandler extends IOHandler{
@Override
public void add(String id,String name){
}
@Override
public void remove(String id){
}
@Override
public void update(String id,String name){
}
@Override
public void query(String id){
}
//..
}

DBHandler

public class DBHandler extends IOHandler{
@Override
public void add(String id,String name){
}
@Override
public void remove(String id){
}
@Override
public void update(String id,String name){
}
@Override
public void query(String id){
}
//..
}

工厂类的定义

public class IOFactory{
public static <T extends IOHandler> T getIOHandler(Class<T> clz){
IOHandler handler=null;

try{
handler=(IOHandler) class.forName(clz.getName()).newInstance();


}
catch(Exception e){
e.printStackTrace();
}
return T handler;
}
}

最后在Activity中从不同数据文件中查询得到的数据展示在一个TextView

public class FactoryActivity extends Activity{

@Override
protected void onCreate(Bundle savedInstanceState){
super.onCreate();
setContentView(R.layout.main);
final TextView tvContent=(TextView)findViewById(R.id.factory_content_tw);
//三个Button我就懒得初始化了
btnFile.setOnClickListener(new View.onClickListener(){
@Override
public void onClick(View view){
IOHandler handler=IOFactory.getIOEHandler(FileHandler.class);
Log.d("Aigestudio",handler.query("121212"));
}

});

btnXml.setOnClickListener(new View.onClickListener(){
@Override
public void onClick(View view){
IOHandler handler=IOFactory.getIOEHandler(XmlHandler.class);
Log.d("Aigestudio",handler.query("121212"));
}

});

btnDB.setOnClickListener(new View.onClickListener(){
@Override
public void onClick(View view){
IOHandler handler=IOFactory.getIOEHandler(DBHandler.class);
Log.d("Aigestudio",handler.query("121212"));
}

});

}
}

优点：降低对象的耦合，很好的扩展性
缺点：每次加入一个新产品就需要一个抽象类,新产品类和具体工厂类