设计模式之工厂模式（总结）

工厂模式其主要作用就是用于对象的实例化操作，负责同一个接口的多个类的实例化工作

工厂方法主要有以下四种形式

1，基本工厂模

2，多个工厂模式

3，静态工厂模式

4，抽象工厂模式

具体实列如下：

public interface Animal
{
    public int sale();
}

public class Pig implements Animal
{
    // 价格
    private int price = 10;
    // 重量
    private int weight = 200;

    @Override
    public int sale()
    {
        // 收入 = 价格 * 重量
        return price * weight;
    }
}

public class Chicken implements Animal
{
    private int price = 5;
    private int weight = 5;
    private int egg = 20;

    @Override
    public int sale()
    {
        return price * weight + egg;
    }
}

public class Sheep implements Animal
{
    // 价格
    private int price = 10;
    // 重量
    private int weight = 100;

    private int wool = 50;  // 羊毛

    @Override
    public int sale()
    {
        // 收入 = 价格 * 重量
        return price * weight + wool;
    }
}

1，基本工厂模式

基本工厂类：

public class Farm1
{
    public Animal produce(String type)
    {
        if ("Pig".equals(type))
        {
            return new Pig();
        }
        if ("Chicken".equals(type))
        {
            return new Chicken();
        }
        if ("Sheep".equals(type))
        {
            return new Sheep();
        }
        else
        {
            return new Pig();
        }
    }
}

测试类

public class FarmTest1
{
    public static void test(int pigCount, int chickenCount, int sheepCount)
    {
        Farm1 farm = new Farm1();
        Animal pig = farm.produce("Pig");
        Animal chicken = farm.produce("Chicken");
        Animal sheep = farm.produce("Sheep");

        int saleForPig = pig.sale() * pigCount;
        int saleForChicken = chicken.sale() * chickenCount;
        int saleForSheep = sheep.sale() * sheepCount;
        System.out.println("养猪的收入为：" + saleForPig);
        System.out.println("养鸡的收入为：" + saleForChicken);
        System.out.println("养羊的收入为：" + saleForSheep);

        int allSale = saleForPig + saleForChicken + saleForSheep;
        System.out.println("总收入为：" + allSale);

    }

    public static void main(String[] args)
    {
        test(10, 19, 20);
    }
}

2，多个工厂模式

工厂类：

public class Farm2
{
    public Animal producePig()
    {
        return new Pig();
    }

    public Animal produceChicken()
    {
        return new Chicken();
    }

    public Animal produceSheep()
    {
        return new Sheep();
    }
}

测试类：

public class FarmTest2
{
    public static void test(int pigCount, int chickenCount, int sheepCount)
    {
        Farm2 farm = new Farm2();
        Animal pig = farm.producePig();
        Animal chicken = farm.produceChicken();
        Animal sheep = farm.produceSheep();

        int saleForPig = pig.sale() * pigCount;
        int saleForChicken = chicken.sale() * chickenCount;
        int saleForSheep = sheep.sale() * sheepCount;
        System.out.println("养猪的收入为：" + saleForPig);
        System.out.println("养鸡的收入为：" + saleForChicken);
        System.out.println("养羊的收入为：" + saleForSheep);

        int allSale = saleForPig + saleForChicken + saleForSheep;
        System.out.println("总收入为：" + allSale);

    }

    public static void main(String[] args)
    {
        test(10, 19, 20);
    }
}

3，静态工厂模式

工厂类：

public class Farm3
{
    public static Animal producePig()
    {
        return new Pig();
    }

    public static Animal produceChicken()
    {
        return new Chicken();
    }

    public static Animal produceSheep()
    {
        return new Sheep();
    }
}

测试类：

public class FarmTest3
{
    public static void test(int pigCount, int chickCount, int sheepCount)
    {
        Animal pig = Farm3.producePig();
        Animal chicken = Farm3.produceChicken();
        Animal sheep = Farm3.produceSheep();

        int saleForPig = pig.sale() * pigCount;
        int saleForChicken = chicken.sale() * chickCount;
        int saleForSheep = sheep.sale() * sheepCount;
        System.out.println("养猪的收入为：" + saleForPig);
        System.out.println("养鸡的收入为：" + saleForChicken);
        System.out.println("养羊的收入为：" + saleForSheep);

        int allSale = saleForPig + saleForChicken + saleForSheep;
        System.out.println("总收入为：" + allSale);

    }

    public static void main(String[] args)
    {
        test(10, 19, 20);
    }
}

4，抽象工厂：

抽象工厂是将工厂类抽象化，然后对每个实列实现具体的实例工厂，方便后续增加新的实列工厂进行扩展

工厂类接口：

public interface Farm
{
    Animal produce();
}

工厂类实现

public class FarmPig implements Farm
{
    @Override
    public Animal produce()
    {
        return new Pig();
    }
}

public class FarmChicken implements Farm
{
    @Override
    public Animal produce()
    {
        return new Chicken();
    }
}

public class FarmSheep implements Farm
{
    @Override
    public Animal produce()
    {
        return new Sheep();
    }
}

测试类：

public class FarmTest
{
    public static void test(int pigCount, int sheepCount, int chickenCount)
    {
        Farm farmPig = new FarmPig();
        Farm farmChicken = new FarmChicken();
        Farm farmSheep = new FarmSheep();

        Animal pig = farmPig.produce();
        Animal chicken = farmChicken.produce();
        Animal sheep = farmSheep.produce();

        int pigSale = pig.sale() * pigCount;
        int sheepSale = sheep.sale() * sheepCount;
        int chickSale = chicken.sale() * chickenCount;

        System.out.println("养猪收入为：" + pigSale);
        System.out.println("养羊收入为：" + sheepSale);
        System.out.println("养鸡收入为：" + chickSale);

        System.out.println("总收入为：" + (sheepSale + pigSale + chickSale));
    }

    public static void main(String[] args)
    {
        test(10, 20, 30);
    }
}