设计模式知识

1、目录1. S i ng I eton一单例模式32. Factory一工厂 模式63. Abst ractFactor y-才由 象工 厂模式74. Proxy一代理模式105. Strategy - 我略模 式136. Facade一夕卜现模式14l_Mediator-调停（中介）者模式168. Decorat。一装饰器模式179. Cha i nOfRespons i b i I i ty-责任链模 式1810. Observer-观察者模式2111. Compos i te一组合模式2312. I terator一迭代 等才契 式2513. Fly/eight-字元（蝇量）模式2614.

2、 Bui Ider-建造者模式2815. Visitor-访问者模式2916. Adapter-适配器模式.3117. Bridge-桥接模式3318. Prototype-原 型1美 式3519. Command-命令模式372。Memento一备忘 录模式3821. Temp late一模为模式4022. State-状态模式4123. I nterpr eter-解彳车 器 模 式42总述设计模式的三个分类1)创建型模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程。2)结构型模式：把类或对象结合在一起形成一个更大的结构。3)行为型模式：类和对象如何交互，及划分责任和算法。访问者

3、模式 模板模式第略横式状态模式观察者模式 备忘录模式 中介者模式 迭代器横式设计模式二、行为型模式创建型模式结构型模式e解释署模式命令横式责任楂模式单例横式工厂方法模式 抽象工厂模式.建迨者横式适配器板式桥接横式 组合模式 装饰模式 外观模式 享元模式 代理模式设计模式的六大原则1)开闭原则(Open Close Principle)对扩展开放，对修改关闭。尽量在不修改原有的代码的基础之上进行扩展。尽可能 提高程序的扩展性，易于维护和升级。抽象化，多态是开闭原则的关键。2)里氏代换原则(Liskov Substitution Principle)所有使用父类的地方，必须能够使用子类对象去替代、

4、且原有的功能不受影响。任何基类可以出现的地方，子类一定可以出现。只有当派生类可以替换掉基类，且 功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行 为。3)依赖倒转原则(Dependence Inversion Principle)依赖抽象而不是依赖具体。面向抽象编程、面向接口编程，只有这样、具体的实现 细节才可以被替换而接口不变，可替代性较高。4)接口隔离原则(Interface Segregation Principle)每一个接口应该承担独立的角色，做自己该做的事情、不做不该做的，不该把两类功能合二为一，避免子类实现不该实现的方法。需要对外暴露接口时，要暴露最少

5、量的接口。5)迪米特法则,又称最少知道原则(Demeter Principle)一个实体应当尽量少地与其他实体之间发生相互作用，使系统功能模块相对独立。6)合成复用原则(Composite Reuse Principle)尽量使用合成/聚合的方式，而不是使用继承。系统设计指导思想1)可维护性修改功能，需要改动的地方越少，可维护性就越好2）可复用性代码可以被后续重复使用：写出自己总结的类库3）可扩展性添加功能无需修改原来的代码4）灵活性代码接口可以可以灵活调用1. Singleton一单例模式概述：某个类只能有一个实例，提供一个全局的访问点 何时使用：当您想控制实例数目，节省系统资源的时候。 应

6、用场景：在内存中只需要存在一个实例封装的足够完善，在代码层面保证它在内存中只有一个实例存在。例如：各种Factory,比如I/O与数据库的连接等优点：1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例 （比如管理学院首页页面缓存）。2、避免对资源的多重占用（比如写文件操作）。缺点：没有接口，不能继承，与单一职贵原则冲突，一个类应该只关心内部逻辑，而不 关心外面怎么样来实例化。一）饿汉式类加载到内存后，就实例化一个单例，JVM保证线程安全。之所以是线程安全的是 因为，JVM能够保证每个Class只能被load到内存一次，INSTANCE变量是在Class被 load到内存之后

7、马上就会被初始化的。因为静态变量只要被load到内存就会被初始化。 块点：无论用到与否，类装载时就会完成实例化 示例：public class SingletonHungry （private static final SingletonHungry INSTANCE = new SingletonHungry（）;private SingletonHungry（） ;pub Ii c static SingletonHungry get Instance （） return INSTANCE.）说明：5）声明一个private static final变量供调用方使用；6）仅有的一个构造方法

