1.Java设计模式-工厂模式
1．简单工厂模式（Factory Method）
常用的工厂模式是静态工厂模式，利用static修饰方法，作为一种类似于常见的工具类Utils等辅助效果，一般情况下工厂类不需要实例化。
//1.定义一个基类接口 public interface Video { //定义一个生产视频的方法 public void produce(); } //2.定义实现类 public class JavaVideo implements Video { @Override public void produce() { System.out.println("生产java视频"); } } public class PythonVideo implements Video { @Override public void produce() { System.out.println("生产python视频的方法"); } } //3.定义视频工厂 public class VideoFactory { public static Video getVideo(String type) { if("java".equalsIgnoreCase(type)) { return new JavaVideo(); }else if("python".equalsIgnoreCase(type)) { return new PythonVideo(); }else { return null; } } } //4.测试类 public class Test { public static void main(String[] args) { Video video = VideoFactory.getVideo("java"); if(video==null) { return; } video.produce(); } }
工厂模式缺点：
工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，违反开闭原则。但上述工厂类模式随着生产课程种类原来越多，工厂里的方法要不断修改，不符合开闭原则。
改进：
1.1. 利用反射弥补扩展性，重新定义VideoFactory内的getVideo方法。
//修改工厂类 public class VideoFactory01 { 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(); } return video; } } //测试类 public class Test1 { public static void main(String[] args) { Video video = VideoFactory01.getVideo(PythonVideo.class); video.produce(); }
1.2.工厂类只定义规范（接口），创建不同的实例只需要不同的工厂类实现统一的工厂接口即可。这样可以放VideoFactory这个超类代码与子类创建对象的代码解耦。(工厂模式)
//视频工厂只提供规范，具体创建何种实例由具体的工厂实现类来决定 public interface VideoFactory02 { public Video getVideo(); } //具体的实现 public class JavaVideoFactory02 implements VideoFactory02 { @Override public Video getVideo() { return new JavaVideo(); } } public class PythonVideoFactory02 implements VideoFactory02 { @Override public Video getVideo() { // TODO Auto-generated method stub return new PythonVideo(); } } //测试类 public class Test2 { /** * 现在创建什么类型的视频是由VideoFactory的子类决定的，VideoFactory只定义规范，契约 * @param args */ public static void main(String[] args) { VideoFactory02 factory=new JavaVideoFactory02(); Video video= factory.getVideo(); video.produce(); } }
从扩展性的角度来看，现在如果要添加一门前端课程，只需要创建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接口 package com.itheima.pattern.entity; public interface CPU { //CPU具有计算功能 public void calculate(); } //Cpu具体实现Intel，可供客户选择 package com.itheima.pattern.entity; public class IntelCpu implements CPU { private int pins; public IntelCpu(int pins) { this.pins = pins; } @Override public void calculate() { System.out.println("Intel Cpu的针脚数："+pins); } } //Cpu具体实现Amd，可供客户选择 package com.itheima.pattern.entity; public class AmdCpu implements CPU { private int pins; public AmdCpu(int pins) { this.pins = pins; } @Override public void calculate() { System.out.println("Amd Cpu针脚数："+pins); } }
2.2.主板接口与具体实现
//主板接口 package com.itheima.pattern.entity; public interface Mainboard { //主板上安装Cpu public void installCpu(); } //主板具体实现Intel，可供客户选择 package com.itheima.pattern.entity; public class IntelMainboard implements Mainboard { /** * cpu插槽孔数 */ private int cpuHolds; public IntelMainboard(int cpuHolds) { this.cpuHolds = cpuHolds; } @Override public void installCpu() { System.out.println("Intel主板CPU插槽孔数是："+cpuHolds); } } //主板具体实现Amd，可供客户选择 package com.itheima.pattern.entity; public class AmdMainboard implements Mainboard { private int cpuHolds; public AmdMainboard(int cpuHolds) { this.cpuHolds = cpuHolds; } @Override public void installCpu() { System.out.println("Amd 主板Cpu插槽孔数："+cpuHolds); } }
2.3.创建Cpu工厂
package com.itheima.pattern.factory; import com.itheima.pattern.entity.AmdCpu; import com.itheima.pattern.entity.CPU; import com.itheima.pattern.entity.IntelCpu; public class CpuFactory { public static CPU createCpu(int type) { CPU cpu=null; if(type==1) { cpu=new IntelCpu(755); }else if(type==2) { cpu=new AmdCpu(938); }else { return null; } return cpu; } }
2.4.创建主板工厂
package com.itheima.pattern.factory; import com.itheima.pattern.entity.AmdMainboard; import com.itheima.pattern.entity.IntelMainboard; import com.itheima.pattern.entity.Mainboard; public class MainboardFactory { public static Mainboard createMainboard(int type) { if(type==1) { return new IntelMainboard(755); }else if(type==2) { return new AmdMainboard(938); }else { return null; } } }
2.5.电脑组装工程师（工厂调用者）
package com.itheima.pattern.computerEngineer; import com.itheima.pattern.entity.CPU; import com.itheima.pattern.entity.Mainboard; import com.itheima.pattern.factory.CpuFactory; import com.itheima.pattern.factory.MainboardFactory; public class ComputerEngineer { //装机需要Cpu private CPU cpu; //装机需要主板 private Mainboard mainboard; //组装电脑 public void makeComputer(int cpuType,int boardType) { cpu=CpuFactory.createCpu(cpuType); mainboard=MainboardFactory.createMainboard(boardType); cpu.calculate(); mainboard.installCpu(); System.out.println("电脑组装完成，可以使用"); } }
2.6.客户（使用者）
package com.itheima.pattern.client; import com.itheima.pattern.computerEngineer.ComputerEngineer; public class Client { public static void main(String[] args) { ComputerEngineer computerEngineer = new ComputerEngineer(); computerEngineer.makeComputer(1, 1); } }
2.7.程序运行结果
上边的实现是采用简单工厂模式实现的，但有个问题没有解决，就是Cpu与主板之间的兼容关系没有解决，实际上Cpu与主板之间时候有关系的，需要相互匹配。而上边的实现并没有维护这种关系。因此当客户选择makeComputer(1, 2)时，将出现无法组装的情况。该如何避免这种情况的发生？需要引入抽象工厂模式。见下一节。
