二十三种设计模式——工厂模式

前页：二十三种设计模式总说

---

工厂模式（Factory Pattern）：创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

每次看定义的时候都是一头雾水，实际上就是类似于函数的重载而已。

通过菜鸟教程，总结出使用工厂模式的几种方法：

1. 实现接口。

C++中没有接口这个概念，C++中接口的实现是通过抽象类完成的。如果不知道什么是抽象类，请看：抽象类与纯虚函数。

而java则不同，java有接口的概念，比如我们在实现多线程的时候，有两种方法，其中一种就是实现Runnable接口，从而实现线程的开启。

class TestClass implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
			
	}
		
}

可以看到，我们在实现Runnable接口的同时，编译器会让我们重写run方法，这就是工厂模式的体现。我们写出不同的类，想要开启不同的线程，就需要不断的实现Runnable接口。然后在剩下的类中再去决定使用哪一个线程（类）。

      2. 继承类。

继承类有两种方式：一种是继承抽象类，如同实现接口一般；再一种是单纯的父类。父类一般定义重载函数实现该功能。

public abstract class GetInfo{
    public abstract String getName();
    public abstract int getAge();
    public abstract String getType();
    @Override
    public String toString(){ //对toString方法进行重写，得到想要的信息
    	return "name: "+this.getName()+"; age: "+this.getAge()+"; type: "+getType();
    }
}

 public class Animal extends GetInfo{
        private String name;
        private int age;
        private String type;
        public Animal(String name, int age, String type){
            this.name = name;
            this.age = age;
            this.type = type;
        }
		@Override
		public String getName() {
			return this.name;
		}
		@Override
		public int getAge() {
			return this.age;
		}
		@Override
		public String getType() {
			return this.type;
		}
    }

public class Plants extends GetInfo{
    	private String name;
        private int age;
        private String type;
        public Plants(String name, int age, String type) {
			this.name = name;
			this.age = age;
			this.type = type;
		}
		@Override
		public String getName() {
			return this.name;
		}
		@Override
		public int getAge() {
			return this.age;
		}
		@Override
		public String getType() {
			return this.type;
		}
    }

public class FactoryClass {  //工厂类，通过判断进行区分调用的类
	public static GetInfo getInfo(String name, int age, String type){
		if (type.equals("animal")) {
			return new Animal(name, age, type); 
		}
		else {
			return new Plants(name, age, type);
		}
	}
}

public class Test{  //主方法
	public static void main(String[] args){
		System.out.println(FactoryClass.getInfo("DOG", 3, "animal"));
		System.out.println(FactoryClass.getInfo("Zhuzi", 9, "plant"));
	}
}

可以看到，我们通过集成了父类，从而达到了在工厂类（FactoryClass）调用不同的类的目的。

这只是我们自己设计的内容，而实际情况中，往往GetInfo，Animal，Plants，工厂类类都是JDK中设计好的（比如迭代器Iterator()），我们只要写主方法调用就可以了。

---

总结一下工厂模式

• 优点：

1. 一个调用者想创建一个对象，只要知道其名称就可以了。
2. 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3. 屏蔽产品的具体实现，调用者只关心产品的接口。 

• 缺点

1. 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。