设计模式花园(三)-工厂模式

工厂模式

创建一个接口和一系列实现该接口的实体类，然后创建一个工厂类，由传入类型判断实例化哪一个实体类。选择的问题。例如：1）日志记录器。选择哪种存储方式：硬盘、远程服务器等。2）数据库访问，选择哪类数据库进行链接。3）设计一个连接服务器的框架，选择哪种协议进行连接。

Design Garden女主人需要一只猫和一只狗，提高花园温馨度，于是我们设计一个宠物工厂，根据女主人需要创造各类宠物。

Pet接口

public interface Pet {
    public void eat();
}

Dog类

public class Dog implements Pet{
    @Override
    public void eat() {
        System.out.println("dog eat bone.");
    }
}

Cat类

public class Cat implements Pet{
    @Override
    public void eat() {
        System.out.println("cat eat fish.");
    }
}

PetFactory类

public class PetFactory {
    public Pet getPet(String petType) {
        if (petType == null) {
            return null;
        }
        else if (petType.equalsIgnoreCase("DOG")) {
            return new Dog();
        }
        else if (petType.equalsIgnoreCase("CAT")) {
            return new Cat();
        }
        return null;
    }
}

测试工厂模式

public class TestFactory {
    public static void main(String[] args) {
        PetFactory petFactory = new PetFactory();
        Pet pet = petFactory.getPet("Dog");
        pet.eat();
    }
}

抽象工程模式

创建一个抽象工厂类和工厂生产类，根据传入字符串类型判断使用哪种工厂对象，然后工厂类传入字符串类型判断创建哪个类。

Design Garden女主人需要一只猫和一只狗和一些小孩子的玩具，提高花园温馨度和欢乐度，于是我们设计一个抽象工厂，根据需要创建宠物工厂和玩具工厂，然后两个工厂可以根据女主人需要创造各类宠物和玩具。

AbstractFactory抽象工程类

public abstract class AbstractFactory {
    public abstract Pet getPet(String petType);
    public abstract Toy getToy(String toyType);
}

FactoryProducer工厂生产类，根据传入字符串决定所创建的工厂类

public class FactoryProducer {
    public static AbstractFactory getFactory(String choice) {
        if (choice.equalsIgnoreCase("PET")) {
            return new PetFactory();
        } else if (choice.equalsIgnoreCase("TOY")) {
            return new ToyFactory();
        }
        return null;
    }
}

PetFactory宠物工厂

public class PetFactory extends AbstractFactory{

    @Override
    public Pet getPet(String petType) {
        if (petType == null) {
            return null;
        }
        if (petType.equalsIgnoreCase("CAT")) {
            return new Cat();
        }
        return null;
    }

    @Override
    public Toy getToy(String toyType) {
        return null;
    }
}

ToyFactory玩具工厂

public class ToyFactory extends AbstractFactory{
    @Override
    public Pet getPet(String petType) {
        return null;
    }

    @Override
    public Toy getToy(String toyType) {
        if (toyType == null) {
            return null;
        }
        if (toyType.equalsIgnoreCase("TANK")) {
            return new Tank();
        }
        return null;
    }
}

宠物接口

public interface Pet {
    public void eat();
}

猫类，实现宠物接口

public class Cat implements Pet{
    @Override
    public void eat() {
        System.out.println("cat eat fish");
    }
}

玩具接口

public interface Toy {
    public void makeSound ();
}

坦克类，实现玩具接口

public class Tank implements Toy{
    @Override
    public void makeSound() {
        System.out.println("shut tong~~");
    }
}

测试抽象工程

public class TestAbstractFactory {
    public static void main(String[] args) {
        AbstractFactory petFactory = FactoryProducer.getFactory("PET");
        Pet cat = petFactory.getPet("CAT");
        cat.eat();

        AbstractFactory toyFactory = FactoryProducer.getFactory("TOY");
        Toy toy = toyFactory.getToy("TANK");
        toy.makeSound();
    }
}