工厂方法模式

工厂方法模式中有4种角色：
抽象产品（Product）、具体产品（ConcreteProduct）、
构造者（Creator）、具体构造者（ConcreteCreator）

工厂方法模式的优点：
1.使用工厂方法可以让用户的代码和某个特定类的子类的代码解耦。
2.工厂方法使用户不必知道它使用的对象是怎么样被创建的，
只需知道该对象有哪些方法即可。

适合用工厂方法模式的情景：
1.用户需要一个类的子类的实例，但不希望和该类的子类形成耦合。
2.用户需要一个类的子类的实例，但用户不知道到该类有哪些子类可用

例一：

//抽象产品product
public abstract class PenCore {
    //颜色
    public String color;
    //写字
    public abstract void writeWord(String s);
}

//具体产品ConcreteProduct
public class BlackPenCore extends PenCore{
    public BlackPenCore(){
        color = "黑色";
    }

    @Override
    public void writeWord(String s) {
        System.out.println("写出了" +color+ "的字：" +s);
    }
}

//具体产品ConcreteProduct
public class BluePenCore extends PenCore{
    public BluePenCore(){
        color = "蓝色";
    }

    @Override
    public void writeWord(String s) {
        System.out.println("写出了" +color+ "的字：" +s);
    }
}

//具体产品ConcreteProduct
public class RedPenCore extends PenCore{
    public RedPenCore(){
        color = "红色";
    }

    @Override
    public void writeWord(String s) {
        System.out.println("写出了" +color+ "的字：" +s);
    }

}

//构造者Creator
public abstract class PenCoreCreator {
    public abstract PenCore getPencore();
}

//具体构造者 ConcreteCreator
public class RedPenCoreCreator extends PenCoreCreator{
    //得到具体的红色笔芯实例
    @Override
    public PenCore getPencore() {
        return new RedPenCore();
    }

}

//具体构造者 ConcreteCreator
public class BluePenCoreCreator extends PenCoreCreator{
    //得到具体的蓝色笔芯实例   
    @Override
    public PenCore getPencore() {
        return new BluePenCore();
    }

}

//具体构造者 ConcreteCreator
public class BlackPenCoreCreator extends PenCoreCreator{
    //得到具体的黑色笔芯实例
    @Override
    public PenCore getPencore() {
        return new BlackPenCore();
    }
}

//用户应用程序Application.java的圆珠笔（BallPen）使用工厂方法
//得到笔芯

public class BallPen {
    //笔芯
    PenCore core;
    //使用笔芯
    public void usePencore(PenCore core){
        this.core = core;
    }
    //写字
    public void write(String s){
        core.writeWord(s);
    }
}

public class Application {
    public static void main(String[] args) {
           PenCore penCore;             //笔芯
           PenCoreCreator creator;      //笔芯构造者
           BallPen ballPen = new BallPen(); //圆珠笔
           creator = new RedPenCoreCreator();
           penCore = creator.getPencore(); //使用工厂方法返回笔芯
           ballPen.usePencore(penCore); 
           ballPen.write("程序猿是不会有女票的！");

           creator = new BluePenCoreCreator();
           penCore = creator.getPencore();
           ballPen.usePencore(penCore);
           ballPen.write("程序猿还会缺女朋友？？？");

           creator = new BlackPenCoreCreator();
           penCore = creator.getPencore();
           ballPen.usePencore(penCore);
           ballPen.write("旱的旱死，涝的涝死。");

           System.out.println("我可能属于前者！！");
    }
}

例二：

//抽象产品
public abstract class Drug {
    String name;
    String constitute;

    public String getName(){
        return name;
    }
    public String getConstitute(){
        return constitute;
    }
}

//具体产品
public class Paracetamol extends Drug{
    String part1 = "每粒含乙酰氨基酚";
    String part2 = "每粒含咖啡因";
    String part3 = "每粒含人工牛黄";
    String part4 = "每粒含马来酸氯苯";

    public Paracetamol(String name, int [] a){
        this.name = name;
        part1 = part1 + ":" +a[0]+"毫克\n";
        part2 = part2 + ":" +a[1]+"毫克\n";
        part3 = part3 + ":" +a[2]+"毫克\n";
        part4 = part4 + ":" +a[3]+"毫克\n";
        constitute = part1+part2+part3+part4;
    }

}

//具体产品
public class Amorolfine extends Drug{
    String part1 = "每粒含甲硝唑";
    String part2 = "每粒含人工牛黄";

    public Amorolfine(String name, int [] a){
        this.name = name;
        part1 = part1 + ":" +a[0]+"毫克\n";
        part2 = part2 + ":" +a[1]+"毫克\n";
        constitute = part1+part2;       
    }

}

//构造者
public interface DrugCreator {
    public abstract Drug getDrug();
}

//具体构造者
public class ParaDrugCreator implements DrugCreator{

    @Override
    public Drug getDrug() {
        int [] a = {250, 15, 1, 10};
        Drug drug = new Paracetamol("氨加黄敏胶囊", a);
        return drug;
    }

}
//具体构造者
public class AmorDrugCreator implements DrugCreator{

    @Override
    public Drug getDrug() {
        int [] a = {200, 5};
        Drug drug = new Amorolfine("甲硝唑胶囊", a);
        return drug;
    }


}

//Application.java使用了上述的工厂模式中所涉及的抽象产品
//构造者以及具体构造者，即使用构造者为用户提供药品
public class Application {
    public static void main(String[] args) {
        DrugCreator creator = new ParaDrugCreator();
        Drug drug = creator.getDrug();
        System.out.println(drug.getName() + "的成分：");
        System.out.println(drug.getConstitute());

        DrugCreator creator1 = new AmorDrugCreator();
        Drug drug1 = creator1.getDrug();
        System.out.println(drug1.getName() + "的成分：");
        System.out.println(drug1.getConstitute());


    }
}