8、设置成private,其他的类无法再实例化此类：7）其他类想用的时候只能通过get Instance （）方法获取实例：8）因为仅有的一次new的操作是静态的，所以无论调用多少次get Instance 0方法得到 的都是同一个实例；二）懒汉式（Lazy Load i ng）类加载到内存的时候不会被初始化，只有在第一次被调用的时候才会被初始化。 块点：无论用到与否，类装载时就会完成实例化 示例一：pub Iic class SingletonLazy private static SingletonLazy INSTANCE = null;private SingletonLazy0 ;pub

9、 Ii c static SingletonLazy get Instance() N (INSTANCE 二 INSTANCE = new SingletonLazy0 ;)return INSTANCE;)上面方法虽然达到了单例的目的，并且可以被初始化，但是是线程不安全的。例如：线 程A走到了 if (/超null)还未new实例之前、线程B也走到了 if语句，两个线程 都new 了 SingletonLazy的实例，不再是同一个实例了。可以用示例二的方式保证线程安全。 示例二：public class SingletonLazy private static SingletonLazy

10、INSTANCE = null;private SingletonLazy () ;pub Ii c static synchronized SingletonLazy get Instance () INSTANCE null) INSTANCE = new SingletonLazy0 ;)return INSTANCE;)上面的方法虽然能够保证线程安全，但是synchronized关键字的效率较低。经过优化、 缩小synchronized的范围得出下方示例三双重判断的写法： 示例三：public class SingletonLazy private static volatile Si

11、ngletonLazy INSTANCE = null;private SingletonLazy () ;public stat ic SingletonLazy get Instance() INSTANCE null) synchronized (S i ng IetonLazy. cI ass) xiUNSTANCE null) INSTANCE = new SingletonLazy0 ;return INSTANCE； ) 第一次INSTANCE的判空能够过滤掉大部分多线程调用初始化时的互斥锁的操作，因为如果 判断出实例已经存在就不会再执行synchronized的操作。只有小部分

12、会发生并发问题， 通过第二次判空去解决。三)将态内部类方式在懒汉式的基础上延伸出的静态内部类方式 示例：public class SingletonLazy private SingletonLazy() ;private stat i c class S i ng IetonLazyHoIder private final static SingletonLazy INSTANCE = new SingletonLazy0;pub Ii c static SingletonLazy get Instance 0 return Si ng IetonLazyHoIder. INSTANCE )

13、 说明：加载外部类时内部类不会被加载、通过这种方式实现懒加载。由JVM保证单例。由JVM 保证线程安全，JVM加载Class只加载一次、无论是外层的类还是内部类都只加载一次，所 以能够保证INSTANCE只被实例化一次。在内部类中去实例化，而构造方法同样是private的，外部无法访问，只能通过内部类 的方式访问。然最后在外部通过调用野态内部类的方法来进行实例化。四)枚举美方式EffectiveJava中提到的一种单例模式，不仅可以保证线程安全，还可以防止反序列化。 public enum SingletonEnum INSTANCE,pub Iic void doSomet ing() /业

14、务代码) 说明： 调用时直接 Singl etonEnum. INSTANCE. doSomet i ng (); 为什么要防止反序列化？因为JAVA的反射机制可以通过一个Class文件，把类load到内存，然后new 一个实例 出来。前几种方式都可以通过这样的方法来破坏单例。只有这样的方式才能够防止被破坏。 枚举单例不会被反序列话的原因是因为枚举类没有构造方法，所以就算拿到Class文件 也无法构造其对象。2. Factory一工厂模式概述：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其 创建过程延迟到子类进行。任何可以产生对象的方法或者类，都可以称之为工厂。单例也

