创建型模式--工厂模式

一、三种工厂模式的优缺点

1、简单工厂模式

    最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类。对于客户端来说，去除了与

   具体产品的依赖。

   简单工厂模式违背了开-闭原则，有保持了封装对象创建过程的优点。

 2、  工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子

      类。

   工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类。选择判断的问题还是存在的，也就是说，工厂方

  法把简单工厂的内部逻辑判断移到了客户端代码来进行。

  工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，

   而且克服了它的缺点。但缺点是由于每加一个产品，就需要增加一个产品工厂的类，增加了额外的开发量。

  3、 抽象工厂模式

         好处：易于交换产品系列，由于具体工厂类，在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具

   体工厂变得非常容易，他只需要改变具体工厂即可使用不同的产品配置。

   4、反射：所有在用简单工厂的地方，都可以考虑用反射技术来去除Switch或if,解除分支判断带来的耦合。

 

二、模式实现

   1、工厂方法模式：

public class GongChangFangFaMode {
	public static void main(String[] args) {
		WorkFactory factory1 = new StudentWorkFactory();
		factory1.getWork().doWork();
		WorkFactory factory2 =new TeacherWorkFactory();
		factory2.getWork().doWork();
	}
}

interface Work {
	public void doWork();
}

class StudentWork implements Work {

	@Override
	public void doWork() {
		System.out.println("写作业");
	}

}

class TeacherWork implements Work {

	@Override
	public void doWork() {
		System.out.println("批作业");
	}

}

interface WorkFactory {
	Work getWork();
}

class StudentWorkFactory implements WorkFactory {

	@Override
	public Work getWork() {
		return new StudentWork();
	}

}

class TeacherWorkFactory implements WorkFactory {

	@Override
	public Work getWork() {
		return new TeacherWork();
	}

}

2、抽象方法模式

    

package com.ChuangJianZheMode;

public class ChouXiangFangFaMode {
	/**
	 */
	public static void main(String[] args) {
       AnimalFactory aFactory = new AAnimalFactory();
       Cat cat1 = aFactory.createCat();
       Dog dog1 = aFactory.createDog();
       cat1.eat();
       dog1.speak();
       AnimalFactory bFactory = new BAnimalFactory();
       Cat cat2 = bFactory.createCat();
       Dog dog2 = bFactory.createDog();
       cat2.eat();
       dog2.speak();
       AnimalFactory cFactory = new ABAnimalFactory();
       Cat cat3 = cFactory.createCat();
       Dog dog3 = cFactory.createDog();
       cat3.eat();
       dog3.speak();
	}
}

interface Cat {
	public abstract void eat();
}

interface Dog {
	public abstract void speak();
}

class ACat implements Cat {

	@Override
	public void eat() {
		System.out.println("this is a A cat");
	}

}

class BCat implements Cat {

	@Override
	public void eat() {
		System.out.println("this is a B cat");
	}

}

class ADog implements Dog {

	@Override
	public void speak() {
		System.out.println("this is a A dog");
	}

}

class BDog implements Dog {

	@Override
	public void speak() {
		System.out.println("this is a B dog");
	}

}

interface AnimalFactory {
	Cat createCat();

	Dog createDog();
}

class AAnimalFactory implements AnimalFactory {

	@Override
	public Cat createCat() {
		// TODO Auto-generated method stub
		return new ACat();
	}

	@Override
	public Dog createDog() {
		// TODO Auto-generated method stub
		return new ADog();
	}
}

class BAnimalFactory implements AnimalFactory {

	@Override
	public Cat createCat() {
		// TODO Auto-generated method stub
		return new BCat();
	}

	@Override
	public Dog createDog() {
		// TODO Auto-generated method stub
		return new BDog();
	}
}

class ABAnimalFactory implements AnimalFactory {

	@Override
	public Cat createCat() {
		return new ACat();
	}

	@Override
	public Dog createDog() {
		// TODO Auto-generated method stub
		return new BDog();
	}

}