设计模式：简单工厂、工厂方法、抽象工厂

一.简单工厂
简单工厂其实不能算是一种设计模式，在某种程序上来说它更像是一种编程习惯。
简单工厂的常见做法是封装创建对象的代码，通过工厂类静态调用返回创建的对象

那简单工厂有什么优缺点呢
优点：不需要通过创建对象的方法来实例化对象
缺点：不能通过继承来改变创建方法，不修改代码的话，是无法扩展的

大致类图如下：

大致的代码如下 :

/**
 * Created by pcf
 * 书本类
 */
public abstract class Book {

    public static final String ENGLISH_BOOK = "ENGLISH_BOOK";
    public static final String CHINESE_BOOK = "CHINESE_BOOK";

    private int price;

    public String type;

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public abstract String getType();

}

/**
 * Created by pcf
 * 中文书类
 */
public class ChineseBook extends Book {

    @Override
    public String getType() {
        return Book.CHINESE_BOOK;
    }
}

/**
 * Created by pcf
 * 英文书类
 */
public class EnglishBook extends Book {

    @Override
    public String getType() {
        return Book.ENGLISH_BOOK;
    }
}

/**
 * Created by pcf
 * 简单书本工厂类
 */
public class SimpleBookFactory {

    public static Book createBook(String type) {
        switch (type) {
            case Book.CHINESE_BOOK:
                return new ChineseBook();
            case Book.ENGLISH_BOOK:
                return new EnglishBook();
        }
        return null;
    }
}

/**
 * Created by pcf
 * 书店类
 */
public class BookShop {

    public List<Book> bookList = new ArrayList<>();

    public void orderBook(){
        bookList.add(SimpleBookFactory.createBook(Book.CHINESE_BOOK));
        bookList.add(SimpleBookFactory.createBook(Book.ENGLISH_BOOK));
    }
}

二.工厂方法
工厂方法模式定义了一个创建对你的接口，但由子类决定要实例化的类是哪一个。
工厂方法让类的实例化推迟到子类。
工厂方法用来处理对象的创建，并由子类去实现工厂方法。
这样程序中关于超类的代码就和子类对象创建的代码解耦了。
工厂方法比简单工厂更具有弹性。

大致类图如下：

大致代码如下：
上面有的类，并且代码没有更新的 就不再列出

/**
 * Created by pcf
 * 书本类
 * 新增了几种书
 */
public abstract class Book {

    public static final String ENGLISH_BOOK = "ENGLISH_BOOK";
    public static final String CHINESE_BOOK = "CHINESE_BOOK";
    public static final String CHILDREN_BOOK = "CHILDREN_BOOK";
    public static final String LITERATURE_BOOK = "LITERATURE_BOOK";
    public static final String REFERENCE_BOOK = "REFERENCE_BOOK";

    private int price;

    public String type;

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public abstract String getType();

}

/**
 * Created by pcf
 * 文学书本类
 */
public class LiteratureBook extends Book {
    @Override
    public String getType() {
        return Book.LITERATURE_BOOK;
    }
}

/**
 * Created by pcf
 * 儿童书本类
 */
public class ChildrenBook extends Book {

    @Override
    public String getType() {
        return Book.CHILDREN_BOOK;
    }
}

/**
 * Created by pcf
 * 工具书本类
 */
public class ReferenceBook extends Book {
    @Override
    public String getType() {
        return Book.REFERENCE_BOOK;
    }
}

/**
 * Created by pcf
 * 工厂方法
 * 书店类
 */
public abstract class BookShop {

    public List<Book> bookList = new ArrayList<>();

    public abstract void orderBook();
}

/**
 * Created by pcf
 * 高山书店类
 * 自行创建自己需要的类
 * 不再依赖书店类
 */
public class HighMountainBookShop extends BookShop {

    @Override
    public void orderBook() {
        bookList.add(new ChildrenBook());
        bookList.add(new LiteratureBook());
        bookList.add(new ReferenceBook());
        bookList.add(new EnglishBook());
    }
}

/**
 * Created by pcf
 * 西海岸书店类
 * 自行创建自己需要的类
 * 不再依赖书店类
 */
public class WestCoastBookShop extends BookShop {

    @Override
    public void orderBook() {
        bookList.add(new ChildrenBook());
        bookList.add(new LiteratureBook());
        bookList.add(new ReferenceBook());
        bookList.add(new ChineseBook());
    }
}

