简单工厂 工厂方法 抽象工厂

一、简单工厂

简单工厂通过传入的标识来生成对应的子类。

比如创建动物需要有动物父类，各个子类以及动物工厂。

public interface Animal{
	public void create();
}

 狗：

public class Dog implements Animal{
	@Override
	public void create(){
		System.out.println("一条小狗");
	}
}

 鸟：

public class Bird implements Animal{
	@Override
	public void create(){
		System.out.println("一只小鸟");
	}
}

工厂类：

public class AnimalFactory{
	public static Animal createAnimal(String type) throws Exception{
		if (type.equalsIgnoreCase("小鸟")){
			return new Bird ();
		}else if (type.equalsIgnoreCase("小狗")){
			return new Dog();
		}else{
			throw new Exception("对不起，暂时无法创造该动物。");
		}
	}
}

优点： 我们可以对创建的对象进行一些“加工”，且客户端无需知道其过程，拿来即用；

缺点：每次增加动物都需要对简单工厂类进行修改违反了开闭原则，频繁修改会导致工厂类很庞大、耦合性高。

二、工厂方法

用来生产同一等级结构事物，支持增加多种不同的鸟。

例如创建不同种类的鸟

public interface Bird{
		void createBird();
	}

麻雀：

public class Sparrow implements Bird{
	@Override
	public void createBird(){
		System.out.println("我是一只麻雀");
	}
}

燕子：

public class swallow implements Bird{
	@Override
	public void createSwallow(){
		System.out.println("我是一只燕子");
	}
}

鸟类工厂：

public interface BirdFactory{
	Bird createBird();
}

麻雀工厂：

public class SparrowFactory implements BirdFactory{
	@Override
	public Sparrow createBird(){
		return new Sparrow();
	}
}

燕子工厂：

public class SwallowFactory implements BirdFactory{
	@Override
	public Swallow createBird(){
		return new Swallow();
	}
}

 生产麻雀、燕子：

	public static void main(String[] args){
		Sparrow sparrow = new SparrowFactory().createBird();
		Swallow swallow = new SwallowFactory().createBird();
	}

优点：当新增鸟类时，无需改变原来的类，只需新增个鸟类工厂即可，实现解耦，满足开闭原则。
缺点：当种类非常多，不同的鸟又有很多的自己的特点，这种模式就满足不了需求。

三、抽象工厂

抽象工厂模式提供了创建一系列相关或者相互依赖对象的接口，无需指定他们具体的类。

鸟类工厂：

public interface Bird{
	public void fly();
}

南方鸟类：

public SouthBird  implements Bird{
	@Override
	public void fly(){
       System.out.println("会飞的南方鸟");
    }
}

北方鸟类：

public NorthBird  implements Bird{
	@Override
	public void fly(){
        System.out.println("会飞的北方鸟"); 
    }   
}

老虎工厂：

public interface Tiger{
	public void run();
}

华南虎：

public SouthTiger  implements Tiger{
    @Override
    public void run(){
        System.out.println("奔跑的华南虎");
    }
}

东北虎：

public NorthBirdTiger  implements Tiger{
    @Override
    public void run(){
	    System.out.println("奔跑的东北虎");
	}
}

动物工厂：

public interface AnimalFactory{
	Bird createBird();
	Tiger createTiger();
}

南方动物工厂：

public interface SouthAnimalFactory implements AnimalFactory{
	@Override
	public void createBird(){
		return new SouthBird();
	}
	@Override
	public void createTiger{
		return new SouthTiger();
	}
}

北方动物工厂：

public interface NorthAnimalFactory implements AnimalFactory{
	@Override
	public void createBird(){
		return new NorthBird();
	}
	@Override
	public void createTiger{
		return new NorthTiger();
	}
}

客户端：

public staic void main(String[] args){
		/** 南方动物 **/
		SouthAnimalFactory southAnimalFactory = new SouthAnimalFactory();
		SouthBird southBird =southAnimalFactory.createBird();
		southBird.fly(); //"会飞的南方鸟"

		SouthTiger southTiger =	southAnimalFactory.createTiger();
		southTiger.run();//奔跑的华南虎

		/** 北方动物 **/
		NorthAnimalFactory northAnimalFactory = new NorthAnimalFactory();
		NorthBird northBird = northAnimalFactory.createBird();
		northBird.fly();//"会飞的北方鸟"
}

优点：动物在应用层的代码隔离，无需关系创建的细节，不同地区动物统一创建，实现高内聚，低耦合
缺点：规定所有可能被创建的动物集合，扩展新的动物种类困难，增加了系统的抽象性和复杂程度