15、是一种工厂，有人称之为静态工厂。在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的 对象。何时使用：根据不同条件创建不同实例应用场景：日志记录器：记录可能记录到本地硬疝、系统事件、远程服务器等，用户可以选择记录日志 到什么地方。数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。优点：1、一个调用者想创建一个对象，只要知道其名称就可以了。2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。3、屏蔽产品的具体实现，调用者只关心产品的接口。抉点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数 成倍增加，在一定程

16、度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是 什么好事。示例：public interface Shape void drawO ;)public class Circle implements Shape 0verridepublic void draw0 System. out. pr int In ("drawed a Circle!”);)public class Rectangle implements Shape©Overridepubl ic void drav/() System. out- pr int In ("drawed

17、a Rectangle!");)public class Square implements Shape 0verridepubl ic void drav/() System. or/t. pr int In ("drawed a Square!u);pub Iic class ShapeFactory pub Ii c Shape getShape (Str i ng type) Shape shape = null;sw i tch (type) case MCi role":shape = new CircleO ;break;case 'Squa

18、re1':shape = new Square ();break;case 'RectangIeu:shape = new Rectang I e();break;)return shape;)3. AbstractFactory-抽象工厂模式概述：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。应用场景：现代人与古代人在衣、食、住、行方面的体现。优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个 产品族中的对象。缺点：产品族扩展非常困难，要增加一个系列的某一产品，

19、既要在抽象的Creator里加代 码，又要在具体的里面加代码。示例：一)为形状创建一个接口public interface Shape void drawO ;)二)创建形状接口的实现类public class Circle impIements Shape ,?0ver r i depubl ic void draw() System. out. pr i nt I n ("drawed a Circle!");)public class Square implements Shape 0verridepubl ic void drav/() System. out. p

20、r int In ("drawed a Square!u);pub Iic class Rectangle implements Shape fflOverr i depub I ic void drawO System. out. pr int InC'drawed a Rectangle!");)三)为颜色创建一个接口pub Iic interface Color vo id fill ();)四)创建颜色接口的实现类public class Blue implements Color( 0verridepublic void f i I I 0 System.

21、 out，pr intlnC'f i I I color is blue"); )public class Red implements Color( ©Overridepub lie void f i I I 0 System. out- pr intlnC'f i I I color i s red"); ) public class Green implements Color(©Overridepub lie void f i I I 0 System. out. pr intln(Hf i I I color is green&

22、quot;); ) 五)创建抽象类工厂 public abstract class AbstractFactory abstract Shape getShape(Str i ng type);abstract Color getColor(Str ing color);)六)创建扩展AbstractFactory的工厂类，能够基于给定的信息生成实体类的对象 public class ColorFactory extends AbstractFactory ®0verr i deColor getColor (Str ing color) switch (color) case re

23、d :return new Red (); case 'blue":return new BI ue ();case 'green":return new Green ();) return null;©OverrideShape getShape(String type) return null;)pub Iic class ShapeFactory extends AbstractFactory ( pub Ii c Shape getShape (Str i ng type) Shape shape = null; switch (type)

24、 case "Circle”:shape = new CircleO ;break;case "Square":shape = new Square ();break;case "RectangIeM:shape = new Rectang I e();break;)return shape;0verrideColor getColor (String color) return null;)七)创建一个工厂创造器/生成器类，通过传递形状或颜包信息来获取工厂 public class FactoryProducer (pub Iic static Abs

25、tractFactory getFactory (Str i ng choose) if (choose = "color") return new ColorFactory(); else if (choose = "shape'*) return new ShapeFactory();) return null;1八）使用FactoryProducer来获取AbstractFactory,通过传递类型信息来获取实体类的对象pub Iic class tester pub Ii c static void main(String args) Abstra

26、ctFactory colorFactory = FactoryProducer. getFactoryCcolor1');Color blueColor = colorFactory. getColor (Mblue，');blueColor. f i I I ();AbstractFactory shapeFactory = FactoryProducer. getFactoryCshape' );Shape squareShape = shapeFactory. getShape ('*Square");squareShape. drav/();

27、)4. Proxy-代理模式概述：为其他对象提供一种代理以控制对这个对象的访问。一般是因为客户端不想直接 访问实际的对象，或者访问实际的对象存在困难，因此通过一个代理对象来完成间接的 访问。何时使用：想在访问一个类时做一些控制应用场景：1、买火车票不一定在火车站买，也可以去代售点。2、SpringAOP优点：1、职贵清晰。2、高扩展性。缺点：1、由于在客户端和真实实体之间增加了代理对象，因此有些类型的代理模式可 能会造成请求的处理速度变慢。2、实现代理模式需要额外的工作，有些代理模式的实 现非常复杂。注意事项：1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理 模式不能改变所代

