精华内容
下载资源
问答
  • 1、 原型模式实现机制原型模式在设计模式中相对比较简单,它直接通过实现 Cloneable接口,再重写 clone()方法返回想要的对象就OK 了。一起来看下代码 :public class ProtoType implements Cloneable {public ...

    1、 原型模式实现机制

    原型模式在设计模式中相对比较简单,它直接通过实现 Cloneable接口,再重写 clone()方法返回想要的对象就OK 了。

    一起来看下代码 :

    public class ProtoType implements Cloneable {

    public ProtoType(){

    System.out.println("new ");

    }

    /**

    * 重写clone

    * @return

    * @throws CloneNotSupportedException

    */

    @Override

    protected Object clone() throws CloneNotSupportedException {

    System.out.println("clone");

    return (ProtoType)super.clone();

    }

    //测试 : 依次打印 new clone

    public static void main(String[] args) throws CloneNotSupportedException {

    //通过new 方式

    ProtoType protoType = new ProtoType();

    //通过clone方式,注意不走构造函数

    ProtoType protoType2 =(ProtoType) protoType.clone();

    // false 两个对象是不同引用

    System.out.println(protoType ==protoType2);

    }

    }

    可以看到,我们需要多少对象,直接调用clone()克隆即可。

    2、优缺点分析

    优点: 它是在运行时操作对象,操作的是内存中的二进制流,在创建大对象时,相比 new 一个对象,性能优势明显。

    缺点:必须实现Cloneable接口

    3、使用场景

    希望以一个对象为原型,创建其他近似的对象的时候;

    代码优化场景, 业务中用的比较少,一般很少单独使用,会结合工厂方法模式使用;

    多个调用者使用时,并且需要修改对象中的值,可以考虑原型模式来提供对象;

    ok,很简单吧🤙🤙🤙

    展开全文
  • 2、原型(Prototype)模式:将一个对象作为原型,通过对其进行复制而克隆出多个和原型类似的新实例。 3、工厂方法(Factory Method)模式:定义一个用于创建产品的接口,由子类决定生产什么产品。 4、抽象工厂...

    1、单例(Singleton)模式:某个类只能生成一个实例,该类提供了一个全局访问点供外部获取该实例,其拓展是有限多例模式。

    2、原型(Prototype)模式:将一个对象作为原型,通过对其进行复制而克隆出多个和原型类似的新实例。

    3、工厂方法(Factory Method)模式:定义一个用于创建产品的接口,由子类决定生产什么产品。

    4、抽象工厂(AbstractFactory)模式:提供一个创建产品族的接口,其每个子类可以生产一系列相关的产品。

    5、建造者(Builder)模式:将一个复杂对象分解成多个相对简单的部分,然后根据不同需要分别创建它们,最后构建成该复杂对象。

    6、代理(Proxy)模式:为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象,从而限制、增强或修改该对象的一些特性。

    7、适配器(Adapter)模式:将一个类的接口转换成客户希望的另一个接口,使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

    8、桥接(Bridge)模式:将抽象与实现分离,使它们可以独立变化。它是用组合关系代替继承关系来实现,从而降低了抽象和实现这两个可变维度的耦合。

    9、装饰(Decorator)模式:动态的给对象增加一些职责,即增加其额外的功能。

    10、外观(Facade)模式:为多个复杂的子系统提供一个一致的接口,使这些子系统更加容易被访问。

    11、享元(Flyweight)模式:运用共享技术来有效地支持大量细粒度对象的复用。

    12、组合(Composite)模式:将对象组合成树状层次结构,使用户单个对象和组合对象具有一致的访问性。

    13、模板方法(TemplateMethod)模式:定义一个操作中的算法骨架,而将算法的一些步骤延迟到子类中,使得子类可以不改变该算法结构的情况下定义该算法的某些特定步骤。

    14、策略(Strategy)模式:定义了一系列算法,并将每个算法封装起来,使它们可以相互替换,且算法的改变不会影响使用算法的客户。

    15、命令(Command)模式:将一个请求封装为一个对象,使发出请求的责任和执行请求的责任分隔开。

    16、职责链(Chain of Responsibility)模式:把请求从链中的一个对象传到下一个对象,直到请求被响应为止。通过这种方式去除对象之间的耦合。

    17、状态(State)模式:允许一个对象在其内部状态改变时改变其行为能力。

    18、观察者(Observer)模式:多个对象间一对多关系,当一个对象发生改变时,把这种改变通知给其他多个对象,从而影响其他对象的行为。

    19、中介者(Mediator)模式:定义一个中介对象来简化原有对象之间的交互关系,降低系统中对象间的耦合度,使原有对象之间不必相互了解。

    20、迭代器(Iterator)模式:提供一种方法来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。

    21、访问者(Visitor)模式:在不改变集合元素的前提下,为一个集合中的每个元素提供多种访问方式,即每个元素有多个访问者对象访问。

    22、备忘录(Memento)模式:在不破坏封装性的前提下,获取并保存一个对象的内部状态,以便以后恢复它。

    23、解释器(Interpreter)模式:提供如何定义语言的文法,以及对语言句子的解释方法,即解释器。

     

    一、开闭原则

    定义:一个软件实体,如类,模块和函数应该对拓展开放,对修改关闭。用抽象构建框架,用实现拓展细节。

    优点:提高软件系统的可复用性及可维护性。

    二、依赖倒置原则

    定义:高层模块不应该依赖低层模块,两者都应该依赖其抽象。抽象不应该依赖细节;细节应该依赖抽象。针对接口编程,不要针对实现编程

    优点:可以减少类之间的耦合性、提高系统稳定性、提高代码可读性和可维护性,可降低修改程序所造成的风险。

    三、单一职责原则

    定义:不要存在多于一个导致类变更的原因。一个类\接口\方法只负责一项职责。

    优点:降低类的复杂度、提高类的可读性,提高系统的可维护性、降低变更引起的风险。

    四、接口隔离原则

    定义:用多个专门的接口,而不使用单一的总接口,客户端不应该依赖它不需要的接口。一个类对一个类的依赖应该建立在最小的接口上。建立单一接口,不要建立庞大臃肿的接口。尽量细化接口,接口中的方法尽量少。

    优点:符合我们常说的高内聚低耦合的设计思想,从而使得类具有良好的可读性、可拓展性和可维护性。

    五、迪米特原则

    定义:一个对象应该对其他对象保持最少的了解。又叫最少知道原则。尽量降低类与类之间的耦合。强调只和朋友交流,不和陌生人说话。朋友--出现在成员变量、方法的输入、输出参数中的类称为成员朋友类,而出现在方法体内部的类不属于朋友类。

    优点:降低类之间的耦合。

    六、里式替换原则

    定义:如果对每一个类型为T1的对象O1,都有类型为T2的对象O2,使得以T1定义的所有程序P在所有的对象O1都替换成O2时,程序P的行为没有发生变化,那么类型T2是类型T1的子类型。

    定义拓展:一个软件实体如果适用一个父类的话,那一定适用于其子类,所有引用父类的地方必须能透明地使用其子类的对象,子类对象能够替换父类对象,而程序逻辑不变。

    引申意义:子类可以拓展父类的功能,但不能改变父类原有的功能。

    含义1:子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法。

    含义2:子类中可以增加自己特有的方法。

    含义3:当子类的方法重载父类的方法时,方法的前置条件(即方法的输入/入参)要比父类方法的输入参数更宽松。

    含义4:当子类的方法实现父类的方法时(重写\重载或实现抽象方法),方法的后置条件(即方法的输出\返回值)要比父类更严格或相等。

    优点1:约束继承泛滥,开闭原则的一种体现。

    优点2:加强程序的健壮性,同时变更时也可以做到非常好的兼容性,提高程序的维护性、拓展性。降低需求变更时引入的风险。

    七、合成(组合)/聚合复用原则

    定义:尽量使用对象组合/聚合,而不是继承关系达到软件复用的目的。

    优点:可以使系统更加灵活,降低类与类之间的耦合度,一个类的变化对其他类造成的影响相对较少。

    八、简单工厂

    定义:由一个工厂对象决定创建出哪一种产品类的实例。

    类型:创建型,但不属于GOF23种设计模式。

    使用场景:工厂类负责创建的对象比较少。客户端(应用层)只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心。

    优点:只需要传入一个正确的参数,就可以获取你所需要的对象,而无需知道其创建的细节。

    缺点:工厂类的职责相对过重,增加新的产品,需要修改工厂类的判断逻辑,违背开闭原则。

    九、工厂方法

    定义:定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个类,工厂方法让类的实例化推迟到子类中进行。

    适用场景:创建对象需要大量重复的代码。客户端(应用层)不依赖于产品类实例如何被创建、实现等细节。一个类通过其子类来指定创建哪个对象。

    优点:用户只需要关心所需的产品对应的工厂,无需关心创建细节。加入新产品符合开闭原则,提高可拓展性。

    缺点:类的个数容易过多,增加复杂度。增加了系统的抽象性和理解难度。

    十、抽象工厂

    定义:抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口。无需指定它们具体的类。

    使用场景:客户端(应用层)不依赖于产品实例如何被创建、实现等细节。强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量重复的代码。提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。

    优点:具体产品在应用层代码隔离,无需关心创建细节。将一个系列的产品族统一到一起创建。

    缺点:规定了所有可能被创建的产品集合,产品族中扩展新的产品困难,需要修改抽象工厂的接口。增加了系统的抽象性和理解难度。

     

    十一、建造者模式

    定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。用户只需指定所要建造的类型就可以得到它们,建造过程及细节不需要知道。

    适用场景:如果一个对象有非常复杂的内部结构(很多属性)。想把复杂对象的创建和使用分离。

    优点:封装性好,创建和使用分离。扩展性好、建造类之间独立、一定程度上解耦。

    缺点:产生多余的Builder对象。产品内部发生变化,建造者都要修改,成本较大。

    十二、单例设计模式

    定义:保证一个类仅有一个实例,并提供一个全局的访问点。

    适用场景:想确保任何情况下都绝对只有一个实例。

    优点:在内存里只有一个实例,减少了内存的开销。可以避免对资源的多重占用。设置全局访问点,严格控制访问。

    缺点:没有接口,扩展困难。

    重点:私有构造器。线程安全。延迟加载。序列化和反序列化安全。反射。

    十三、原型模式

    定义:指原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。不需要知道任何创建的细节,不调用构造函数

    适用场景:类初始化消耗较多资源。new产生的一个对象需要非常繁琐的过程(数据准备、访问权限等)。构造函数比较复杂。循环体中产生大量对象时。

    优点:原型模式性能比直接new一个对象性能高。简化创建过程。

    缺点:必须配备克隆方法。对克隆复杂对象或对克隆出的对象进行复杂改造时,容易引入风险。深拷贝、浅拷贝要运用得当。

    十四、外观模式

    定义:又叫门面模式,提供了一个统一的接口,用来访问子系统中的一群接口。外观模式定义了一个高层接口,让子系统更容易使用。

    使用场景:子系统越来越复杂,增加外观模式提供简单调用接口。构建多层系统结构,利用外观对象作为每层的入口,简化层间调用。

    优点:简化了调用过程,无需了解深入子系统,防止带来风险。减少系统依赖、松散耦合。更好的划分访问层次。符合迪米特法则,即最少知道原则。

    缺点:增加子系统、扩展子系统行为容易引入风险。不符合开闭原则。

    十五、装饰者模式

    定义:在不改变原有对象的基础上,将功能附加到对象上。提供了比继承更有弹性的替代方案(扩展原有对象功能)。

    优点:继承的有力补充,比继承灵活,不改变原有对象的情况下给一个对象扩展功能。通过使用不同装饰类以及这些装饰类的排列组合,可以实现不同的效果。符合开闭原则。

    缺点:会出现更多的代码,更多的类,增加程序复杂性。动态装饰时,多层装饰时会更复杂。

    十六、适配器模式

    定义:将一个类的接口转换成客户期望的另一个接口。使原本接口不兼容的类可以一起工作。

    适用场景:已经存在的类,它的方法和需求不匹配时(方法结果相同或相似)。不是软件设计阶段考虑的设计模式,是随着软件维护,由于不同产品、不同厂家造成功能类似而接口不相同情况下的解决方案。

    优点:能提高类的透明性和复用,现有的类复用但不需要改变。目标类和适配器类解耦,提高程序扩展性。符合开闭原则。

    缺点:适配器编写过程需要全面考虑,可能会增加系统的复杂性。增加系统代码可读的难度。

    十七、享元模式

    定义:提供了减少对象数量从而改善应用所需的对象结构的方式。运用共享技术有效地支持大量细粒度的对象

    适用场景:常常应用于系统底层的开发,以便解决系统的性能问题。系统有大量相似对象、需要缓冲池的场景。

    优点:减少对象的创建,降低内存中对象的数量,降低系统的内存,提高效率。减少内存之外的其他资源占用。

    缺点:关注内/外部状态、关注线程安全问题。使系统、程序的逻辑复杂化。

    十八、组合模式

    定义:将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式是客户端对单个对象和组合对象保持一致的方式处理。

    适用场景:希望客户端可以忽略组合对象与单个对象的差异时。处理一个树形结构时。

    优点:清楚地定义分层次的复杂对象,表示对象的全部或部分层次。让客户端忽略了层次的差异,方便对整个层次结构进行控制。简化客户端代码。符合开闭原则。

    缺点:限制类型时会较为复杂。使设计变得更加抽象。

    十九、桥接模式

    定义:将抽象部分与它的具体实现部分分离,使它们都可以独立地变化。通过组合的方式建立两个类之间关系,而不是继承。

    适用场景:抽象和具体实现之间增加更多的灵活性。一个类存在两个(或多个)独立变化的维度,且这两个(或多个)维度都需要独立进行拓展。不希望使用继承,或因为多层继承导致系统类的个数剧增。

    优点:分离抽象部分及其具体实现部分。提高了系统的可扩展性。符合开闭原则。符合合成复用原则。

    缺点:增加了系统的理解与设计难度。需要正确地识别出系统中两个独立变化的维度。

    二十、代理模式

    定义:为其他对象提供一种代理,以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介的作用。

    适用场景:保护目标对象。增强目标对象。

    优点:代理模式能将代理对象与真实被调用的目标对象分离。一定程度上降低了系统的耦合度,扩展性好。保护目标对象。增强目标对象。

    缺点:代理模式会造成系统设计中类的数目增加。在客户端和目标对象增加一个代理对象,会造成请求处理速度变慢。增加系统的复杂度。

    二十一、模板模式

    定义:定义了一个算法的骨架,并允许子类为一个或多个步骤提供实现。模板方法使得子类可以在不改变算法结构的情况下,重新定义算法的某些步骤。

    适用场景:一次性实现一个算法的不变的部分,并将可变的行为留给子类来实现。各子类中公共的行为被提取出来并集中到一个公共父类中,从而避免代码重复。

    优点:提高复用性,提高扩展性,符合开闭原则。

    缺点:类数目增加。增加了系统实现的复杂度。继承关系自身缺点,如果父类添加新的抽象方法,所有子类都要改一遍。

    二十二、迭代器模式

    定义:提供一种方法,顺序访问一个集合对象中的各个元素,而又不暴露该对象的内部表示。

    适用场景:访问一个集合对象的内容而无需暴露它的内部表示。为遍历不同的集合结构提供一个统一的接口。

    优点:分离了集合对象的遍历行为。

    缺点:类的个数成对增加。

    二十三、策略模式

    定义:定义了算法家族,分别封装起来,让它们之间可以相互替换,此模式让算法的变化不会影响到使用算法的用户。

    适用场景:系统有很多类,而它们的区别仅仅在于它们的行为不同。一个系统需要动态地在几种算法中选择一种。

    优点:符合开闭原则。避免使用多重条件转移语句。提高算法的保密性和安全性。

    缺点:客户端必须知道所有的策略类,并自行决定使用哪一个策略类。产生很多策略类。

    二十四、解释器模式

    定义:给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。为了解释一种语言,而为语言创建的解释器。

    适用场景:某个特定类型问题发生频率足够高。

    优点:语法由很多类表示,容易改变及扩展此"语言"。

    缺点:当语法规则数目太多时,增加了系统复杂度。

    二十五、观察者模式

    定义:定义了对象之间的一对多依赖,让多个观察者对象同时监听某一个主题对象,当主题对象发生变化时,它的所有依赖者(观察者)都会收到通知并更新。

    适用场景:关联行为场景,建立一套触发机制。

    优点:观察者和被观察者之间建立一个抽象的耦合。观察者模式支持广播通信。

    缺点:观察者之间有过多的细节依赖、提高时间消耗及程序复杂度。使用要得当,要避免循环调用。

    二十六、备忘录模式

    定义:保存一个对象的某个状态,以便在适当的时候恢复对象。“没有后悔药”。“存档”。

    适用场景:保存及恢复数据相关业务场景。后悔的时候,即想恢复到之前的状态。

    优点:为用户提供一种可恢复机制。存档信息的封装。

    缺点:资源占用。

    二十七、命令模式

    定义:将"请求"封装成对象,以便使用不同的请求。命令模式解决了应用程序中对象的职责以及它们之间的通信方式。

    适用场景:请求调用者和请求接收者需要解耦,使得调用者和接受者不直接交互。需要抽象出等待执行的行为。

    优点:降低耦合。容易扩展新命令或一组命令。

    缺点:命令的无限扩展会增加类的数量,提高系统实现复杂度。

    二十八、中介者模式

    定义:定义一个封装一组对象如何交互的对象。通过使对象明确地相互引用来促进松散耦合,并允许独立的改变它们的交互。

    适用场景:系统中对象之间存在复杂的引用关系,产生的相互依赖关系结构混乱且难以理解。交互的公共行为,如果需要改变行为则可以增加新的中介类。

    优点:将一对多转换成了一对一,降低程序复杂度。类之间解耦。

    缺点:中介者过多,导致系统复杂。

    二十九、责任链模式

    定义:为请求创建一个接受此次请求对象的链。

    适用场景:一个请求的处理需要多个对象当中的一个或几个协作处理。

    优点:请求的发送者和接受者(请求的处理)解耦。责任链可以动态组合。

    缺点:责任链太长或者处理时间过长,影响性能。责任链有可能过多。

    三十、访问者模式

    定义:封装作用于某数据结构(如List/Set/Map等)中的各元素的操作。可以在不改变各元素的类的前提下,定义作用于这些元素的操作。

    适用场景:一个数据结构如(List/Set/Map等)包含很多类型对象。数据结构与数据操作相分离。

    优点:增加新的操作很容易,即增加一个新的访问者。

    缺点:增加新的数据结构困难。具体元素变更比较麻烦。

    三十一、状态模式

    定义:允许一个对象在其内部状态改变时,改变它的行为。

    适用场景:一个对象存在多个状态(不同状态下行为不同),且状态可相互转换。

    优点:将不同的状态隔离。把各个状态的转换逻辑,分布到State的子类中,减少相互间依赖。增加新的状态很简单。

    缺点:状态多的业务场景导致类数目增加,系统变复杂。

     

    展开全文
  • 一、状态模式简介、 ...三、状态模式优缺点、 四、状态模式相关设计模式、 五、状态模式代码示例、 1、状态类父类、 2、播放状态类、 3、暂停状态类、 4、快进状态类、 5、停止状态类、 6、上下文控制类、 7、测试、





    一、状态模式简介



    状态模式 : 允许 对象 在 内部状态 改变时 , 改变它的行为 ;

    一个对象 , 如果其 内部状态改变 , 其 行为也需要进行改变 ; 如果其行为不需要改变 , 也可以只 控制 该对象的状态 的 互相转换 ;

    当控制一个对象 , 其状态转换过程比较复杂时 , 将 状态判断逻辑 , 转到代表不同状态的一系列类中 ;

    如 : 引入 视频播放 的业务场景 , 播放器有 初始状态 , 播放状态 , 暂停状态 , 停止状态 , 快进状态 等多种状态 , 将这些 状态 都封装到 代表不同状态的类 中 , 可以将复杂的判断逻辑简化 , 将这些 逻辑 扩展到不同的状态类中 ;


    状态模式类型 : 行为型 ;





    二、状态模式适用场景



    状态模式适用场景 : 一个对象 , 存在多个状态 , 状态可以相互转换 ; 不同状态下 , 行为不同 ;


    不同状态下 , 行为不同的示例 , 如 :

    购买物品 , 将物品放入购物车并生成订单 , 可以进行付款 ; 如果 订单 超过 24 小时后 , 被关闭订单 , 此时订单取消 , 无法付款 ;

    电梯运行时 , 不能开门 ; 电梯停止后 , 才能开门 ;





    三、状态模式优缺点



    状态模式优点 :

    可以将 不同的状态 隔离 ; 每个状态都是一个单独的类 ;

    可以将 各种状态 的 转换逻辑 , 分布到 状态 的子类中 , 减少相互依赖 ;

    增加 新状态 , 操作简单 ;


    状态模式缺点 :

    如果 状态数量 比较多 , 状态类 的 数量会增加 , 业务场景系统变得很复杂 ; 如果业务中某个对象由几十上百个状态 , 就会很复杂 , 这时就需要对状态进行拆分处理 ;





    四、状态模式相关设计模式



    状态模式 与 享元模式 , 可以配合在一起使用 , 可以使用享元模式 , 在多个上下文中 , 共享状态实例 ;





    五、状态模式代码示例



    业务场景 :

    视频播放器 , 有 : 暂停 , 播放 , 快进 , 停止 , 四个状态 ;

    在 停止 状态下 , 无法快进 , 如果当前是 停止 状态 , 此时要转为 快进 状态 , 需要进行校验 ;

    • 如果不使用 状态模式 , 则需要进行 if else 判断 ;
    • 如果使用 状态模式 , 就很容易实现 ;

    状态类 :

    • 定义状态父类抽象类 , 抽象方法是各个状态对应的方法 ;
    • 定义状态子类 , 每个状态对应一个子类对象 ;

    上下文类 :

    • 在该类中封装 所有的状态实例 , 以及定义 状态改变方法 ;
    • 封装当前状态类 , 状态改变方法 调用时 , 实际上调用的是 当前状态类的 对应方法 ;


    1、状态类父类


    package state;
    
    /**
     * 视频状态 父类
     *      所有的视频状态 , 都要继承该类
     */
    public abstract class VedioState {
        /**
         * 视频播放上下文
         *      声明为 protected , 子类可以拿到该成员变量
         */
        protected VedioContext vedioContext;
    
        public void setVedioContext(VedioContext vedioContext) {
            this.vedioContext = vedioContext;
        }
    
        /**
         * 播放
         *      对应播放状态
         */
        public abstract void play();
    
        /**
         * 停止
         *      对应停止状态
         */
        public abstract void pause();
    
        /**
         * 快进
         *      对应快进状态
         */
        public abstract void speed();
    
        /**
         * 停止
         *      对应停止状态
         */
        public abstract void stop();
    }
    
    

    2、播放状态类


    package state;
    
    /**
     * 视频的播放状态
     *      可以进行 快进 , 暂停 , 停止 操作
     */
    public class PlayState extends VedioState{
        @Override
        public void play() {
            System.out.println("正常播放视频");
        }
    
        /**
         * 暂停时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 暂停 的状态即可
         */
        @Override
        public void pause() {
            super.vedioContext.setVedioState(VedioContext.PAUSE_STATE);
        }
    
        /**
         * 快进时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 快进 的状态即可
         */
        @Override
        public void speed() {
            super.vedioContext.setVedioState(VedioContext.SPEED_STATE);
        }
    
        /**
         * 停止时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 停止 的状态即可
         */
        @Override
        public void stop() {
            super.vedioContext.setVedioState(VedioContext.STOP_STATE);
        }
    }
    
    

    3、暂停状态类


    package state;
    
    /**
     * 视频暂停状态
     *      暂停状态 可以 切换到 播放 , 快进 , 停止 状态
     */
    public class PauseState extends VedioState{
        /**
         * 播放时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 播放 的状态即可
         */
        @Override
        public void play() {
            super.vedioContext.setVedioState(VedioContext.PLAY_STATE);
        }
    
        /**
         * 暂停时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 暂停 的状态即可
         */
        @Override
        public void pause() {
            System.out.println("暂停播放视频");
        }
    
        /**
         * 快进时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 快进 的状态即可
         */
        @Override
        public void speed() {
            super.vedioContext.setVedioState(VedioContext.SPEED_STATE);
        }
    
        /**
         * 停止时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 停止 的状态即可
         */
        @Override
        public void stop() {
            super.vedioContext.setVedioState(VedioContext.STOP_STATE);
        }
    }
    
    

    4、快进状态类


    package state;
    
    /**
     * 视频快进状态
     *      快进状态下 , 可以进行 播放 , 暂停 , 停止操作
     */
    public class SpeedState extends VedioState{
        /**
         * 播放时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 播放 的状态即可
         */
        @Override
        public void play() {
            super.vedioContext.setVedioState(VedioContext.PLAY_STATE);
        }
    
        /**
         * 暂停时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 暂停 的状态即可
         */
        @Override
        public void pause() {
            System.out.println("快进播放视频");
        }
    
        /**
         * 快进时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 快进 的状态即可
         */
        @Override
        public void speed() {
            super.vedioContext.setVedioState(VedioContext.SPEED_STATE);
        }
    
        /**
         * 停止时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 停止 的状态即可
         */
        @Override
        public void stop() {
            super.vedioContext.setVedioState(VedioContext.STOP_STATE);
        }
    }
    
    

    5、停止状态类


    package state;
    
    /**
     * 视频的停止状态
     *      可以进行 播放 操作
     *      不能进行 快进 , 暂停 操作
     */
    public class StopState extends VedioState{
        /**
         * 播放时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 播放 的状态即可
         */
        @Override
        public void play() {
            super.vedioContext.setVedioState(VedioContext.PLAY_STATE);
        }
    
        /**
         * 不能暂停
         */
        @Override
        public void pause() {
            System.out.println("停止状态不能暂停");
        }
    
        /**
         * 不能快进
         */
        @Override
        public void speed() {
            System.out.println("停止状态不能快进");
        }
    
        /**
         * 停止时 , 只需要调用 PlayState 父类 VedioState 的上下文 VedioContext
         *      将上下文 VedioContext 中的状态 , 设置为 停止 的状态即可
         */
        @Override
        public void stop() {
            System.out.println("停止播放视频");
        }
    }
    
    

    6、上下文控制类


    package state;
    
    /**
     * 使用享元模式 , 共享同一个对象
     *
     * 上下文也有 play , pause , speed , stop 等状态
     *      执行这些方法时 , 调用状态的相应方法
     */
    public class VedioContext {
    
        /**
         * 当前的状态
         */
        private VedioState mVedioState;
        public final static PlayState PLAY_STATE = new PlayState();
        public final static PauseState PAUSE_STATE = new PauseState();
        public final static SpeedState SPEED_STATE = new SpeedState();
        public final static StopState STOP_STATE = new StopState();
    
        public VedioState getVedioState() {
            return mVedioState;
        }
    
        /**
         * 将传入的 VedioState , 赋值给当前的 VedioState mVedioState 成员
         *      除此之外 , 还要设置 VedioState 的上下文 , 即该类本身
         *      将当前的环境 VedioContext , 通知到各个状态实现类
         * @param mVedioState
         */
        public void setVedioState(VedioState mVedioState) {
            this.mVedioState = mVedioState;
            this.mVedioState.setVedioContext(this);
        }
    
        public void play() {
            this.mVedioState.play();
        }
    
        public void pause() {
            this.mVedioState.pause();
        }
    
        public void speed() {
            this.mVedioState.speed();
        }
    
        public void stop() {
            this.mVedioState.stop();
        }
    }
    
    

    7、测试


    package state;
    
    public class Main {
        public static void main(String[] args) {
            VedioContext vedioContext = new VedioContext();
            vedioContext.setVedioState(VedioContext.PLAY_STATE);
            System.out.println("当前视频状态 : " + vedioContext.getVedioState().getClass().getSimpleName());
    
            vedioContext.pause();
            System.out.println("当前视频状态 : " + vedioContext.getVedioState().getClass().getSimpleName());
    
            vedioContext.speed();
            System.out.println("当前视频状态 : " + vedioContext.getVedioState().getClass().getSimpleName());
    
            vedioContext.stop();
            System.out.println("当前视频状态 : " + vedioContext.getVedioState().getClass().getSimpleName());
    
            vedioContext.speed();
            System.out.println("当前视频状态 : " + vedioContext.getVedioState().getClass().getSimpleName());
        }
    }
    
    

    执行结果 :

    在这里插入图片描述

    展开全文
  • 菜鸟教程设计模式https://www.runoob.com/design-pattern/design-pattern-tutorial.html 一、创建型模式 简述:提供一种在创建对象的同时隐藏创建逻辑的方式 包括:工厂模式、抽象工厂模式、单例模式、建造者模式...

    菜鸟教程设计模式icon-default.png?t=LA46https://www.runoob.com/design-pattern/design-pattern-tutorial.html

    一、创建型模式

    简述:提供一种在创建对象的同时隐藏创建逻辑的方式

    包括:工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式 

    工厂模式

    简述:定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。

    优点:1、扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以。 2、屏蔽产品的具体实现,调用者只关心产品的接口。

    缺点:每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。

    抽象工厂模式

    简述:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

    优点:当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。

    缺点:产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator 里加代码,又要在具体的里面加代码。

    单例模式

    简述:保证一个类仅有一个实例,并提供一个访问它的全局访问点。

    优点:1、在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例(比如管理学院首页页面缓存)2、避免对资源的多重占用(比如写文件操作)

    缺点:没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。

    建造者模式

    简述:将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。

    优点:1、建造者独立,易扩展。 2、便于控制细节风险。

    缺点: 1、产品必须有共同点,范围有限制。 2、如内部变化复杂,会有很多的建造类。

    原型模式

    简述:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。

    优点:1、性能提高。 2、逃避构造函数的约束。

    缺点: 1、配备克隆方法需要对类的功能进行通盘考虑,这对于全新的类不是很难,但对于已有的类不一定很容易,特别当一个类引用不支持串行化的间接对象,或者引用含有循环结构的时候。 2、必须实现 ICloneable接口。

    展开全文
  • 1 工厂模式: 优点:1 .一个调用者创建对象方便 2 .扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以。 3 .屏蔽产品的具体实现,调用者只关心产品的接口。 缺点:每次增加一个产品时,都需要增加一个具体...
  • 三、解释器模式优缺点、 四、解释器模式与适配器模式、 五、解释器模式代码示例、 1、解释器接口、 2、加法解释器、 3、乘法解释器、 4、整型解释器、 5、语法解析类、 6、工具类、 7、测试类、
  • 一、组合模式简介、 二、组合模式适用场景、 三、组合模式优缺点、 四、组合模式和访问者模式、 五、组合模式代码示例、 1、书籍和目录的抽象父类、 2、书籍类、 3、目录类、 4、测试类、
  • 一、代理模式简介、 二、代理模式适用场景、 三、代理模式优缺点、 四、代理扩展、 五、代理模式相关设计模式
  • 三、策略模式优缺点、 四、策略模式与其它设计模式、 五、策略模式代码示例、 1、促销策略接口、 2、满减促销策略、 3、返现促销策略、 4、空促销策略、 5、促销策略工厂、 6、促销活动、 7、测试类、
  • 面经-设计模式优缺点

    2021-09-15 20:04:16
    缺点: 没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。 二、工厂模式(不同条件下创建不同实例) 优点: 1、一个调用者想创建一个对象,只要知道其名称就可以了...
  • 一、迭代器模式简介、 ...三、迭代器模式优缺点、 四、迭代器模式和访问者模式、 五、迭代器模式代码示例、 1、迭代器接口、 2、迭代器实现、 3、集合元素实例类、 4、集合管理接口、 5、集合管理实现类、 6、测试类、
  • 三、建造者模式优缺点、 四、建造者模式与工厂模式、 五、建造者模式代码示例、 1、学生类、 2、建造者抽象类、 3、建造者实现类、 4、教师类 ( 非必须 )、 5、测试类、 六、实例类和建造者类定义在同一个类中 ( ...
  • 三、桥接模式优缺点、 四、桥接模式相关设计模式、 五、桥接模式代码示例、 1、视频格式抽象、 2、FLV 视频格式实现、 3、MP4 视频格式实现、 4、系统平台抽象、 5、Linux 系统平台实现、 6、Android 系统平台实现、...
  • 各位小伙伴好,今天给大家主要介绍一下简单工厂模式、工厂模式和抽象工厂模式的区别及各自的优缺点。(本文实现语言为Python3)【前言】 众所周知今天所讲的内容是设计模式的一类;对于设计模式这个概念,我想首先请...
  • 一、模板方法模式简介、 ...三、模板方法模式优缺点、 四、模板方法扩展、 五、模板方法模式相关设计模式、 六、模板方法模式代码示例、 1、模板方法抽象类、 2、模板方法实现类 1、 3、模板方法实现类 2、 4、测试类、
  • 工厂模式优缺点分析

    2021-06-11 18:18:46
    工厂模式优缺点分析 function createPerson(name, age, sex) { var p = new Object(); p.name = name; p.age = age; p.sex = sex; p.sayName = function() { console.log("我的名字是:" + this.name); } ...
  • 一、中介者模式简介、 二、中介者模式适用场景、 三、中介者模式优缺点、 四、中介者模式 与 观察者模式、 五、中介者模式 代码示例、 1、聊天室、 2、用户、 3、运行实例、
  • 原型模式优缺点

    2021-06-11 18:24:27
    function Person() { } Person.prototype = { constructor: Person, name: "LiBai", age: 60, job: "诗人", friends: ["杜甫", "白居易"], sayName: function() { console.log(this.name) ...
  • 一、备忘录模式简介、 二、备忘录模式 适用场景、 三、备忘录模式 优缺点、 四、备忘录模式 与 状态模式、 五、备忘录模式 代码示例、 1、文档类、 2、文档备忘录类、 3、文档备忘录管理类、 4、测试类、
  • 今天阿粉要跟大家分享的是结构型模式之享元模式,既然享元模式是属于结构性模式中的一种,那自然是用来组织代码,调整相应的代码结构来达到效果的,下面我们一起来看一下吧。 享元模式首先常规操作,我们先看一下...
  • 一、命令模式简介、 ...三、命令模式 优缺点、 四、命令模式 与 备忘录模式、 五、命令模式 代码示例、 1、命令接口、 2、发布命令类、 3、关闭命令类、 4、游戏类、 5、命令执行者类、 6、测试类、
  • 工厂模式优缺点以及存在的意义1.简单工厂模式(静态工厂模式)1.工厂方法模式 工厂模式的本质 实例化对象不使用new,用工厂方法代替 将选择实现类,创建对象统一管理和控制。从而将调用者跟我们的实现解耦 - ...
  • 一、简单工厂模式简介、 二、简单工厂模式适用场景、 三、简单工厂模式优缺点、 四、简单工厂模式代码示例、 1、抽象类、 2、子类对象 1、 3、子类对象 2、 4、工厂类、 5、测试类、
  • 三、工厂方法模式优缺点、 四、工厂方法模式代码示例、 1、产品抽象类、 2、产品实现类 1、 3、产品实现类 2、 4、抽象工厂类、 5、实现工厂类 1、 6、实现工厂类 2、 7、测试类、 五、扩展上述工厂方法模式、 1、...
  • 简单工厂模式介绍:概要:简单工厂模式,又称为静态工厂方法(Static Factory Method)模式,它属于类创建型模式。在简单工厂模式中,把产品的生产方法封装起来放进工厂类,工厂类可以根据参数的不同返回不同产品类的...
  • 二、什么是设计模式 这个问题我问过的面试者不下数十次,回答五花八门,在我看来,模式就是经验,涉及模式就是涉及经验,有了这些经验,我们就能在特定情况下使用特定的设计、组合设计。这样可以大大节省我们的设计...
  • 单例模式是常用设计模式之一,其定义是单例对象的类只能允许一个实例存在。基本实现思路要求类能够有返回对象的一个引用(永远是同一个)和一个获得实例的方法(必须是静态方法)。实现单例模式时,需要考虑使用的环境,...
  • 目录单例模式单例模式作用:单例模式应用场景:手撸单例模式懒汉式线程不安全懒汉式线程安全饿汉式工厂模式简单工厂模式工厂方法模式抽象工厂模式总结 单例模式 单例模式(Singleton Pattern) : 确保一个类只有一个实例...
  • 策略模式总结,适用场景,优缺点,代码示例1、简介1.1 继承带来的扩展和复用问题1.2 进一步改进,利用接口1.3 进一步改进,策略模式2、适用场景3、优点4、缺点5、代码示例6、源码分析6.1 spring中应用7、策略模式...
  • C/S模式和B/S模式优缺点

    千次阅读 2021-02-24 12:34:53
    C/S模式是传统的网络应用设计模式,客户机(client)/服务器(server)模式。需要在通讯两端各自部署客户机和服务器来完成数据通信。如(QQ、微信、LOL、CF、DNF等游戏需要下载客户端) 什么是B/S模式 浏览器(browser)/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 130,979
精华内容 52,391
关键字:

原型模式的优缺点