typescript 装饰器 json转换装饰器 java

转载

mob64ca1403528a 2023-09-27 13:32:35

文章标签 ide java 装饰器模式 文章分类 TypeScript 前端开发

前言

今天做实验，要求用到了装饰器模式，写一点感悟

装饰器模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

我们通过下面的实例来演示装饰器模式的用法。其中，我们将把一个形状装饰上不同的颜色，同时又不改变形状类。

介绍

意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。

主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

何时使用：在不想增加很多子类的情况下扩展类。

如何解决：将具体功能职责划分，同时继承装饰者模式。

关键代码： 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。

应用实例： 1、孙悟空有 72 变，当他变成"庙宇"后，他的根本还是一只猴子，但是他又有了庙宇的功能。 2、不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体。

优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

缺点：多层装饰比较复杂。

使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。

注意事项：可代替继承。

实现

步骤 1

创建一个接口：

package intervalset;
import java.util.Set;
public interface MultiIntervalSet<L> {
     public static <L> MultiIntervalSet<L> empty() {
         return new CommonMultiIntervalSet<L>();
     }
     public static  <L> MultiIntervalSet<L> inite(IntervalSet<L> initial)
     {
         CommonMultiIntervalSet<L> temp=new CommonMultiIntervalSet<L>();
         temp.init(initial);
         return temp;
     }
     public void insert(long start,long end,L lable);
     public Set<L> labels() ;
     public boolean    remove(L label);
     public IntervalSet<Integer> intervals(L label);
 }

这个接口是一个时间段的类，有一个标签L，对应了很多个时间段，每个时间段有一个开始和一个结束。

步骤 2

创建实现接口的实体类。

package intervalset;
import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Set;public class CommonMultiIntervalSet<L> implements MultiIntervalSet<L>{
     private HashMap<Integer,IntervalSet<L>> map=new HashMap<Integer,IntervalSet<L>>();
     private HashMap<L, Integer> size=new HashMap<L, Integer>();
     private Integer maxsize =0;
     public void init(IntervalSet<L> initial) {
         map=new HashMap<Integer,IntervalSet<L>>();
         size=new HashMap<L, Integer>();
         maxsize =0;
         map.put(0, initial);
     }
     @Override
     public void insert(long start, long end, L lable) {
         if (size.containsKey(lable)) {
             if (maxsize>size.get(lable)) {
                 int temp =size.get(lable)+1;
                 size.put(lable, temp);
                 IntervalSet<L> tempIntervalSet= map.get(temp);
                 tempIntervalSet.insert(start, end, lable);
                 map.put(temp, tempIntervalSet);
             }
             else {
                 maxsize++;
                 size.put(lable, maxsize);
                 IntervalSet<L> tempIntervalSet= IntervalSet.empty();
                 tempIntervalSet.insert(start, end, lable);
                 map.put(maxsize,tempIntervalSet);
             }        } else {
             size.put(lable, 0);
             IntervalSet<L> tempIntervalSet;
             if ((tempIntervalSet=map.get(0))==null) {
                 tempIntervalSet=IntervalSet.empty();
             }
             else {
                 tempIntervalSet=map.get(0);
             }
                 tempIntervalSet.insert(start, end, lable);
                 map.put(0, tempIntervalSet);
                 size.put(lable, 0);
         }
         
     }    @Override
     public Set<L> labels() {
         return size.keySet();
     }    @Override
     public boolean remove(L label) {
         Integer tempInteger=size.get(label);
         if (tempInteger==null) {
             return false;
         } else {
             IntervalSet<L> tempIntervalSet;
             for(int i=0;i<=tempInteger;i++)
             {
                 tempIntervalSet=map.get(i);
                 tempIntervalSet.remove(label);
                 map.put(i, tempIntervalSet);
             }
             size.remove(label);
             return true;
         }
     }    @Override
     public IntervalSet<Integer> intervals(L label) {
         IntervalSet<Integer> intervalSet=new CommonIntervalSet<Integer>();
         ArrayList<Interval> arrayList =new ArrayList<Interval>();
         Integer integer=size.get(label);
         if (integer==null) {
             return null;
         }
         for (int i = 0; i <= integer; i++) {
             Interval tempInterval=new Interval();
             tempInterval.setStart(map.get(i).start(label));
             tempInterval.setEnd(map.get(i).end(label));
             arrayList.add(tempInterval);
         }
         arrayList.sort(new Comparator<Interval>() {
             @Override
             public int compare(Interval o1, Interval o2) {
                 return o1.getStart()>o2.getStart()?1:0;
             }
         });
         for (int i = 0; i < integer; i++) {
             intervalSet.insert(arrayList.get(i).getStart(), arrayList.get(i).getEnd(), i);
         }
         return intervalSet;
     }}

这是对接口的实现

步骤 3

创建实现了 MultiIntervalSet<L> 接口的抽象装饰类。

package intervalset;
import java.util.Set;
public abstract class MultiIntervalSetDecorator<L> implements MultiIntervalSet<L> {
     protected MultiIntervalSet<L> multiIntervalSet;
     public MultiIntervalSetDecorator(MultiIntervalSet<L> multiIntervalSet) {
         this.multiIntervalSet=multiIntervalSet;
     }
     @Override
     public void insert(long start, long end, L lable) {
         multiIntervalSet.insert(start, end, lable);
         
     }
     @Override
     public Set<L> labels() {
         return multiIntervalSet.labels();
     }
     @Override
     public boolean remove(L label) {
         return multiIntervalSet.remove(label);
     }
     @Override
     public IntervalSet<Integer> intervals(L label) {
         return multiIntervalSet.intervals(label);
     }
 }

步骤 4

创建扩展了 MultiIntervalSetDecorator<L>类的实体装饰类。，这里我们给它添加一些属性，完成一个让多个对象的每个时间段不能发生重叠的限定

package intervalset;
import java.util.ArrayList;
 import java.util.Iterator;public class NOOverlapInterval<L> extends MultiIntervalSetDecorator<L>{
    private  ArrayList<Interval> arrayList=new ArrayList<Interval>();
     public NOOverlapInterval(MultiIntervalSet<L> multiIntervalSet) {
         super(multiIntervalSet);
     }
     @Override
     public void insert(long start, long end, L lable) {
         for (Iterator<Interval> iterator = arrayList.iterator(); iterator.hasNext();) {
             Interval interval = (Interval) iterator.next();
             if ((start>interval.getStart() && start <interval.getEnd()) || (end>interval.getStart() && end<interval.getEnd()) ) {
                 System.out.print("Overlap error \n");
                 return;
             }
         }
         multiIntervalSet.insert(start, end, lable);
         Interval interval=new Interval();
         interval.setStart(start);
         interval.setEnd(end);
         arrayList.add(interval);
     }
     @Override
     public boolean remove(L label) {
         IntervalSet<Integer> intervalSet=multiIntervalSet.intervals(label);
         for (int i = 0; i < intervalSet.labels().size(); i++) {
             Interval interval=new Interval();
             interval.setStart(intervalSet.start(i));
             interval.setEnd(intervalSet.end(i));
             for (int j = 0; i < arrayList.size(); j++) {
                 if (arrayList.get(j).equal(interval)) {
                     arrayList.remove(j);
                 }
             }
         }
         return multiIntervalSet.remove(label);
     }
 }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。