当前位置:首页 > 开发 > 行业应用 > 正文

1.工厂方法与2.抽象工厂详解

发表于: 2011-11-15   作者:bingyingao   来源:转载   浏览次数:
摘要: 下面是一个典型的工厂方法模式: package com; import java.util.Properties; /** * 动物接口,所有的具体动物类均需要继承此接口 * @author abing * */ interface Animal { void eat(); void sleep(); } /** * 动物子类老虎
下面是一个典型的工厂方法模式:
package com;

import java.util.Properties;

/**
 * 动物接口,所有的具体动物类均需要继承此接口
 * @author abing
 *
 */
interface Animal {
	void eat();

	void sleep();

}
/**
 * 动物子类老虎
 * @author abing
 *
 */
class Tiger implements Animal {

	@Override
	public void eat() {
		System.out.println("老虎要吃饭...");

	}

	@Override
	public void sleep() {
		System.out.println("老虎要睡觉...");

	}

}
/**
 * 动物子类狼
 * @author abing
 *
 */
class Walf implements Animal {

	@Override
	public void eat() {
		System.out.println("狼要吃饭...");

	}

	@Override
	public void sleep() {
		System.out.println("狼要睡觉...");

	}

}

/**
 * 工厂方法类
 * @author abing
 *
 */
class AnimalFactory {
	/**
	 * 根具传入参数创建相应的子类
	 * @param type
	 * @return
	 * @throws Exception
	 */
	public Animal createAnimal(String type) throws Exception {
		Animal animal = (Animal) Class.forName(type).newInstance();//创建动物子类,用反射的方式避免此处代码的修改
		return animal;
	}

}

/**
 * 测试类
 * @author abing
 *
 */
public class FactoryMethod {
	static Properties properties = new Properties();
	/**
	 * 这部分可以写在配置文件里面,每当新扩展一个子类,只用修改配置文件即可
	 */
	static {
		properties.setProperty("t", "com.Tiger");
		properties.setProperty("w", "com.Walf");
	}

	public static void main(String[] args) throws Exception {
		String type = "w";
		AnimalFactory animalFactory = new AnimalFactory();
		Animal animal = animalFactory.createAnimal(properties.getProperty(type));
		animal.eat();
		animal.sleep();
	}

}



在此基础上,假如系统中又要创建植物系列对象,则实现抽象工厂模式如下:
package com.koubei.demo2;

import java.util.Properties;

/**
 * 动物接口,所有的具体动物类均需要继承此接口
 * @author abing
 *
 */
interface Animal {
	void eat();

	void sleep();

}
/**
 * 动物子类老虎
 * @author abing
 *
 */
class Tiger implements Animal {

	@Override
	public void eat() {
		System.out.println("老虎要吃饭...");

	}

	@Override
	public void sleep() {
		System.out.println("老虎要睡觉...");

	}

}
/**
 * 动物子类狼
 * @author abing
 *
 */
class Walf implements Animal {

	@Override
	public void eat() {
		System.out.println("狼要吃饭...");

	}

	@Override
	public void sleep() {
		System.out.println("狼要睡觉...");

	}

}

/**
 * 植物接口,所有的具体植物类均需要继承此接口
 * @author abing
 *
 */
interface Plant {
	/**
	 * 植物生长
	 */
	void grow();
	/**
	 * 植物开花
	 */
	void flower();

}

class SunFlower implements Plant{

	@Override
	public void flower() {
		System.out.println("向日葵要开花...");
		
	}

	@Override
	public void grow() {
		System.out.println("向日葵要生长...");
		
	}
	
	
}
class Pumpkin implements Plant{

	@Override
	public void flower() {
		System.out.println("南瓜要开花...");
		
	}

	@Override
	public void grow() {
		System.out.println("南瓜要生长...");
		
	}
	
	
}



/**
 * 动物工厂方法类
 * @author abing
 *
 */
class AnimalFactory  extends AbstractFactory{
	/**
	 * 根具传入参数创建相应的动物子类
	 * @param type
	 * @return
	 * @throws Exception
	 */
	public  Animal createAnimal(String type) throws Exception {
		Animal animal = (Animal) Class.forName(type).newInstance();//创建动物子类,用反射的方式避免此处代码的修改
		return animal;
	}

	@Override
	Plant createPlant(String type) throws Exception {
		// TODO Auto-generated method stub
		return null;
	}

}

/**
 * 植物工厂方法类
 * @author abing
 *
 */
class PlantFactory extends AbstractFactory {
	/**
	 * 根具传入参数创建相应的植物子类
	 * @param type
	 * @return
	 * @throws Exception
	 */
	public  Plant createPlant(String type) throws Exception {
		Plant plant = (Plant) Class.forName(type).newInstance();//创建动物子类,用反射的方式避免此处代码的修改
		return plant;
	}

