简单工厂、工厂方法、抽象工厂区别与联系

工厂模式按照对类的抽象程度可以划分为如下三种类型

1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）

简单工厂

定义：是由一个工厂对象决定创建出哪一种产品类的实例。
简单工厂模式中包含的角色及其相应的职责如下：

工厂角色（Creator）：这是简单工厂模式的核心，由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外界调用，创建所需要的产品对象。
抽象（Product）产品角色：简单工厂模式所创建的所有对象的父类，注意，这里的父类可以是接口也可以是抽象类，它负责描述所有实例所共有的公共接口。
具体产品（Concrete Product）角色：简单工厂所创建的具体实例对象，这些具体的产品往往都拥有共同的父类。

//抽象产品
abstract class Car {
	private String name;
	public abstract void drive();
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
//具体产品
class Benz extends Car {
	public void drive() {
		System.out.println(this.getName() + " " + "GO");
	}
}
//具体产品
class Bmw extends Car {
	public void drive() {
		System.out.println(this.getName() + "GO");
	}
}
//简单工厂
class Drive {
	public static Car createCar(String car) {
		Car c = null;
		if ("Benz".equalsIgnoreCase(car))
			c = new Benz();
		else if ("Bmw".equalsIgnoreCase(car))
			c = new Bmw();
		return c;
	}
}
//老板（客户端）
public class Boss {
	public static void main(String[] args) {
		Car car = Drive.createCar("Benz");
		car.setName("Benz");
		car.drive();
	}
}

使用简单工厂模式的优势：让对象的调用者和对象创建过程分离，当对象调用者需要对象时，直接向工厂请求即可。从而避免了对象的调用者与对象的实现类以硬编码方式耦合，以提高系统的可维护性、可扩展性。工厂模式也有一个小小的缺陷：当产品修改时，工厂类也要做相应的修改，违反了开-闭原则。如上例，需要增加 奥迪 时，需要修改工厂类 Driver

简单工厂模式适用于业务简单的情况下或者具体产品很少增加的情况。而对于复杂的业务环境可能不太适应了。这就应该由工厂方法模式来出场了！！

工厂方法

不在工厂类中进行逻辑判断，程序可以为不同产品类提供不同的工厂，不同的工厂类和产不同的产品。当使用工厂方法设计模式时，对象调用者需要与具体的工厂类耦合

类图：

    //抽象产品  
    abstract class Car{  
        private String name;  
        public abstract void drive();  
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
    }  
    //具体产品  
    class Benz extends Car{  
        public void drive(){  
            System.out.println(this.getName()+"GO");  
        }  
    }  
    class Bmw extends Car{  
        public void drive(){  
            System.out.println(this.getName()+"GO");  
        }  
    }  
    //抽象工厂  
    abstract class Driver{  
        public abstract Car createCar(String car) throws Exception;  
    }  
    //具体工厂（每个具体工厂负责一个具体产品）  
    class BenzDriver extends Driver{  
        public Car createCar(String car) throws Exception {  
            return new Benz();  
        }  
    }  
    //具体工厂（每个工厂负责一个具体产品）
    class BmwDriver extends Driver{  
        public Car createCar(String car) throws Exception {  
            return new Bmw();  
        }  
    }  
    //老板（客户端）
    public class Boss{  
        public static void main(String[] args) throws Exception {  
            Driver d = new BenzDriver();  
            Car c = d.createCar("benz");   
            c.setName("benz");  
            c.drive();  
        }  
    }  

使用开闭原则来分析下工厂方法模式。当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代码。（即当有新产品时，只要创建并基础抽象产品；新建具体工厂继承抽象工厂；而不用修改任何一个类）工厂方法模式是完全符合开闭原则的！

抽象工厂模式

先来认识下什么是产品族： 位于不同产品等级结构中，功能相关联的产品组成的家族。

举个例子海尔可以生产冰箱、彩电、和空调。那么冰箱就是一个产品族。
在以下类图中productC和productD是处于同一产品族，productA和productB是处于同一产品等级。

抽象工厂满足条件

系统中有多个产品族，而系统一次只可能消费其中一族产品
同属于同一个产品族的产品以其使用。
角色

抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。它由抽象类或者接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。一般有抽象类或者接口来实现。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。由具体的类来实现。

    //抽象产品（Bmw和Audi同理）  
    abstract class BenzCar{  
        private String name;  
          
        public abstract void drive();  
          
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
    }  
    //具体产品（Bmw和Audi同理）  
    class BenzSportCar extends BenzCar{  
        public void drive(){  
            System.out.println(this.getName()+"----BenzSportCar-----------------------");  
        }  
    }  
    class BenzBusinessCar extends BenzCar{  
        public void drive(){  
            System.out.println(this.getName()+"----BenzBusinessCar-----------------------");  
        }  
    }  
      
    abstract class BmwCar{  
        private String name;  
          
        public abstract void drive();  
          
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
    }  
    class BmwSportCar extends BmwCar{  
        public void drive(){  
            System.out.println(this.getName()+"----BmwSportCar-----------------------");  
        }  
    }  
    class BmwBusinessCar extends BmwCar{  
        public void drive(){  
            System.out.println(this.getName()+"----BmwBusinessCar-----------------------");  
        }  
    }  
    abstract class AudiCar{  
        private String name;  
          
        public abstract void drive();  
          
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
    }  
    class AudiSportCar extends AudiCar{  
        public void drive(){  
            System.out.println(this.getName()+"----AudiSportCar-----------------------");  
        }  
    }  
    class AudiBusinessCar extends AudiCar{  
        public void drive(){  
            System.out.println(this.getName()+"----AudiBusinessCar-----------------------");  
        }  
    }  
      
    //抽象工厂  
    abstract class Driver3{  
        public abstract BenzCar createBenzCar(String car) throws Exception;  
          
        public abstract BmwCar createBmwCar(String car) throws Exception;  
          
        public abstract AudiCar createAudiCar(String car) throws Exception;  
    }  
    //具体工厂  
    class SportDriver extends Driver3{  
        public BenzCar createBenzCar(String car) throws Exception {  
            return new BenzSportCar();  
        }  
        public BmwCar createBmwCar(String car) throws Exception {  
            return new BmwSportCar();  
        }  
        public AudiCar createAudiCar(String car) throws Exception {  
            return new AudiSportCar();  
        }  
    }  
    class BusinessDriver extends Driver3{  
        public BenzCar createBenzCar(String car) throws Exception {  
            return new BenzBusinessCar();  
        }  
        public BmwCar createBmwCar(String car) throws Exception {  
            return new BmwBusinessCar();  
        }  
        public AudiCar createAudiCar(String car) throws Exception {  
            return new AudiBusinessCar();  
        }  
    }  
      
    //老板  
    public class BossAbstractFactory {  
      
        public static void main(String[] args) throws Exception {  
              
            Driver3 d = new BusinessDriver();  
            AudiCar car = d.createAudiCar("");  
            car.drive();  
        }  
    }  

三种模式的对比

三种工厂模式使用要视情况而定，假如写个hello world 完全没有必要使用抽象工厂模式，使用工厂模式的根本目的是为了降低程序的耦合性从而应对客户需求的变化。

常用设计模式
https://blog.csdn.net/qq_33326449/article/details/78946364