工厂模式 java 电脑配件_1.Java设计模式-工厂模式

1．简单工厂模式(Factory Method)

常用的工厂模式是静态工厂模式，利用static修饰方法，作为一种类似于常见的工具类Utils等辅助效果，一般情况下工厂类不需要实例化。

//1.定义一个基类接口

public interfaceVideo {//定义一个生产视频的方法

public voidproduce();

}//2.定义实现类

public class JavaVideo implementsVideo {

@Overridepublic voidproduce() {

System.out.println("生产java视频");

}

}public class PythonVideo implementsVideo {

@Overridepublic voidproduce() {

System.out.println("生产python视频的方法");

}

}//3.定义视频工厂

public classVideoFactory {public staticVideo getVideo(String type) {if("java".equalsIgnoreCase(type)) {return newJavaVideo();

}else if("python".equalsIgnoreCase(type)) {return newPythonVideo();

}else{return null;

}

}

}//4.测试类

public classTest {public static voidmain(String[] args) {

Video video= VideoFactory.getVideo("java");if(video==null) {return;

}

video.produce();

}

}

View Code

工厂模式缺点：

工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，违反开闭原则。但上述工厂类模式随着生产课程种类原来越多，工厂里的方法要不断修改，不符合开闭原则。

改进：

1.1.  利用反射弥补扩展性，重新定义VideoFactory内的getVideo方法。

//修改工厂类

public classVideoFactory01 {public static Video getVideo(Class>c) {

Video video=null;try{

video=(Video) Class.forName(c.getName()).newInstance();

}catch(InstantiationException e) {//TODO Auto-generated catch block

e.printStackTrace();

}catch(IllegalAccessException e) {//TODO Auto-generated catch block

e.printStackTrace();

}catch(ClassNotFoundException e) {//TODO Auto-generated catch block

e.printStackTrace();

}returnvideo;

}

}//测试类

