设计模式之工厂模式

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

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;
    }
}

package designModel.factoryModel;

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

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");
    }

}

@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();
        }
    }

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;
    }

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();
        }
    }
}

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

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();
    }
}

@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();
        }
    }