Java开发中的23中设计模式详解（二）创建型模式之工厂模式

设计模式一共有23种，分为三大类

创建型模式：

单例模式，工厂模式，抽象工厂模式，原型模式

结构型模式：

适配器模式，桥接模式，装饰器模式，组合模式，外观模式，享元模式，代理模式

行为型模式：

模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，解释器模式，策略模式，责任链模式，访问者模式

这23种设计模式本质上是对Java面向对象原则实际运用，这23种设计模式更多是为了提高代码的可读性、可复用性、可维护性、稳健性以及安全性。让我们写出的代码更加整洁。

一、创建型模式

1、单例模式

2、工厂模式

工厂模式实现了调用者和创建者的分离，即不会暴露具体的实现逻辑，用工厂方法代替了new。

工厂模式具体分为三类：

• 简单工厂方式
• 工厂方法模式
• 抽象工厂模式

简单工厂模式

以生产一部手机为例

首先需要创建一个接口

public interface Phone {
	void showTime();
}

然后创建接口的实现类

public class NewPhone implements Phone{
	@Override
	public void showTime() {
		System.out.println("NewPhone");
	}
}

public class YoungPhone implements Phone{
	@Override
	public void showTime() {
		System.out.println("YoungPhone");		
	}
}

public class OldPhone implements Phone{
	@Override
	public void showTime() {
		System.out.println("OldPhone");
	}
}

创建一个工厂，生成一个给定信息的实体类的对象

public class PhoneFactory {
	public static Phone getPhone(String name) {
		if(name.equals("") || name==null) {
			return null;
		}
		if(name.equals("new")) {
			return new NewPhone();
		}
		if(name.equals("young")) {
			return new YoungPhone();
		}
		if(name.equals("old")) {
			return new OldPhone();
		}
		return null;
	}
}

然后就可以使用该工厂，根据传递进来的信息返回不同的对象

public class GetPhone {
	public static void main(String[] args) {
		Phone p1=PhoneFactory.getPhone("new");
		p1.showTime();
		Phone p2=PhoneFactory.getPhone("young");
		p2.showTime();
		Phone p3=PhoneFactory.getPhone("old");
		p3.showTime();
	}
}

输出结果：

NewPhone
YoungPhone
OldPhone

简单工厂模式的缺点：无法扩展，如果需要增加新的功能，是需要重写添加代码的。

工厂方法模式

工厂方法模式是对简单工厂模式的改进，在使用简单工厂模式时，如果传递的字符串出错，则无法产生对应的对象，而工厂方法模式中则给每一天实现了接口的方法，都建了对应的工厂，通过调用该工厂即可产生对应的对象
将工厂类的代码改为：

public class PhoneFactory {
	public static Phone getNewPhone() {
		return new NewPhone();
	}
	public static Phone getYoungPhone() {
		return new YoungPhone();
	}
	public static Phone getOldPhone() {
		return new OldPhone();
	}
}

根据想要得到对象，调用工厂的不同方法生产对象

public class GetPhone {
	public static void main(String[] args) {
		Phone p1=PhoneFactory.getNewPhone();
		p1.showTime();
		Phone p2=PhoneFactory.getYoungPhone();
		p2.showTime();
		Phone p3=PhoneFactory.getOldPhone();
		p3.showTime();
	}
}

输出结果为：

NewPhone
YoungPhone
OldPhone

抽象工厂模式

而在使用完工厂方法模式之后，会发现在创建对象时需要区调用工厂类，那么当有新的对象需要被创建时，就需要去改动工厂类，这就未必了闭包原则，所有就需要在不改动已有类的情况下，新增工厂类，当用户需要新增新的对象时，就可以直接创建新的工厂类来获取对象，这就是所谓的抽象工厂模式
首先写一个接口

public interface Phone {
	void showTime();
}

三个实现类

public class NewPhone implements Phone{
	@Override
	public void showTime() {
		System.out.println("NewPhone");
	}
}

public class YoungPhone implements Phone{
	@Override
	public void showTime() {
		System.out.println("YoungPhone");		
	}
}

public class OldPhone implements Phone{
	@Override
	public void showTime() {
		System.out.println("OldPhone");
	}
}

再写一个接口

public interface PhoneFactory {
	Phone getPhone();
}

再写三个实现该接口的实现类

public class NewPhoneFactory implements PhoneFactory{
	@Override
	public Phone getPhone() {
		return new NewPhone();
	}
}

public class YoungPhoneFactory implements  PhoneFactory{
	@Override
	public Phone getPhone() {
		return new YoungPhone();
	}
}

public class OldPhoneFactory implements PhoneFactory{
	@Override
	public Phone getPhone() {
		return new OldPhone();
	}
}

此时就可以根据不同的工厂产生不同的对象

public class GetPhone {
	public static void main(String[] args) {
		PhoneFactory pf1=new NewPhoneFactory();
		Phone p1=pf1.getPhone();
		p1.showTime();
	}
}

输出结果为：

NewPhone

如果此时想再增加一个APhone，只需要创建一个实现Phone接口的类和一个实现PhoneFactory接口的AFactory类，此时就可以不需要修改原有代码，保证了闭包原则。

在平常中使用到工厂模式的地方（列举）

• JDBC中Connection对象的获取
• MyBatis中SessionFactory中Session的创建
• Spring的IOC(控制反转)容器创建管理Bean对象