	@Override
	Animal createAnimal(String type) throws Exception {
		// TODO Auto-generated method stub
		return null;
	}

}

 abstract class AbstractFactory {
	
	 /**
	  * 生成相应的实体工厂
	  * @param factorytype
	  * @return
	  * @throws Exception
	  */
	  public static AbstractFactory getConcreteFactory(String factorytype) throws Exception
	  {
		AbstractFactory factory=(AbstractFactory)Class.forName(factorytype).newInstance();  
		return  factory;
	  }
	
	
	/**
	 * 根具传入参数创建相应的动物子类
	 * @param type
	 * @return
	 * @throws Exception
	 */
	  abstract 	Animal createAnimal(String type)throws Exception;
	/**
	 * 根具传入参数创建相应的植物子类
	 * @param type
	 * @return
	 * @throws Exception
	 */
	  abstract   Plant createPlant(String type)throws Exception;

}

/**
 * 测试类
 * @author abing
 *
 */
public class AbstractFactoryTest{
	static Properties properties = new Properties();
	/**
	 * 这部分可以写在配置文件里面,每当新扩展一个子类,只用修改配置文件即可
	 */
	static {
		//------------加入植物动物相关子类到配置中-----------
		properties.setProperty("t", "com.Tiger");
		properties.setProperty("w", "com.Walf");
		//------------加入植物相关子类到配置中-----------
		properties.setProperty("s", "com.SunFlower");
		properties.setProperty("p", "com.Pumpkin");
	}
	public static void main(String[] args) throws Exception {
		String factorytype = "com.PlantFactory";//具体工厂代号,这个也应该放在配置中
		String concretetype="s";//具体子类代号
		AbstractFactory factory=AbstractFactory.getConcreteFactory(factorytype);//获得具体工厂-PlantFactory
		Plant plant= factory.createPlant(properties.getProperty(concretetype));//通过工厂生产实际产品-Sum
		plant.grow();
		plant.flower();
	}
}


JDK中体现:Collection.iterator方法

但是上面这种情况下,植物系列与动物系列的行为不是一样的,到底适合用抽象工厂模式吗?
----------------------------------------------------------
而下面一种方式,应该是最适合于使用抽象工厂模式的。
解决跨数据库的功能,用到抽象工厂模式.用于创建多系列化的对象(如Orale系列,MySql系列)
1.首先定义相关接口(与平常的做法没什么区别)

Java代码 
// 角色表DAO接口   
interface IroleDao {   
    void insert();   
  
    void update();   
}   
// 用户表DAO接口   
interface IuserDao {   
    void find();   
  
    void delete();   
}  

// 角色表DAO接口
interface IroleDao {
 void insert();

 void update();
}
// 用户表DAO接口
interface IuserDao {
 void find();

 void delete();
} 2.不同的数据库有不同的SQL语句所以实现时必须分数据库来实现

Java代码 
// 用户表Oralce数据库DAO   
class OracleuserDao implements IuserDao {   
    public void delete() {   
        System.out.println("Oralce 删除用户表数据");   
    }   
  
    public void find() {   
        System.out.println("Oralce 查询用户表数据");   
    }   
}   
  
// 用户表MySql数据库DAO   
class MySqluserDao implements IuserDao {   
    public void delete() {   
        System.out.println("MySql 删除用户数据");   
    }   
  
    public void find() {   
        System.out.println("MySql 查询用户数据");   
    }   
}   
// 角色表Oracle数据库DAO   
class OracleroleDao implements IroleDao {   
    public void insert() {   
        System.out.println("Oralce 对角色表插入数据");   
    }   
  
    public void update() {   
        System.out.println("Oracle 对角色表更新数据");   
    }   
}   
  
// 角色表MySql数据库DAO   
class MySqlroleDAO implements IroleDao {   
    public void insert() {   
        System.out.println("MySql 对角色表插入数据");   
    }   
  
    public void update() {   
        System.out.println("Mysql 对角色表更新数据");   
    }   
}  

// 用户表Oralce数据库DAO
class OracleuserDao implements IuserDao {
 public void delete() {
  System.out.println("Oralce 删除用户表数据");
 }

 public void find() {
  System.out.println("Oralce 查询用户表数据");
 }
}

// 用户表MySql数据库DAO
class MySqluserDao implements IuserDao {
 public void delete() {
  System.out.println("MySql 删除用户数据");
 }

 public void find() {
  System.out.println("MySql 查询用户数据");
 }
}
// 角色表Oracle数据库DAO
class OracleroleDao implements IroleDao {
 public void insert() {
  System.out.println("Oralce 对角色表插入数据");
 }

 public void update() {
  System.out.println("Oracle 对角色表更新数据");
 }
}

// 角色表MySql数据库DAO
class MySqlroleDAO implements IroleDao {
 public void insert() {
  System.out.println("MySql 对角色表插入数据");
 }

