Factory Method Pattern

The factory method pattern is divided into three types:

1. Ordinary factory mode is to establish a factory class to create instances of some classes that implement the same interface. First, look at the relationship diagram:

The example is as follows: (We give an example of sending emails and text messages)

First, create a common interface between the two:

public interface Sender {  
    public void Send();  
}

Secondly, Create the implementation class:

public class MailSender implements Sender {  
    @Override  
    public void Send() {  
        System.out.println("this is mailsender!");  
    }  
}

public class SmsSender implements Sender {  
  
    @Override  
    public void Send() {  
        System.out.println("this is sms sender!");  
    }  
}

Finally, build the factory class:

public class SendFactory {  
  
    public Sender produce(String type) {  
        if ("mail".equals(type)) {  
            return new MailSender();  
        } else if ("sms".equals(type)) {  
            return new SmsSender();  
        } else {  
            System.out.println("請(qǐng)輸入正確的類型!");  
            return null;  
        }  
    }  
}

Let’s test it:

public class FactoryTest {  
  
    public static void main(String[] args) {  
        SendFactory factory = new SendFactory();  
        Sender sender = factory.produce("sms");  
        sender.Send();  
    }  
}

Output:

this is sms sender!

2. Multiple factories The method pattern is an improvement over the ordinary factory method pattern. In the ordinary factory method pattern, if the passed string is wrong, the object cannot be created correctly, while the multiple factory method pattern provides multiple factory methods to create objects separately. Relationship diagram:

Modify the above code and change the SendFactory class, as follows:

public class SendFactory {  
   public Sender produceMail(){  
        return new MailSender();  
    }  
      
    public Sender produceSms(){  
        return new SmsSender();  
    }  
}

The test class is as follows:

public class FactoryTest {  
  
    public static void main(String[] args) {  
        SendFactory factory = new SendFactory();  
        Sender sender = factory.produceMail();  
        sender.Send();  
    }  
}

Output:

this is mailsender!

3. Static factory method mode. Make the methods in the multiple factory method modes above static. There is no need to create an instance, just call them directly.

public class SendFactory {  
      
    public static Sender produceMail(){  
        return new MailSender();  
    }  
      
    public static Sender produceSms(){  
        return new SmsSender();  
    }  
}

public class FactoryTest {  
  
    public static void main(String[] args) {      
        Sender sender = SendFactory.produceMail();  
        sender.Send();  
    }  
}

Output:

this is mailsender!

Generally speaking, the factory pattern is suitable: whenever there are a large number of products that need to be created and have a common interface, they can be created through the factory method pattern. Among the above three modes, the first mode cannot create the object correctly if the incoming string is wrong. The third mode does not need to instantiate the factory class compared to the second mode. Therefore, in most cases, we will Choose the third one - static factory method pattern.

4. Abstract Factory Pattern

One problem with the factory method pattern is that the creation of classes depends on the factory class. That is to say, if you want to expand the program, you must modify the factory class. Making modifications violates the closure principle. Therefore, from a design perspective, there are certain problems. How to solve them? Just use the abstract factory pattern and create multiple factory classes. Once you need to add new functions, you can just add new factory classes directly without modifying the previous code. Because the abstract factory is not easy to understand, it will be easier to understand if we look at the diagram first and then the code.

Please see the example:

public interface Sender {  
    public void Send();  
}

Two implementation classes:

public class MailSender implements Sender {  
    @Override  
    public void Send() {  
        System.out.println("this is mailsender!");  
    }  
}

public class SmsSender implements Sender {  
  
    @Override  
    public void Send() {  
        System.out.println("this is sms sender!");  
    }  
}

Two factory classes:

public class SendMailFactory implements Provider {  
      
    @Override  
    public Sender produce(){  
        return new MailSender();  
    }  
}

public class SendSmsFactory implements Provider{  
  
    @Override  
    public Sender produce() {  
        return new SmsSender();  
    }  
}

Providing an interface:

public interface Provider {  
    public Sender produce();  
}

Test class:

public class Test {  
  
    public static void main(String[] args) {  
        Provider provider = new SendMailFactory();  
        Sender sender = provider.produce();  
        sender.Send();  
    }  
}

In fact, the advantage of this model is that if you want to add a function: sending real-time information, you only need to make an implementation class, implement the Sender interface, and make a factory class at the same time. It's OK to implement the Provider interface, and there is no need to change the existing code. In this way, the scalability is better!

php Chinese website, a large number of free Java introductory tutorials, welcome to learn online!

The above is the detailed content of What is factory pattern in java. For more information, please follow other related articles on the PHP Chinese website!