java基于抽象类的工厂模式

工厂模式的主要思想

工厂模式的基本思想就是引入第三方类，将一些共有的操作从具体实现的类中解耦（抽离）出来，这样有利于统一化，有利于扩展。引入工厂从而把一些需要在客户端频繁的操作比如类的实例化操作，解耦（抽离）出来，拿到工厂类中，从而降低对客户端的依赖。

简单工厂模式

简单工厂模式用于产品较少，也就是产品类较少的情况。专门定义一个类(第三方类)用于创建其他具体类实例，(将客户端创建对象的操作解耦到第三方类中)，要求被创建的具体实例化的产品类都具有相同的父类。
简单工厂模式的组成：
1.一个抽象类
2.多个具体产品类
3.一个工厂类
举个例子：卖糖

package www.Factory;

import java.util.Scanner;
//抽象接口
interface  ISuger {
    void printSuger();
}
//具体实现类
class ChocolateCandy implements ISuger{
     public void printSuger(){
         System.out.println("这里生产巧克力糖");
     }
}
class Toffee implements ISuger{
    public void printSuger(){
        System.out.println("这里生产太妃糖");
    }
}
class FrultCandy implements ISuger{
    public void printSuger(){
        System.out.println("这里生产水果糖");
    }
}
//工厂类
class SugerFactory{
    public static ISuger getSuger(String type){
        if (type.equals("水果糖")){
            return new FrultCandy();
        }
        else if(type.equals("太妃糖")){
            return new Toffee();
        }
        else if(type.equals("巧克力糖")){
            return new ChocolateCandy();
        }
        else return null;
    }
}

//客户端
public class EasyFactory {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要生产的糖种类");
        String type = scanner.nextLine();
        ISuger suger = SugerFactory.getSuger(type);
        suger.printSuger();
    }
}

优点：简单，把类的实例化工作交给工厂，利于解耦
缺点：增加具体产品需要修改工厂

工厂方法模式

当产品较少时，一个工厂只生成单一产品时，用简单工厂模式较好，但是当产品较多。工厂生产多个产品，而且工厂间生产不同，比如苹果公司就生产手机，电脑，平板等，这些产品合在一处变成产品族。所以一个工厂类不能满足需要。
定义一个用来创建对象的接口，让子类决定实例化哪个工厂。把实例化操作还给客户端。
工厂方法模式组成：
一个抽象产品类
多个具体类
一个抽象工厂
多个具体工厂
举个例子：继续卖糖吧

package www.Factory;
//抽象产品类
interface  ISuger {
    void printSuger();
}
//具体的产品类
class ChocolateCandy implements ISuger{
    public void printSuger(){
        System.out.println("这里生产巧克力糖");
    }
}
class Toffee implements ISuger{
    public void printSuger(){
        System.out.println("这里生产太妃糖");
    }
}
class FrultCandy implements ISuger{
    public void printSuger(){
        System.out.println("这里生产水果糖");
    }
}
//抽象工厂类
interface ISugerFactory{
    ISuger CreatSugerFactory();
}
//具体实现工厂类
class Eclair implements ISugerFactory{
    @Override
    public ISuger CreatSugerFactory() {
        return new Toffee();
    }
}
class Dove implements ISugerFactory{
    @Override
    public ISuger CreatSugerFactory() {
        return new ChocolateCandy();
    }
}

public class FactoryIdea {
    public static void main(String[] args) {
        ISugerFactory sugerFactory = new Dove();
        ISuger suger = sugerFactory.CreatSugerFactory();
        suger.printSuger();
    }
}

优点：有利于横向扩展，也就是说该工厂由有新的产品了，无需修改原先工厂或者产品类或者客户端。
缺点：增加了代码量，如果增加新的产品族需要修改工厂

抽象工厂

如果一个工厂生产多个产品时就由工厂方法模式变成了抽象工厂
提供一个创建一系列相关或相互依赖对象的接口（抽象工厂，多条产品线），
而无需指定他们具体的类
组成：

1. 多个抽象产品类
2. 多个具体产品类
3. 抽象工厂类 - 声明(一组)返回抽象产品的方法
4. 具体工厂类 - 生成(一组)具体产品

对比以上三种模式

1.简单工厂模式最大的优点就是工厂内有具体的逻辑去判断生成什么产品，将类的实例化交给了工厂，这样当我们需要什么产品只需要修改工厂的调用而不需要去修改客户端，对于客户端来说降低了与具体产品的依赖。
2.工厂方法模式是简单工厂的扩展，工厂方法模式把原先简单工厂中的实现那个类的逻辑判断交给了客户端，如果像添加功能只需要修改客户和添加具体的功能，不用去修改之前的类。
3.抽象工厂模式进一步扩展了工厂方法模式，它把原先的工厂方法模式中只能有一个抽象产品不能添加产品族的缺点克服了，抽象工厂模式不仅仅遵循了OCP原则，而且可以添加更多产品(抽象产品),具体工厂也不仅仅可以生成单一产品，而是生成一组产品，抽象工厂也是声明一组产品，对应扩展更加灵活，但是要是扩展族系就会很笨重。