28、理类的接口。2、和装饰器模式的区别：装饰器模式为了增强功能， 而代理模式是为了加以控制。示例：-)价态代理public interface IPrinter void doPrint();)public class Printer implements IPrinter 0Overridepublic void doPrint() try System.out.println("I have printed the v/ords on pages!M);new Thread().$(eep(3000); catch (InterruptedException e) e.printSt

29、ackTrace();)public class PrintLogProxy implements IPrinter IPrinter printer;public PrintLogProxy(IPrinter printer) this.printer = printer;)Overridepublic void doPrint() System.out.printIn(MBefore print!printer doPrint();System.out.printIn(MAfter print!");)public class PrintTimeProxy implements

30、IPrinter IPrinter printer;public PrintTimeProxy(IPrinter printer) this.printer = printer;)0Overridepublic void doPrint() Long before = System.currentprinter doPrint();Long after = System.currentTimeMiLLis();System.out.printIn(MIt cost+ (after - before);)public class Tester public static void main(St

31、ring args) new PrintTimeProxy(new PrintLogProxy (nev/ Printer (), doPrint ();)二)Ref lectProx动态代理：用ASM的方式动态生成了 class文件，必须指定接口java. lang, reflect. Proxy:生成动态代理类和对象：java. lang, reflect. I nvocat i onHand ler (处理器接口 ):可以通过 i nvoke 方法实现 public interface IPrinter void doPrint();)public class Printer imple

