best java design patterns book

, creating instances*/ Public StaticSingleton getinstance () {if(Instance = =NULL) {instance=NewSingleton (); } returninstance; } /*if the object is used for serialization, you can ensure that the object remains consistent before and after serialization*/ PublicObject readresolve () {returninstance; }}This class can meet the basic requirements, but, like this no thread-safe class, if we put it into multi-threaded environment, there will be problems, how to solve? We will first

I. Classification of design PatternsIn general, design patterns fall into three broad categories:Create five types of models: Factory method mode, abstract Factory mode, singleton mode, builder mode, prototype mode.Structure mode, a total of seven kinds: Adapter mode, adorner mode, proxy mode, appearance mode, bridging mode, combined mode, enjoy the meta-mode.The

handling. From the method that invokes the processor interface declaration, it can be seen theoretically that it can throw any type of exception, because all exceptions are inherited from the Throwable interface, but is it true? The answer is no, because we must obey an inheritance principle: When a subclass overrides a parent or implements a parent interface, the exception thrown must be within the list of exceptions supported by the original method. So while the calling processor is theoretic

.html proxy mode http://www.cnblogs.com/java-my-life/archive/2012/ 04/23/2466712.html Behavioral TypeResponsibility chain Modelhttp://blog.csdn.net/zhouyong0/article/details/7909456Command modehttp://www.cnblogs.com/java-my-life/archive/2012/06/01/2526972.htmlInterpreter modehttp://www.cnblogs.com/java-my-life/archive/2012/06/19/2552617.htmlIterative

combination of objects, and the encapsulation doesn't matter. Seven major design principles Single RESPONSIBILITY PRINCIPLE: one class is responsible for one responsibility. Richter replacement principle "LISKOV SUBSTITUTION PRINCIPLE": Inherited and derived rules. Dependency inversion principle "dependence inversion PRINCIPLE": The high-level module should not rely on the lower layer module, both should rely on its abstraction;

/archive/2012/04/20/2455726.html Enjoy meta-mode http:/ /www.cnblogs.com/java-my-life/archive/2012/04/26/2468499.html Proxy Mode http://www.cnblogs.com/java-my-life /archive/2012/04/23/2466712.html Behavioral typeResponsibility chain Mode http://blog.csdn.net/zhouyong0/article/details/7909456Command mode http://www.cnblogs.com/java-my-life/archive/2012/06/01/25

/2468499.html Proxy Mode http://www.cnblogs.com/java-my-life /archive/2012/04/23/2466712.html Behavioral typeResponsibility chain Mode http://blog.csdn.net/zhouyong0/article/details/7909456Command mode http://www.cnblogs.com/java-my-life/archive/2012/06/01/2526972.htmlInterpreter Mode http://www.cnblogs.com/java-my-life/archive/2012/06/19/2552617.htmlIterative m

java Design PatternsDesign Pattern ClassificationThe Java design pattern can be divided into three categories according to the creation pattern, the structure pattern and the behavioral pattern: Create pattern Single-instance mode, Factory mode, abstract Factory mode,Builder mode, prototype mode

A single-instance pattern of Java design patternsRecently because want to understand the bottom of the source code, so looked at some design patterns, follow-up to read several kinds of writingSingle-Case Pattern English Original: Ensure a class have only one instance,and provide a global point of access to it

Recently looking at design patterns, find a good blog, explaining the various design patterns in the Java specific application scenarios, Bowen address http://blog.jobbole.com/62314/. Structured mode: Adapter Mode: Used to transform an interface into another interface. Jav

of the subclass is given to the decorator class at the client. is an alternative to inheritance2) Implementation: (The IO stream will wrap the file into an efficient character stream) publicinterfacephone{voidcall ();} publicclasscallphoneimplementsphone{@Overridepublic voidcall () { SYSTEM.OUT.PRINTLN ("call");}} publicclassphonedecorateextendscallphone{privatephonephone;public Phonedecorate (Phonephone) {super (); this.phone=phone;} @Overridepublic voidcall () {phone.call ();}} Publicclassmus

23 Design Patterns and 7 major principles in Java Create type Mode 5 Abstract Factory mode (abstract Factory pattern): Provides an interface for creating a family of related or dependent objects without specifying a specific class. Generator mode (Builder pattern): Encapsulates a product's construction process using the builder pattern and allows you to constru

Java and design patterns in Spring practice-collection Spring practice Labels: Java and Design Patterns Junit Integration Previously used multiple times@RunWithAnd@ContextConfigurationAdd these two annotations to the test clas

-safeTest method Public classTestxiaolv { Public Static voidMain (string[] args)throwsinterruptedexception {//Thread Counter FinalCountdownlatch Countdownlatch =NewCountdownlatch (10); LongT1 =System.currenttimemillis (); for(inti = 0; I ) { NewThread (NewRunnable () { Public voidrun () { for(inti = 0; I ) {Object o=lanhandl.getinstance (); } countdownlatch.countdown (); }}). Start (); } countdownlatch.await (); Longt2 =

objects, and be able to manipulate the interaction between objects more flexibly.SummarizeIn object-oriented programming, a class is bound to have dependencies on other classes, and completely independent classes are meaningless. It is also quite common for a class to rely on multiple classes at the same time, since there is a case that a one-to-many dependency has its rationality, and proper use of the mediator pattern can make the original messy object relationship clear, but if abused, it ca

thread-safe/* Type: A hungry man mode */public class Singleton {//1. Privatization of the construction method, not allowing external direct creation of the object private Singleton () {}//2. Create a unique instance of the class, using the private static modifier private static Singleton instance=new Singleton ();//3. Provides a method for obtaining an instance, using public static to decorate public static Singleton GetInstance () {return instance;}}Lazy mode: Class loading when not to create,

principle.DisadvantagesEach different implementation needs to define a subclass, which causes the number of classes to increase and the design to be more abstract.Applicable ScenariosIn some classes of algorithms, the same method is used, resulting in code duplication. Control subclass extensions, subclasses must adhere to algorithmic rules.More Design Patterns:

rely on its abstraction; abstraction should not depend on detail; detail should be dependent on abstraction. That is, for interface programming, do not program for implementation.4, the interface isolation principle "INTERFACE segregation PRINCIPLE": Establish a single interface, do not set up a huge bloated interface, as far as possible to refine the interface, the interface of the method as little as possible.5. Dimitri law "low of DEMETER": Cohesion Poly.6. Open Close PRINCIPLE: A software e

about the classes it relies on. That is to say, for a dependent class, no matter how complex the logic, as far as possible to encapsulate the logic inside the class, outside the public method provided, not to disclose any information.6. Open Close PRINCIPLE: A software entity such as classes, modules, and functions should be open to extensions and closed for modification.7, combination/aggregation multiplexing principle "composition/aggregation reuse Principle (CARP)": Try to use combination an

Class:Package Com.test.demo;public class Director extends Leader {@Overridepublic int limit () {return 5000;} @Overridepublic void Handler (int money) {System.out.println ("Supervisor approved" +money);}Manager class:Package Com.test.demo;public class Manager extends Leader {@Overridepublic int limit () {return 10000;} @Overridepublic void Handler (int money) {System.out.println ("manager approved" +money);}Boss class:Package Com.test.demo;public class CEO extends Leader {@Overridepublic int li