creational design patterns in java

pool overflow, if the instantiated object is not exploited for a long time,The system is considered garbage and is recycled by GC resulting in loss of object state　　Lazy mode:　　　　　　A Hungry man mode:Dual Lock mode:　　　　　　Summarize:　　1, lazy mode features: Thread insecure, load classes faster, run time to get objects slower,2, a Hungry man mode features: Thread safety, load class is slow, run time to get objects faster3, double lock mode: Thread-safe, load class faster, run-time to get objects at

Opening and closing principle OCP (Open for extension,closed for modification). The core idea of open and close principle is that an object is opened to expansion and closed to modification. In fact, the opening and closing principle means that changes to the class are made by adding code rather than altering the existing code. In other words, once the software developer writes out the code that can be run, it should not change it, but to ensure that it can continue to run, how to do this? Th

this class in the class (the final keyword, etc. have learned, is the ultimate meaning, hehe)Private Finla Static single =new single ();Provides a public access method that can be obtained to the class objectpublic static single getinstance () {return single;}The lazy type of the single case design patternobject is initialized when the method is called, or deferred loading of the objectSingle class into memory, the object does not exist, only the obj

}Singletonlazy The object is not created immediately after it is loaded into the method area, it is not created until the GetInstance method is called. This way can save memory space, but there is also a thread security problem, when thread a execution to the judgment object is null, when thread B gets execution, thread B determines that the object is null, then thread a regain execution, create the object, thread B resumes, continue to create the object. Modify the code as follows, using a sync

Java Singleton design pattern, there are many ways to implement, the following describes some of the more famous implementation methods A Hungry man typeThis design pattern is simple, and there is no multi-threading security problem, which is generally used in practical development. Class Hungerydemo{private Hungerydemo () {}private static final Hun

. Template method Mode Defines the skeleton of an algorithm in an operation, and delays some steps into subclasses. Templatemethod allows subclasses to redefine some specific steps of the algorithm without altering the structure of an algorithm. Visitor mode Represents an operation that acts on each element in an object structure. It allows you to define new actions that act on these elements without changing the class of each element. If many

: Interface high cohesion is internally highly dependent and isolated as much as possible. That is, the method of internal declaration of an interface is related to a sub-module, and is required by this submodule. Interface design is limited: If you fully follow the principle of interface separation, there will be a problem, that is, the design of the interface will be less and less, so that the number

), using iterators to traverse simple fission rather cumbersome, large as a list, we prefer to use the Foreach loop to traverse. 　　11, Interpreter mode (interpreter pattern)-this pattern is the rule that defines the language, and an interpreter is created to explain the semantics of the rule. If a particular type of problem occurs at a sufficiently high frequency, it is worthwhile to describe each instance of the problem as a sentence in a simple language, and you will naturally need to construc

Designing the design mode of Banqiao is the earliest introduction of the system in the domestic media (including books and websites). This series introduces pure for free dissemination (reprint this website article, please keep the author and the website), as far as possible concise, is easy to understand, but inevitably has the omission to ask the letter or the forum discussion, unceasingly consummates. The real mastery of

Design pattern (Patterns) --the foundation of reusable object-oriented software Design patterns are a set of repeated use, most people know, through the classification of purpose, code design experience Summary. Design

Ref:http://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.htmlDesign mode (Patterns)--the basis of reusable object-oriented softwareDesign patterns are a set of reusable, most known, categorized purposes, code design experience Summary. Design patterns are used in or

, adorner mode, agent mode, appearance mode, bridging mode, combination mode, enjoy meta mode. There are 11 types of behavioral Patterns: Policy mode, template method pattern, observer mode, iterative sub mode, responsibility chain mode, Command mode, Memo mode, state mode, visitor mode, mediator mode, interpreter mode. There are two other types of concurrency: concurrent and thread-pool mode. Use a picture to describe the whole: Second,

Since the advent of Java-EE, it has greatly simplified the enterprise-level development under the java-based. But as Java EE becomes more and more widely used in various fields, developers are becoming aware of the need for a way to standardize the application's development process by standardizing the architectural layers of the application. The structure layer

mentioned in the Introduction are examples of stream processors. 1. modifier mode: in the hierarchical structure represented by inputstream, outputstream, reader, and writer, some stream processors can play a decorative role on other stream processors to form a new one, stream processor with improved features. The modifier mode is the overall design mode of the Java I/O library. This principle complies wit

We found that design patterns are very popular in the Java community, but not so much in the C + + community, or even a bit of exclusion, what causes this difference. (1) C + + memory needs to be managed by itself, so some patterns are not easy to use in C + +, but Java doe

dependencies and reducing coupling. Dimitri Law (Demeter principle): An entity interacts with other entities as little as possible, making the system function modules relatively independent. Synthetic multiplexing principle (composite reuse principle): Use composition/aggregation as much as possible, rather than using inheritance. The focus of design pattern interpretationThis topic talk about design