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外观）