Beispiele für Proxy- und Dekorationsmuster in Java

Dieser Artikel stellt hauptsächlich den Proxy-Modus und den Dekorationsmodus von Java-Entwurfsmustern vor. Er analysiert die Konzepte, Funktionen, Java-Implementierungsmethoden und zugehörigen Vorsichtsmaßnahmen für die Verwendung des Proxy-Modus und des Dekorationsmodus anhand spezifischer Beispiele Nachfolgend

Dieser Artikel beschreibt den Proxy-Modus und den Dekorationsmodus von Java-Entwurfsmustern anhand von Beispielen. Teilen Sie es als Referenz mit allen. Die Details lauten wie folgt:

Der Grund, warum ich über diese beiden Modi zusammen spreche, ist, dass ich festgestellt habe, dass diese beiden Modi fast identisch sind!

Ich habe auch einige Informationen im Internet durchsucht und festgestellt, dass es einige Unterschiede zwischen den beiden gibt. Auch diese Verwirrung haben wir im Studium geklärt.

Definition:

Proxy-Muster stellt einen Proxy für andere Objekte bereit, um den Zugriff auf dieses Objekt zu steuern.

Der Dekorationsmodus fügt einem Objekt dynamisch einige zusätzliche Verantwortlichkeiten hinzu.

Der Proxy-Modus ist leicht zu verstehen. Er besteht darin, ein Objekt erneut zu kapseln und dann auf das gekapselte Objekt zuzugreifen.

Weil das Proxy-Objekt das Proxy-Objekt ersetzt hat.

Der Dekorationsmodus fügt einem Objekt Funktionen hinzu. Das Bild ist, als würde man als Kellner zur Seite stehen, um Dienstleistungen zu erbringen.

Der grundlegende Unterschied besteht also darin, dass das Objekt im Dekorationsmodus immer noch vorhanden ist und nicht das ursprüngliche Objekt ersetzt, sondern nebenbei Dienste bereitstellt.

Die in diesem Artikel geäußerten Meinungen sind persönliche Meinungen und ich bin nur für sie verantwortlich.

Das Folgende ist ein Beispiel:

package test.design.proxydecorator;
/**
 * 接口定义行为：吃饭
 * @author lushuaiyin
 *
 */
public interface Eatable {
  void eatFood();
}

package test.design.proxydecorator;
/**
 * 实现类
 * @author lushuaiyin
 *
 */
public class Man implements Eatable{
  @Override
  public void eatFood() {
    System.out.println("I am eating food! Happy!");
  }
}

Das Obige ist die gemeinsame Schnittstelle und Implementierung , unten ist eine Musterinstanz

Proxy-Muster

package test.design.proxydecorator;
/**
 * 代理模式
 * 代理对象把被代理对象封装，像一个包装盒把被代理对象包裹起来。
 * 它不改变被代理对象的原有逻辑，只是增加来了一些自己的服务，像一个代理一样。
 * 代理从使用上给调用者的感觉就是你已经取代了原来的对象。
 * 就像皇太后取代小皇帝实行垂帘听政。
 * @author Administrator
 *
 */
public class ProxyMan implements Eatable{
  private Eatable eatable;
  public ProxyMan(){
    System.out.println("proxy: I am proxy object. I will help you create a object of Man that wnt to be proxyed");
    this.eatable=new Man();
    //注意代理对象把被代理对象封装，在内部有实际的被代理对象，这个调用者是不知道的。
  }
  @Override
  public void eatFood() {
    //代理对象把被代理对象的功能封装，蛋不改变其内部逻辑，只是增加一些服务。
    System.out.println("proxy: I know you are hungry,so I cook for you some food.");
    this.eatable.eatFood();
    System.out.println("proxy: Now you eat up food. Let me help you clean the dishes.");
  }
}

Dekorationsmuster

package test.design.proxydecorator;
/**
 * 装饰的抽象.
 * 也可以不用抽象类，简单的父类也可以，只要实现装饰功能.
 * 抽象只是为了增加一层封装，规定装饰者必有的装饰功能而已。
 * @author lushuaiyin
 *
 */
public abstract class DecoratorMan {
  protected Eatable eatable;
  //使用构造函数或者set方法（或其他方法）把接口对象传入。
  //注意，必须保证这个对象的传入，最好还是用构造函数。
  public DecoratorMan(Eatable eatable){
    this.eatable=eatable;
  }
  public void eatFood(){
    this.eatable.eatFood();
  };
}

package test.design.proxydecorator;
/**
 * 装饰模式
 * 装饰对象时独立于原来的对象的。它和被装饰的对象有关系，但是是独立的对象。
 * 装饰对象更像一个酒店服务生，为别人提供服务，所以他还是他自己，他有自己的实际存在。
 * @author lushuaiyin
 *
 */
public class Decorator extends DecoratorMan{
  public Decorator(Eatable eatable) {
    super(eatable);
  }
  //重写父类方法
  public void eatFood(){
    decoratorServiceCookFood();//装饰的具体行为
    super.eatable.eatFood();
    decoratorServiceCleanDishes();//装饰的具体行为
  };
  public void decoratorServiceCookFood(){
    System.out.println("Decorator: I know you are hungry,so I cook for you some food.");
  }
  public void decoratorServiceCleanDishes(){
    System.out.println("Decorator: Now you eat up food. Let me help you clean the dishes.");
  }
}

Das Wichtigste ist der Anruf, der auch den Hauptunterschied zwischen diesen beiden Modi darstellt!

package test.design.proxydecorator;
public class TestMain {
  /**
   * @param args
   */
  public static void main(String[] args) {
    //代理模式
    System.out.println("代理模式:");
    Man m1=new Man();//通常情况下
    m1.eatFood();
    System.out.println("---------------------------");
    //代理模式者直接取代某对象，你连你想要见的人的面都见不到。
    //它说你要见的人已经把所有事委托于我，他会的我会；他不会的，我也会。我就是他的替代增强版。
    Eatable e1=new ProxyMan();
    e1.eatFood();
    System.out.println("------------分割---------------");
    System.out.println("装饰模式:");
    Man m2=new Man();//通常情况下
    m2.eatFood();
    System.out.println("---------------------------");
    //装饰模式者站在一边提供各种服务.
    //装饰者和被装饰者都在场，装饰者提供服务，赚取小费。
    Decorator d1=new Decorator(m2);
    d1.eatFood();
  }
}

Drucken:

代理模式:
I am eating food! Happy!
---------------------------
proxy: I am proxy object. I will help you create a object of Man that wnt to be proxyed
proxy: I know you are hungry,so I cook for you some food.
I am eating food! Happy!
proxy: Now you eat up food. Let me help you clean the dishes.
------------分割---------------
装饰模式:
I am eating food! Happy!
---------------------------
Decorator: I know you are hungry,so I cook for you some food.
I am eating food! Happy!
Decorator: Now you eat up food. Let me help you clean the dishes.

Das obige ist der detaillierte Inhalt vonBeispiele für Proxy- und Dekorationsmuster in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!