java工厂方法模式记录日志_Java工厂方法模式

工厂方法模式的意图是：抽象类需要创建一个对象时，让子类决定实例化哪一个类。

使用工厂方法模式可以不用关心构造对象的细节(不对具体产品依赖即解耦)，同时也保证了创建的对象的类对外可扩展，对内不可修改即开闭原则。应用于客户端不了解调用几个类进行实例化、父类考虑使用其子类去指定创建对象、类不清楚它需要建立的对象的类。工厂方法模式包含四个元素：抽象工厂、具体工厂、抽象产品、具体产品。

工厂方法

/**

* 客户端

*/

public class Client {

private static AbstractFactoryI factory;

private static AbstatctProductI product;

public static void main(String[] args) {

factory = new ConcreteFactory();

product = factory.factory();//用工厂方法创建产品对象

product.doSth();

}

}

将客户端放在最前面可以直观的看出，创建一个对象不是new处出来的，其实说白了这就够了。所有创建型的设计模式，只不过是在具体场景要求下不同方式的创建对象(个人短见)。

/**

* 抽象工厂(接口)

*/

public interface AbstractFactoryI {

/**

* 创建产品对象工厂方法

*/

AbstatctProductI factory();

}

/**

* 抽象产品(接口)

*/

public interface AbstatctProductI {

public void doSth();

}

/**

* 具体工厂

*/

public class ConcreteFactory implements AbstractFactoryI{

/**

* 创建具体产品对象工厂方法

*/

@Override

public AbstatctProductI factory() {

return new ConcreteProduct();

}

}

/**

* 具体产品

*/

public class ConcreteProduct implements AbstatctProductI{

/**

* 具体业务

*/

@Override

public void doSth() {

System.out.println("dosth...");

}

}

抽象工厂：与工厂方法不同的是，抽象工厂是一个抽象类。多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

/**

* 客户端

*/

public class Client {

private static AbstractFactoryI factory,factory1;

private static AbstatctProductI product,product1;

public static void main(String[] args) {

factory = new ConcreteFactory();

factory1 = new ConcreteFactory1();

product = factory.getProduct();

product1 = factory1.getProduct();

product.doSth();

product1.doSth();

}

}

/**

* 抽象工厂(抽象类)

*/

public abstract class AbstractFactoryI {

/**

* 创建具体产品对象抽象方法

*/

abstract AbstatctProductI getProduct();

}

/**

* 抽象产品

*/

public interface AbstatctProductI {

public void doSth();

}

/**

* 具体工厂

*/

public class ConcreteFactory extends AbstractFactoryI{

/**

* 创建具体产品对象

*/

@Override

AbstatctProductI getProduct() {

//不同的工厂对应不同的产品，生产不同的产品

return new ConcreteProduct();

}

}

/**

* 具体工厂

*/

public class ConcreteFactory1 extends AbstractFactoryI{

/**

* 创建具体产品对象

*/

@Override

AbstatctProductI getProduct() {

//不同的工厂对应不同的产品，生产不同的产品

return new ConcreteProduct1();

}

}

/**

* 具体产品

*/

public class ConcreteProduct implements AbstatctProductI{

/**

* 具体业务

*/

@Override

public void doSth() {

System.out.println("dosth...");

}

}

/**

* 具体产品

*/

public class ConcreteProduct1 implements AbstatctProductI{

/**

* 具体业务

*/

@Override

public void doSth() {

System.out.println("dosth1...");

}

}

简单工厂方法的抽象工厂是具体类(不是接口和抽象类)，就是不抽象了，自然不符合开闭原则，耦合性也高。

代码运行一下，自然理解。理论是建立在实践的基础之上。

代码示例：https://yunpan.cn/cSeLzVtdmFe8p (提取码：fb57)