设计模式学习之工厂模式设计模式学习之工厂模式

设计模式之工厂模式 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(); } }

输出结果