hungry buzzard

The singleton pattern, as the name implies, is to ensure that a class is allowed only one instance in the program. This class can create a unique instance of itself and only provide this unique instance to the system. We usually say that there are five types of singleton patterns: a Hungry man, lazy, double lock, Static inner class, enumeration type. Among them, the A hungry man and the lazy type are the mo

main ways, namely lazy mode and a hungry man mode, they have different time and efficiency of instantiation.1. Lazy mode/** * Created by Jesse on 15-6-28. */public class Singleton { private static Singleton instance; Private Singleton () {}//must have a proprietary structure, or talk about a singleton public static Singleton getinstance () { if (null = = instance) { Instance = new Singleton (); } return instan

GitHub Address: objects and classes in Https://github.com/lily1010/java_learn/tree/master/dogjavaAll things in Java are objects, such as animals, cats, dogs, fish and so on, they can run, can breathe, in short, they have some common characteristics of animals, Java can be categorized as a category. This is the class in java, and a cat, a dog, is a specific object in this class.The cat, the dog has some action behavior, is the Method.When you want to invoke those action actions, you cannot call t

Before you understand the singleton pattern, understand what a pattern is.The so-called pattern refers to the specific fixed steps to solve a class of problems.Singleton mode: a step that guarantees that a class has only one object in memory.Types of Singleton patterns:1, a hungry man single case mode.2, lazy single case mode.3, the registration of single-case mode. (Can ignore, want to know can self-check)Understanding: First it uses less, in fact, t

methods, it is more likely to encounter special problems when dealing with constructor methods than writing common methods: If the constructor of a class is overwritten, you need to call the constructor of the super class. Otherwise, the object may not be correctly initialized. Parent class: >>> Class Bird: Def _ init _ (self ): Self. hungry = True Def eat (self ): If self. hungry: Print "Aaaaah" Self.

Transferred from: http://blog.csdn.net/jason0539/article/details/23297037In Java, the singleton pattern is a common design pattern, the single-case pattern has a variety of ways, here are mainly only: lazy type single case, a hungry man type single case　　Singleton mode ensures that a class has only one instance, and instantiates itself and provides this instance to the system as a wholeSelect singleton mode to avoid inconsistent state and reduce resou

carfactory{private static Bmwfactory ins;public static Bmwfactory Getins () {if (null==ins) {Ins=new bmwfactory ();}return ins;}Bmwfactory () {}Public Car Build (String name) {if (Name.equals ("BMW")) {return new BMW ();}return null;}}4. Some people will be a little grumble, I do not want to always run the factory, so much trouble! Right? Well, then we'll write him a car dealer:public class Agentfactor {private static Agentfactor ins;public static Agentfactor Getins () {if (ins==null) {Ins=new

These two days, I learned one of the simplest patterns in Java design Patterns--singleton mode.It is said that in the Java design pattern, the total can be divided into 23 kinds: Singleton mode, abstract Factory mode, builder mode, prototype mode and so on.Design patterns: In fact, is a set of repeated use, most people know, through the classification of the purpose of writing, code design experience Summary. Design patterns are used in order to reuse code and make it easier for others to unders

the singleton mode guarantees that there is only one object in memory, and if the class is guaranteed to have only one object in memory, the following steps are givenHow do I guarantee that the class has only one object in memory? 1. Privatize the construction method in order not to allow the outside world to create objects2. Creating an object in a class3. Provide an entrance to the outside world through a public access approach.　　By following this step, we can guarantee that the class has onl

Definition: Ensure that a class has only one instance, and that it instantiates itself and provides this instance to the system as a whole. Type: Create class pattern Class Diagram: Class diagram Knowledge points: 1, the class diagram is divided into three parts, followed by the class name, properties, methods. 2, to > Ends with annotation information. 3, modifier + represents public,-on behalf of private, #代表protected, nothing is visible on behalf of the package. 4, the underlined property

spiritual level, so we say addictions is to say that you go to meet your physical desires, but also not too much, especially to talk about this desire," The Yellow Emperor internal sutra • Ancient Innocence " We talked about it now. It emphasizes two words, one is God, you see the Yellow Emperor, the birth of the spirit, and then the spiritual, and then the form of God together, these all talk about a God, another often appear in the word is this desire, so we again today to re-recognize it, th

instantiated objects: one is a hungry man type single case, one is lazy type single case.A hungry man singleton when a singleton class is loaded, it instantiates a reference that an object is given to itself. The lazy type will instantiate the object when the instance method is called.The code is as follows:A hungry man type single case public cl

to consider JDK1.42 as well as previous versions, so the improvement of the single-instance pattern in this article continues.A class will only be initialized once in a ClassLoader, which is guaranteed by the JVM itself, so throw the initialized instance to the JVM, and the code is changed to this:public class Singletonkerrigane { /** * Singleton object instance * / private static Singletonkerrigane instance = new Singletonkerrigane (); public static Singletonkerr

Http://www.cnblogs.com/zyi1992/p/4509908.htmlReprinted, studied the A proxy is a simple and powerful design pattern that is used by an object to "represent" another object to do and implement something. The main object maintains a reference to a proxy (delegate) and sends a message to the agent at the appropriate time, which notifies the "agent" that the object is about to be processed or that an event has been processed. The agent can respond to the message of the event sent by the main o

Single-case mode:There is only one instance during the runI. Key points:1. A class has only one instance------the most basic -----(private constructors only)2. The class must create the instance itself-----(defines a static private object of the Class)3. The class must provide this instance to the entire system on its own---(Provides a static public method that returns a static private object that creates or acquires itself)two. Basic single-case mode1. Lazy ModeLazy mode: When the class is load

The Singleton mode applies in many scenarios, such as database connection pools, logs, and so on. When the system only needs one instance for a class, if two or more instances can be generated, it will only cause troubles and errors. For example, if two programs operate not the same memory, then all the operations of the two programs will not be agreed, or errors will occur during the synchronization process. In the singleton mode, I think from the memory perspective, multiple threads share a pi

If you do not understand the concepts of classes and objects, please click here: Concepts of Java Classes and objectsclass must be defined before it can be used. The class is the template that creates the object, and the object that is created is also called the instantiation of the class.Here's a simple example to understand the definition of a class in Java: Public class Dog{ String name; int age; void Bark(){ //bark System. Out. println("bark, don't come Over");

As programmers such special species, have mastered a special ability is the programming idea, logic is more cautious, but sometimes always ignore some details, for example, I always think Singleton is the simplest design pattern, do not care too much, However, it is because this is not intended to be a disadvantage in development. Really too young and simple.No nonsense, straight into the subject.In the Code of the world found there are various forms of the single case, some people say that ther

() { if (single = null) {Single = new Singleton (); } return single; } }Singleton by restricting the construction method to private to prevent the class from being instantiated externally, the unique instance of Singleton can only be accessed through the getinstance () method within the same virtual machine scope. In fact, through the Java reflection mechanism is able to instantiate the construction method for the private class, which will basical