creational design patterns in java

that makes external objects not new related instances, * This particular note, be sure to provide a default privatization method to override the default constructor method otherwise, if the user goes directly to the new object * , there is no guarantee of a single case ~ ~ ~ 　　3. Design mode of a hungry man in the process of initializing the class will complete the initialization of the relevant instance, generally think that this way to be more

. /***/Publicclass Singleton {privatestatic New Singleton (); Private Singleton () {} Public Static synchronized Singleton Getsingleton () { return Singleton; }}The creation of a single piece in the static initializer guarantees thread safety. Of course, this approach works for applications that always create and use a single instance, or that the burden of creating and running is not too heavy.3, a relatively better way is: with "Double check lock", in Getsingleton ()

("Internet browsing information! "); } } Class Proxy implements network {//proxy Internet private network network; Public Proxy (Network network) {//Set the real operation of the agent this.network = Network;//Set the subclass of the proxy } public void Check () {//Body Verification Action System.out.println ("Check if the user is legal! "); } public void browse () { this.check ();//Invoke specific proxy business Op

to encapsulate some action that is applied to a data structure element. Once these operations need to be modified, the data structure that accepts the operation can remain unchanged. The visitor pattern is suitable for systems with relatively indeterminate data structures, which frees up the coupling between the structure and the operation of the structure so that the set of operations can evolve relatively freely. The visitor pattern makes it easy to add new operations, which is to add a new v

registerreceiver (Broadcastreceiver receiver,intentfilter filter); public abstract void Unregisterreceiver (Broadcastreceiver receiver);} Abstract Viewer Public abstract class Broadcastreceiver {public abstract void onreceive (context context, Intent Intent); Specific topics public class Activity extends Contextthemewrapper ... { //Contextthemewrapper extends Contextwrapper //Contextwrapper extends Context} Specific observers Class Mediarec

singletonholder.instance, causing the Singletonholder class to be initialized, and when the class is loaded and initialized, it initializes its static domain to create an instance of singleton, because it is a static domain, so only when the virtual machine loads the class Initialized once and is guaranteed to be thread-safe by a virtual machine.The advantage of this pattern is that the GetInstance method is not synchronized and only performs a domain access, so deferred initialization does not

{void吃饭();void看电影();void逛街();void啪啪啪();}abstractclass恋爱中的妹子 implements 谈恋爱{@Overridepublicvoid吃饭() {// TODO Auto-generated method stub}@Overridepublicvoid看电影() {// TODO Auto-generated method stub}@Overridepublicvoid逛街() {// TODO Auto-generated method stub}@Overridepublicvoid啪啪啪() {// TODO Auto-generated method stub}}class阿乐 extends 恋爱中的妹子{publicvoid啪啪啪() {// TODO Auto-generated method stubSystem.out.println("阿乐：亚美爹，好害羞");}}} Here I have written an interface that defines several methods

coupling between classes, improve the stability of the system, reduce the risk caused by concurrent development, and improve the readability and maintainability of the code. Let's then use the example in the JDK to illustrate:Look at the following section of code:publicclass Test { publicstaticvoidmain(String[] args) { List list=new ArrayList(); list.add("11"); System.out.println(list.get(0)); }}This code we run is definitely output 11; Next we modify the codepubliccl

Hungry man mode and the lazy mode, and according to the implementation details of the specific project, we can apply the template code to the application of the singleton design pattern.Advantages of a singleton design patternFinally, let's summarize the advantages of a singleton design pattern: can be controlled access to unique instances; The ability to redu

construction methodPrivateSingletontest () {}Defines a static private variable (uninitialized, does not use the final keyword, and volatile guarantees the visibility of the instance variable when multi-threaded access is avoided, and is called by another thread when the other variable property is not assigned when instance initialized)Privatestatic volatile singletontest instance;//defines a common static method that returns an instance of this type public Span style= "COLOR: #0000ff" >static S

, do not need to create factory objects, this pattern is more extensive, the code example is as follows: Package Com.factory.factorymethod;public class Senderfactory {public static sendable Producetextsender () { return New Textsender (); } public static sendable Producephotosender () { return to new Photosender ();} public static sendable Producevideosender ( { return new Videosender ();} } Factory Method Model Summary When there are a large number of products that need to be created and

1. Strategy design modeCreating a method that can vary depending on the parameter object being passed is called a policy design pattern. This type of method contains a fixed portion of the algorithm that is requested to execute, and the "policy" contains the changed parts. A policy is a parameter object that is passed in. In the following code example, the process object is a policy. Applied on the S.code e

combination of objects, it is possible to mix and match the beverage and seasoning more flexibly.Code External details:When implemented in code, the decorator can be passed into the decorator by the constructor, as in the final invocation form as follows:Beverage beverage = new Darkroast ();Beverage = new Mocha (beverage);Beverage = new Whip (beverage);The two-tier wrapper is completed, and the cost () function of the beverage is then called to get the total price.Seven, java.io in the package

... ") ;}}; Class factory{//factory class public static Fruit Getfruit (String className) {Fruit F = null, if ("Apple". Equals (ClassName)) {f = new A Pple ();} if ("Orange". Equals (ClassName)) {f = new orange ();} return f;}; public class Interdemo{public static void Main (String args[]) {Fruit f = factory.getfruit (Args[0]); if (f!=null) {f.eat ();} }}Three, the agent design modeTake debt collection as an exampleInterface give{public void Givemone

Observer Observableex Public class extends Observable { /** * When the principal changes, the notification method is called @param newstate * /publicvoid change (String newstate) {this . Nodifyobservers (newstate); } }5. Create a clientImportorg.junit.Test; Public classClient {/*** Create three new observers, add them to the list, and call the change method*/@Test Public voidTest () {Observer OBS1=NewObserverimpl (); Observer OBS2=NewObserverimpl (); Observ

() { for(Observer observer:observers) {observer.notice (); } }} package Com.roc.observer; /** * abstract Observer * @author LIAOWP * */ public interface Observer { public void notice (); } Package Com.roc.observer; /** @author*/Publicclassimplements observer{ @Override Public void notice () { System.out.println ("Observer1 received push");} } PackageCom.roc.observer;/*** Viewer Mode *@authorLIAOWP **/ Public classClient { Public Static voidMain (string

complex, there are many properties, and these properties are references to other objects, which may include a lot of object references. By encapsulating these complexities, you can use the build mode.Recommended Link: http://www.cnblogs.com/cbf4life/archive/2010/01/14/1647710.html4. Façade modeThis pattern feels like a replica of the service layer. For example DAO we define a lot of persistence methods, we use the service layer to make the DAO atomic method into business logic, and then provide

layer. Object-oriented methods can be used to store, update, delete records of a database, and query database information. Persistent layer can also choose Ibatis, etc. Data layer: Used to store business data for the upper call, mainly refers to some database systems. The 3 framework features of the classic SSH (Struts, Spring, Hibernate) are different, and depending on the functional hierarchy of the Web application, these 3 frameworks can be applied to various levels, ultimately enabling the

implementation. Because the structure inside the parameters are eat interface, as long as the implementation of the Eat class can be passed in, that is to show　　　　　　　　　　Likeeat likeeat = new Endeat (New Eatfoot (New Inrestaurant (New Gotorestaurant (New Findinmap (person)))))The look of this structure. So when calling Likeeat.eat () , and because of each specific decorator class, first call super.eat (); method, and the Super has been passed by the construction and pointed to a specific decorat

whole pattern of using lambda expressions is greatly simplified because we can completely abolish these classes. Let's see if the macro Class (client) uses a lambda expression instead of the command class's effect.Filereceiver.closefile (), new--- Macro.run (); If you can realize that each lambda expression is executing a separate method call, you can further refine it. Therefore, you can use the method reference directly.New Macro (); Macro.record (filereceiver::openfile); Macro.record (filere