public classTest1 {public static voidmain(String[] args) {

Video video= VideoFactory01.getVideo(PythonVideo.class);

video.produce();

}

View Code

1.2.工厂类只定义规范(接口)，创建不同的实例只需要不同的工厂类实现统一的工厂接口即可。这样可以放VideoFactory这个超类代码与子类创建对象的代码解耦。(工厂模式)

//视频工厂只提供规范，具体创建何种实例由具体的工厂实现类来决定

public interfaceVideoFactory02 {publicVideo getVideo();

}//具体的实现

public class JavaVideoFactory02 implementsVideoFactory02 {

@OverridepublicVideo getVideo() {return newJavaVideo();

}

}public class PythonVideoFactory02 implementsVideoFactory02 {

@OverridepublicVideo getVideo() {//TODO Auto-generated method stub

return newPythonVideo();

}

}//测试类

public classTest2 {/*** 现在创建什么类型的视频是由VideoFactory的子类决定的，VideoFactory只定义规范，契约

*@paramargs*/

public static voidmain(String[] args) {

VideoFactory02 factory=newJavaVideoFactory02();

Video video=factory.getVideo();

video.produce();

}

}

View Code

从扩展性的角度来看，现在如果要添加一门前端课程，只需要创建FeVideoFactory实现VideoFactory接口就可以了，不需要修改VideoFactory的代码实现。符合开闭原则。且FeVideo,JavaVideo,PythonVideo处于同一产品等级，工厂模式就是方便解决同一产品等级创建实例的。

2.工厂模式深入——体现产品等级概念

举个栗子：假设我们想要找电脑组装人员DIY组装一台电脑。我们希望自己选择CPU、主板、内存、电源、显卡、电源等。由于内容较多，我们就拿CPU和主板来说事。

在选择CPU的时候，主要的参数有CPU品牌，型号，针脚数量，主频等，只有这些都确定下来，我们才能确定具体的CPU；

主板也一样，主板的主要参数有品牌，芯片组，总线频率等，只有这些确定下来，我们才能确定具体主板；

且在选择的时候我们还需要考虑到CPU和主板的兼容性，比如说Intel的CPU与AMD的主板就不兼容，因为Intel的CPU的针脚数目与AMD主板的CPU插孔数量不一致，根本无法插入。所以装机方案需要整体考虑，里边的不同模块之间是有关联的。

对于装机工程师来说，他只知道组装一台电脑需要响应的配件，而具体的配件选择还是需要由客户决定。对于不同的客户做出的选择不同，他需要根据客户的选择去获取配件，然后为该客户完成组装。

使用工厂模式的解决方案：

对于装机工程师来说，他只知道组装电脑需要CPU和主板，而两者具体选择什么品牌，型号他确定不了，需要客户去选择，客户选择好后他负责去相应的工厂里边获取这两种配件，然后组装。

2.1.Cpu接口与具体实现

//Cpu接口

packagecom.itheima.pattern.entity;public interfaceCPU {//CPU具有计算功能

public voidcalculate();

}//Cpu具体实现Intel，可供客户选择

packagecom.itheima.pattern.entity;public class IntelCpu implementsCPU {private intpins;public IntelCpu(intpins) {this.pins =pins;

}

@Overridepublic voidcalculate() {

System.out.println("Intel Cpu的针脚数："+pins);

}

}//Cpu具体实现Amd，可供客户选择

packagecom.itheima.pattern.entity;public class AmdCpu implementsCPU {private intpins;public AmdCpu(intpins) {this.pins =pins;

}

@Overridepublic voidcalculate() {

System.out.println("Amd Cpu针脚数："+pins);

}

}

View Code

2.2.主板接口与具体实现

//主板接口

packagecom.itheima.pattern.entity;public interfaceMainboard {//主板上安装Cpu

public voidinstallCpu();

}//主板具体实现Intel，可供客户选择

packagecom.itheima.pattern.entity;public class IntelMainboard implementsMainboard {/*** cpu插槽孔数*/

private intcpuHolds;public IntelMainboard(intcpuHolds) {this.cpuHolds =cpuHolds;

}

@Overridepublic voidinstallCpu() {

System.out.println("Intel主板CPU插槽孔数是："+cpuHolds);

}

}//主板具体实现Amd，可供客户选择

packagecom.itheima.pattern.entity;public class AmdMainboard implementsMainboard {private intcpuHolds;public AmdMainboard(intcpuHolds) {this.cpuHolds =cpuHolds;

}

@Overridepublic voidinstallCpu() {

System.out.println("Amd 主板Cpu插槽孔数："+cpuHolds);

}

}

View Code

2.3.创建Cpu工厂

packagecom.itheima.pattern.factory;importcom.itheima.pattern.entity.AmdCpu;importcom.itheima.pattern.entity.CPU;importcom.itheima.pattern.entity.IntelCpu;public classCpuFactory {public static CPU createCpu(inttype) {

CPU cpu=null;if(type==1) {

cpu=new IntelCpu(755);

}else if(type==2) {

cpu=new AmdCpu(938);

}else{return null;

}returncpu;

}

}

View Code

2.4.创建主板工厂

packagecom.itheima.pattern.factory;importcom.itheima.pattern.entity.AmdMainboard;importcom.itheima.pattern.entity.IntelMainboard;importcom.itheima.pattern.entity.Mainboard;public classMainboardFactory {public static Mainboard createMainboard(inttype) {if(type==1) {return new IntelMainboard(755);

}else if(type==2) {return new AmdMainboard(938);

}else{return null;

}

}

}

View Code

2.5.电脑组装工程师(工厂调用者)

packagecom.itheima.pattern.computerEngineer;importcom.itheima.pattern.entity.CPU;importcom.itheima.pattern.entity.Mainboard;importcom.itheima.pattern.factory.CpuFactory;importcom.itheima.pattern.factory.MainboardFactory;public classComputerEngineer {//装机需要Cpu

privateCPU cpu;//装机需要主板

privateMainboard mainboard;//组装电脑

public void makeComputer(int cpuType,intboardType) {

cpu=CpuFactory.createCpu(cpuType);

mainboard=MainboardFactory.createMainboard(boardType);

cpu.calculate();

mainboard.installCpu();

System.out.println("电脑组装完成，可以使用");

}

}

View Code

2.6.客户(使用者)

packagecom.itheima.pattern.client;importcom.itheima.pattern.computerEngineer.ComputerEngineer;public classClient {public static voidmain(String[] args) {

ComputerEngineer computerEngineer= newComputerEngineer();

computerEngineer.makeComputer(1, 1);

}

}

View Code

2.7.程序运行结果

上边的实现是采用简单工厂模式实现的，但有个问题没有解决，就是Cpu与主板之间的兼容关系没有解决，实际上Cpu与主板之间时候有关系的，需要相互匹配。而上边的实现并没有维护这种关系。因此当客户选择makeComputer(1, 2)时，将出现无法组装的情况。该如何避免这种情况的发生？需要引入抽象工厂模式。见下一节。