A brief introduction to the simple factory pattern of java design patterns

The concept of simple factory pattern

is to establish a factory class to create instances of some classes that implement the same interface. The essence of the simple factory pattern is that a factory class dynamically determines which instance of the product class (these product classes inherit from a parent class or interface) should be created based on the incoming parameters.

UML diagram of simple factory pattern

Simple factory pattern code
When I learned the simple factory pattern, I used a human There are relevant examples. Human beings are divided into men and women in the world. First define an abstract interface for Human products

/**
 * This is factory patter package
 */
package com.roc.factory;
 
/**
 * 产品的抽象接口 人类
 * @author liaowp
 *
 */
public interface Human {
  
 public void say();
 
}

Then define men and women, both of whom can speak. method.

/**
 * This is factory patter package
 */
package com.roc.factory;
 
/**
 * man 男人
 * @author liaowp
 *
 */
public class Man implements Human {
 
 /* say method
 * @see com.roc.factory.Human#say()
 */
 @Override
 public void say() {
 System.out.println("男人");
 }
 
}

/**
 * This is factory patter package
 */
package com.roc.factory;
 
/**女人
 * @author liaowp
 *
 */
public class Woman implements Human {
 
 /* say method
 * @see com.roc.factory.Human#say()
 */
 @Override
 public void say() {
 System.out.println("女人");
 }
 
}

Finally write a factory class to create men and women. The first way is to use logical judgment.

package com.roc.factory;
/**
 * 简单工厂
 * @author liaowp
 *
 */
public class SampleFactory {
 public static Human makeHuman(String type){
 if(type.equals("man")){
  Human man = new Man();
  return man;
 }else if(type.equals("womman")){
  Human woman = new Woman();
  return woman;
 }else{
  System.out.println("生产不出来");
  return null;
 } 
 }
}

#The second way is to use Java's radiation. I think this type of implementation is better.

package com.roc.factory;
/**
 * 简单工厂放射实现
 * @author liaowp
 *
 */
public class SampleFactory1 {
 public static Human makeHuman(Class c){
 Human human = null;
 try {
  human = (Human) Class.forName(c.getName()).newInstance();
 } catch (InstantiationException e) {
  // TODO Auto-generated catch block
  System.out.println("不支持抽象类或接口");
  e.printStackTrace();
 } catch (IllegalAccessException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  System.out.println("没有足够权限，即不能访问私有对象");
 } catch (ClassNotFoundException e) {
  // TODO Auto-generated catch block
  System.out.println("类不存在");
  e.printStackTrace();
 }
 return human;
 }
}

The last is the client code

package com.roc.factory;
/**
 * 简单工厂测试
 * @author liaowp
 *
 */
public class Client {
 public static void main(String[] args) {
// Human man = SampleFactory.makeHuman("man");
// man.say();
// Human womman = SampleFactory.makeHuman("womman");
// womman.say();
// Human test = SampleFactory.makeHuman("tttt");
  
 Human man = SampleFactory1.makeHuman(Man.class);
 man.say();
 Human woman = SampleFactory1.makeHuman(Woman.class);
 woman.say();
 }
}

Simple factory mode application scenario

Advantages: The factory class is The key to the entire model. It contains the necessary logical judgment to decide which specific class of objects should be created based on the information given by the outside world. By using the factory class, the outside world can get rid of the embarrassing situation of directly creating specific product objects, and only needs Just be responsible for "consuming" the object. It doesn't matter how these objects are created and organized. Clarifying their respective responsibilities and rights is conducive to the optimization of the entire software architecture.

Disadvantages: Since the factory class concentrates the creation logic of all instances, it violates the principle of high cohesion responsibility allocation and concentrates all creation logic into one factory class; the classes it can create can only It was considered in advance that if a new class needs to be added, the factory class needs to be changed. When the number of specific product categories in the system continues to increase, there may be a need for the factory class to create different instances according to different conditions. This kind of judgment on conditions and judgment on specific product types are intertwined, which makes it difficult to avoid the spread of module functions and is very detrimental to the maintenance and expansion of the system;

The above is the entire content of this article, I hope it will be helpful to everyone The learning is helpful, and I hope everyone will support the PHP Chinese website.

For more articles related to the brief description of the simple factory pattern of java design patterns, please pay attention to the PHP Chinese website!