三.抽象工厂
抽象工厂提供一个接口。
用于创建相关的对象或有依赖关系的对象，而不需要明确指定具体类。
用于创建产品族和集合相关产品。

大致类图如下：

大致代码如下：

/**
 * Created by pcf
 * 抽象工厂
 * 背包类
 */
public interface Backpack {
    String description();
}

/**
 * Created by pcf
 * 抽象工厂
 * 学生背包类
 */
public class StudentBackpack implements Backpack{
    public String description(){
        return "I am StudentBackpack";
    }
}

/**
 * Created by pcf
 * 抽象工厂
 * 办公背包类
 */
public class OfficeBackpack implements Backpack{
    public String description(){
        return "I am OfficeBackpack";
    }
}

/**
 * Created by pcf
 * 抽象工厂
 * 文件夹类
 */
public interface Folder {
    String description();
}

/**
 * Created by pcf
 * 抽象工厂
 * 学生文件夹类
 */
public class StudentFolder implements Folder {
    public String description(){
        return "I am StudentFolder";
    }
}

/**
 * Created by pcf
 * 抽象工厂
 * 办公文件夹类
 */
public class OfficeFolder implements Folder {
    public String description(){
        return "I am OfficeFolder  ";
    }
}

/**
 * Created by pcf
 * 抽象工厂
 * 笔类
 */
public interface Pen {
    String description();
}

/**
 * Created by pcf
 * 抽象工厂
 * 铅笔类
 */
public class Pencil implements Pen {
    public String description(){
        return "I am Pencil";
    }
}

/**
 * Created by pcf
 * 抽象工厂
 * 钢笔类
 */
public class FountainPen implements Pen {
    public String description(){
        return "I am FountainPen";
    }
}

/**
 * Created by pcf
 * 抽象工厂
 * 书店工厂类
 */
public interface BookShopFactory {

    List<Book> createBook();

    Pen createPen();

    Backpack createBackpack();

    Folder createFolder();

}

/**
 * Created by pcf
 * 抽象工厂
 * 书店类
 */
public abstract class BookShop {

    public BookShopFactory bookShopFactory;

    BookShop(BookShopFactory bookShopFactory) {
        this.bookShopFactory = bookShopFactory;
    }

    public abstract void prepare();

}

/**
 * Created by pcf
 * 抽象工厂
 * 办公书店类
 */
public class OfficeBookShop extends BookShop {

    OfficeBookShop(BookShopFactory bookShopFactory) {
        super(bookShopFactory);
    }

    @Override
    public void prepare() {
        bookShopFactory.createBackpack();
        bookShopFactory.createBook();
        bookShopFactory.createFolder();
        bookShopFactory.createPen();
    }
}

/**
 * Created by pcf
 * 抽象工厂
 * 学生书店类
 */
public class StudentBookShop extends BookShop {

    StudentBookShop(BookShopFactory bookShopFactory) {
        super(bookShopFactory);
    }

    @Override
    public void prepare() {
        bookShopFactory.createBackpack();
        bookShopFactory.createBook();
        bookShopFactory.createFolder();
        bookShopFactory.createPen();
    }
}

/**
 * Created by pcf
 * 抽象工厂
 * 办公书店工厂类
 */
public class OfficeBookShopFactory implements BookShopFactory {

    @Override
    public List<Book> createBook() {
        ArrayList<Book> bookList = new ArrayList<>();
        bookList.add(new LiteratureBook());
        bookList.add(new ReferenceBook());
        bookList.add(new EnglishBook());
        bookList.add(new ChineseBook());
        return bookList;
    }

    @Override
    public Pen createPen() {
        return new FountainPen();
    }

    @Override
    public Backpack createBackpack() {
        return new OfficeBackpack();
    }

    @Override
    public Folder createFolder() {
        return new OfficeFolder();
    }
}

/**
 * Created by pcf
 * 抽象工厂
 * 学生书店工厂类
 */
public class StudentBookShopFactory implements BookShopFactory {

    @Override
    public List<Book> createBook() {
        ArrayList<Book> bookList = new ArrayList<>();
        bookList.add(new LiteratureBook());
        bookList.add(new ReferenceBook());
        bookList.add(new EnglishBook());
        bookList.add(new ChineseBook());
        bookList.add(new ChildrenBook());
        return bookList;
    }

    @Override
    public Pen createPen() {
        return new Pencil();
    }

    @Override
    public Backpack createBackpack() {
        return new StudentBackpack();
    }

    @Override
    public Folder createFolder() {
        return new StudentFolder();
    }
}