设计模式之工厂模式

Posted 2020-07-15

1.创建抽象工厂

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

2.创建工厂

package designModel.factoryModel;
//这个工厂用来生产对象,用来生产商品
public class Factory extends AbstractFactory {    
    //通过传进来的类名，创建相应的商品
    public  <T extends GoodInterface> 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;
//定义了商品B
public 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 extends GoodInterface> 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 extends GoodInterface> 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();
        }
    }