参考博文:https://www.cnblogs.com/toutou/p/4899388.html 侵权必删
什么是工厂模式:通过“对象创建”模式绕开new,来避免对象创建(new)过程中所导致的紧耦合(依赖具体类)。
适用性:使用new创建对象且导致紧耦合的场景。
思考:面向对象编程要以动态的思维去看待代码。换句话说,在看代码时需要时间概念,发现代码在未来的稳定之处和变化之处。一般接口和抽象类是稳定的,而具体实现是变化的,这也是面向接口/抽象编程的原因,可以使代码更加稳定。
先思考如下场景:目前只有一种ProductA,需要productA时,使用代码 ProductA pa = new ProductA()。如果未来需求变化,添加ProductB、ProductC等,会导致上述代码是不稳定。因为ProductA pa = new ProductA() 这俩部分都依赖了具体实现。
将ProductA、ProductB、ProductC抽象出Product,改写代码Product pa = new ProductA(),目前依然依赖nProductA,工厂问题就是为了解决这种new依赖的问题。
一、简单工厂模式
基本代码:
package simpleFactory; public abstract class Produce { public abstract void readme(); }
package simpleFactory; public class ProductA extends Produce{ @Override public void readme() { System.out.println("AAAAAAA"); } }
package simpleFactory; public class ProduvtB extends Produce { @Override public void readme() { System.out.println("BBBBBBBBBB"); } }
package simpleFactory; public class SimpleFacory { public Produce getProduce(String type){ if(type.equals("A")) { return new ProductA(); }else if(type.equals("B")){ return new ProduvtB(); }else { System.out.println("typr error"); } return null; } }
public static void main(String[] args) { ////---------------简单工厂模式--------------------- //// 通过向工厂传递参数而获取期望的对象,单工厂模式能够根据外界给定的信息,决定究竟应该创建哪个具体类的对象。 //// 明确区分了各自的职责和权力,有利于整个软件体系结构的优化。 //// 但是工厂类集中了所有实例的创建逻辑,容易违反GRASPR的高内聚的责任分配原则 // // SimpleFacory sf = new SimpleFacory(); // Produce p = sf.getProduce("A"); // p.readme(); // } }
二、工厂模式
package FactoryMethod; import simpleFactory.Produce; public abstract class Factory { public abstract Produce getProduce(); }
package FactoryMethod; import simpleFactory.Produce; import simpleFactory.ProductA; public class FactoryA extends Factory{ @Override public Produce getProduce() { return new ProductA(); } }
package FactoryMethod; import simpleFactory.Produce; import simpleFactory.ProduvtB; public class FactoryB extends Factory { @Override public Produce getProduce() { return new ProduvtB(); } }
////------------------工厂模式------------------------ Factory f = new FactoryA(); //这里使用new的方式代替,实际情况下应该根据需要传入具体的工厂 Produce p = f.getProduce(); //均依赖抽象 p.readme();
三、抽象工厂模式(可以认为抽象工厂模式是工厂模式的一般形式)
package AbstractFactory; public abstract class ProduceNumber { public abstract void readme(); }
package AbstractFactory; /** * 只能与产品A配套 */ public class Produce1 extends ProduceNumber { public void readme(){ System.out.println("111111111"); } }
package AbstractFactory; /** * 只能与产品B配套 */ public class Produce2 extends ProduceNumber { public void readme() { System.out.println("222222"); } }
package AbstractFactory; import simpleFactory.Produce; public abstract class AbstractFactory { public abstract Produce getProduce(); public abstract ProduceNumber getProduceNumber(); }
package AbstractFactory; import simpleFactory.Produce; import simpleFactory.ProductA; public class FactoryA1 extends AbstractFactory { @Override public Produce getProduce() { return new ProductA(); } @Override public ProduceNumber getProduceNumber() { return new Produce1(); } }
package AbstractFactory; import simpleFactory.Produce; import simpleFactory.ProduvtB; public class FactoryB2 extends AbstractFactory{ @Override public Produce getProduce() { return new ProduvtB(); } @Override public ProduceNumber getProduceNumber() { return new Produce2(); } }
//--------------------抽象工厂模式----------------------- // 有产品A和产品1配套,产品B和产品2配套。如果只用工厂模式需要4个具体工厂,且有可能出现产品不匹配的问题。 // 抽象工厂模式为创建一组相关或相互依赖的对象提供一个接口,保证产品的配套问题,使得上述问题只要两个工厂。
// 适用场合:多个需要配套的产品
AbstractFactory f = new FactoryA1();//这里使用new的方式代替,实际情况下应该根据需要传入具体的工厂 Produce p = f.getProduce(); ProduceNumber pn = f.getProduceNumber(); p.readme(); pn.readme();