java设计模式之工厂模式

  工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽起来，达到提高灵活型的目的。

   （1）简单工厂模式：

属于类的创新模式，又叫静态工厂模式，是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类：

 实现如下：

1： 新建一个娃娃接口

 // 娃娃接口 （扩展其他信息比较方便）

interface Doll {

// 获取娃娃的信息

public String getInfo();

}

2： 创建具体的娃娃产品（布娃娃和芭比娃娃）

 class ClothDoll implements Doll {

public String getInfo() {

return "我是布娃娃，我怕脏！！";

}

}

class BarbieDoll implements Doll {

public String getInfo() {

return"芭比娃娃，美的不可思议";

}

}

 （3）创建娃娃工厂：

 class DollFactory {

public static Doll getInstance(String name) {

// 根据不同条件生产不同的对象

if ("cloth".equals(name)) {

return new ClothDoll();

} else if ("barbie".equals(name)) {

return new BarbieDoll();

}

  return null;

}

}

 （4）：测试类

  public class FactoryDemo {

public static void main(String[] args) {

Doll dol = DollFactory.getInstance("cloth");

if (dol!=null){

System.out.println(dol.getInfo());

}

Doll dos = DollFactory.getInstance("barbie");

 if (dos!=null){

System.out.println(dos.getInfo());

}

}

}

  缺点：违背了“开放封闭”（系统对扩展开放，对修改关闭）的原则， 因为增加一个产品的时候，必须修改工厂类，相应的工厂类就得重新编译即可。

 

 （2） 工厂方法模式：

简单工厂模式的进化版，工厂方法模式是定义一个创建产品对象的工厂接口，工厂接口本身不去创建对象，而是交给其子类或者实现类去创建，将实际创建工作推迟到子类中进行，

具体实现：

 抽象产品：

interface Food {

public String mySelf ();

}

具体的产品类：

 class Vegetable implements Food{

@Override

public String mySelf() {

return "我是蔬菜";

}

}

class Meat implements Food{

 

@Override

public String mySelf() {

return "我是肉";

}

}

工厂类接口

abstract class foodFactory{

abstract Food Makefood();

}

具体的工厂实现类：

class VegFactory extends foodFactory{

@Override

Food Makefood() {

return new Vegetable();

}

}

class MeatFactory extends foodFactory{

@Override

Food Makefood() {

return new Meat();

}

}

测试类：

 public static void main(String[] args) {

//生产肉

   foodFactory factory= new MeatFactory();

   Food f =factory.Makefood();

    System.out.println(f.mySelf());

}

}

工厂方法模式，使得结构变得灵活起来，当有新产品产生的时候，只要按照抽象角色和抽象工厂提供的“合同”来生产，就可以被用户使用，而不必去修改任何已有的代码，可以看做角色也是符合开放封闭原则。

（3）抽象工厂模式：

  实现：

     // Method可以看成是不同产品的共性

interface ProductA {

public void Method();

}

interface ProductB {

public void Method();

}

/*

 * 实现产品的标准

 */

class ProductA1 implements ProductA {

@Override

public void Method() {

System.out.println("厂商1     生产productA1");

}

}

class ProductA2 implements ProductA {

@Override

public void Method() {

System.out.println("厂商2   生产productA2");

}

}

class ProductB1 implements ProductB {

@Override

public void Method() {

System.out.println("厂商1   生产productB1");

}

}

class ProductB2 implements ProductB {

@Override

public void Method() {

System.out.println("厂商2    生产productB2");

}

}

// 每一种牌子的产品生产工厂,不同的厂商负责自己牌子产品的生产

abstract class Factory1 {

abstract ProductA getProductA1();

abstract ProductB getProductB1();

}

abstract class Factory2 {

abstract ProductA getProductA2();

abstract ProductB getProductB2();

}

// 具体的工厂用来生产相关的产品

class OnCreateFactoryA extends Factory1 {

@Override

ProductA getProductA1() {

return new ProductA1();

}

@Override

ProductB getProductB1() {

return new ProductB1();

}

}

class onCreateFactoryB extends Factory2 {

@Override

ProductA getProductA2() {

return new ProductA2();

}

 

@Override

ProductB getProductB2() {

return new ProductB2();

}

}

 测试类：

  public class chouxiangFactory {

public static void main(String[] args) {

// 厂商１负责生产产品A1,B1;

Factory1 f1 = new OnCreateFactoryA();

ProductA pa = f1.getProductA1();

ProductB pb = f1.getProductB1();

pa.Method();

pb.Method();

// 厂商二负责生产A2,B2;

Factory2 f2 = new onCreateFactoryB();

ProductA pa1 = f2.getProductA2();

ProductB pb2 = f2.getProductB2();

pa1.Method();

pb2.Method();

}

}

抽象工厂模式：可以在类的内部对产品族进行约束。产品族一般或多或少都存在一定的关联，抽象工厂模式就可以在类的内部对产品族的关联关系进行定义和描述，而不必引入一个新的类进行管理。

 工厂模式的好处：

  1： 将创建实例的工作与使用实例的工作分开，（避免代码重复，创建蔓延）

  2: 把初始化实例时的工作放到工厂里进行，使代码更加容易维护。

  3 ：使得修改代码时不会引起太大的变化，良好的扩展性。

  4： 一个类可以拥有多个构造函数，我们可以提供一系列名字完全不同的工厂方法组，每一个工厂方法对应一个构造方法。