Use the decoration mode to view the interface, and the decoration Mode Interface

Use the decoration mode to view the interface, and the decoration Mode Interface
Decorator)Intention

Decoration Mode

Dynamically add some additional responsibilities to an object. The Decorator mode is more flexible than the subclass generation function. Applicability

• Add roles to a single object dynamically and transparently without affecting other objects.
• Handle unrecoverable responsibilities.
• When the subclass generation method cannot be used for expansion. One case is that there may be a large number of independent extensions. To support each combination, a large number of subclasses will be generated, resulting in explosive growth of the number of subclasses. Another scenario is that the class definition is hidden, or the class definition cannot be used to generate a subclass.
• Using the decoration mode, we can see that the interface is implemented in the called interface,
• The interface method is implemented where the interface is implemented, then, the interface implementation object is received at the place where the interface is called, and then the methods in the interface can be directly implemented in the class that calls the interface (the method in the interface ).
• Java code of the abstract component role
  1. Package decorator;
  2. /**
  3. * Common method interface between the decorator and the original component (Abstract component role)
  4. * @ Author mouca. he
  5. *
  6. */
  7. Public interface InterfaceComponent {
  9. /**
  10. * Component method say ()
  11. *
  12. */
  13. Public void say ();
  14. }

  Java code of the specific component role

  1. Package decorator;
  2. /**
  3. * Original component (specific component role)
  4. * @ Author mouca. he
  5. *
  6. */
  7. Public class Component implements InterfaceComponent {
  9. Public void say (){
  10. // TODO automatically generates method stubs
  11. System. out. println ("Component. say (): Method of the original Component! ");
  12. }
  14. }

  Java code of the abstract modifier role

  1. Package decorator;
  2. /**
  3. * Abstract Modifier
  4. * @ Author mouca. he
  5. *
  6. */
  7. Public abstract class AbstractDecorator implements InterfaceComponent {
  9. Private InterfaceComponent component;
  11. Public AbstractDecorator (InterfaceComponent component ){
  12. This. component = component;
  13. }
  14. /**
  15. * Component Method Pre-processing method
  16. *
  17. */
  18. Protected void preSay (){};
  20. /**
  21. * Post-processing method for component method execution
  22. *
  23. */
  24. Protected void afterSay (){};
  26. Public void say (){
  28. PreSay ();
  29. Component. say ();
  30. AfterSay ();
  32. };
  33. }

  Specific modifier 2 java code

  1. Package decorator;
  2. /**
  3. * Decorator 2
  4. * @ Author mouca. he
  5. *
  6. */
  7. Public class DecoratorTwo extends actdecorator {
  9. Public DecoratorTwo (InterfaceComponent component ){
  10. Super (component );
  11. // TODO automatically generates the constructor stub
  12. }
  14. /**
  15. * Reload the template class preSay () method as needed
  16. */
  17. Protected void preSay (){
  18. System. out. println ("DecoratorTwo. preSay (): preSay () method of modifier 2! ");
  19. }
  21. /**
  22. * Overload the template class afterSay () method as needed
  23. */
  24. Protected void afterSay (){
  25. System. out. println ("DecoratorTwo. afterSay (): The afterSay () method of modifier 2! ");
  26. }
  28. }

  Modifier 1 java code

  1. Package decorator;
  2. /**
  3. * Decorator 1
  4. * @ Author mouca. he
  5. *
  6. */
  7. Public class DecoratorOne extends actdecorator {
  9. Public DecoratorOne (InterfaceComponent component ){
  10. Super (component );
  11. // TODO automatically generates the constructor stub
  12. }
  13. /**
  14. * Reload the template class preSay () method as needed
  15. */
  16. Protected void preSay (){
  17. System. out. println ("DecoratorOne. preSay (): preSay () method of modifier 1! ");
  18. }
  20. /**
  21. * Overload the template class afterSay () method as needed
  22. */
  23. Protected void afterSay (){
  24. System. out. println ("DecoratorOne. afterSay (): The afterSay () method of modifier 1! ");
  25. }
  26. /**
  27. * Test Method
  28. * @ Param args
  29. */
  30. Public static void main (String [] args ){
  31. // TODO automatically generates method stubs
  32. InterfaceComponent interfaceComponent = new DecoratorTwo (new DecoratorOne (new Component ()));
  33. InterfaceComponent. say ();
  34. /*
  35. * Console output:
  36. * DecoratorTwo. preSay (): The preSay () method of DecoratorTwo!
  37. * DecoratorOne. preSay (): The preSay () method of DecoratorOne 1!
  38. * Component. say (): Method of the original Component!
  39. * DecoratorOne. afterSay (): The afterSay () method of modifier 1!
  40. * DecoratorTwo. afterSay (): The afterSay () method of DecoratorTwo!
  41. */
  42. }
  43. }

  4. Advantages and Disadvantages

  Advantages: 1) provide more flexibility than inheritance 2) use different decorative combinations to create combinations of different behaviors 3) Reduce the number of classes required

  Disadvantages: 1) Flexibility leads to greater errors. 2) more objects are generated, which makes error detection difficult.