精华内容
下载资源
问答
  • DP什么意思 design pattern 设计模式

    DP  design pattern 大话设计模式  中的DP 是设计模式的意思

     

    设计模式的书 ,最经典最原始的就是 GOF 的《设计模式》了。

    设计模式的书基本上大多是以这 20 多个模式分开讲。含《大话设计模式》
      

    学了 OOL 写的程序基本上是 OB 的。
    只有慢慢掌握了 DP 才能写出真正的 OO 程序。
      
    思想 -> 设计原则 -> DP -> OOD

     

    ADT:Abstract Data Type 抽象数据类型

    OO:Object   Oriented   面向对象  

    OOL:Object   Oriented   Langua 面向对象语言

    OOD:Object   Oriented Design 面向对象设计

    OB:Object   Based   基于对象,ADT

    DP:Design Pattern  设计模式



     

    展开全文
  • 1.什么设计模式 2.设计模式的发展 3.设计原则6大原则 3.1 开闭原则 3.2 里氏转换原则 3.3 依赖倒转原则 3.4 接口隔离原则 3.5 合成/聚合复用原则 3.6 迪米特原则 1.什么设计模式 软件设计模式(Design ...

     

    目录

    1.什么设计模式

    2.设计模式的发展

    3.设计模式6大原则

     3.1 开闭原则

    3.2  里氏转换原则

    3.3 依赖倒转原则

    3.4  接口隔离原则

    3.5  合成/聚合复用原则 

    3.6 迪米特原则


    1.什么设计模式

    软件设计模式(Design pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。设计模式使代码开发真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。只有夯实地基搭好结构,才能盖好坚壮的大楼。也是我们迈向高级开发人员必经的一步。即12字真言:设计模式是设计经验的总结

     

    2.设计模式的发展

    说起设计模式的发展,还要从四个男人的故事(注意此处没有女人)开始说起,这四个男人分别是 Erich Gamma, Richard Helm,Ralph Johnson,和John Vlissides,他们是软件设计领域的四位世界顶级大师,那软件设计水平真是不知道高到哪里去了,反正我是自愧不如。这四位大佬合著了一本书《设计模式:可复用面向对象软件的基础》, 提出了23种基本设计模式,从理论高度提炼并规范了设计模式,对面向对象设计,软件复用领域产生了巨大影响。现在设计模式已经被应用到各种各样的编程语言中,不管是后端的Java,C#还是前端的JavaScript, 你都能看到它的身影,设计模式最大的魅力在于,不管在那种编程语言中,它思想和表现都是一样的,只是代码语法略有不同而已。

     

    3.设计模式6大原则

    设计模式存在的根本原因是为了更好地复用代码,增加代码可维护性。所以有如下6大原则:

     3.1 开闭原则

           对扩展开放,对修改关闭, 即在程序需要进行拓展的时候,不能去修改原有的代码,只能增加新的代码。

    这样的例子在我们的生活中随处可见,比如在各种选秀比赛里,如果两个选手在比赛中打成了平手,我们不可能说通过穿越到过去,去改变过去的结果,让他们不打成平手,这是不可能实现的。但是我们可以通过添加附加的比赛,决定他们的胜负。即已经发生的已经不可以改变 ,我们只能改变那些事情对现在的影响。

    3.2  里氏转换原则

            子类继承父类,任何基类出现的地方,一定可以用子类替代出现。

    这怎么理解呢?比如说你的朋友u盘A中有一些小电影,一天你们像往常一样,把u盘A插入电脑准备一起欣赏小电影,却发现u盘A坏了。这给正在兴致勃勃的你们顿时浇了一盆凉水,这时候你灵机一动说,幸好老子有备份。原来之前你已经把朋友u盘A中的小电影复制到了你的 u盘B中,而且你的u盘B中除了从朋友哪儿复制的小电影,还有一些其它不可描述的内容,这时候你有点犹豫要不要用自己的U盘B,看着正在兴头上的朋友,你一咬牙一跺脚说算了,不管那么多了,淦。于是你拔下朋友的u盘A插入自己的u盘B,顺利打开电影,于是你们又兴致勃勃的观看起来。即子类是对父类的完全复制,父类可以被子类完全替代,子类可以增加新的内容,而且不影响父类。

    3.3 依赖倒转原则

             引用一个对象,如果这个对象有底层类型,直接引用底层类型。

    说到这里不得不吐槽一些博客的博主,好歹也是写代码的,写博客的时候真没有一点设计模式的原则。前几天在网上搜一个问题,打开一看给我贴了一个另外博客的链接,打开这个链接之后又贴了另外一个博客的链接。。。。。。,你引用别人的博客我不反对,你这引用引用的博客就过分了吧。  总结一句话:引用的时候禁止套娃,直接引用最底层的类型

    3.4  接口隔离原则

    使用多个隔离的接口,比使用单个接口要好,每一个接口应该是一种角色。

    比如我们的电脑上有多种不同类型的接口,像USB接口,电源接口,高清输出接口等等,它们各自有着不同的功能,那么为什么不用一个接口完成所有的功能呢,这是因为不同的设备,有不同的数据规格,而且数据带宽需求也是是不同的,然他们都使用同一个接口是不科学的,这从usb与hdmi设备的使用环境就能看出来差别。但你也不能每个设备都分一个接口,这是不现实的,应该把统一数据规格的设备分为一个接口,例如USB接口可以同时支持,鼠标键盘和U盘。即使用多个接口,比使用单个接口要好,但是小得要有限度。

    3.5  合成/聚合复用原则 

    新的对象应使用一些已有的对象,使之成为新对象的一部分。

    举个例子:周末天气晴朗,你和好朋友约好一起去爬山(不是张东升的那种爬山),这时候就需要有一个相机,但是不巧的是你的相机坏了,于是你就拿着相机来到了修理店。老板告诉你有一个零件坏了,问你是要更换零件,还是再买一个新的呢?你心里MMP了一句对老板说,当然是更换零件了,我这相机才买没多久还新着呢。即用已经有的东西合成新的东西,使原来的东西成为新东西的一部分。

    3.6 迪米特原则

          一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立,即一个对象应对其他对象有尽可能少得了解。

    这里的对象可以理解为对象(女朋友),假如你是一个时间管理大师,同时交往了多个对象,当然由于身经百战,你对这些对象应付自如,不像我们这些老实人,一个都应付不来。但是这是你的小秘密,为了不让她们发现这个秘密,你就应该使这些对象之间应该尽可能少的了解,甚至完全不了解,如果她们之间了解过多,在相互八卦或者看朋友圈的时候,发现了你的这个小秘密,那可是要出大事情的(喜欢多人运动的除外)。即多个对象之间应该尽量避免有任何关联。

    本文只对设计模式进行了简单的介绍,有些例子可能也不太合适。如果想对设计模式有更多的了解,推荐看上文中四位大佬的那本书:《设计模式:可复用面向对象软件的基础》。

    如果觉得不错的话欢迎点赞,转发,评论!

    展开全文
  • 面向对象思想设计原则 单一职责原则 开闭原则 里氏替换原则 依赖注入原则 接口分离原则 迪米特原则 设计模式的分类 简单工厂模式 简单工厂模式概述 工厂方法模式 工厂方法模式概述 单例设计模式 单例设计模式概述 ...

    面向对象思想设计原则

    • 单一职责原则
    • 开闭原则
    • 里氏替换原则
    • 依赖注入原则
    • 接口分离原则
    • 迪米特原则


    单一职责原则

    • 其实就是开发人员经常说的“高内聚,低耦合
    • 也就是说,每个类应该只有一个职责,对外只能提供一种功能,而引起类变化的原因应该只有一个。在设计模式中,所有的设计模式都遵循这一原则


    开闭原则

    • 核心思想是:一个对象对扩展开放,对修改关闭
    • 其实开闭原则的意思就是:对类的改动是通过增加代码进行的,而不是修改现有代码。
    • 也就是说软件开发人员一旦写出了可以运行的代码,就不应该去改动它,而是要保证它能一直运行下去,如何能够做到这一点呢?这就需要借助于抽象和多态,即把可能变化的内容抽象出来,从而使抽象的部分是相对稳定的,而具体的实现则是可以改变和扩展的。


    里氏替换原则

    • 核心思想:在任何父类出现的地方都可以用它的子类来替代
    • 其实就是说:同一个继承体系中的对象应该有共同的行为特征。


    依赖注入原则

    • 核心思想:要依赖于抽象,不要依赖于具体实现
    • 其实就是说:在应用程序中,所有的类如果使用或依赖于其他的类,则应该依赖这些其他类的抽象类,而不是这些其他类的具体类。为了实现这一原则,就要求我们在编程的时候针对抽象类或者接口编程,而不是针对具体实现编程。


    接口分离原则

    • 核心思想不应该强迫程序依赖它们不需要使用的方法
    • 其实就是说:一个接口不需要提供太多的行为,一个接口应该只提供一种对外的功能,不应该把所有的操作都封装到一个接口中。


    迪米特原则

    • 核心思想一个对象应当对其他对象尽可能少的了解
    • 其实就是说:降低各个对象之间的耦合,提高系统的可维护性。在模块之间应该只通过接口编程,而不理会模块的内部工作原理,它可以使各个模块耦合度降到最低,促进软件的复用


    设计模式的分类

    • 创建型模式:对象的创建(6)

      • 简单工厂模式工厂方法模式抽象工厂模式建造者模式原型模式单例模式
    • 结构型模式:对象的组成(结构)(7)

      • 外观模式适配器模式代理模式装饰模式桥接模式组合模式享元模式
    • 行为型模式:对象的行为(10)

      • 模版方法模式观察者模式状态模式职责链模式命令模式访问者模式策略模式备忘录模式迭代器模式解释器模式



    简单工厂模式

    简单工厂模式概述

    • 又叫静态工厂方法模式,它定义一个具体的工厂类负责创建一些类的实例
    • 优点
      • 客户端不需要再负责对象的创建,从而明确了各个类的职责
    • 缺点
      • 这个静态工厂类负责所有对象的创建,如果有新的对象增加,或者某些对象的创建方式不同,就需要不断的修改工厂类,不利于后期的维护
    public class AnimalDemo {
        public static void main(String[] args) {
            // 具体类调用
            Dog d = new Dog();
            d.eat();
            Cat c = new Cat();
            c.eat();
            System.out.println("------------");
    
            // 工厂有了后,通过工厂给造
            // Dog dd = AnimalFactory.createDog();
            // Cat cc = AnimalFactory.createCat();
            // dd.eat();
            // cc.eat();
            // System.out.println("------------");
    
            // 工厂改进后
            Animal a = AnimalFactory.createAnimal("dog");
            a.eat();
            a = AnimalFactory.createAnimal("cat");
            a.eat();
    
            // NullPointerException
            a = AnimalFactory.createAnimal("pig");
            if (a != null) {
                a.eat();
            } else {
                System.out.println("对不起,暂时不提供这种动物");
            }
        }
    }
    
    
    
    
    public abstract class Animal {
        public abstract void eat();
    }
    
    
    public class Cat extends Animal {
    
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    
    }
    
    
    public class Dog extends Animal {
    
        @Override
        public void eat() {
            System.out.println("狗吃肉");
        }
    
    }
    
    
    public class AnimalFactory {
    
        private AnimalFactory() {
        }
    
        // public static Dog createDog() {
        // return new Dog();
        // }
        //
        // public static Cat createCat() {
        // return new Cat();
        // }
    
        public static Animal createAnimal(String type) {
            if ("dog".equals(type)) {
                return new Dog();
            } else if ("cat".equals(type)) {
                return new Cat();
            } else {
                return null;
            }
        }
    }




    工厂方法模式

    工厂方法模式概述

    • 工厂方法模式中抽象工厂类负责定义创建对象接口具体对象的创建工作由继承抽象工厂的具体类实现。

    • 优点

      • 客户端不需要再负责对象的创建,从而明确了各个类的职责,如果有新的对象增加,只需要增加一个具体的类具体的工厂类即可,不影响已有的代码,后期维护容易增强了系统的扩展性
    • 缺点

      • 需要额外的编写代码,增加了工作量
    public class AnimalDemo {
        public static void main(String[] args) {
            // 需求:我要买只狗
            Factory f = new DogFactory();
            Animal a = f.createAnimal();
            a.eat();
            System.out.println("-------");
    
            //需求:我要买只猫
            f = new CatFactory();
            a = f.createAnimal();
            a.eat();
        }
    }
    
    
    public abstract class Animal {
        public abstract void eat();
    }
    
    
    public interface Factory {
        public abstract Animal createAnimal();
    }
    
    
    public class Dog extends Animal {
    
        @Override
        public void eat() {
            System.out.println("狗吃肉");
        }
    
    }
    
    
    public class DogFactory implements Factory {
    
        @Override
        public Animal createAnimal() {
            return new Dog();
        }
    
    }
    
    
    public class Cat extends Animal {
    
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    
    }
    
    
    public class CatFactory implements Factory {
    
        @Override
        public Animal createAnimal() {
            return new Cat();
        }
    
    }



    单例设计模式

    单例设计模式概述

    • 单例模式就是要确保类在内存中只有一个对象,该实例必须自动创建,并且对外提供。

    • 优点

      • 在系统内存中只存在一个对象,因此可以节约系统资源,对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
    • 缺点

      • 没有抽象层,因此扩展很难
      • 职责过重,在一定程序上违背了单一职责
    • 如何保证类在内存中只有一个对象呢?

      • A:把构造方法私有
      • B:在成员位置自己创建一个对象
      • C:通过一个公共的方法提供访问

    单例设计模式分类

    • 饿汉式(开发使用)
      • 类一加载就创建对象
    public class StudentDemo {
        public static void main(String[] args) {
            // Student s1 = new Student();
            // Student s2 = new Student();
            // System.out.println(s1 == s2); // false
    
            // 通过单例如何得到对象呢?
    
            // Student.s = null;
    
            Student s1 = Student.getStudent();
            Student s2 = Student.getStudent();
            System.out.println(s1 == s2);
    
            System.out.println(s1); // null,cn.itcast_03.Student@175078b
            System.out.println(s2);// null,cn.itcast_03.Student@175078b
        }
    }
    
    
    
    public class Student {
        // 构造私有,不让外界构造对象。
        private Student() {
        }
    
        // 自己造一个
        // 静态方法只能访问静态成员变量,加静态
        // 为了不让外界直接访问修改这个值,加private
        private static Student s = new Student();
    
        // 提供公共的访问方式
        // 为了保证外界能够直接使用该方法,加静态
        public static Student getStudent() {
            return s;
        }
    }


    • 懒汉式(面试常问): 用的时候,才去创建对象
      • 线程安全问题
      • 懒加载思想(延迟加载)
    public class TeacherDemo {
        public static void main(String[] args) {
            Teacher t1 = Teacher.getTeacher();
            Teacher t2 = Teacher.getTeacher();
            System.out.println(t1 == t2);
            System.out.println(t1); // cn.itcast_03.Teacher@175078b
            System.out.println(t2);// cn.itcast_03.Teacher@175078b
        }
    }
    
    
    public class Teacher {
        private Teacher() {
        }
    
        private static Teacher t = null;
    
        public synchronized static Teacher getTeacher() {
            // t1,t2,t3
            if (t == null) {
                //t1,t2,t3
                t = new Teacher();
            }
            return t;
        }
    }


    代理模式

    • 1,什么是代理模式?
      代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问。

    • 2,代理模式有什么好处?
      在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。

    • 3,代理模式一般涉及到的角色有:

      • 抽象角色:声明真实对象代理对象共同接口,这样一来在任何可以使用目标对象的地方都可以使用代理对象
      • 代理角色:代理对象内部含有目标对象的引用,从而可以在任何时候操作目标对象;代理对象提供一个与目标对象相同的接口,以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后,执行某个操作,而不是单纯地将调用传递给目标对象,同时,代理对象可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装。
      • 真实角色:定义了代理对象所代表的目标对象,代理角色所代表的真实对象,是我们最终要引用的对象,定义了代理对象所代表的目标对象。
    public abstract class AbstractObject {
        //操作
        public abstract void operation();
    }
    public class RealObject extends AbstractObject {
        @Override
        public void operation() {
            //一些操作
            System.out.println("一些操作");
        }
    }
    
    public class ProxyObject extends AbstractObject{
        RealObject realObject = new RealObject();
        @Override
        public void operation() {
            //调用目标对象之前可以做相关操作
            System.out.println("before");        
            realObject.operation();        
            //调用目标对象之后可以做相关操作
            System.out.println("after");
        }
    }
    
    
    public class Client {
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            AbstractObject obj = new ProxyObject();
            obj.operation();
        }
    }
    


    模版设计模式(抽象类)

    • 模版方法模式就是定义一个算法的骨架,而将具体的算法延迟到子类中来实现
    • 优点
      • 使用模版方法模式,在定义算法骨架的同时,可以很灵活的实现具体的算法,满足用户灵活多变的需求
    • 缺点
      • 如果算法骨架有修改的话,则需要修改抽象类
    public class ForDemo extends GetTime {
    
        @Override
        public void code() {
            for (int x = 0; x < 100000; x++) {
                System.out.println(x);
            }
        }
    
    }
    
    
    
    public abstract class GetTime {
        // 需求:请给我计算出一段代码的运行时间
        public long getTime() {
            long start = System.currentTimeMillis();
            code();
    
            long end = System.currentTimeMillis();
    
            return end - start;
        }
    
        public abstract void code();
    }
    
    
    
    public class GetTimeDemo {
        public static void main(String[] args) {
            // GetTime gt = new GetTime();
            // System.out.println(gt.getTime() + "毫秒");
    
            GetTime gt = new ForDemo();
            System.out.println(gt.getTime() + "毫秒");
    
            gt = new IODemo();
            System.out.println(gt.getTime() + "毫秒");
        }
    }
    
    
    
    
    public class IODemo extends GetTime{
    
        @Override
        public void code() {
            try {
                BufferedInputStream bis = new BufferedInputStream(
                        new FileInputStream("a.avi"));
                BufferedOutputStream bos = new BufferedOutputStream(
                        new FileOutputStream("b.avi"));
                byte[] bys = new byte[1024];
                int len = 0;
                while ((len = bis.read(bys)) != -1) {
                    bos.write(bys, 0, len);
                }
                bos.close();
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }


    装饰设计模式

    • 当想要对已有的对象进行功能增强时,可以定义类,将已有对象传入,基于已有的功能,并提供加强功能。
      • 其中自定义的该类称为装饰类。
      • 装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能,提供更强的功能。
    • 优点
      • 使用装饰模式,可以提供比继承更灵活的扩展对象的功能,它可以动态的添加对象的功能,并且可以随意的组合这些功能
    • 缺点
      • 正因为可以随意组合,所以就可能出现一些不合理的逻辑
    public interface Phone {
        public abstract void call();
    }
    
    
    
    public class IPhone implements Phone {
    
        @Override
        public void call() {
            System.out.println("手机可以打电话了");
        }
    
    }
    
    
    
    public class MusicPhoneDecorate extends PhoneDecorate {
    
        public MusicPhoneDecorate(Phone p) {
            super(p);
        }
    
        @Override
        public void call() {
            super.call();
            System.out.println("手机可以听音乐");
        }
    }
    
    
    
    
    
    public class RingPhoneDecorate extends PhoneDecorate {
    
        public RingPhoneDecorate(Phone p) {
            super(p);
        }
    
        @Override
        public void call() {
            System.out.println("手机可以听彩铃");
            super.call();
        }
    }
    
    
    
    public abstract class PhoneDecorate implements Phone {
    
        private Phone p;
    
        public PhoneDecorate(Phone p) {
            this.p = p;
        }
    
        @Override
        public void call() {
            this.p.call();
        }
    }
    
    
    
    
    public class PhoneDemo {
        public static void main(String[] args) {
            Phone p = new IPhone();
            p.call();
            System.out.println("------------");
    
            // 需求:我想在接电话前,听彩铃
            PhoneDecorate pd = new RingPhoneDecorate(p);
            pd.call();
            System.out.println("------------");
    
            // 需求:我想在接电话后,听音乐
            pd = new MusicPhoneDecorate(p);
            pd.call();
            System.out.println("------------");
    
            // 需求:我要想手机在接前听彩铃,接后听音乐
            // 自己提供装饰类,在打电话前听彩铃,打电话后听音乐
            pd = new RingPhoneDecorate(new MusicPhoneDecorate(p));
            pd.call();
            System.out.println("----------");
            // 想想我们在IO流中的使用
            // InputStream is = System.in;
            // InputStreamReader isr = new InputStreamReader(is);
            // BufferedReader br = new BufferedReader(isr);
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            BufferedWriter bw = new BufferedWriter((new OutputStreamWriter(
                    System.out)));
    
            Scanner sc = new Scanner(System.in);
        }
    }




    适配器设计模式

    • 通过适配器设计模式改进窗口关闭案例
    /*
     * 问题:
     * 接口(方法比较多) -- 实现类(仅仅使用一个,也得把其他的实现给提供了,哪怕是空实现)
     * 太麻烦了。
     * 解决方案:
     * 接口(方法比较多) -- 适配器类(实现接口,仅仅空实现) -- 实现类(用哪个重写哪个)
     */
    public class UserDaoDemo {
        public static void main(String[] args) {
            UserDao ud = new UserDaoImpl();
            ud.add();
            // 我没有说我们需要四种功能都实现啊。
            UserDao ud2 = new UserDaoImpl2();
            ud2.add();
        }
    }
    
    public abstract class UserAdapter implements UserDao {
    
        @Override
        public void add() {
        }
    
        @Override
        public void delete() {
        }
    
        @Override
        public void update() {
        }
    
        @Override
        public void find() {
        }
    
    }
    
    public class UserDaoImpl2 extends UserAdapter {
        @Override
        public void add() {
            System.out.println("添加功能");
        }
    }
    展开全文
  • 设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段...

    23种设计模式+额外常用设计模式汇总 (持续更新)

    设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的
    .
    设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。
    .
    毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题,每种模式在现实中都有相应的原理来与之对应,每种模式都描述了一个在我们周围不断重复发生的问题,以及该问题的核心解决方案,这也是设计模式能被广泛应用的原因。
    .
    我们不只总结GOF所提到的23种设计模式,我们也要总结一些Headfirst提到一些新的设计模式和一些额外再应用中,用的比较普遍的设计模式。文章为总结倾向并且加入个人的思想

    设计模式的七大原则

    1. 单一职责原则SRP(Single Responsibility Principle)
      就一个类而言,应该仅有一个引起它变化的原因。
    2. 开放-关闭原则OCP(Open-CLosed Principle)
      一个软件的实体应该对扩展开放,对修改关闭。
    3. 里氏代换原则(Liskov Substitution Principle)
      子类型必须能够替换他们的基类(父类)。
    4. 依赖倒置原则DIP(Dependence Inversion Principle)
      要依赖于抽象,不要依赖于具体。
    5. 最少知识原则LKP(Least Knowledge Principle)或称 迪米特法则(LoD)
      一个类对于其他类知道的越少越好,就是说一个对象应当对其他对象有尽可能少的了解,只和朋友通信,不和陌生人说话
    6. 接口隔离原则(ISP)
      使用多个专门的接口比使用单一的功能更多的总接口要好
    7. 合成/聚合原则
      要尽量使用合成/聚合,而不是继承关系达到复用的目的

    详细介绍戳这里

    经典23种设计模式分类

    在这里插入图片描述

    前置知识:
    1. JAVA反射机制
    2. 简单工厂模式
    创建型模式 (5种):
    1. 工厂方法模式 (Factory Pattern)
    2. 抽象工厂模式 (Abstract Factory Pattern)
    3. 单例模式 (Singleton Pattern)
    4. 建造者模式 (Builder Pattern)
    5. 原型模式(Prototype Pattern)

    结构型模式 (7种):
    1. 适配器模式 (Adapter Pattern)
    2. 装饰者模式(Decorator Pattern)
    3. 代理模式(Proxy Pattern)
    4. 外观模式(门面模式Facade Pattern)
    5. 桥接模式 (Bridge)
    6. 组合模式(Composite Pattern)
    7. 享元模式(Flyweight Pattern)

    行为型模式(11种):
    1. 策略模式 (Strategy Pattern)
    2. 模板方法模式(Template Pattern)
    3. 观察者模式(Observer Pattern)
    4. 迭代子模式(Iterator Pattern)
    5. 责任链模式 (Chain of Responsibility Pattern)
    6. 命令模式(Command Pattern)
    7. 备忘录模式(Memento Pattern)
    8. 状态模式(State Pattern)
    9. 访问者模式(Visitor Pattern)
    10. 中介者模式(Mediator Pattern)
    11. 解释器模式(Interpreter Pattern)

    不在23种的额外两类:

    并发型模式
    1. 发布者/订阅者模式
    线程池模式

    不属于以上,但也经常使用的:
    1. 简单工厂模式
    2. MVC设计模式

    推荐书籍

    没恰饭,这些是我看完或者在看到书,都是一些经典书目了,另外虽有有PDF建议大家还是入手一本。

    • 《Design Patterns: Elements of Reusable Object-Oriented Software》
      由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 合著(Addison-Wesley,1995)。这几位作者常被称为"四人组(Gang of Four)就是大名鼎鼎的GOF"

    • 《Head First 设计模式》
      本书作者Eric Freeman,是作家、讲师和技术顾问。完整地涵盖了四人组版本全部23个设计模式,并介绍如何将两个以上的设计模式结合起来成为新的设计模式(例如著名的MVC模式),以及介绍如何进一步学习设计模式,如何发觉新的设计模式等。

    • 《大话设计模式》
      作者是程杰,本书中以情景对话的形式,用多个小故事或编程示例来组织讲解GoF总结的23个设计模式,开创了国内设计模式通俗读物的先河。用C#写的代码, 虽然感觉有些文章故事确实太牵强,但是觉得前两者太枯燥的话,看看这个也是挺不错的。看到作者的代码挺用心的,但凡书中有所提及,都会给你一份很详细的代码,作者的前瞻性也很高,书中预料到了会出现一个系统统一手机软件,果真安卓出现了,这是题外话了,这本书应该是比较早的国内写设计模式那一批,还能流出到现在还有大量受众的书了,C#描述。

    • 《软件设计模式(Java版)》
      作者是程细柱,大学老师写的,就是那种很工整的教学性质的书籍,而且每章之后都会有练习题,很适合大学生,他几乎把所有能想到的东西,都告诉了你,也就是说他都帮你总结了,真的挺用心的老师,采用“任务驱动”的教学方法,根据各种设计模式之间的关系和相似点组织教材目录,对每种模式提出产生背景,并用UML 建模语言分析模式的结构,然后用简单易懂的实例加深学生对该模式的理解。

    第一本是让大家知道设计模式的鼻祖,设计模式首次总结,Headfirst也是故事形式,但是观感一般,我学习的时候也借鉴了,所以也放在这里,然后是程杰的大话设计模式,故事生动趣味性高,最后呢就是想用C#去看程杰,想用Java去看程细柱老师的。别说我恰饭了,好吧,程细柱老师也不是我的老师,书也是最近几年才开始发行的,程杰老师的书都流行多少年了,剩下两本也众人皆知,你百度一搜设计模式立马就有,也不用我提。然后我的文章也是跟据上面的书,和自己的想法总结的,可能会有个小部分的雷同,但是那是确实没有比作者能想到更好的语言,其他的都是自己提炼然后总结写出来的,如果作者对我本人的文章有意见或者说我不能用相同的语言描述,我会立刻作出修改。
    最后本文的写作,我绝对没有获利一分钱,这个请大家放心白嫖,一个是自己学习以后复习可能会用到,另一个是希望和大家分享一起进步。如果没有基础,或者我的文章一点也看不懂还是建议大家买书,毕竟作者两三百页的书,博主几万个字就写完了,肯定不如作者详细。

    写在最后:
    Name:风骨散人,目前是一名双非在校大学生,预计考研,热爱编程,热爱技术,喜欢分享,知识无界,希望我的分享可以帮到你!名字的含义:我想有一天我能有能力随心所欲不逾矩,不总是向生活低头,有能力让家人拥有富足的生活而不是为了生计而到处奔波。“世人慌慌张张,不过是图碎银几两。偏偏这碎银几两,能解世间惆怅,可让父母安康,可护幼子成长 …”
    文章主要内容:
    Python,C++,C语言,JAVA,C#等语言的教程
    ACM题解、模板、算法等,主要是数据结构,数学和图论
    设计模式,数据库,计算机网络,操作系统,计算机组成原理
    Python爬虫、深度学习、机器学习
    计算机系408考研的所有专业课内容
    目前还在更新中,先关注不迷路。微信公众号,cnblogs(博客园),CSDN同名“风骨散人”

    联系博主,侧面的企业微信号就是我平时办公用的,扫码即可联系到本人,嘻嘻。

    如果有什么想看的,可以私信我,如果在能力范围内,我会发布相应的博文!
    感谢大家的阅读!😘你的点赞、收藏、关注是对我最大的鼓励!

    展开全文
  • 有效个数(Quorum)这个设计模式一般是指分布式系统的每一次修改都要在大多数实例上通过来确定修改通过。 问题背景 在一个分布式存储系统中,用户请求会发到一个实例上。通常在一个实例上面执行的修改,需要复制到...
  • 什么是工厂模式

    万次阅读 2007-04-02 22:42:00
    1、 传授设计模式中存在的问题 我个人最近对设计模式中的工厂模式进行了比较深入的学习,通过学习感悟出,现在很多设计模式传道者,在讲述设计模式的过程中存在一些问题,使得设计模式变得很难理解。设计模式本身...
  • 目录 一、概述 二、7个设计原则 1、单一职责原则 ( SRP ) 2、开闭原则 ( OCP ) 3、里氏替换原则 ( LSP ) ...三、创建型模式 ( 5种 ) 1.单例模式 2.工厂方法模式 3.抽象工厂模式 4.建造者模式 5.原型模...
  • 首先,什么是编程思想? 编程思想是一种指导思想,这个指导思想,将会诱发你如何写代码的行为。 如果理解这话的意思呢?打个比方,中华文明千百年在民众心中形成了一个“统一天下”的思想,这种思想会诱发各个混乱...
  • Java - 什么是DAO模式

    万次阅读 2019-03-16 12:15:09
    分享一个大牛的人工智能教程。...DAO模式实际上包含了两个模式,一是Data Accessor(数据访问器),二是Data Object(数据对象),前者要解决如何访问数据的问题,而后者要解决的是如何用对象封装数据。
  • JAVA基础再回首(二十六)——面向对象思想设计原则、设计模式、简单工厂模式、工厂方法模式、单例设计模式之饿汉式和懒汉式、Runtime类 版权声明:转载必须注明本文转自程序员杜鹏程的博客:...
  • 什么是模型,什么是模式

    万次阅读 2016-01-16 11:05:30
    虽然,我还不清楚厘清这两个词的关系,对基层的数学工作者有怎样的价值,但是至少对理解什么是数学是有益处的,能够帮助我们不止是了解数学的结论,而且了解数学的思考方法。     一、模型与数学模型    ...
  • 模式识别又常称作模式分类,从处理问题的性质和解决问题的方法等角度,模式识别分为有监督的分类(Supervised Classification)和无监督的分类(Unsupervised Classification)两种。 模式还可分成抽象的和具体的两种...
  • 面向对象思想设计原则 •在实际的开发中,我们要想更深入的了解面向对象思想,就必须熟悉前人总结过的面向对象的思想的设计原则 •单一职责原则 •开闭原则 •里氏替换原则 •依赖注入原则 •接口分离原则 •...
  • 什么是软件设计模式

    千次阅读 2016-04-17 15:38:31
    设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统...
  • 什么是模式

    千次阅读 2008-04-17 23:01:00
    1.什么是模式模式,即pattern。其实就是解决某一类问题的方法论。你把解决某类问题的方法总结归纳到理论高度,那就是模式。 Alexander给出的经典定义是:每个模式都描述了一个在我们的环境中不断出现的问题,...
  • 什么是OO思想

    千次阅读 2007-11-30 11:57:00
    UML 这是OO的工具,OO 开发人员交流思想的工具.2. 了解RUP. 掌握好的软件开发过程才能开发出好的软件,RUP其实就是指导我们OO分析与设计的一个开发过程.我一直认为RUP是正宗,虽然他烦琐.3. 理解建立领域模型...
  • SAP ERP是什么意思

    千次阅读 2010-06-18 17:02:00
    SAP ERP是什么意思? SAP ERP是什么意思?每天都在讲ERP,公司在做ERP软件,到底... ERP系统集中信息技术与先进的管理思想於一身,成为现代企业的运行模式,反映时代对企业合理调配资源,最大化地创
  • 什么是测试的PO模式

    千次阅读 2019-05-30 10:24:37
    核心思想是通过对界面元素的封装减少冗余代码,同时在后期维护中,若元素定位发生变化, 只 需要调整页面元素封装的代码,提高测试用例的可维护性、可读性。 PO模式可以把一个页面分为三层,对象库层、操作层、业务...
  • ERP和SAP是什么意思

    千次阅读 2017-02-07 15:04:52
    每天都在讲ERP,公司在做ERP软件,到底ERP是什么意思呢?ERP和SAP指什么意思呢?老吧查询并整理了ERP和SAP的相关解释如下: ERP是英文Enterprise Resource Planning(企业资源计划)的简写。指建立在信息技术基础上,...
  • JavaScript设计模式之享元模式

    万次阅读 2019-12-05 22:42:18
    什么是享元模式? 享元(flyweight)模式是一种用于性能优化的模式,“fly”在这里是苍蝇的意思,意为蝇量级。享元模式的核心是运用共享技术来有效支持大量细粒度的对象。 如果系统中因为创建了大量类似的对象而导致...
  • 一、什么是PO模式 全称:page object model 简称POM PO模式最核心的思想是分层,实现松耦合!实现脚本重复使用,实现脚本易维护性! 主要分三层: 1.基础层BasePage:封装一些最基础的selenium的原生的api方法,...
  • 内卷到底是什么意思

    千次阅读 2020-11-18 14:09:25
    由青塔发的微信推文,清北硕博生,也难逃「内卷」,这一文让我意思到最近听到的很多遍的“内卷”,思考“内卷”到底是什么意思? 我觉得知乎上说的很好,内卷。 通俗易懂的解释内卷,并列举一些例子: 看电影,为了...
  • 面向对象设计模式的几个基本原则及其核心思想简介  Author: Macower 在讲述设计模式的原则之前,我们必须要了解面向对象的几个基本目标。 面向对象,将世界归纳为一句话:万事万物皆对象。...
  • 【设计模式】策略模式

    万次阅读 多人点赞 2018-08-08 11:50:37
    博主声明: 转载请在开头附加本文链接及作者信息,并标记为转载。本文由博主威威喵原创,请多支持与指教。 ... 晚上的时候,抽了点时间看了一下设计模式...看着看着就看到了策略设计模式,关于这个策略模式,它书本...
  • 系统错误null是什么意思 Java中NULL用法的简单示例: public Employee getByName(String name) { int id = database.find(name); if (id == 0) { return null; } return new Employee(id); } 这种方法有什么...
  • 设计模式

    千次阅读 多人点赞 2019-07-22 09:33:22
    设计模式简介 设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过...
  • ERP和SAP是什么意思

    千次阅读 2008-12-31 19:51:00
    每天都在讲ERP,公司在做ERP软件,到底ERP是什么意思呢?ERP和SAP指什么意思呢? ERP是英文Enterprise Resource Planning... ERP系统集中信息技术与先进的管理思想於一身,成为现代企业的运行模式,反映时代对企业合

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 95,047
精华内容 38,018
关键字:

思想模式是什么意思