一、定义
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
优点：良好的封装性，代码结构清晰，扩展性强，屏蔽产品类。
二、实现
public class Client {
public static void main(String[] args) {
Factory factory = new ConcreteFactory();
Product product1 = factory.createProduct(ConcreteProduct1.class);
Product product2 = factory.createProduct(ConcreteProduct2.class);
}
}
//抽象产品类
abstract class Product {
//产品类的公共方法
public void method1(){
//业务逻辑处理
}
//抽象方法
public abstract void method2();
}
//具体产品类
class ConcreteProduct1 extends Product {
public void method2() {
//业务逻辑处理
}
}
class ConcreteProduct2 extends Product {
public void method2() {
//业务逻辑处理
}
}
//抽象工厂类
abstract class Factory {
/*
*创建一个产品对象，其输入参数类型可以自行设置
*通常为String、Enum、Class等，当然也可以为空
*/
public abstract <T extends Product> T createProduct(Class<T> c);
}
//具体工厂类
class ConcreteFactory extends Factory {
public <T extends Product> T createProduct(Class<T> c) {
Product product = null;
try {
product = (Product) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
//异常处理
}
return (T) product;
}
}
三、扩展
- 缩小为简单工厂模式
public class Client {
public static void main(String[] args) {
Product product1 = SimpleFactory.createProduct(ConcreteProduct1.class);
Product product2 = SimpleFactory.createProduct(ConcreteProduct2.class);
}
}
//抽象产品类
abstract class Product {
//产品类的公共方法
public void method1(){
//业务逻辑处理
}
//抽象方法
public abstract void method2();
}
//具体产品类
class ConcreteProduct1 extends Product {
public void method2() {
//业务逻辑处理
}
}
class ConcreteProduct2 extends Product {
public void method2() {
//业务逻辑处理
}
}
class SimpleFactory {
public static <T extends Product> T createProduct(Class<T> c) {
//定义一个生产出的产品
Product product = null;
try {
//产生一个产品
product = (Product) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
//异常情况
}
return (T) product;
}
}
- 升级为多个工厂类
public class Client {
public static void main(String[] args) {
Product product1 = new ConcreteFactory1().createProduct();
Product product2 = new ConcreteFactory2().createProduct();
}
}
//抽象产品类
abstract class Product {
//产品类的公共方法
public void method1(){
//业务逻辑处理
}
//抽象方法
public abstract void method2();
}
//具体产品类
class ConcreteProduct1 extends Product {
public void method2() {
//业务逻辑处理
}
}
class ConcreteProduct2 extends Product {
public void method2() {
//业务逻辑处理
}
}
//抽象工厂类
abstract class AbstractFactory {
public abstract Product createHuman();
}
//具体工厂类
class ConcreteFactory1 {
public Product createProduct() {
return new ConcreteProduct1();
}
}
class ConcreteFactory2 {
public Product createProduct() {
return new ConcreteProduct2();
}
}
- 延迟初始化
//tips:一个对象被消费完毕后，并不立刻释放，工厂类保持其初始状态，等待再次被使用。
public class Client {
public static void main(String[] args) {
Product product = ProductFactory.createProduct("Product1");
}
}
//抽象产品类
abstract class Product {
//产品类的公共方法
public void method1(){
//业务逻辑处理
}
//抽象方法
public abstract void method2();
}
//具体产品类
class ConcreteProduct1 extends Product {
public void method2() {
//业务逻辑处理
}
}
class ConcreteProduct2 extends Product {
public void method2() {
//业务逻辑处理
}
}
class ProductFactory {
private static final Map<String, Product> prMap = new HashMap();
public static synchronized Product createProduct(String type){
Product product = null;
//如果Map中已经有这个对象
if (prMap.containsKey(type)) {
product = prMap.get(type);
} else {
if (type.equals("Product1")) {
product = new ConcreteProduct1();
} else {
product = new ConcreteProduct2();
}
//同时把对象放到缓存容器中
prMap.put(type, product);
}
return product;
}
}
- 替代单例模式
public class Client {
public static void main(String[] args) {
Singleton singleton = SingletonFactory.getSingleton();
}
}
class Singleton {
//不允许通过new产生一个对象
private Singleton(){
}
public void doSomething(){
//业务处理
}
}
class SingletonFactory {
private static Singleton singleton;
static{
try {
Class cl= Class.forName(Singleton.class.getName());
//获得无参构造
Constructor constructor=cl.getDeclaredConstructor();
//设置无参构造是可访问的
constructor.setAccessible(true);
//产生一个实例对象
singleton = (Singleton)constructor.newInstance();
} catch (Exception e) {
//异常处理
}
}
public static Singleton getSingleton(){
return singleton;
}
}
