精华内容
下载资源
问答
  • 文章目录Java中的设计模式 - 观察者模式【又:发布/订阅模式】1、观察者模式是为了解决什么问题2、核心逻辑3、优点4、缺点5、应用场景6、构建观察者...当我们在定义对象间的一种一对多的依赖关系,一个对象的状...

    Java中的设计模式 - 观察者模式【又叫:发布/订阅模式】


    1、观察者模式是为了解决什么问题

    当我们在定义对象间的一种一对多的依赖关系,一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。

    一个对象状态改变给其他对象通知的问题,而且要考虑到易用和低耦合,保证高度的协作。所以使用观察者模式

    2、核心逻辑

    在抽象类中有一个注册观察者的List 对象

    3、优点

    1、观察者与被观察者是抽象耦合的
    2、存在触发机制

    4、缺点

    1、如果某个被观察对象,拥有很多的观察者,则全部通知到会花费较多的时间
    2、观察者与被观察者之间有可能存在循环依赖,导致系统宕机
    3、观察者对于被观察者来说,是一个相对的黑箱,观察者只知道结果是这样,但是并不知道究竟是怎么变成这样的。

    5、应用场景

    1、发布/订阅
    2、一个对象的状态变更,会影响到与他关联的对象
    3、链式传递,一个对象的变更,会影响到与他关联的对象,而这个状态导致的关联变更,又会影响到关联对象的关联对象,那么可以设计一个链式观察模式来传递变更

    6、构建观察者抽象类,抽离观察者属性
    public abstract class Observer {
        protected Subject subject;
        public abstract void whileUpdate();
    }
    
    
    7、构建被观察者,主题
    @Getter
    public class Subject {
    
    
        private List<Observer> observers = Lists.newArrayList();
    
        private Object data;
    
        public void whileDataUpdated(Object data) {
            this.data = data;
            notifyAllObserbers();
        }
    
    
        /**
         * 新增一个观察者
         */
        public void newObserver(Observer observer) {
            observers.add(observer);
        }
    
        /**
         * 通知所以的观察者
         */
        public void notifyAllObserbers() {
            observers.forEach(Observer::whileUpdate);
        }
    }
    
    8、创建3个观察者 A B C
    public class ObserverA extends Observer {
    
    
    
        public ObserverA(Subject subject) {
            this.subject = subject;
            this.subject.newObserver(this);
        }
    
        @Override
        public void whileUpdate() {
            System.out.println("我是A观察者,我监听到变化:" + subject.getData().toString());
        }
    }
    
    
    
    
    public class ObserverB extends Observer {
    
    
        public ObserverB(Subject subject) {
            this.subject = subject;
            this.subject.newObserver(this);
        }
    
    
        @Override
        public void whileUpdate() {
            System.out.println("我是B观察者,我监听到变化:" + subject.getData().toString());
        }
    }
    
    
    public class ObserverC extends Observer {
    
    
        public ObserverC(Subject subject) {
            this.subject = subject;
            this.subject.newObserver(this);
        }
    
    
        @Override
        public void whileUpdate() {
            System.out.println("我是C观察者,我监听到变化:" + subject.getData().toString());
        }
    }
    
    
    9、测试
    public class Main {
    
    
        public static void main(String[] args) {
            Subject subject = new Subject();
            new ObserverA(subject);
            new ObserverB(subject);
            new ObserverC(subject);
    
            subject.whileDataUpdated("我注册了一张银行卡");
            subject.whileDataUpdated("我注销了一张银行卡");
    
        }
    }
    
    10、输出
    我是A观察者,我监听到变化:我注册了一张银行卡
    我是B观察者,我监听到变化:我注册了一张银行卡
    我是C观察者,我监听到变化:我注册了一张银行卡
    我是A观察者,我监听到变化:我注销了一张银行卡
    我是B观察者,我监听到变化:我注销了一张银行卡
    我是C观察者,我监听到变化:我注销了一张银行卡
    
    展开全文
  • 设计模式):策略模式

    万次阅读 多人点赞 2019-03-01 21:37:32
    设计模式):策略模式 本文将以个小Demo及其新需求来分析使用策略模式的好处。 设计模式简述: 设计模式: 1.设计模式是人们在面对同类型软件工程设计问题所总结出的一些有用的经验。模式不是代码,而是某类...

    设计模式(一):策略模式

    本文将以一个小Demo及其新需求来分析使用策略模式的好处。
    设计模式简述:
    设计模式:
    1.设计模式是人们在面对同类型软件工程设计问题所总结出的一些有用的经验。模式不是代码,而是某类问题的通用设计解决方案。
    2.经典书籍《设计模式》
    3.设计模式的优点和用途:和其他相关人员沟通有一定的术语基础。
    4.学习设计模式最好的方式:在你的实际和以往的工程里寻找何处可以使用它。
    5.设计模式的本质目的是使软件工厂在维护性、扩展性、变化性、复杂度方面O(N)。
    6.OO是原则,设计模式是具体方法、工具。

    在java里IO流的类设计,为什么把BufferedReader设计成:
    new BufferedReader(new FileReader(“F:\test.java”));
    而不是设计成:
    BufferedReader extends FileReader;
    然后new BufferedReader(“F:\test.java”);
    因为IO流种类很多,基类、扩展子类有很多种,继承会编程n对n的关系。复杂度为n*n


    设计模式有哪些?

    共23种设计模式:
    策略模式
    观察者模式
    装饰者模式
    单例模式
    工厂模式
    命令模式
    适配器模式
    外观模式
    模板模式
    迭代器模式
    组合模式
    状态模式
    代理模式
    复合模式
    桥接模式
    生成器模式
    责任链模式
    蝇量模式
    解释器模式
    中介者模式
    备忘录模式
    原型模式
    访问者模式


    策略模式简述:
    策略模式:
    分别封装行为接口,实现算法族,超类里放行为接口对象,在子类里具体设定行为对象。
    原则就是:分离变化部分,封装接口,基于接口编程各种功能。此模式让行为的变化独立于算法的使用者。


    Demo描述:(OO原则解决方式)
    模拟鸭子项目:

    1. 从项目“模拟鸭子游戏”开始
    2. 从OO角度设计这个项目,鸭子超类,扩展超类。

    .java文件说明:
    Dock.java:基类鸭子
    GreenHeadDuck.java:绿头鸭
    RedHeadDuck.java:红头鸭
    StimulateDuck.java:模拟鸭子(main)

    Dock.java:

    //抽象类:鸭子
    public  abstract class Duck {
        FlyBehavior flyBehavior;
        QuackBehavior quackBeahavior;
        public Duck(){//子类的构造函数中可以定义行为
    
        }
    
        //在本抽象类中已经自己实现了
        public void Quack(){
            System.out.println("~~嘎嘎嘎~~");
        }
    
        //由子类去实现
        public abstract void display();
    
        //在本抽象类中已经自己实现了
        public void swim(){
            System.out.println("~~我会游泳~~");
        }
    
    }
    

    GreenHeadDuck.java:

    public class GreenHeadDuck extends Duck {
    
        @Override
        public void display() {
            System.out.println("我和你们不一样,我是绿色的头");
        }
    
    }
    

    RedHeadDuck.java:

    public class RedHeadDuck extends Duck {
        @Override
        public void display() {
            System.out.println("我是独一无二的,我是红头鸭。");
        }
    }
    

    StimulateDuck.java:

            GreenHeadDuck greenHeadDuck=new GreenHeadDuck();
            RedHeadDuck redHeadDuck=new RedHeadDuck();
    
            greenHeadDuck.display();
            greenHeadDuck.Quack();
            greenHeadDuck.swim();
     
    
    
            redHeadDuck.display();
            redHeadDuck.Quack();
            redHeadDuck.swim();
     
    

    上面的代码都是java基础。好了,我们已经实现了基本的项目需求了。模拟鸭子算是成功啦~!在这里插入图片描述


    项目的新需求:
    1.应对新的需求,看看这个设计的可扩展性
    1):添加会飞的鸭子(并不是所有的鸭子都能飞)
    ** OO思维里的继承方式解决方案:
    如果在基类写Fly()方法,这个Fly让所有的子类都会飞了,违背逻辑。
    继承问题:对类的局部改动,尤其超类的局部改动,会影响其他部分,影响会有溢出效应。
    继续用OO原理来解决,覆盖:(后期工作量大)**
    2):又有新需求,石头鸭子,填坑:
    public class StoneDuck extends Duck{

    }
    超类挖的一个坑,每个子类都要来填,增加工作量,复杂度O(N^2).不是好的设计方式
    综上,如果在基类Duck中添加fly()方法,然后让子类去继承。但是不是每个鸭子都能飞。比如北京烤鸭。。。试问,烤鸭也是鸭的子类,它继承了鸭,那么基类鸭的fly()方法,它也会有。意思是可以在烤鸭中调用fly()方法,显然这是不可能的。
    所以, 我们应该解决这个问题。并不是每个子类都需要该方法
    这时候,我们应该考虑哈继承的弊端了。使用接口就可以很好的解决这个问题。(思路:继承是实现共性,减少代码的重复。接口是实现特性。


    用策略模式来解决新需求:
    需要新的设计方式,应对项目的扩展性,降低复杂度:
    1):分析项目变化与不变部分,提取变化部分,抽象成接口+实现;(抽象是共性,接口是特性)
    2):鸭子那些功能是会根据新需求变化的?叫声、飞行
    接口:
    1):public interface FlyBehavior{
    void fly();
    }
    2):public interface QuackBehavior{
    void quack();
    }
    3):好处:新增行为简单,行为类更好的复用,组合方便。既有继承带来的复用好处,没有挖坑。


    策略模式解决代码:
    .java文件说明:
    Dock.java:基类鸭子
    GreenHeadDuck.java:绿头鸭
    RedHeadDuck.java:红头鸭
    StimulateDuck.java:模拟鸭子(main)
    FlyBehavior.java:(接口)特有的飞行行为
    QuackBehavior.java:(接口)特有的叫喊行为
    BadFlyBehavior.java:飞行行为的实现类
    BadQuack.java:叫喊行为的实现类

    Dock.java:

    //抽象类:鸭子
    public  abstract class Duck {
        FlyBehavior flyBehavior;
        QuackBehavior quackBeahavior;
        public Duck(){//子类的构造函数中可以定义行为
    
        }
    
        //在本抽象类中已经自己实现了
        public void Quack(){
    //        System.out.println("~~嘎嘎嘎~~");
            quackBeahavior.quack();
        }
    
        //由子类去实现
        public abstract void display();
    
        //在本抽象类中已经自己实现了
        public void swim(){
            System.out.println("~~我会游泳~~");
        }
    
        //实例化对象时可以动态的改变对象的行为(比继承灵活性强)
        public void SetFlyBehavoir(FlyBehavior fb){
            flyBehavior=fb;
        }
    
        //实例化对象时可以动态的改变对象的行为
        public void SetQuackBehavoir(QuackBehavior qb){
            quackBeahavior=qb;
        }
    
        public void Fly(){
            flyBehavior.fly();
        }
    
    
    }
    
    

    GreenHeadDuck.java:

    /**
     * 绿头鸭:继承自基类Duck
     */
    public class GreenHeadDuck extends Duck {
        public GreenHeadDuck(){
            //行为轴展示具体的行为
            flyBehavior=new BadFlyBehavior();
        }
        @Override
        public void display() {
            System.out.println("我和你们不一样,我是绿色的头");
        }
    
        //覆盖超类的
    //    public void Fly() {
    //        System.out.println("我不会飞!");
    //    }
    }
    
    

    RedHeadDuck.java:

    /**
     * 红头鸭:继承基类Duck
     */
    public class RedHeadDuck extends Duck {
    
        public RedHeadDuck(){
            quackBeahavior=new BadQuack();
        }
    
        @Override
        public void display() {
            System.out.println("我是独一无二的,我是红头鸭。");
        }
    }
    
    

    FlyBehavior.java:

    public interface FlyBehavior {
        void fly();
    }
    
    

    QuackBehavior.java:

    public interface QuackBehavior  {
        void quack();
    }
    
    

    BadFlyBehavior.java:

    public class BadFlyBehavior implements  FlyBehavior {
        @Override
        public void fly() {
            System.out.println("---我不会飞---");
        }
    }
    
    

    BadQuack.java:

    public class BadQuack implements  QuackBehavior {
        @Override
        public void quack() {
            System.out.println("我不会叫~");
        }
    }
    
    

    StimulateDuck.java:

    /**
     * 主类:模拟鸭子
     */
    public class StimulateDuck {
        public static void main(String[] args){
            //父类为Duck,屏蔽了超类的差别性
            Duck greenHeadDuck=new GreenHeadDuck();
            Duck redHeadDuck=new RedHeadDuck();
    
            greenHeadDuck.display();
            greenHeadDuck.Fly();
            greenHeadDuck.SetQuackBehavoir(new QuackBehavior() {
                @Override
                public void quack() {
                    System.out.println("我会叫");
                }
            });
    //        greenHeadDuck.Quack();
    
    
    
            greenHeadDuck.swim();
    
            System.out.println();
            System.out.println();
    
            redHeadDuck.display();
            redHeadDuck.Quack();
            redHeadDuck.swim();
            redHeadDuck.SetFlyBehavoir(new FlyBehavior() {
                @Override
                public void fly() {
                    System.out.println("我会飞");
                }
            });
        }
    }
    
    

    注:以上代码都是java中的基础知识。运用设计模式中的策略模式。把变化的部分提取出来变为接口+实现。其中,main方法中,父类为Dock基类,是为了屏蔽子类的超类Dock的差别性。Dock类中的SetQuackBehavoir()方法,灵活的让实例化对象灵活的改变对象的行为。比如,绿头鸭,使用了SetQuackBehavoir()方法,定制了自己的quck()方法。因为不是每只鸭都能叫的。叫的是当前鸭的特性。


    本文中的小Demo不用继承的原因是。我们可以假想。一个鸭子可以有很多子类。如果把方法全部写在基类。子类都会继承它,对于不同的子类,有些方法违反了逻辑成为了冗余。关于IO流中用的装饰者模式,而不是继承模式,不写为new BufferedReader(“F:\test.java”);
    是因为IO流种类很多,基类、扩展子类有很多种,继承会编程n对n的关系。复杂度为n*n。每个IO的子类去继承超类,继承多次虽然调用的时候简写代码,但是对基类和子类的结构来说确是一种负担。所以IO流采用的是装饰者模式:new BufferedReader(new FileReader(“F:\test.java”));


    (小Ddemo过于简单,就不细致分析,对比新需求前看源码即可明白策略模式的妙处)
    总结:
    策略模式注意点:
    1.分析项目中变化部分与不变部分
    2.多用组合少用继承;用行为类组合,而不是行为的继承。更有弹性。
    3.设计模式没有相应的库直接使用,有些库或框架本身就用某种设计模式设计的。

    展开全文
  • 装饰模式(Decorator Pattern) 动态地给个对象添加一些额外的职责。就增加功能来说,装饰模式相比生成子类更为灵活。 ...装饰模式的通用类图 ...Component是个接口或者...注意 在装饰模式中,必然有个最基本、

    装饰模式(Decorator Pattern)

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


    装饰模式的通用类图



    在类图中,有四个角色需要说明:
    ● Component抽象构件
    Component是一个接口或者是抽象类,就是定义我们最核心的对象,也就是最原始的对象,如上面的成绩单。

    注意 在装饰模式中,必然有一个最基本、最核心、最原始的接口或抽象类充当Component抽象构件。


    ● ConcreteComponent 具体构件

    ConcreteComponent是最核心、最原始、最基本的接口或抽象类的实现,你要装饰的就是它。


    ● Decorator装饰角色

    一般是一个抽象类,做什么用呢?实现接口或者抽象方法,它里面可不一定有抽象的方法呀,在它的属性里必然有一个private变量指向Component抽象构件。


    ● 具体装饰角色
    ConcreteDecoratorA和ConcreteDecoratorB是两个具体的装饰类,你要把你最核心的、最原始的、最基本的东西装饰成其他东西,上面的例子就是把一个比较平庸的成绩单装饰成家长认可的成绩单。

    装饰模式的所有角色都已经解释完毕,我们来看看如何实现,先看抽象构件,


    抽象构件

    public abstract class Component {
    //抽象的方法
    public abstract void operate();
    
    }

    具体构件


    public class ConcreteComponent extends Component {
    //具体实现
    @Override
    public void operate() {
    System.out.println("do Something");
    }
    }

    装饰角色通常是一个抽象类


    抽象装饰者

      public abstract class Decorator extends Component {
            private Component component = null;
            //通过构造函数传递被修饰者
            public Decorator(Component _component){
                this.component = _component;
            }
            //委托给被修饰者执行
            @Override
            public void operate() {
                this.component.operate();
            }
        }

    当然了,若只有一个装饰类,则可以没有抽象装饰角色,直接实现具体的装饰角色即可。


    具体的装饰类


      public class ConcreteDecorator1 extends Decorator {
            //定义被修饰者
            public ConcreteDecorator1(Component _component){
                super(_component);
            }
            //定义自己的修饰方法
            private void method1(){
                System.out.println("method1 修饰");
            }
            //重写父类的Operation方法
            public void operate(){
                this.method1();
                super.operate();
            }
        }
    
    
    
    public class ConcreteDecorator2 extends Decorator {
            //定义被修饰者
            public ConcreteDecorator2(Component _component){
                super(_component);
            }
            //定义自己的修饰方法
            private void method2(){
                System.out.println("method2修饰");
            }
            //重写父类的Operation方法
            public void operate(){
                super.operate();
                this.method2();
            }
        }

    注意 原始方法和装饰方法的执行顺序在具体的装饰类是固定的,可以通过方法重载实现多种执行顺序。我们通过Client类来模拟高层模块的耦合关系,看看装饰模式是如何运行的,如代码清单17-14所示。


    场景类

     public class Client {
            public static void main(String[] args) {
                Component component = new ConcreteComponent();
               //第一次修饰
                component = new ConcreteDecorator1(component);
               //第二次修饰
                component = new ConcreteDecorator2(component);
              //修饰后运行
                component.operate();
            }
        }

     装饰模式的优点

    ● 装饰类和被装饰类可以独立发展,而不会相互耦合。换句话说,Component类无须知道Decorator类,Decorator类是从外部来扩展Component类的功能,而Decorator也不用知道具体的构件。


    ● 装饰模式是继承关系的一个替代方案。我们看装饰类Decorator,不管装饰多少层,返回的对象还是Component,实现的还是is-a的关系。


    ● 装饰模式可以动态地扩展一个实现类的功能,这不需要多说,装饰模式的定义就是如此。


    装饰模式的缺点
    对于装饰模式记住一点就足够了:多层的装饰是比较复杂的。为什么会复杂呢?你想想看,就像剥洋葱一样,你剥到了最后才发现是最里层的装饰出现了问题,想象一下工作量吧,因此,尽量减少装饰类的数量,以便降低系统的复杂度。


     装饰模式的使用场景


    ● 需要扩展一个类的功能,或给一个类增加附加功能。


    ● 需要动态地给一个对象增加功能,这些功能可以再动态地撤销。


    ● 需要为一批的兄弟类进行改装或加装功能,当然是首选装饰模式。



    最佳实践


    装饰模式是对继承的有力补充。你要知道继承不是万能的,继承可以解决实际的问题,但是在项目中你要考虑诸如易维护、易扩展、易复用等,而且在一些情况下你要是用继承就会增加很多子类,而且灵活性非常差,那当然维护也不容易了,也就是说装饰模式可以替代继承,解决我们类膨胀的问题。同时,你还要知道继承是静态地给类增加功能,而装饰模式则是动态地增加功能。装饰模式还有一个非常好的优点:扩展性非常好。通过装饰模式重新封装一个类,而不是通过继承来完成。
    展开全文
  • 23种设计模式汇总整理

    万次阅读 多人点赞 2015-04-09 10:57:11
    行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 其实还有两类:并发型模式和线程池模式。 ...

    设计模式分为三大类:

    创建型模式,共五种:工厂方法模式抽象工厂模式单例模式建造者模式原型模式

    结构型模式,共七种:适配器模式装饰者模式代理模式外观模式桥接模式组合模式享元模式

    行为型模式,共十一种:策略模式模板方法模式观察者模式迭代子模式责任链模式命令模式备忘录模式状态模式访问者模式中介者模式、解释器模式

    其实还有两类:并发型模式和线程池模式。

     

    设计模式的六大原则:

    总原则-开闭原则

    对扩展开放,对修改封闭。在程序需要进行拓展的时候,不能去修改原有的代码,而是要扩展原有代码,实现一个热插拔的效果。所以一句话概括就是:为了使程序的扩展性好,易于维护和升级。

    想要达到这样的效果,我们需要使用接口和抽象类等,后面的具体设计中我们会提到这点。

     

    1、单一职责原则

    不要存在多于一个导致类变更的原因,也就是说每个类应该实现单一的职责,否则就应该把类拆分。

     

    2、里氏替换原则(Liskov Substitution Principle)

    任何基类可以出现的地方,子类一定可以出现。里氏替换原则是继承复用的基石,只有当衍生类可以替换基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。

    里氏代换原则是对“开-闭”原则的补充。实现“开闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。里氏替换原则中,子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构,通过这个规范的接口与外界交互,子类不应该随便破坏它。

     

    3、依赖倒转原则(Dependence Inversion Principle)

    面向接口编程,依赖于抽象而不依赖于具体。写代码时用到具体类时,不与具体类交互,而与具体类的上层接口交互。

     

    4、接口隔离原则(Interface Segregation Principle)

    每个接口中不存在子类用不到却必须实现的方法,如果不然,就要将接口拆分。使用多个隔离的接口,比使用单个接口(多个接口方法集合到一个的接口)要好。

     

    5、迪米特法则(最少知道原则)(Demeter Principle)

    一个类对自己依赖的类知道的越少越好。无论被依赖的类多么复杂,都应该将逻辑封装在方法的内部,通过public方法提供给外部。这样当被依赖的类变化时,才能最小的影响该类。

    最少知道原则的另一个表达方式是:只与直接的朋友通信。类之间只要有耦合关系,就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

     

    6、合成复用原则(Composite Reuse Principle)

    尽量首先使用合成/聚合的方式,而不是使用继承。

     

    之前已经陆续整理了9种设计模式,链接如下,接下来一段时间陆续把剩余的过一遍,整理出来,理解设计模式还是很重要的。

     

    创建型模式:工厂方法模式抽象工厂模式单例模式建造者模式原型模式

    结构型模式:适配器模式装饰者模式代理模式外观模式桥接模式组合模式享元模式

    行为型模式:策略模式模板方法模式观察者模式迭代子模式责任链模式命令模式备忘录模式状态模式访问者模式中介者模式、解释器模式

    还有两类:并发型模式和线程池模式。

     

     

    -------2017年8月31日更新----------------

    设计模式需要几个阶段的学习,

    没有大量项目经验的时候学习,可能只是了解,

    当有了一些项目场景的时候,才会深刻体会到其中的奥妙。

     

    上面文章有些在写的时候,“借鉴”甚至“抄袭”了很多其他博主的文章,主要也是当时自己理解的不够深刻,需要借助现有的场景去理解,接下来会抽时间梳理一下设计模式的东西,整理一遍,希望能帮到大家。

    作者:jason0539

    博客:http://blog.csdn.net/jason0539(转载请说明出处)

     

    展开全文
  • 设计模式全解(

    万次阅读 2016-08-12 23:39:49
    设计模式(Design Patterns)  ——可复用面向对象软件的基础 设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被...
  • 篇文章搞懂Java设计模式之责任链模式

    万次阅读 多人点赞 2017-05-05 12:50:14
    我们先来了解一下什么是责任链模式: 职责链模式(Chain of Responsibility):使多个对象都有机会处理同个请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成条链,并沿着这条链传递该
  • 设计个只能创建个唯一实例的类——单例模式 1. 背景  老师布置了个思考题:设计个只能创建个唯一实例的类。让我们只要想一下思路即可。自己的第反应就是设计模式中的单例模式。自己百度了一下单例...
  • 个线程安全的单例模式

    千次阅读 2017-09-18 22:25:21
    单例模式,也单子模式,是种常用的软件设计模式。在应用这个模式时,单例对象的类必须保证只有个实例存在。许多时候整个系统只需要拥有个的全局对象,这样有利于我们协调系统整体的行为。比如在某个服务器...
  • 设计模式“六原则法则”

    万次阅读 2019-08-01 13:54:21
    1. 单一职责原则:个类只做它该做的事情。(单一职责原则想表达的就是"高内聚",写代码最终极的原则只有六个字"高内聚、低耦合",就如同葵花宝典或辟邪剑谱的...我们都知道句话"因为专注,所以专业",个对象...
  • 设计模式)——单例设计模式

    千次阅读 2017-08-30 23:07:41
    设计模式大家一定不陌生,Java语言中我们经常会有意无意的就使用到一些设计模式,那么设计模式到底是什么,为什么要使用设计模式呢?其实设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、...
  • 常用设计模式总结

    万次阅读 多人点赞 2019-07-31 19:13:12
    毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现在中...
  • JAVA设计模式--命令模式

    万次阅读 2017-02-11 14:06:52
    命令(Command)模式作动作(Action)模式或事务(Transaction)模式,是种对象的行为模式。将个请求封装为个对象,从而使你可用不同的请求客户进行参数化;请求排队或记录请求日志,以及支持可撤消的操作。...
  • 代理模式的使用总结

    万次阅读 多人点赞 2020-04-20 14:14:37
    、代理模式 二、静态代理 ()静态代理 (二)静态代理简单实现 三、动态代理 ()动态代理 (二)动态代理简单实现 四、动态代理原理分析 五、InvocationHandler接口和Proxy类详解 六、JDK动态代理...
  • 组合模式

    千次阅读 2019-09-25 20:43:06
    组合模式(Composite Pattern),又部分整体模式,是用于把组相似的对象当作个单一的对象。组合模式依据树形结构来组合对象,用来表示部分以及整体层次。这种类型的设计模式属于结构型模式,它创建了对象组的...
  • 个示例让你明白适配器模式

    万次阅读 多人点赞 2014-01-26 00:08:28
    适配器模式是23中设计模式,它的主要作用是在新接口和老接口之间进行适配。它非常像我们出国旅行时带的电源转换器。为了举这个例子,我还特意去京东上搜了一下电源转换器,确实看到了很多地方的标准不一样。我们...
  • JAVA设计模式--备忘录模式

    万次阅读 多人点赞 2017-02-10 21:36:36
    备忘录(Memento)模式作快照(Snapshot)模式或Token模式,是种对象的行为模式。在备忘录模式里,个备忘录是个对象,它存储另个对象(备忘录的原发器)在某个瞬间的内部状态。备忘的目的就是为了以后在需要...
  • 什么是单例模式

    千次阅读 多人点赞 2019-05-13 16:51:29
    保证整个系统中个类只有个对象的实例,实现这种功能的方式就单例模式。 为什么要用单例模式? 1、单例模式节省公共资源 比如:大家都要喝水,但是没必要每人家里都打口井是吧,通常的做法是整个村里打个...
  • 1.1 设计模式的分类 总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式、...行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态 ...
  • 实现个线程安全的单例模式

    千次阅读 2017-08-02 22:28:09
     单例模式单件模式。Singleton是个非常常用的设计模式,几乎所有稍微大一些的程序都会使用它,所以构建个高效的Singleton很重要。 1、单例类保证全局只有个唯一实例对象 2、单例类提供获取这个唯一实例...
  • 在前一阵子为了解决女朋友追剧的问题,使用《创建型模式:建造者模式》给女朋友组装了电脑。 使用了段时间后,我...经过这个问题的解决,我发现了个新的设计模式《适配器模式、适配器模式基本概念 1.1 .
  • JAVA设计模式初探之装饰者模式

    万次阅读 多人点赞 2014-04-01 09:07:37
    定义:动态给个对象添加一些额外的职责,就象在墙上刷油漆.使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活。 设计初衷:通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,...
  • 什么模式识别,模式识别主要识别什么

    万次阅读 多人点赞 2019-03-20 23:01:58
    为了具备这种能力,人类在过去的几千万年里,通过大量事物的认知和理解,逐步进化出了高度复杂的神经和认知系统。举例来说,我们能够轻易的判别出哪个是钥匙、哪个是锁,哪个是自行车、哪个是...
  • 1.什么设计模式 2.设计模式的发展 3.设计原则6大原则 3.1 开闭原则 3.2 里氏转换原则 3.3 依赖倒转原则 3.4 接口隔离原则 3.5 合成/聚合复用原则 3.6 迪米特原则 1.什么设计模式 软件设计模式(Design ...
  • JAVA设计模式--迭代器模式

    万次阅读 多人点赞 2017-02-11 13:01:59
    迭代器(Iterator)模式作游标(Cursor)模式,是种对象的行为模式。提供种方法顺序访问个聚合(指组对象的组合结构,如:Java中的集合、数组等)对象中各个元素,而又不需暴露该对象的内部表示。 迭代器...
  • 发布—订阅模式观察者模式,它定义了对象间的一种一对多的关系,让多个观察者对象同时监听某一个主题对象,当一个对象发生改变时,所有依赖于它的对象都将得到通知。 二 现实中的发布订阅者模式 1.比如小红...
  • Reactor模式什么

    万次阅读 多人点赞 2018-07-26 09:22:21
    、Reactor模式什么 反应器设计模式(Reactor pattern)是种为处理并发服务请求,并将请求提交到个或 者多个服务处理程序的事件设计模式。当客户端请求抵达后,服务处理程序使用多路分配策略,由个非阻塞的...
  • 在网络上流畅很广的篇旧文,暂时没找到原作者,目前所看到的最早转载时间是 2005 年 2 月 28 日。作者用轻松的语言,形象解释了 23 种模式,有很好的启发作用。 创建型模式 1、FACTORY—追MM少不了请吃饭了...
  • 在这一节我们就看看第类:类适配器模式 、类适配器基本概念 1.1 说明 类适配器模式在编译时实现target(目标)接口。这种适配器模式使用了多个实现了期待的接口或者已经存在的接口的多态接口。比较典型的...
  • 创建型模式,是对象创建过程的各种问题和解决方案的总结,包括各种工厂模式(Factory、Abstract Factory)、单例模式(Singleton)、构建器模式(Builder)、原型模式(ProtoType)。 结构型模式,是针对软件设计...
  • JAVA设计模式--适配器模式

    万次阅读 2016-08-28 20:42:19
    适配器(Adapter)模式又叫做包装( Wrapper )模式,是由GOF提出的23种设计模式中的种结构型设计模式,Adapter模式的设计意图:将个类的接口转换成客户希望的另外个接口,使得原本由于接口不兼容而不能一起工作.....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 503,204
精华内容 201,281
关键字:

一对一叫什么模式