设计模式学习之工厂模式

设计模式之工厂模式

1 简单工厂

简单工厂严格来说不属于23种设计模式的一种，其只是将创建对象的过程封装到了方法之中

下面是简单工厂的具体实例

创建一个Animal接口，定义一个公共方法

public interface IAnimal {
    void eat();
}

创建Animal的实现类

Bird.class

public class Bird implements IAnimal{
    @Override
    public void eat(){
        System.out.println("bird eating...");
    }
}

Cat.class

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

创建工厂类AnimalFactory

public class AnimalFactory {
    public static IAnimal instance(Class clazz){
        if(clazz == null) return null;
        return instance(clazz.getName());
    }
    private static IAnimal instance(String name){
        if(name == null || "".equals(name)) return null;
        try {
            return (IAnimal)Class.forName(name).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

测试案例

public class Main {
    public static void main(String[] args) {
        IAnimal animal = AnimalFactory.instance(Cat.class);
        animal.eat();
    }
}

输出结果

cat eating...

2 工厂方法

当我们需要在创建对象的前后执行一些不同的业务逻辑，以上代码就需要做出很大的变动。

工厂方法模式针对每一个对象都创建对应的工厂，每个对象的创建工厂是相互独立的

创建公共工厂AnimalFactory

public interface IAnimalFactory {
    IAnimal instance();
}

创建对象工厂实现

BirdFactory.class

public class BirdFactory implements IAnimalFactory{
    @Override
    public IAnimal instance() {
        return new Bird();
    }
}

CatFactory.class

public class CatFactory implements IAnimalFactory{
    @Override
    public IAnimal instance() {
        return new Cat();
    }
}

如上可以在对应的instance方法中加入相应的处理逻辑

测试案例

public class Main {
    public static void main(String[] args) {
        IAnimalFactory animalFactory = new BirdFactory();
        IAnimal animal = animalFactory.instance();
        animal.eat();
    }
}

输出结果

bird eating...

3 抽象工厂

每添加一个产品，工厂方法模式都要创建一个工厂，久而久之类会非常之多。

工厂方法模式也不能构建有具体行为的产品

抽象工厂的理念是抽象，将工厂进行加工，最终生成有具体行为的产品

创建行为

public interface ICreate {}
public interface IDead {}
public interface ILive {}

创建有具体行为的产品

bird

public class BirdCreate implements ICreate{
    public BirdCreate(){
        System.out.println("bird create...");
    }
}

public class BirdDead implements IDead{
    public BirdDead(){
        System.out.println("bird dead...");
    }
}

public class BirdLive implements ILive{
    public BirdLive(){
        System.out.println("bird live...");
    }
}

cat

public class CatCreate implements ICreate{
    public CatCreate(){
        System.out.println("cat create...");
    }
}

public class CatDead implements IDead{
    public CatDead(){
        System.out.println("cat dead...");
    }
}

public class CatLive implements ILive{
    public CatLive(){
        System.out.println("cat live...");
    }
}

创建工厂

public interface IAnimalFactory {
    //创建新生动物
    ICreate create();
    //创建活物
    ILive live();
    //创建死物
    IDead dead();
}

最后实现具体的产品工厂

BirdFactory

public class BirdFactory implements IAnimalFactory {
    @Override
    public ICreate create() {
        return new BirdCreate();
    }
    @Override
    public ILive live() {
        return new BirdLive();
    }
    @Override
    public IDead dead() {
        return new BirdDead();
    }
}

CatFactory

public class CatFactory implements IAnimalFactory {
    @Override
    public ICreate create() {
        return new CatCreate();
    }
    @Override
    public ILive live() {
        return new CatLive();
    }
    @Override
    public IDead dead() {
        return new CatDead();
    }
}

测试案例

public class Main {
    public static void main(String[] args) {
        IAnimalFactory animalFactory = new CatFactory();
        animalFactory.create();
        animalFactory.live();
        animalFactory.dead();
    }
}

输出结果

cat create...
cat live...
cat dead...

抽象工厂模式不符合开闭原则，当增加行为时，所有的具体实现都需要增加相应的行为

ps：以上接口可用抽象类代替