a、简单工厂
1.建立接口——抽象的产品
package com.yenange.factory.easy;
public interface ISample {
}
2.建立两种实现类——实际的产品了
package com.yenange.factory.easy;
public class SampleA implements ISample {
public SampleA () {
System.out.println("我是SampleA");
}
}
package com.yenange.factory.easy;
public class SampleB implements ISample {
public SampleB () {
System.out.println("我是SampleB");
}
}
3.建立工厂——注意:这个工厂的方法必须是static的(方便调用),返回类型应该是上面的接口,参数标识了产生对象的类型。
package com.yenange.factory.easy;
public class Factory {
public static ISample creator(String type) {
if (type.equals("A")) {
return new SampleA();
}else if (type.equals("B")) {
return new SampleB();
}else {
return null;
}
}
}
4.建立测试类——很简单,就是工厂名.方法名,加上要产生产品的代号(参数)
package com.yenange.factory.easy;
public class Test {
public static void main(String[] args) {
ISample sample1=Factory.creator("A");
ISample sample2=Factory.creator("B");
}
}
b.抽象工厂模式
抽象工厂,用的最多的地方,就是在项目中,要用到两种不同的数据库,而两种数据库,必然对应两种不同的操作,在项目中如何达到最快速的切换?
这就要用到抽象工厂模式了。
还是从实例开始:
现在有两种数据库:MySql和Oracle
里面都有两张表:role,user
要对role进行insert和update操作,对user进行find和delete操作
用抽象工厂怎么样实现?
1、既然是同一个表有两种数据库的操作形式,那么自然这个操作应该是一个接口:IroleDao和IuserDao,以便有多种实现。
package com.yenange.factory.abstractF;
public interface IuserDao {
public void find();
public void delete();
}
package com.yenange.factory.abstractF;
public interface IroleDao {
public void insert();
public void update();
}
2、建立了接口,还要用每一种数据库来实现它。所以应该有4个实现类:
package com.yenange.factory.abstractF;
public class MySqlroleDAO implements IroleDao {
public void insert() {
System.out.println("MySql 对角色表插入数据");
}
public void update() {
System.out.println("Mysql 对角色表更新数据");
}
}
package com.yenange.factory.abstractF;
public class MySqluserDao implements IuserDao {
public void delete() {
System.out.println("MySql 删除用户数据");
}
public void find() {
System.out.println("MySql 查询用户数据");
}
}
package com.yenange.factory.abstractF;
public class OracleroleDao implements IroleDao {
public void insert() {
System.out.println("Oralce 对角色表插入数据");
}
public void update() {
System.out.println("Oracle 对角色表更新数据");
}
}
package com.yenange.factory.abstractF;
public class OracleuserDao implements IuserDao {
public void delete() {
System.out.println("Oralce 删除用户表数据");
}
public void find() {
System.out.println("Oralce 查询用户表数据");
}
}
3、建立抽象工厂,来选择实际工厂——关键了!
a、同样,创建工厂的是static方法,返回的也是自己的类型。
b、要通过Class.forName(String).newInstance()来得到一个类型;
c、余下的两个抽象方法,返回类型应该是抽象产品;
package com.yenange.factory.abstractF;
public 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();
}
4、建立两个实际工厂,来实现取得对应的前面的抽象工厂。
package com.yenange.factory.abstractF;
public class MysqlFactory extends DaoFactory {
public IroleDao getroledao() {
return new MySqlroleDAO();
}
public IuserDao getuserdao() {
return new MySqluserDao();
}
}
package com.yenange.factory.abstractF;
public class OracleFactory extends DaoFactory {
public IroleDao getroledao() {
return new OracleroleDao();
}
public IuserDao getuserdao() {
return new OracleuserDao();
}
}
5、测试。
package com.yenange.factory.abstractF;
public class Test {
static final String ORALCE = "com.yenange.factory.abstractF.OracleFactory";
static final String MYSQL = "com.yenange.factory.abstractF.MysqlFactory";
public static void main(String[] args) {
DaoFactory.getInstance(ORALCE).getroledao().insert();
DaoFactory.getInstance(MYSQL).getroledao().insert();
}
}
好象没有什么了不起,只是:好难记的。大概:要训练二三十遍了,印象才深刻!
c、工厂方法模式
与抽象工厂一样,只是少了一个抽象工厂而已,创建时直接new FactoryA或B就好了。
1、两种产品,所以要有两个抽象产品的接口;
package com.yenange.factory.factorymethod;
//产品 Fruit接口
public interface Fruit {
}
package com.yenange.factory.factorymethod;
//产品 Plant接口
public interface Plant {
}
2、有两个工厂,所以有这两个接口合起来有四个实现类。
package com.yenange.factory.factorymethod;
//具体产品A
public class FruitA implements Fruit {
public FruitA() {
System.out.println("create FruitA !");
}
public void doSomething() {
System.out.println(" FruitA do something ...");
}
}
package com.yenange.factory.factorymethod;
//具体产品B
public class FruitB implements Fruit {
public FruitB() {
System.out.println("create FruitB !");
}
public void doSomething() {
System.out.println(" FruitB do something ...");
}
}
package com.yenange.factory.factorymethod;
//具体产品A
public class PlantA implements Plant {
public PlantA() {
System.out.println("create PlantA !");
}
public void doSomething() {
System.out.println(" PlantA do something ...");
}
}
package com.yenange.factory.factorymethod;
//具体产品B
public class PlantB implements Plant {
public PlantB() {
System.out.println("create PlantB !");
}
public void doSomething() {
System.out.println(" PlantB do something ...");
}
}
3、抽象工厂(接口):里面有两个生产抽象产品的方法。
package com.yenange.factory.factorymethod;
public interface IAbstractFactory {
public Plant createPlant();
public Fruit createFruit();
}
4、两个实现抽象工厂的实际工厂。
package com.yenange.factory.factorymethod;
public class FactoryA implements IAbstractFactory {
public Fruit createFruit() {
return new FruitA();
}
public Plant createPlant() {
return new PlantA();
}
}
package com.yenange.factory.factorymethod;
public class FactoryB implements IAbstractFactory {
public Fruit createFruit() {
return new FruitB();
}
public Plant createPlant() {
return new PlantB();
}
}
5、测试。
package com.yenange.factory.factorymethod;
public class Test {
public static void main(String[] args) {
IAbstractFactory factory=new FactoryA();
factory.createFruit();
factory.createPlant();
factory=new FactoryB();
factory.createFruit();
factory.createPlant();
}
}
现在说起来,还是水平有限,讲不了那么的清楚。有空参考:
http://jackyi.javaeye.com/blog/170656
----------------------------------------------------------------------------------------------------------
在抽象工厂模式中,抽象产品 (AbstractProduct) 可能是一个或多个,从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下,抽象工厂模式实际上退化到工厂方法模式。
总结: 简单工厂模式是由一个具体的类去创建其他类的实例,父类是相同的,父类是具体的。
工厂方法模式是有一个抽象的父类定义公共接口,子类负责生成具体的对象,这样做的目的是将类的实例化操作延迟到子类中完成。
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。