An explanation of the power of singletons in design patterns in Java

This article mainly introduces the relevant information about the singleton design pattern in java. Here we explain the villain mode and the lazy mode. Friends in need can refer to the list of design patterns in java

Example

Design Pattern Thought

What is Design Pattern: As a beginner, I am learning design pattern formally for the first time today. What do I feel right and understand? Design patterns are very important, so what are design patterns?

Design pattern: an effective idea for solving problems.

Design pattern: a solution used to solve specific recurring problems in a specific environment

My understanding is that predecessors encountered a problem during software design. Such problems, they summarized a set of effective and proven solutions.

Advantages of design patterns:

1. Design patterns are relatively excellent solutions, and many problems are typical and representative. By learning design patterns, we don’t have to solve these problems ourselves from scratch. It is equivalent to reusing these solutions on the shoulders of giants.

2. Design patterns have become a common vocabulary used by professionals, and not understanding them is not conducive to communication.

3. It can make the system you design more professional and give the system a better architecture.

Design Pattern 1~~Single Case

The single-interest design pattern is used to solve the problem that only one class can exist in the memory. The problem. This is more abstract. For example, if you want to play a mahjong game and throw dice, if the first person loses the displayed numbers, the people behind him will also use them. Only one copy of the dice class is allowed in memory. Such problems need to be solved with a single case design solution.

The first type: Hungry Chinese style, first come out by yourself. It's fast but takes up a lot of memory.

public class Single {
  private final static Single s = new Single();

  //类只能有一个故私有化构造方法，不让外面new对象
  private Single(){
  }
//工厂方法的命名规范
 getinstance
//当外面没办法new对象时候，我们对像给外面调要自己来new
// 当没发new 对象时候，必须是静态方法，给外界使用。
    public static Single getInstance(){
    return s;
  }
}

The second type: lazy style

//懒汉式
public class Single2 {
  // 先步开内存，需要用的时候才new 
  private static Single2 s=null;
  private Single2(){
  }
  // synchronized 用来防多线程时。第一个和第二个线程抢资源都会进入s==null,
时new 两次。
  public synchronized static Single2 getInstance(){
    if(s==null){
      s = new Single2();
    }
    return s;
  }
}

synchronized is regarded as a lock and belongs to the getInstance method. When the method is static, the lock belongs to the class template. When the method is called by an object, the lock belongs to the object.

The above is the detailed content of An explanation of the power of singletons in design patterns in Java. For more information, please follow other related articles on the PHP Chinese website!