 public void update() {
  System.out.println("Mysql 对角色表更新数据");
 }
}
这里增加了一套DAO的实现 (与平时有所不同,如果有10个数据库就要加上10种不同的实现,比较麻烦呀)

3.定义DAO工厂接口与实现(利用java反射机制生产出你需要的DAO如:userDAO,roleDao)

Java代码 
// DAO工厂   
abstract class DaoFactory {   
    public static DaoFactory getInstance(String classname) {   
        DaoFactory dao = null;   
        try {   
            dao = (DaoFactory) Class.forName(classname).newInstance();   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
        return dao;   
    }   
  
    abstract IuserDao getuserdao();   
  
    abstract IroleDao getroledao();   
}   
  
// Oralce工厂   
class OracleFactory extends DaoFactory {   
    public IroleDao getroledao() {   
        return new OracleroleDao();   
    }   
    public IuserDao getuserdao() {   
        return new OracleuserDao();   
    }   
}   
  
// MySql工厂   
class MysqlFactory extends DaoFactory {   
    public IroleDao getroledao() {   
        return new MySqlroleDAO();   
    }   
    public IuserDao getuserdao() {   
        return new MySqluserDao();   
    }   
}  

// DAO工厂
abstract class DaoFactory {
 public static DaoFactory getInstance(String classname) {
  DaoFactory dao = null;
  try {
   dao = (DaoFactory) Class.forName(classname).newInstance();
  } catch (Exception e) {
   e.printStackTrace();
  }
  return dao;
 }

 abstract IuserDao getuserdao();

 abstract IroleDao getroledao();
}

// Oralce工厂
class OracleFactory extends DaoFactory {
 public IroleDao getroledao() {
  return new OracleroleDao();
 }
 public IuserDao getuserdao() {
  return new OracleuserDao();
 }
}

// MySql工厂
class MysqlFactory extends DaoFactory {
 public IroleDao getroledao() {
  return new MySqlroleDAO();
 }
 public IuserDao getuserdao() {
  return new MySqluserDao();
 }
}  

4. 定义配置文件

Java代码 
class Config {   
    // Oralce   
    static final String ORALCE = "org.abc.OracleFactory";   
  
    static final String MYSQL = "org.abc.MysqlFactory";   
}  

class Config {
 // Oralce
 static final String ORALCE = "org.abc.OracleFactory";

 static final String MYSQL = "org.abc.MysqlFactory";
} 

 配置文件可以定义到XML中去(好处:修改配置项之后不需要对JAVA文件进行编译.)

5.测试你的输出的DAO

Java代码 
public class Dao {   
    public static void main(String[] args) {   
        DaoFactory.getInstance(Config.ORALCE).getroledao().insert();   
        DaoFactory.getInstance(Config.MYSQL).getroledao().insert();   
    }   
  
}  

public class Dao {
 public static void main(String[] args) {
  DaoFactory.getInstance(Config.ORALCE).getroledao().insert();
  DaoFactory.getInstance(Config.MYSQL).getroledao().insert();
 }

}  

总结

使用条件:一系列接口有一系列的实现
如上IuserDao、IroleDao等一系列的接口,他们可以有一系列的实现(Oracle方式、MySql方式)

OracleuserDao、OracleroleDao、MySqluserDao、MySqlroleDAO
组成元素(以上面例子)
一系列接口:IuserDao、IroleDao
一系列实现:Oracle系列、MySql系列
系列工厂类:Oracle系列工厂类、MySql系列工厂类(必须继承抽象工厂类)
抽象工厂类:DaoFactory





JDK中体现:
(1)java.sql包
(2)UIManager(swing外观)

1.工厂方法与2.抽象工厂详解

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
工厂方法: 理解了简单工厂模式之后,再看工厂方法就相对简单多了,对比多的是Product有了父类(接
要创建一个对象,可以使用new关键字,但是这样的初始化方式常常导致耦合的问题,如何避免这样的问题
一、简单工厂 实现如下: 1 //计算器总的抽象类 2 public abstract class Computer 3 { 4 private i
简单工厂 package com.lucas.ModelSimpleFactory; public abstract class Operation { public doubl
工厂方法模式 工厂方法模式(Factory Method,别名虚拟构造):定义一个用于创建对象的接口,让子类
总结: 简单工厂模式: public interface car(){ public void drive(); } public BMWcar() implemen
本文介绍工厂方法和抽象工厂区别。   工厂方法创建一般只有一个方法,创建一种产品。   抽象工
本文是转的 一、引子 话说十年前,有一个暴发户,他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪,
作者:zuoxiaolong8810(左潇龙),转载请注明出处。 前两章我们已经讨论了两种有关工厂的模式,今
前两章我们已经讨论了两种有关工厂的模式,今天我们来看最后一种与工厂相关的模式,抽象工厂模式。
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号