三种工厂模式

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)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。
总结：  简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。
          工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
          抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。