32、ments IPrinter Overridepublic void doPrint() try (System. out. print In (" I have printed the v/ords on pages!new Thread。,s，eep(3000) ; catch (InterruptedException e) e.printStackTrace();)/每次通过Proxy生成的代理类对象都要指定对应的处理器对象口public class MylnvocationHandler implements InvocationHandler IPrinter print

33、er;public MylnvocationHandler(IPrinter printer) this.printer = printer;)Overridepublic Object invoke(Object proxy. Method method? Object args) throws Throv/able System. out. print In (M Before print!Object invoke = method.invokeCprinter> args);System.out.printin("After print!"); return

34、invoke;)public class Tester public static void main(String args) IPrinter pr = new Printer();MylnvocationHandler mylnvocationHandler = new MyInvocationHandler(pr); /代理对象IPrinter proxyClass = (IPrinter)Proxy.neuProxylnstance(ClassLoader.getSystemCLassLoader()new Class IPrinter.class > mylnvocation

35、Handler); proxyClass.doPrint();)三)Cgl ib动态代理Cglib动态代理是针对代理的类，动态生成一个子类，然后子类覆盖代理类中的方 法，如果是pr ivate或是final类修饰的方法，则不会被重写。CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK 的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理 的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。/被代理类public class Printer (public void doPrint() try (System. out. pr

36、int In (" I have printed the v/ords on pages!new Thread(),s/e2p(3000); catch (InterruptedException e) e.printStackTrace();)/回调对象public class MyMethodinterceptor implements Methodinterceptor Overridepublic Object intercept(Object sub, Method method> Object objects, MethodProxy methodProxy) th

37、rows Throv/able System.out.printIn(Mbefore doPrint!");Object object = methodProxy.invokeSuper(subobjects);System.out.printIn(Mafter doPrint!");return object;)public class Tester public static void main(String args) /代理类class文件存入本地磁盘方便我们反编译查看源码System.setProperty(DebuggingClassriter.DEBUG_LO

38、CATION_PROPERTY, '7demo/src/DesignModel/Proxy_CGLIBM); CGLIB代理类Enhancer enhancer = new Enhancer();enhancer.setSuperclass(Printor.class);enhancer.setCallback(new MyMethodInterceptor();Printor printor = (Printor)enhancer.create();printor.doPrint();) )5. Strategy-策略模式概述：定义一系列的算法，把它们一个个封装起来，并且使它们可相互

39、替换。在有多种算法 相似的情况下，可以替代if分支语句所带来的复杂难以维护的问题。何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为，可以把他们各自进 行封装然后实现统一的接口，使他们能够任意的替换。应用场景：各种付款方式，出行的各种交通方式等。优点：1、算法可以自由切换。2、避免使用多重条件判断。3、扩展性良好。缺点：1、策略类会增多。2、所有策略类都需要对外暴露。示例：/定义一个接口public interface ICaIculator int doCalc(int a, int b);)/创建实现接口的各个实现类public class Adder implements (

40、Calculator (©Overridepub Ii c int doCaIc (i nt a, int b) return a + b;pub Iic class Reducer implements I Calculator Overr i depub Iic int doCaIc (i nt a, int b) return a - b;)pub Iic class Rider implements I Calculator ©Overridepub Ii c int doCaIc (i nt a, int b) return a * b;)/创建Context类p

41、ub Iic class Context (pr ivate I Calculator calcu;pub Ii c void setCaIcu (ICaIcuIator calcu) this.calcu = calcu;pub Ii c int doCaIc (i nt a, int b) return calcu. doCaIc(a, b);)/创建测试类pub Iic class Tester pub Ii c stat i c void ma in(Str ing args) Context context = new Context();context. setCaIcu(new

42、Adder ();int result = context. doCalc(4, 3);System. out. printing'加法结果一一n + result);context. setCaIcu (new Reducer ();result = context.doCaIc(4, 3);System.t. print In (“减法结果一" + result);context. setCaIcu(new Rider ();result = context.doCaIc(4, 3);System.。" print In ("乘结果一"+ r

43、esult);)6. Facade-外观模式概述：隐藏系统的复杂性，向外部使用者提供的仅是使用起枭比较简单的接口或单一的 类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。与调停者模式区 别在于此种模式是对于外部调用内部来讲的，而前者是内部互相调用的封装。pub Ii c void draw (String type) switch (type) case circle :ci rc I eShape. draw();break;case 'square*':squareShape. draw();break;case "rectangle1':

44、rectang I eShape, draw ();break;default: break;)四)实例化外观类、使用这个外观类7. Mediator-调停(中介)者模式概述：提供一个中介类用枭降低多个对象之间的耦合性，处理不同类之间的交互，使代 码易于维护。用一共中介类来封装一系列对象之间的交互行为、使对象之间不需要显示 的互相引用。与外观模式区别在于这种模式是存在于系统内部、而外观模式是对于外部 使用者产生的封装类。何时使用：多个类之间耦合性较高时，为了降低耦合程度而产生，一组定义良好的对象， 现在要进行复杂的相互通信。应用场景：1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖

45、关系结构混 乱而且难以复用该对象。2、想通过一个中间类来封装多个类中的行为，而又不想生成太多 的子类。3、消息中间件思想-发布消息、需要的系统去订阅获取消息。优点：1、降低了类的复杂度，将一对多转化成了一对一。2、各个类之间的解犒。3、 符合迪米特原则。缺点：中介者会庞大，变得复杂难以维护。示例：public class User Str ing userName;pub Ii c User (Str i ng userName) this. userName = userName;1pub Ii c void sendMsg (Str ing message) MsgQueue. showM

46、sgih i s, message);pub I i c String getllserName () return userName;pub I i c void setllserName (Str i ng userName) this.userName = userName;)/中介类pub Iic class MsgQueue pub Iic stat i c void showMsg (User user, String msg) System, out- pr i nt I n (new Date (). toStr i ng () +” M + user. getllserNam

47、e () + ": " + msg);)/使用User对象来显示他们之间的通信pub Iic class Tester pub Iic stat i c void main(String args) User userA = new User ("Aber");User userB = new User ("Boom");userA. sendMsgC'Hi, Boom!M);userB. sendMsgC'Hi, Aber!M);)8. Decorato-装饰器模式概述：允许向现有的对象添加新功能或额外的功能，同时又

