设计模式之工厂模式
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：以上接口可用抽象类代替
