java pattern class

Use Observer Mode (Observer) The Observer pattern defines a one-to-many dependency that allows multiple observer objects to listen to a Subject object at the same time.This subject object notifies all observer objects when the state changes, enabling them to automatically update themselves. The Observer pattern is aBehavioral Patterns。structureFigure-Viewer

I. OverviewCapture the internal state of an object without destroying it, and save the state outside the object so that it can be restored to its previously saved state. It is an object-behavioral pattern .Second, the application scenario1, similar to the implementation of the Undo function, save an object at a certain time part of the state or all the state, when it is needed later can be restored to the previous state.2, the object's historical stat

language, can be a basic data type, can be a user-defined type, can also be a null type (void), and if it is a construction method, no return value type. Example This diagram class is named demo, which has four methods of operation: The visibility of the action method is private (-), with a parameter par of type object, and a return value of type int;Operation Method1 Visibility is public (+), no parameters, return value

1 overviewThe single example pattern has several benefits: (1) Some classes are created more frequently, and for some large objects, this is a large system overhead. (2) eliminates the new operator, reduces the system memory usage frequency, reduces the GC pressure. (3) Some classes, such as the core trading engine of the exchange, control the transaction flow, if the class can create multiple words, the

, it communicates with its intermediaryClass diagram:Example:Mediator public abstract class Mediator { public abstract void notice(String content);}Concretemediator Public class concretemediator extends mediator {private colleaguea CA; private colleagueb CB; Public concretemediator () {CA = new colleaguea (); Cb = new colleagueb ();} public void notice (string content) {If (content. equals ("boss") {// T

Suppose we are playing an instant strategy game. We design a soldier. He was an infantry when he was just produced, but he can switch weapons. The first switch will become an archer, the second switch will become an armored soldier holding a shield, and the third switch will become an infantry ...... How to implement this switching mechanism? At the beginning, we will think that adding a switch statement to the infantry class is not conducive to code

attack power value and color to generate a weapon, and finally return the generated weapon. The Java code is as follows: Class Weapon {private String color; private String name; private int attack; public String getName () {return name;} public int getAttack () {return attack;} public String getColor () {return color;} public void setAttack (int _ attack) {attack = _ attack;} public void setName (String _

Java Basics _ Inner classes: In Java, a class can be defined inside another class or inside a method, such that a class is called an inner class.The primary role of inner classes: using internal classes can reduce naming conflicts.Define location: An inner

();} class FlyweightMapItem implements FlyweightItem {String name; public FlyweightMapItem (MapItem map) {this. name = map. name;} public void draw () {System. out. printf ("Drawing % s \ n", name) ;}} class MapItem {String name; public MapItem (String name) {this. name = name ;}} class FlyweightMapFactory {private static FlyweightMapFactory flyweightMapFactory

com.qianyan.calcuator;public class SubtractOperation extends Operation{@Overridepublic double getResult() {return this.getNum1() - this.getNum2();}} User class: Package COM. qianyan. user; import Java. util. producer; import COM. qianyan. calcuator. operation; import COM. qianyan. factory. operationfactory; public class