工厂设计模式

工厂设计模式

介绍

工厂设计模式按类别的话是属于创建型设计模式，在面向对象编程中,通常使用new的方式来创建一个对象,但是在一些情况下使用new来创建对象会有一些问题,比如说new一个对象可能面临初始化设置，选择生成哪一个对象实例或一系列生成对象之前需要做的工作。在此时创建一个对象就不是new这么简单了

而工厂设计模式就是解决上述问题，让你不在关注构造对象实例的细节和过程,只需要调用工厂方法即可获得一个对象实例.

分类

工厂设计模式也分成三类

• 简单工厂模式
• 工厂方法模式
• 抽象方法模式

简单工厂模式

• 介绍

简单工厂模式,又名静态工厂模式,顾名思义静态工厂模式，主要有一个静态方法，用来接受参数，并根据参数来决定返回实现同一接口的不同类的实例

• 举例

客户自己创建奔驰，拿来用

public class BenzS {  
    public BenzS(){  
        System.out.println("制造-->BenzS");  
    }  
}  
  
public class BenzG {  
    public BenzG(){  
        System.out.println("制造-->BenzG");  
    }  
}  
  
public class Customer {  
    public static void main(String[] args) {  
        BenzS benzS = new BenzS();  
        BenzG benzG = new BenzG();  
    }  
}

客户需要知道怎么创建一辆车，才能获得车，这就耦合在一起了。所以创建一个工厂，只需告诉车型号，就能获得车，而不需要知道怎么创建车的细节，这就是一个简单工厂模式

产品类

abstract class Benz {  
    public Benz(){  
          
    }  
}  
  
public class BenzS extends Benz {  
    public Benzs() {  
        System.out.println("制造-->Benzs");  
    }  
}  
public class BenzG extends Benz{  
    public BenzG(){  
        System.out.println("制造-->BenzG");  
    }  
}

简单工厂类

public class Factory {  
    public static Benz createBenz(String type) {  
        switch (type) {  
          
        case "S":  
            return new BenzS();  
  
        case "G":  
            return new BenzG();  
  
        default:  
            break;  
        }  
        return null;  
    }  
}

客户类

public class Customer {  
    public static void main(String[] args) {  
        Benz benzS = Factory.createBenz("S");  
        Benz benzG = Factory.createBenz("G");  
    }  
}

• 分析

我们可以从开闭原则（对扩展开发，对修改关闭)分析),对于产品类来说是符号开闭原则的，只需新建一个车类继承父类即可，不用修改原有代码.但是对于工厂类来说是不符号的，因为每多出一个车型都要在工厂类中增加相应的创建业务逻辑（createBMW(int type)方法需要新增,这显然是违反开闭原则的

工厂方法模式

工厂方法模式去掉了简单工厂模式的静态属性,抽象出来一个抽象的工厂类，使得它可以被继承,以后新增车型时只需新建一个工厂类继承抽象工厂类即可

产品类

abstract class Benz {  
    public Benz(){  
          
    }  
}  
  
public class BenzS extends Benz {  
    public Benzs() {  
        System.out.println("制造-->Benzs");  
    }  
}  
public class BenzG extends Benz{  
    public BenzG(){  
        System.out.println("制造-->BenzG");  
    }  
}

工厂方法模式类

interface FactoryBenz {  
    Benz createBenz();  
}  

public class FactoryBenzS implement FactoryBenz{ 
    @Override  
    public Benz createBenz() {  
       return BenzS()
    }  
} 

public class FactoryBenzG implement FactoryBenz{ 
    @Override  
    public Benz createBenz() {  
       return BenzG()
    }  
}

客户类

public class Customer {  
    public static void main(String[] args) {  
        FactoryBenzS factoryBenzS = new FactoryBenzS();  
        Benz benz = factoryBenzS.createBenz();  
  
        FactoryBenzG factoryBenzG = new FactoryBenzG();  
        Benz benz = factoryBenzG.createBenz(); 
    }  
}

• 分析

工厂方法模式虽然解决了简单工厂方法模式的问题，但是当产品种类很多时会出现大量的工厂对象，这不是我们希望出现的

抽象工厂模式

意的意图在于创建一系列互相关联或互相依赖的对象,大白话就是抽象工厂模式比工厂方法模式同一个工厂能创建更大的种类,比如某工厂不止能造空调还能造冰箱

产品类

//洗衣机接口 
public interface Washer{ 
} 
 
//冰箱接口 
public interface Icebox{ 
} 

//洗衣机-A 
public class WasherA implements Washer{ 
   public WasherA(){ 
       System.out.println("洗衣机-A被制造了"); 
   } 
} 
 
//洗衣机-B 
public class WasherB implements Washer{ 
   public WasherB(){ 
       System.out.println("洗衣机-B被制造了"); 
   } 
} 
 
//冰箱-A 
public class IceboxA implements Icebox{ 
   public IceboxA(){ 
       System.out.println("冰箱-A被制造了"); 
   } 
} 
 
//冰箱-B 
public class IceboxB implements Icebox{ 
   public IceboxB(){ 
       System.out.println("冰箱-B被制造了"); 
   } 
}

工厂

public interface Factory{ 
       public Washer createWasher(); 
       public Icebox createIcebox(); 
}


/创建型号为A的产品工厂 
public class FactoryA implements Factory{ 
       //创建洗衣机-A 
       public Washer createWasher(){ 
            return new WasherA(); 
       } 
 
       //创建冰箱-A 
       public Icebox createIcebox(){ 
            return new IceboxA(); 
       } 
} 
 
//创建型号为B的产品工厂 
public class FactoryB implements Factory{ 
       //创建洗衣机-B 
       public Washer createWasher(){ 
            return new WasherB(); 
       } 
 
       //创建冰箱-B 
       public Icebox createIcebox(){ 
            return new IceboxB(); 
       } 
}

总结

三种模式的工厂方法虽然有一些不一样，但是都是类似的，而且目的都是为了解耦，只要能达到解耦的目的，可以使用任意一种，不用纠结使用哪一种，随需求变化即可