1.创建抽象工厂

package designModel.factoryModel;//创建一个抽象的工厂，其中定义了一个方法，用来创建商品public abstract class AbstractFactory {    public abstract 
     
       T createGood(Class c);}
     

2.创建工厂

package designModel.factoryModel;//这个工厂用来生产对象,用来生产商品public class Factory extends AbstractFactory {        //通过传进来的类名，创建相应的商品    public  
     
       T createGood(Class c){        GoodInterface good=null;        try {            good = (GoodInterface) Class.forName(c.getName()).newInstance();        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {            System.out.println("创建相应的商品对象异常");            e.printStackTrace();        }        return (T)good;    }}
     

3. 创建商品接口

package designModel.factoryModel;//定义所有商品共有的方法public interface GoodInterface {    //定义商品输出价格的方法    public void printPrice();    //定义商品输出商品名字的方法    public void printName();}

4.实现商品接口的商品

package designModel.factoryModel;public class GoodA  implements GoodInterface{    @Override    public void printPrice() {        System.out.println("GoodA price");    }    @Override    public void printName() {        System.out.println("GoodA name");    }}package designModel.factoryModel;//定义了商品Bpublic class GoodB implements GoodInterface{    public GoodB() {    }    @Override    public void printPrice() {        System.out.println("GoodB price");    }    @Override    public void printName() {        System.out.println("GoodB name");    }}

4.测试工厂模式

@Test    public void testAbstractFactory() {        AbstractFactory abstractFactory;        try {            abstractFactory = Factory.class.newInstance();            GoodInterface goodA = abstractFactory.createGood(GoodA.class);            goodA.printName();            goodA.printPrice();        } catch (InstantiationException | IllegalAccessException e) {            e.printStackTrace();        }    }

5.变种

1）、简单工厂模式

与上述的工厂模式的区别，上述工厂模式继承一个抽象类，实现抽象类的方法，来创建商品对象，简单工厂模式继承一个抽象类，而是通过自己的本身的静态方法去创建商品对象，该模式是工厂方法模式的弱化，所以叫简单工厂模式，也叫做静态工厂模式。

a、工厂类

package designModel.factoryModel;//这个工厂用来生产对象,用来生产商品public class Factory {        //通过传进来的类名，创建相应的商品    public static 
     
       T createGood(Class c){        GoodInterface good=null;        try {            good = (GoodInterface) Class.forName(c.getName()).newInstance();        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {            System.out.println("创建相应的商品对象异常");            e.printStackTrace();        }        return (T)good;    }
     

b、测试类

package designModel.factoryModel;import org.junit.Test;public class FactoryTest {    @Test    public void testFactory() {        Factory factory;        try {            factory = Factory.class.newInstance();            GoodInterface goodA = factory.createGood(GoodA.class);            goodA.printName();            goodA.printPrice();        } catch (InstantiationException | IllegalAccessException e) {            e.printStackTrace();        }    }}

 

2）、多工厂类模式

a、工厂类

package designModel.factoryModel;//创建一个抽象的工厂，其中定义了一个方法，用来创建商品public abstract class AbstractFactory {    //public abstract 
     
       T createGood(Class c);        //多工厂模式不需要在createGood方法中传递参数    public abstract GoodInterface createGood();}
     

实现GoodA的工厂，实现GoodB的工厂

package designModel.factoryModel;public class GoodAFactory extends AbstractFactory {    @Override    public GoodInterface createGood() {        return new GoodA();    }}package designModel.factoryModel;public class GoodBFactory extends AbstractFactory {    @Override    public GoodInterface createGood() {        return new GoodB();    }}

b、测试多工厂

@Test    public void testMoreAbstractFactory(){        AbstractFactory abstractFactory;        try {            abstractFactory = GoodAFactory.class.newInstance();            GoodInterface goodA = abstractFactory.createGood();            goodA.printName();            goodA.printPrice();        } catch (InstantiationException | IllegalAccessException e) {            e.printStackTrace();        }    }