The design mode in Java Jive-Linux general technology-Linux programming and kernel information. The following is a detailed description. This article does not explain the design patterns in detail. It just uses Jive to look at the application of the design
structure and content of the design pattern, so I should use actual examples to help me understand the design patterns. If you go back and read a book again, there will be a lot of questions, the feeling of another village. (Not even applause)In Java, the design
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
.
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
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
), 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
() method that called them is passed in this and arg as parameters */Publ IC void Notifyobservers (Object arg) {object[] arrlocal; Synchronized (this) {if (!changed) return; arrlocal = Obs.toarray (); Clearchanged (); } for (int i = arrlocal.length-1; i>=0; i--)((Observer) arrlocal[i]). Update (this, ARG); }/** * Will gather the observers to empty */public synchronized void Deleteobservers () {obs.removeallelements (); }/** * Set "changed" to Tru
the Showflight class into the Plotpanel class and use the function object instead to get the x and Y values. Defines the number of points required for a Plotpanel constructor to receive two function instances and drawings.
Class diagram Design,The Main method is still written in Showflight, but we name it ShowFlight2. The function class is used to obtain the corresponding x and Y coordinate values. However, because the specific x and Y are a val
principle) (Demeter Principle)Why is it called the least known principle, that is to say: an entity should be as small as possible interaction with other entities, so that the system function module is relatively independent.3.6. Synthetic multiplexing principles (Composite reuse Principle)The principle is to use composition/aggregation as much as possible, rather than using inheritance. 4. SummaryIn the Java object-oriented programming language, dif
advocated by effective, the Java author, Josh Bloch.SummarizeThere are several uses of the singleton pattern, so let's summarize what we need to pay attention to using the singleton pattern (not including enumerations).
Construction method Privatization (private);
Defines a private (private) static instantiation object;
Provides a public static (static) method to obtain this instance;
Original is not easy, if feel good, hope to
I have been reading the Junit Source Code recently, and I have also read many source code analyses of Junit. I have seen the Java design mode, Command mode, Observer mode, Composite mode, and so on. I used to know that there was a Java design pattern. This time I checked the Junit source code and found that this
(Chinese translation: Design Patterns-Reusable object-oriented software elements) mentioned in a total of 23 Design patterns. These patterns can be categorized into three main categories: the creation pattern (creational Patterns
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.Beh
,Suppose you need to use Swing's user interface to display several rockets in the table. As shown, the Rockettablemodel class can be created to match this set of rockets to the interface expected by TableModel.The reason we use the object adapter pattern here is because the abstract class provides some of the implementation that the adapter needs, and the interface that the client expects, then we inherit from the abstract class instead of implementing the interface, and the adapter object has m
restrict collaboration between objects, which in fact provides greater freedom. It actually prescribes a protocol in which classes that implement this interface must adhere to this protocol. Then no matter how the implementation class changes, as long as it complies with this protocol, then the interface does not need to change.
Implementation classes can provide empty implementations (stubs), such as WindowListener and Windowadapter
Interfaces can be used to declare constants
SummaryTh
Design Patterns are a set of reusable, most known, categorized purposes, code design experience Summary. Design patterns are used in order to reuse code, make code easier for others to understand, and ensure code reliability. There is no doubt that
, 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,
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
The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion;
products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the
content of the page makes you feel confusing, please write us an email, we will handle the problem
within 5 days after receiving your email.
If you find any instances of plagiarism from the community, please send an email to:
info-contact@alibabacloud.com
and provide relevant evidence. A staff member will contact you within 5 working days.