精华内容
下载资源
问答
  • 昨天去面试 被问及了java的设计模式 问我工厂模式的好处在哪儿 我答的是便于管理易改变的类 貌似不怎么对 晚上回来特别再一次看了常用设计模式的应用...常用设计模式应用场景如下: 1、抽象工厂 应用场景:封装

    昨天去面试 被问及了java的设计模式  问我工厂模式的好处在哪儿 我答的是便于管理易改变的类 貌似不怎么对 晚上回来特别再一次看了常用设计模式的应用场景

    实话说设计模式这种东西 很多时候感觉可以用 就用了 为什么用 用了有什么好处 都不会去深究 平时做设计的时候就是凭一个直觉  可是面试不会这样 还得有个书面化的表达

    常用设计模式应用场景如下:


    1、抽象工厂   
    应用场景:封装变化点。创建一系列相互依赖的对象。 
    在软件系统中,经常面临着“一系列相互依赖的对象”的创建工作;同时由于需求的变化,往往存在更多系列对象的创建工作。如何应对这各变化如何绕过常规的对象创建方法(new),提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合。 

    比如游戏里一系列相关联的对象:丛林 房屋 怪物 道路


    2、Builder   
    在软件系统中,有时候面临着“一个复杂对象”的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定。 
    Builder设计模式是应对这样的需求变化:如何提供一种“封装机制”来隔离“复杂对象的各个部分”的变化,从而保持系统中的“稳定构建算法”,不随着需求改变而改变。 



    3、工厂方法(把变和不变的地方隔离出来)   
    紧耦合和松耦合:如何进行模块划分? 
    主模块(抽象部分)-->次模块(细节具体部分) 对模块进行分析(高层模块-->低层模块) 
    在软件系统中,经常面临着“某个对象”的创建工作;由于需求的变化,这个对象的具体实现经常面临着剧烈的变化,但是它却拥有比较稳定的接口。 
    如何应对这种变化?如何提供一种“封装机制”来隔离出“这种易变对象”的变化,从而保持系统中 
    “其他依赖该对象的对象(主逻辑)”不随着需求改变而改变? 
    解决:定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟。 


    4、Bridge模式 

    适用场景:将抽象部分与实现部分分离,使他们都可以独立地变化将 

    或将一个事物的多个维度的变化分离,该模式证明聚合比继承好 

    将导致类改变的两个维度的变化的实现分离开来.



    5、适配器Adapter   回页首 

    在软件系统中,由于应用 环境的变化,常常要将"一些现在的对象"放到新的环境中应用,但是新环境要求的接口是这些现存对象所不满足的 

    适用场景:在不改变原来实现的基础上,将原来不兼容的接口转换为兼容的接口。将一个类的接口转换至客户希望的另一个接口。Adapter 

               模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 



    6、Decarator   回页首 

    过度地使用了继承来扩展对象的功能,由于继承为类型引入的静态特质,使得这种扩展方式缺乏灵活性 

    并且随着子类的增多,各子类的组合会导致更多子类的膨胀.动态地给一个对象增加一些额外的职责 



    详细说明:http://long254229962.iteye.com/admin/blogs/1596617

    展开全文
  • Java常用设计模式总结及应用场景分析

    万次阅读 多人点赞 2019-03-12 16:24:00
    原 java常用设计模式总结 2017年11月23日 21:30:54 qq_14827935 阅读数:3284 ...

    掌握常用的几种(最起码单例模式、工厂模式),了解其他的设计模式即可,做到手里有粮,心里不慌。首先,掌握每种模式的定义及使用场景。其次,掌握一个形象的例子,简单的过一遍代码。
    学习设计模式的真正目的:编程时,有意识地面向接口编程,多用封装、继承、组合、多态等OOP思想,而不仅仅是死记几类设计模式。

    常用的设计模式分类:
    创建型(创建一个对象):单例模式、工厂模式、抽象工厂模式
    结构型(将几个对象组织成一个结构):桥接模式、外观模式、代理模式
    行为型(多个对象间的通信):观察者模式、策略模式
    其中,工厂模式、桥接模式、策略模式有点像,放在一起理解(几个对象具有共同特征,因此继承共同的接口,然后通过工厂、桥去访问)。另外,工厂模式和外观模式(几个对象间有先后关系,是串行的,而非工厂模式中的并行,因此几个对象组合成一个外观类,通过这个外观类来访问)区别很明显,也因此放在一起理解。

    参考引用:

    http://www.runoob.com/design-pattern/proxy-pattern.html
    https://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.html
    https://www.cnblogs.com/chinajava/p/5880870.html

    设计模式定义

    被反复使用的,代码设计经验的总结。

    设计模式的原则

    总结起来,就是多用接口/抽象类,从而增加代码的可扩展性(减少修改代码)。降低模块间的依赖和联系。
    体现了OOP的模块化、可扩展性等特征。

    工厂模式

    定义与使用场合:现在需要创建几个对象,且这几个对象有共同特征,则不需要具体创建各个对象,而是创建对象工厂类即可。
    一般常用静态工厂模式。
    例子:发送邮件和短信(共同特征:发送的消息)
    这里写图片描述

    public interface Sender {  
        public void Send();  
    }  
    • 1
    • 2
    • 3
    public class MailSender implements Sender {  
        @Override  
        public void Send() {  
            System.out.println("this is mailsender!");  
        }  
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    public class SmsSender implements Sender {  
    
        @Override  
        public void Send() {  
            System.out.println("this is sms sender!");  
        }  
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    public class SendFactory {  
    
        public static Sender produceMail(){  
            return new MailSender();  
        }  
    
        public static Sender produceSms(){  
            return new SmsSender();  
        }  
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    public class FactoryTest {  
    
        public static void main(String[] args) {      
            Sender sender = SendFactory.produceMail();  
            sender.Send();  
        }  
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    抽象工厂模式

    工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改,这违背了闭包原则
    定义与使用场景:同上。
    例子:同上。
    这里写图片描述

    public interface Provider {  
        public Sender produce();  
    }  
    • 1
    • 2
    • 3
    public class SendMailFactory implements Provider {  
    
        @Override  
        public Sender produce(){  
            return new MailSender();  
        }  
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    public class SendSmsFactory implements Provider{  
    
        @Override  
        public Sender produce() {  
            return new SmsSender();  
        }  
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    public class Test {  
    
        public static void main(String[] args) {  
            Provider provider = new SendMailFactory();  
            Sender sender = provider.produce();  
            sender.Send();  
        }  
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    总结:如果要新增发送微信,则只需做一个实现类,实现Sender接口,同时做一个工厂类,实现Provider接口,就OK了,无需去改动现成的代码。这样做,拓展性较好!
    所有工厂模式中,抽象工厂模式最先进。

    策略模式及与工厂模式的区别

    定义与使用场合:一个系统需要动态地在几种类似的算法中选择一种。
    与工厂模式异同:实例化一个对象的位置不同。对工厂模式而言,实例化对象是放在了工厂类里面。而策略模式实例化对象的操作在调用的地方。本质都是继承与多态。
    例子: 现有 加/减/乘 几种算法,输入参数返回值都一样(可以理解成类似的算法)。现在需要在调用时动态配置算法策略,实现对不同算法的调用。
    这里写图片描述

    public interface Strategy {
       public int doOperation(int num1, int num2);
    }
    • 1
    • 2
    • 3
    public class OperationAdd implements Strategy{
       @Override
       public int doOperation(int num1, int num2) {
          return num1 + num2;
       }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    public class OperationSubstract implements Strategy{
       @Override
       public int doOperation(int num1, int num2) {
          return num1 - num2;
       }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    public class OperationMultiply implements Strategy{
       @Override
       public int doOperation(int num1, int num2) {
          return num1 * num2;
       }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    public class Context {
       private Strategy strategy;
    
       public Context(Strategy strategy){
          this.strategy = strategy;
       }
    
       public int executeStrategy(int num1, int num2){
          return strategy.doOperation(num1, num2);
       }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    public class StrategyPatternDemo {
       public static void main(String[] args) {
           //实例化对象的位置在调用处
          Context context = new Context(new OperationAdd());        
          System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
    
          context = new Context(new OperationSubstract());        
          System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
    
          context = new Context(new OperationMultiply());        
          System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
       }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    单例模式

    定义及使用场合:只有一个对象被创建。
    例子:
    建议采用 饿汉式 创建方法。线程安全,容易实现。初始化慢一点。

    public class SingleObject {
    
       //创建 SingleObject 的一个对象
       private static SingleObject instance = new SingleObject();
    
       //让构造函数为 private,这样该类就不会被实例化
       private SingleObject(){}
    
       //获取唯一可用的对象
       public static SingleObject getInstance(){
          return instance;
       }
    
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    观察者模式

    定义与使用场景:一个对象(subject)被其他多个对象(observer)所依赖。则当一个对象变化时,发出通知,其它依赖该对象的对象都会收到通知,并且随着变化。
    比如 声音报警器和闪光灯报警器分别订阅热水器温度,热水器温度过高时,发出通知,两个报警器分别发声、闪光以实现报警。
    又比如很多人订阅微信公众号,该公众号有更新文章时,自动通知每个订阅的用户。
    **实现:**1,多个观察者要订阅这个对象 2,这个对象要发出通知

    例子:
    这里写图片描述

    public interface Observer {  
        public void update();  
    }  
    • 1
    • 2
    • 3
    public class Observer1 implements Observer {  
    
        @Override  
        public void update() {  
            System.out.println("observer1 has received!");  
        }  
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    public class Observer2 implements Observer {  
    
        @Override  
        public void update() {  
            System.out.println("observer2 has received!");  
        }  
    
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    public interface Subject {  
    
        /*增加观察者*/  
        public void add(Observer observer);  
    
        /*删除观察者*/  
        public void del(Observer observer);  
    
        /*通知所有的观察者*/  
        public void notifyObservers();  
    
        /*自身的操作*/  
        public void operation();  
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    public abstract class AbstractSubject implements Subject {  
    
        private Vector<Observer> vector = new Vector<Observer>();  
        @Override  
        public void add(Observer observer) {  
            vector.add(observer);  
        }  
    
        @Override  
        public void del(Observer observer) {  
            vector.remove(observer);  
        }  
    
        @Override  
        public void notifyObservers() {  
            Enumeration<Observer> enumo = vector.elements();  
            while(enumo.hasMoreElements()){  
                enumo.nextElement().update();  
            }  
        }  
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    public class MySubject extends AbstractSubject {  
    
        @Override  
        public void operation() {  
            System.out.println("update self!");  
            notifyObservers();  
        }  
    
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    public class ObserverTest {  
    
        public static void main(String[] args) {  
            Subject sub = new MySubject();  
            sub.add(new Observer1());  //订阅这个对象
            sub.add(new Observer2());  
    
            sub.operation();  //发出改变的一个通知
        }  
    
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    代理模式

    定义与使用场景:一个代理类代表一个真实类的功能,通过访问代理类来实现对真实类的访问。
    比如买火车票这件小事:黄牛相当于是火车站的代理,我们可以通过黄牛买票,但只能去火车站进行改签和退票。
    又比如需要对原有的方法进行修改,就是采用一个代理类调用原有的方法,以避免修改原有代码。
    例子:
    这里写图片描述
    一个真实对象realSubject提供一个代理对象proxy。通过proxy可以调用realSubject的部分功能*,并添加一些额外的业务处理*,同时可以屏蔽realSubject中未开放的接口。
    1、RealSubject 是委托类,Proxy 是代理类;
    2、Subject 是委托类和代理类的接口;
    3、request() 是委托类和代理类的共同方法;

    interface Subject {
        void request();
    }
    
    class RealSubject implements Subject {
        public void request(){
            System.out.println("RealSubject");
        }
    }
    
    class Proxy implements Subject {
        private Subject subject;
    
        public Proxy(Subject subject){
            this.subject = subject;
        }
        public void request(){
            System.out.println("begin");
            subject.request();
            System.out.println("end");
        }
    }
    
    public class ProxyTest {
        public static void main(String args[]) {
            RealSubject subject = new RealSubject();
            Proxy p = new Proxy(subject);
            p.request();
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    桥接模式及与策略模式的区别

    定义与使用场景:访问多种数据库驱动(多个具有共同特征的数据库驱动),不是直接访问,而是通过DriverManager桥来访问。

    这里写图片描述
    例子: 不再具体实现了。
    这里写图片描述
    与策略模式的区别:(个人觉得较复杂,了解即可。本质都是面向接口编程,体现继承与多态)
    策略模式:我要画圆,要实心圆,我可以用solidPen来配置,画虚线圆可以用dashedPen来配置。这是strategy模式。
    桥接模式:同样是画圆,我是在windows下来画实心圆,就用windowPen+solidPen来配置,在unix下画实心圆就用unixPen+solidPen来配置。如果要再windows下画虚线圆,就用windowsPen+dashedPen来配置,要在unix下画虚线圆,就用unixPen+dashedPen来配置。
    所以相对策略模式,桥接模式要表达的内容要更多,结构也更加复杂。

    外观模式

    定义与使用场景:见例子。又比如,去医院看病,可能要去挂号、门诊、划价、取药,让患者或患者家属觉得很复杂,如果有提供接待人员,只让接待人员来处理,就很方便。
    例子:计算机启动,需要先启动CPU,再启动memory,最后启动disk。这三个类之间具有先后关系(依赖关系)。
    这里写图片描述
    与工厂模式的区别:工程模式多个类具有共同特征(继承一个共同的接口),是并列的。而外观模式多个类是有先后关系,是串行的,用组合。

    贴部分代码:

    public class Computer {  
    //是组合,而非继承。这是与工程模式的显著区别。
        private CPU cpu;  
        private Memory memory;  
        private Disk disk;  
    
        public Computer(){  
            cpu = new CPU();  
            memory = new Memory();  
            disk = new Disk();  
        }  
    
        public void startup(){  
            System.out.println("start the computer!");  
            cpu.startup();  
            memory.startup();  
            disk.startup();  
            System.out.println("start computer finished!");  
        }  
    
        public void shutdown(){  
            System.out.println("begin to close the computer!");  
            cpu.shutdown();  
            memory.shutdown();  
            disk.shutdown();  
            System.out.println("computer closed!");  
        }  
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    public class User {  
    
        public static void main(String[] args) {  
            Computer computer = new Computer();  
            //将计算机的启动过程封装成一个类
            computer.startup();  
            computer.shutdown();  
        }  
    }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    生产者-消费者模式

    定义与使用场景:生产者把数据放入缓冲区,而消费者从缓冲区取出数据。
    例子:缓冲区一般为队列(FIFO),但在生产消费较为频繁时,队列push,pop内存消耗较大,此时可以考虑环形缓冲区(以数组、链表方式实现)。
    通过互斥锁防止缓冲区同时读写。通过信号量控制缓冲区大小(满的时候不允许写,空的时候不允许读)


    作者:qq_14827935
    来源:CSDN
    原文:https://blog.csdn.net/qq_14827935/article/details/78618652

    展开全文
  • 常用设计模式及其应用场景

    千次阅读 2017-04-13 22:19:41
    设计模式是对设计原则的具体化。用江湖话说就是武林秘籍,总结出来的一些固定套路...单例模式是一种常用的软件设计模式。 在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个

    设计模式是对设计原则的具体化。用江湖话说就是武林秘籍,总结出来的一些固定套路,编程界的《葵花宝典》。

    个人意见,编程过程中设计原则进行遵循,对设计模式进行借鉴。完全按照套路来,有时反而简单问题复杂化。

    常用的模式及其场景如下。

    1) 单例模式。

    单例模式是一种常用的软件设计模式。

    在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问,从而方便对实例个数的控制并节约系统资源。

    对应类图。

    \

    应用场景:如果希望在系统中某个类的对象只能存在一个,单例模式是最好的解决方案。

    2) 工厂模式。

    工厂模式主要是为创建对象提供了接口。

    工厂模式按照《Java与模式》中的提法分为三类:

    a. 简单工厂模式(Simple Factory)

    b. 工厂方法模式(Factory Method) <喎�"/kf/ware/vc/" target="_blank" class="keylink">vcD4KPHA+Yy4gs+nP87mks6fEo8q9KEFic3RyYWN0IEZhY3RvcnkpIDwvcD4KPHA+ICAgICAgINXiyP3W1sSjyr2008nPtb3Pwtbwsr2z6c/zo6yyosfSuPy+39K7sOPQ1KGjPC9wPgo8cD4gICAgICAgttTTpsDgzbyhozwvcD4KPHA+IDxpbWcgc3JjPQ=="/uploadfile/Collfiles/20141213/20141213090340208.png" alt="\">

    下面是使用工厂模式的两种情况:

    a. 在编码时不能预见需要创建哪种类的实例。

    b. 系统不应依赖于产品类实例如何被创建、组合和表达的细节。

    3) 策略模式。

    策略模式:定义了算法族,分别封装起来,让它们之间可以互相替换。此模式让算法的变化独立于使用算法的客户。

    对应类图。

    \

    应用场景如下。

    a. 一件事情,有很多方案可以实现。

    b. 我可以在任何时候,决定采用哪一种实现。

    c. 未来可能增加更多的方案。

    d. 策略模式让方案的变化不会影响到使用方案的客户。

    举例业务场景如下。

    系统的操作都要有日志记录,通常会把日志记录在数据库里面,方便后续的管理,但是在记录日志到数据库的时候,可能会发生错误,比如暂时连不上数据库了,那就先记录在文件里面。日志写到数据库与文件中是两种算法,但调用方不关心,只负责写就是。

    4) 观察者模式。

    观察者模式又被称作发布/订阅模式,定义了对象间一对多依赖,当一个对象改变状态时,它的所有依赖者都会收到通知并自动更新。

    对应类图。

    应用场景如下。

    a. 对一个对象状态的更新,需要其他对象同步更新,而且其他对象的数量动态可变。

    b. 对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节。

    业务场景举例:气象站的故事,气象监控系统必须可以实时跟踪当前的天气状况(温度、湿度、大气压力),并且可以在三种不同设备上显示出来(当前天气状况、天气统计、天气预测)。



    转自:http://www.2cto.com/kf/201412/360988.html

    展开全文
  • 一些常用设计模式应用场景

    千次阅读 2013-12-26 12:39:58
    创建型模式 构建者(builder) 当创建一个类的过程比较复杂时(例如要组合对象、以及判断构造参数是否足够和合法),用专门的类(如建立一个专门的Builder类)和方法将这个创建的过程封装起来。 工厂方法(Factory ...

    创建型模式

    构建者(builder)
    当创建一个类的过程比较复杂时(例如要组合对象、以及判断构造参数是否足够和合法),用专门的类(如建立一个专门的Builder类)和方法将这个创建的过程封装起来。

    工厂方法(Factory Method)
    给方法传入类的名称,方法给你返回你想要的类实例,现在这个模式的功能被spring框架IOC取代

    抽象工厂(Abstract Factory)
    抽象工厂模式与工厂方法模式的区别
    可以这么说,工厂方法模式是一种极端情况的抽象工厂模式,而抽象工厂模式可以看成是工厂方法模式的一种推广。
    (1)、其实工厂方法模式是用来创建一个产品的等级结构的,而抽象工厂模式是用来创建多个产品的等级结构的。工厂方法创建一般只有一个方法,创建一种产品。抽象工厂一般有多个方法,创建一系列产品。
    (2)、工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。
    简而言之->
    工厂方法模式:一个抽象产品类,可以派生出多个具体产品类。   
                  一个抽象工厂类,可以派生出多个具体工厂类。   
                  每个具体工厂类只能创建一个具体产品类的实例。   
    抽象工厂模式:多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。   
                  一个抽象工厂类,可以派生出多个具体工厂类。   
                  每个具体工厂类可以创建多个具体产品类的实例。

    典型应用:GUI工具箱,点击工具箱中的每种工具类型时,使用不同的工厂类,在编辑界面上创建对应的组件对象

    职责型模式

    观察者(observer)

    当对象的状态变化时,需要通知其他对象。使用observer模式,可以使解除通知的依赖关系,发生变化的类不需依赖接收通知的类。借用jdon的一个例子:产品价格和名称发生变化时,需要通知到相关的用户和商家,可以分别定义两个observer类,在producet中包含一个observerList列表,在setName和setPrice方法中分别调用notifyObservers方法。Java的API还为为我们提供现成的Observer接口Java.util.Observer.我们只要直接使用它就可以.


    职责链模式(chain of Responsibility)
    接收GUI响应后(例如按帮助按钮后),响应代码的处理,可以自己处理,也可以将响应传到下一个处理者。
    java中的异常响应机制也是中这种模式,可以捕捉异常,或者将异常抛出到外面一层。

    代理模式(Proxy)

    处理跟外部系统或硬件交互时都用到,例如打印(只是调用打印类的方法,而不是直接调打印机接口)、例如发送JMS消息、导出excel、导入数据到其他系统(ERP),都会用一个代理类操作。

    另外,代理的模式能够在原来的方法上加入自己想要的逻辑。spring AOP就是使用了java的动态代理机制。


    调停者(Mediator)
    定义一个对象,将一组对象之间的交互封装起来,从而降低对象间的耦合度,避免了对象间的显式引用,并且可以独立地改变对象行为。

    经常应用在界面控件的相关性操作中,例如选择省份后,另一个下拉框显示所有该省份的城市。

    命令模式(command)
    将调用封装在一个对象中,而不是直接写调用代码,因为设计时只知道在何时调用,而不知道具体执行什么操作。
    最经常使用在事件通知机制,例如flex中的EventListener。
    在command模式中加入undo方法,也可以实现撤销操作。
    例如:工作流的画图工具。其中有一个具有一些按钮的工具条,用户可以通过这些按钮去添加各种活动节点。用户单击了 Draw Activty(画圆)按钮,系统就创建一个 DrawActivityCommand 对象,并调用了该对象的 Execute()  方法,将一个活动图标添加到画图编辑界面中,并且把这个command对象加入到私有变量(堆栈)中。用户拖动制图窗口中活动节点图标,放开鼠标时,系统创建一个MoveActivityCommand 对象并执行Execute()  方法,同样把这个command对象加入到私有变量(堆栈)中。
     随后,用户单击了工具条上的 Undo 按钮。系统弹出已完成命令栈栈顶的 Command 对象,并调用该对象的 Undo() 方法。接收到 Undo() 消息时,MoveActivityCommand对象从目标位置移动回到原来的位置,如果再次点解Undo 按钮,则调用DrawActivityCommand的Execute()  方法,删除画图编辑界面中的活动图标。
    备忘录(Memento)
    为对象的状态提供存储和恢复的功能。同样也可以实现撤销操作,它比command模式实现撤销功能的优势是不用每次操作都创建一个command对象。

    展开全文
  • 常用设计模式总结

    万次阅读 多人点赞 2019-07-31 19:13:12
    设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结,是可复用面向对象软件的基础。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 ...
  • 设计模式是对设计原则的具体化。用江湖话说就是武林秘籍,总结出来的一些固定套路,编程界的《葵花... 单例模式是一种常用的软件设计模式。  在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保
  • 设计模式 应用场景

    千次阅读 2013-06-25 22:52:15
    设计模式 应用场景 http://hi.baidu.com/goodfriend_001/item/6d062d0c244a92f4a0103487 追MM与设计模式 创建型模式  1、FACTORY—追MM少不了请吃饭了,麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西,虽 然...
  • php常用几种设计模式应用场景

    万次阅读 2016-08-29 16:25:31
    1.单例设计模式所谓单例模式,即在应用程序中最多只有该类的一个实例存在,一旦创建,就会一直存在于内存中!单例设计模式应用于数据库类设计,采用单例模式,只连接一次数据库,防止打开多个数据库连接。一个单例...
  • PHP常用几种设计模式应用场景

    千次阅读 2018-05-27 12:10:25
    1.单例设计模式所谓单例模式,即在应用程序中最多只有该类的一个实例存在,一旦创建,就会一直存在于内存中!单例设计模式应用于数据库类设计,采用单例模式,只连接一次数据库,防止打开多个数据库连接。一个单例...
  • java常用设计模式应用案例

    万次阅读 2012-10-12 16:15:08
    设计模式; 一个程序员对设计模式的理解: “不懂”为什么要把很简单的东西搞得那么复杂。后来随着软件开发经验的增加才开始明白我所看到的“复杂”恰恰就是设计模式的精髓所在,我所理解的“简单”就是一把钥匙开...
  • java常用设计模式详解及应用

    千次阅读 2019-01-18 10:10:31
    java常用设计模式详解及应用 java有23种设计模式,用于解决在编程当中遇到的实际问题。本文主要讲解单例模式、工厂模式、适配器模式、装饰模式、代理模式、模板模式、策略模式、观察者模式。 ...
  • Java常用设计模式的使用场景

    千次阅读 2016-12-19 21:54:20
    单例设计模式单例设计模式就是保证一个类中,有且只有一个实例存在并提供一个访问点供全局访问,该实例可以被所有的程序来访问。一般在这种情况下用: 当要用一个类时,又要用该类中的一个实例; new 来创建实例时会...
  • 常见的六种设计模式以及应用场景

    千次阅读 2018-09-17 22:13:17
    设计模式是对设计原则的具体化。用江湖话说就是武林秘籍,总结出来的一些固定套路,可以...单例模式是一种常用的软件设计模式。 在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一...
  • Java设计模式的常见应用场景

    万次阅读 多人点赞 2017-08-10 16:20:23
    一、Java I/O中的设计模式1、适配器模式适配器模式就是把一个类的接口变换成客户端所能接受的另一种接口,从而使两个接口不匹配而无法在一起工作的两个类能够在一起工作。通常被用在一个项目需要引用一些开源框架来...
  • 24种设计模式及其应用场景

    千次阅读 2019-04-11 11:21:43
    Longronglin之设计模式: Christopher Alexander 说过:“每一个模式描述了一个在我们周围不断重复发生的问题,以及该问题的解决方案的核心。这样,你就能一次又一次地使用该方案而不必做重复劳动”。 模式描述...
  • 从头认识设计模式-策略模式-01-原始应用场景
  • 常用设计模式

    千次阅读 2020-06-29 21:41:01
    设计模式 从程序的结构上实现松耦合,从而可以扩大整体的类结构,用来解决更大的问题。 设计模式的本质是面向对象设计原则的实际运用,是对类的封装性、继承性和多态性以及类的关联和组合关系的充分理解。 正确使用...
  • 在实际的编程开发中,单例设计模式是我们谈得最多但用...可以说我到现在都没有使用上(在实际公司工作中),为什么会这样呢,我们来看看单例设计模式有哪些常见的应用场景 window 的控制面板、任务管理器、回收站 ...
  • 如第三方供应商发布、选品发布、自营发布等等,他们都有一个共同点,业务代码几乎相同,但是里面却需要很多的if else去进行业务的判断,各发布渠道也要许多自己非共性的业务代码,这时候就可以使用到这套业务模式 ...
  • 提到软件设计模式,大家并不陌生,许多的书上面都有很细致深刻的讲解。比如《设计模式》,《设计模式解析》,《重构与模式》等等...以下内容是我自己学习了软件设计模式之后的一些自己的见解,对常用的软件设计模式...
  • 常用设计模式-策略模式

    万次阅读 2020-11-20 09:51:54
    模式简介 它定义了算法家族,分别封装起来,让它们间可以相互替换,此模式让算法的变化,不会影响到使用算法的用户。 模式实现 环境类(Context)用一个ConcreteStrategy对象来配置。维护一个对Strategy对象的...
  • 常用设计模式-适配器模式

    万次阅读 2020-11-27 13:15:05
    这种类型的设计模式属于结构型模式。 优点:1、可以让任何两个没有关联的类一起运行。 2、提高了类的复用。 3、增加了类的透明度。 4、灵活性好。 缺点:1、过多地使用适配器,会让系统非常零乱,不易整体进行把握...
  • 模式是对某情景下,针对某种问题的某种解决方案。而一个设计模式是用来解决一个经常出现的设计...本文所设计到的概念和实例大多来自《Head First设计模式》和《JavaScript设计模式和开发实践》二书,前者以生动形...
  • 常用设计模式-原型模式

    万次阅读 2020-11-27 10:25:17
    模式简介 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象 这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。例如,一个对象需要在...
  • 前言:花了一个上午整理出来的设计模式+自己的一些理解,希望帮助你们能更好的结合实际场景理解设计模式,本文不讨论代码,关于设计模式的代码,网上有很多,本文只讨论理解~~ 1:工厂方法模式:类的创建依赖工厂类...
  • spring中用到的设计模式应用场景

    千次阅读 2017-08-17 17:23:00
    1.工厂模式,在各种BeanFactory以及ApplicationContext创建中都用到了 2.模版模式,在各种BeanFactory以及ApplicationContext实现中也都用到了 3.代理模式,Spring AOP 利用了 AspectJ AOP实现的! AspectJ AOP 的...
  • 在策略模式+工厂模式中,没有使用到模板模式,因为张三和李四的业务逻辑都是调用AAA方法,如果现在在增加一个方法,次方法只需要李四一人去实现BBB方法,此时张三的handel中就会报错,需要张三也去实现BBB方法,这时就出现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 138,451
精华内容 55,380
关键字:

常用设计模式应用场景