48、不改变这个类的结构。作为 现有类的一个包装类，动态的为一个对象添加额外的职责。何时使用：为了扩展一个类经常使用继承的方式，但是随着扩展功能的增多，子类会越来越 膨胀，在不想增加更多子类的情况下扩展类。应用场景：1、扩展一个类的功能。2、动态增加功能，动态撤销。优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式, 装饰模式可以动态扩展一个实现类的功能。缺点：多层装饰比较复杂。示例：public interface Shape void draw();)public class Circle implements Shape 0verridepublic void dr

49、aw0 System. out- pr int In ("Drawed a circle!'*);/抽象装饰类，供实体装饰类继承public abstract class ShapeDecorator implements Shape protected Shape decoratoShape;pub Ii c ShapeDecorator (Shape decoratoShape) this. decoratoShape = decoratoShape;publ ic void drav/() decoratoShape. draw();)/真正的装饰器类，在此添加装饰内容

50、public class Co IorShapeDecorator extends ShapeDecorator (pub Ii c Co IorShapeDecorator (Shape decoratoShape) super (decoratoShape);publ ic void drawO decoratoShape. drawO ;this, f i I IColor ();private void fi I IColor () System. out. pr intln(Mf i I led red color !H);)public class Tester pub Ii c

51、stat i c void main(String args) Shape circle = new Ci rcle();circle, draw();ShapeDecorator ShapeDecorator = new Co IorShapeDecorator(new Ci rcle (); ShapeDecorator. draw();)9. Cha i nOfRespons i b i I ity-责任链模式概述：为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和 接收者进行解耦。通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该 请求，那么它会把相

52、同的请求传给下一个接收者，依此类推，让多个对象都有可能接收请求， 将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。何时使用：在处理消息的时候、让多个处理者都参与处理。应用场景：Struts2的拦极器，jsp servlet 的 Fi IterChain优点：1、降低耦合度。它将请求的发送者和接收者解耦。2、简化了对象,使得对象不需要知道链的结构。3、增强给对象指派职费的灵活性。通过改变链内的成员或者调动它们的次序，允许动 态地新增或者删除责任。4、增加新的请求处理类很方便。缺点：1、不能保证请求一定被接收。2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造

53、成循环调用。3、可能不容易观察运行时的特征，有碍于除错。示例：一)按级别打印Log(定义链式结构中的下一个节点)/创建抽象的日志类，提供设优链式结构中下一个处理节点的功能public abstract class AbstractLogger pub Iic final static int INFO = 1;pub Iic final static int DEBUG = 2;pub Iic final static int ERROR = 4;pub Ii c AbstractLogger nextLogger;pub Iic int I eve I;pub Ii c void setNe

54、xtLogger (AbstractLogger nextLogger) this.nextLogger = nextLogger;public void logMessage(int level, String msg) print (msg);if(nextLogger != null) nextLogger. IogMessage (I eve I, msg);)abstract void print (String msg);)/按级别创建日志类public class LoggerError extends AbstractLoggerpub Ii c LoggerError (in

55、t level) this.level = level;©Overridevoid print (String msg) System. out- pr int In ("Error>"' + msg);)public class Logger Info extends AbstractLoggerpub Ii c Logger Info (int I eve I) this.level = level;0verridevoid print (String msg) System. out. pr i nt I n (" I nfo>

56、" + msg);public class LoggerDebug extends AbstractLogger pub Ii c LoggerDebug(int level) this. I eve I = I eve I;0verr idevoid print (String msg) System. out. pr i nt I n ("Debug>" + msg);public class Tester pub Iic stat i c void AbstractLogger AbstractLogger AbstractLogger/在测试类中将节点组成一条链式结构 main(Str ing args) infoLogger = new Logger Info (AbstractLogger. INFO);d