Detailed explanation of decorator pattern examples in Java

This article mainly introduces the Java decorator pattern, and analyzes the principles of the decorator pattern and Java specific implementation techniques in detail in the form of examples. Friends in need can refer to it

The examples in this article describe the Java decorator model. Share it with everyone for your reference, the details are as follows:

Decoration mode

Without changing the original class file and using inheritance, dynamic Extend the functionality of an object. It wraps the real object by creating a wrapping object, that is, decoration.

The decoration object accepts all requests from the client. It forwards these requests to the real objects. Decorated objects can add additional functionality 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.

Advantages

1. The purpose of Decorator mode and inheritance relationship is to extend the functionality of objects, but Decorator mode can provide better performance than inheritance. More flexibility.

2. By using different specific decoration classes and the permutations and combinations of these decoration classes, designers can create many combinations of different behaviors.

Roles

The various roles in the decoration mode are:

(1) Abstract component (Component) role: Give an abstract interface, Preparing objects to receive additional responsibilities with specifications.
(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.

Sample Code

Let’s take a hand cake as an example. Hand cakes can have many flavors, but the most basic one is an original hand cake. On this basis, we can add one or more combinations such as eggs, beef, tenderloin, etc.

Abstract Component (Component) role

package 装饰者模式;
/**
 * 抽象类接口，规范饼的属性
 * @author oooo
 *
 */
public interface Cake {
//两个属性
  public String descripestion();
//属性描述
  public Double money();
//价格描述
}

Concrete Component (Concrete Component) role

package 装饰者模式;
/**
 * 原味手抓饼类
 * @author oooo
 *负责接收附加属性的类
 */
public class shreddedcake implements Cake{
//实现Cake接口
  @Override
  public String descripestion() {
    //描述属性
    return "原味手抓饼";
  }
  @Override
  public Double money() {
     //描述价格
    return 3.5;
  }
}

Decorator role

package 装饰者模式;
/**
 * 建立和饼的连接，得到原始饼的属性，添加属性的中介。
 * @author oooo
 *
 */
public abstract class Deractor implements Cake{
  Cake cake;
  public Deractor(Cake cake) {
    this.cake=cake;
  }
  public String descripestion(){
    return cake.descripestion();
  }
  public Double money(){
    return cake.money();
  }
}

Concrete Decorator role

##

package 装饰者模式;
/**
 * 鸡蛋手抓饼类
 * @author oooo
 *添加鸡蛋属性
 */
public class EggshrededCake extends Deractor{
  public EggshrededCake(Cake cake) {
    super(cake);
  }
  public String descripestion() {
    return "鸡蛋"+cake.descripestion();
  }
  @Override
  public Double money() {
    return 3.5+1.5;
  }
}

Concrete Decorator ) Role

package 装饰者模式;
/**
 * 牛肉味手抓饼
 * @author oooo
 *添加牛肉属性
 */
public class beffshredded extends Deractor{
  public beffshredded(Cake cake) {
    super(cake);
    // TODO Auto-generated constructor stub
  }
  public String descripestion() {
    return "牛肉"+cake.descripestion();
  }
  @Override
  public Double money() {
    return cake.money()+3.0;
  }
}

Test class

package 装饰者模式;
public class Test {
  /**
   * 测试类
   * @param args
   */
  public static void main(String[] args) {
    //新建一个原味手抓饼类
    shreddedcake sh=new shreddedcake();
    System.out.println(sh.descripestion());
    System.out.print("  价格： "+sh.money());
    //新建一个鸡蛋类，附加鸡蛋属性到手抓饼上
    EggshrededCake egg=new EggshrededCake(sh);
    System.out.println(egg.descripestion());
    System.out.print("  价格："+egg.money());
    //新建一个牛肉类，附加牛肉属性到手抓饼上
    beffshredded beff=new beffshredded(egg);
    System.out.println(beff.descripestion());
    System.out.print("  价格："+beff.money());
  }
}

Output result:

原味手抓饼  价格： 3.5
鸡蛋原味手抓饼  价格：5.0
牛肉鸡蛋原味手抓饼  价格：8.0

The above is the detailed content of Detailed explanation of decorator pattern examples in Java. For more information, please follow other related articles on the PHP Chinese website!