Home  >  Article  >  Java  >  Easily master the java decorator pattern

Easily master the java decorator pattern

高洛峰
高洛峰Original
2017-01-19 16:02:531092browse

Definition: Dynamically extend the functionality of an object without changing the original class file and using inheritance. It wraps the real object by creating a wrapping object, that is, decoration.

Features:

(1) Decorated objects have the same interface as real objects. This way the client object can interact with the decorated object in the same way as a real object.

(2) The decorated object contains a reference to the real object

(3) The decorated object accepts all requests from the client. It forwards these requests to the real objects.

(4) Decoration objects can add some additional functions before or after forwarding these requests. This ensures that additional functionality can be added externally at runtime without modifying the structure of a given object. In object-oriented design, functional extension of a given class is usually implemented through inheritance.

Enterprise-level development and applications in common frameworks: IO stream underlying architecture

Composition:

(1) Abstract component (Component) role: Give an abstract interface, Prepare objects with specifications to receive additional responsibilities.
  (2) Concrete Component role: Define a class that will receive additional responsibilities.
  (3) Decorator role: Holds an instance of a component object and implements an interface consistent with the abstract component interface.
  (4) Concrete Decorator role: Responsible for adding additional responsibilities to component objects.

Specific example:

/**
 * 以下装饰房子举例
 */
public class Demo {
 
 public static void main(String[] args) {
 GenericHouse house = new GenericHouse();
 Garage garage = new Garage(house);
 garage.doSomething();
 Kitchen kitchen = new Kitchen(house);
 kitchen.doSomething();
 }
}
 
/**
 * 抽象构件角色:一个接口,用以规范具体装饰的位置 
 */
interface AbstractHouse{
 public void doSomething();
}
 
/**
 * 装饰角色: 持有要装饰的对象
 */
class Master implements AbstractHouse{
  
 private AbstractHouse abstractHouse;
 
 public Master(AbstractHouse abstractHouse) {
 this.abstractHouse = abstractHouse;
 }
  
 public void doSomething() {
 System.out.println("装饰角色:装饰角色持有者,在这儿就是房子的主人");
 abstractHouse.doSomething();
 }
  
}
 
/**
 * 具体的构件角色:具体需要被装饰的对象 
 */
class GenericHouse implements AbstractHouse{
 public void doSomething() {
 System.out.println("具体构建角色:房子可以住人,遮风挡雨!");
 }
}
 
/**
 * 具体装饰角色: 具体的装饰就是在这儿做的,它继承自装饰角色,因为装饰角色持有被装饰对象,
 * 所以它也就持有了被装饰对象,可以做装饰
 */
class Garage extends Master{
 
 public Garage(AbstractHouse abstractHouse) {
 super(abstractHouse);
 }
  
 public void doSomething() {
 super.doSomething();
 System.out.println("具体装饰角色:在这儿做装饰的事儿,把房子中的一间装饰成车库,所以房子可以存放车子了");
 }
}
/**
 * 具体装饰角色: 具体的装饰就是在这儿做的,它继承自装饰角色,因为装饰角色持有被装饰对象,
 * 所以它也就持有了被装饰对象,可以做装饰
 */
class Kitchen extends Master{
 
 public Kitchen(AbstractHouse abstractHouse) {
 super(abstractHouse);
 }
  
 public void doSomething() {
 super.doSomething();
 System.out.println("具体装饰角色:在这儿做装饰的事儿,把房子中的一间装饰成厨房,所以房子可以做饭了");
 }
}

In actual development, the packaging function decorated with patterns plays a great role. We can do some other things to the object without changing the original object. Operation, this can avoid us transforming the object, but at the same time we can complete some operations well.

The above is the entire content of this article. I hope it will be helpful to everyone's learning. I also hope that everyone will support the PHP Chinese website.

For more articles related to easily mastering the java decorator pattern, please pay attention to the PHP Chinese website!

Statement:
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn