设计模式的工厂模式

设计模式的工厂模式

**简单工厂：**一个工厂类根据传入的参量决定创建出那一种产品类的实例。
**工厂方法：**定义一个创建对象的接口，让子类决定实例化那个类。
**抽象工厂：**创建相关或依赖对象的家族，而无需明确指定具体类。

简单工厂

先将产品类抽象出来，比如，苹果和梨都属于水果，抽象出来一个水果类Fruit，苹果和梨就是具体的产品类，然后创建一个水果工厂，分别用来创建苹果和梨；

水果接口

public interface Fruit {
    public void create();
}

具体类 苹果

public class Apple implements Fruit{
    @Override
    public void create() {

    }
}

具体类 梨

public class Pear implements Fruit{
    @Override
    public void create() {

    }
}

水果工厂

public class FruitFactory {
    public Fruit createFruit(String type) {
        if (type.equals("apple")) {
            return new Apple();
        } else if (type.equals("pear")) {
            return new Pear();
        }
        return null;
    }
}

测试

public class FactoryTest {
    public static void main(String[] args){
        FruitFactory mFactory = new FruitFactory();
        Fruit apple = mFactory.createFruit("apple");
        Fruit pear = mFactory.createFruit("pear");
    }
}

工厂方法

产品类抽象出来，这次我们把工厂类也抽象出来，生产什么样的产品由子类来决定；
延续上例水果接口，苹果、梨类

工厂接口

public interface FruitFactory {
    Fruit createFruit();
}

苹果工厂

public class AppleFactory implements FruitFactory {
    @Override
    public Fruit createFruit() {
        return new Apple();
    }
}

梨工厂

public class PearFactory implements FruitFactory {
    @Override
    public Fruit createFruit() {
        return new Pear();
    }
}

测试

public class FactoryTest {
    public static void main(String[] args){
		AppleFactory appleFactory = new AppleFactory();
		PearFactory pearFactory = new PearFactory();
		Apple apple = appleFactory.createFruit();
		Pear pear = pearFactory.createFruit();
    }
}

抽象工厂

抽象工厂和工厂方法的模式基本一样，区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组相同，有相对关系的产品；重点在于一组，一批，一系列；

水果接口

public interface Fruit {
    public void get();
}

苹果，香蕉抽象类

public abstract class Apple implements Fruit{
    public abstract void get();
}

public abstract class Banana implements Fruit{
    public abstract void get();
}

中国、英国苹果类

public class ChinaApple extends Apple {
    @Override
    public void get() {
        System.out.println("中国的苹果...");
    }
}

public class EnglandApple extends Apple {
    @Override
    public void get() {
        System.out.println("英国的苹果...");
    }
}

抽象工厂

public interface FruitFactory {
    //实例化苹果
    public Fruit getApple();
    //实例化香蕉
    public Fruit getBanana();
}

具体工厂

public class ChinaFactory implements FruitFactory {
    @Override
    public Fruit getApple() {
        return new ChinaApple();
    }
    @Override
    public Fruit getBanana() {
        return new ChinaBanana();
    }
}

public class EnglandFactory implements FruitFactory {

    @Override
    public Fruit getApple() {
        return new EnglandApple();
    }
    
    @Override
    public Fruit getBanana() {
        return new EnglandBanana();
    }
}

测试

public class MainClass {

    public static void main(String[] args){
        //创建中国工厂
        FruitFactory chinaFactory = new ChinaFactory();
        //通过中国工厂生产中国苹果实例
        Fruit apple = chinaFactory.getApple();
        apple.get();
        //通过中国工厂生产中国香蕉实例
        Fruit banana = chinaFactory.getBanana();
        banana.get();        
        
        //创建英国工厂
        FruitFactory englandFactory = new EnglandFactory();
        //通过英国工厂生产英国苹果实例
        Fruit apple1 = englandFactory.getApple();
        apple1.get();
        //通过英国工厂生产英国香蕉实例
        Fruit banana2 = englandFactory.getBanana();
        banana2.get();
    }
}