资讯专栏INFORMATION COLUMN

(CZ深入浅出Java基础)设计模式笔记

李昌杰 / 1529人阅读

摘要:在设计模式中,所有的设计模式都遵循这一原则。其实就是说在应用程序中,所有的类如果使用或依赖于其他的类,则应该依赖这些其他类的抽象类,而不是这些其他类的具体类。使用设计模式是为了可重用代码让代码更容易被他人理解保证代码可靠性。

这是刘意老师的JAVA基础教程的笔记
讲的贼好,附上传送门

传智风清扬-超全面的Java基础

一、面向对象思想设计原则 1.单一职责原则

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

2.开闭原则

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

3.里氏替换原则

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

4.依赖注入原则

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

5.接口分离原则

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

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

二、设计模式 1.概述

1.1.概念
设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
设计模式不是一种方法和技术,而是一种思想
设计模式和具体的语言无关,学习设计模式就是要建立面向对象的思想,尽可能的面向接口编程,低耦合,高内聚,使设计的程序可复用
学习设计模式能够促进对面向对象思想的理解,反之亦然。它们相辅相成

1.2.要素
名字 必须有一个简单,有意义的名字
问题 描述在何时使用模式
解决方案 描述设计的组成部分以及如何解决问题
效果 描述模式的效果以及优缺点

1.3.分类
创建型模式 对象的创建:简单工厂模式,工厂方法模式,抽象工厂模式,建造者模式,原型模式,单例模式。(6个)

结构型模式 对象的组成(结构):外观模式、适配器模式、代理模式、装饰模式、桥接模式、组合模式、享元模式。(7个)

行为型模式 对象的行为:模版方法模式、观察者模式、状态模式、职责链模式、命令模式、访问者模式、策略模式、备忘录模式、迭代器模式、解释器模式。(10个)

2.创建型模式具体使用

2.1.简单工厂模式
又叫静态工厂方法模式,它定义一个具体的工厂类负责创建一些类的实例
优点
客户端不需要在负责对象的创建,从而明确了各个类的职责
缺点
这个静态工厂类负责所有对象的创建,如果有新的对象增加,或者某些对象的创建方式不同,就需要不断的修改工厂类,不利于后期的维护

public class Demo {
    public static void main(String[] args) {

    }

}

class AnimalFactory {
    private AnimalFactory() {
    }

    static Animal creatAnimal(String type) {
        if ("dog".equals(type)) {
            return new Dog();
        }
        if ("cat".equals(type))
            return new Cat();
        return null;
    }
}

abstract class Animal {
    abstract void eat();
}

class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("dog eats meat");
    }
}

class Cat extends Animal {
    @Override
    void eat() {
        System.out.println("cat eats fish");
    }
}

2.2.工厂方法模式
工厂方法模式中抽象工厂类负责定义创建对象的接口,具体对象的创建工作由继承抽象工厂的具体类实现。
优点
客户端不需要在负责对象的创建,从而明确了各个类的职责,如果有新的对象增加,只需要增加一个具体的类和具体的工厂类即可,不影响已有的代码,后期维护容易,增强了系统的扩展性
缺点
需要额外的编写代码,增加了工作量

public class Demo {
    public static void main(String[] args) {
        Factory df=new DogFactory();
        Animal a=df.creatAnimal();
        a.eat();
        Factory cf=new CatFactory();
        Animal b=cf.creatAnimal();
        b.eat();
    }

}

interface Factory{
    Animal creatAnimal();
}

class DogFactory implements Factory{
    @Override
    public Animal creatAnimal() {
        return new Dog();
    }
    
}

class CatFactory implements Factory{
    @Override
    public Animal creatAnimal() {
        return new Cat();
    }
    
}

abstract class Animal {
    abstract void eat();
}

class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("dog eats meat");
    }
}

class Cat extends Animal {
    @Override
    void eat() {
        System.out.println("cat eats fish");
    }
}

2.3.单例设计模式概述
单例模式就是要确保类在内存中只有一个对象,该实例必须自动创建,并且对外提供。优点
在系统内存中只存在一个对象,因此可以节约系统资源,对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
缺点
没有抽象层,因此扩展很难。
职责过重,在一定程序上违背了单一职责

饥饿型
在类加载的时候就已经创建好对象

public class Demo {
    public static void main(String[] args) {
        Student s1=Student.getStudent();
        Student s2=Student.getStudent();
        System.out.println(s1==s2);
    }

}

class Student {
    private Student() {//让外界不能创建这个类的对象

    }

    private static Student s = new Student();//为了不让外界直接访问修改这个值,所以要加private

    static Student getStudent() {
        return s;
    }
}

懒惰式
用的时候才去创建对象
可能产生线程安全问题

public class Demo {
    public static void main(String[] args) {
        Teacher t1=Teacher.getTeacher();
        Teacher t2=Teacher.getTeacher();
        System.out.println(t1==t2);
        
    }

}

class Teacher {
    private Teacher() {
    }

    private static Teacher t = null;

    static Teacher getTeacher() {
        if (t == null)
            t = new Teacher();
        return t;
    }
}

单例模式的应用---Runtime类

public class Demo {
    public static void main(String[] args) {
        Runtime run=Runtime.getRuntime();
        try {
            run.exec("calc");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/67510.html

相关文章

  • CZ深入浅出Java基础)线程笔记

    摘要:一个进程如果有多条执行路径,则称为多线程程序。这可能抛出在当前线程中。考虑多线程的数据安全问题是否是多线程环境。当前线程必须拥有此对象监视器。此方法导致当前线程称之为将其自身放置在对象的等待集中,然后放弃此对象上的所有同步要求。 这是刘意老师的JAVA基础教程的笔记讲的贼好,附上传送门 传智风清扬-超全面的Java基础 一、线程的引入 1.多线程概述 进程 a.正在运行的程序,是...

    harryhappy 评论0 收藏0
  • CZ深入浅出Java基础)反射

    摘要:分类根类加载器也被称为引导类加载器,负责核心类的加载比如等。要想解剖一个类必须先要获取到该类的字节码文件对象。 这是刘意老师的JAVA基础教程的笔记讲的贼好,附上传送门 传智风清扬-超全面的Java基础 一、类的加载 1.类初始化的时机 创建类的实例访问类的静态变量,或者为静态变量赋值调用类的静态方法使用反射方式来强制创建某个类或接口对应的java.lang.Class对象初始化某个类...

    asoren 评论0 收藏0
  • Java9模块化学习笔记二之模块设计模式

    摘要:但是模块化当中,无法扫描只有模块中可以使用有两种解决方案定义一个专门的资源模块,并使用提供的接口,实现它,并将这个实现注册为服务。有两种方式使用或包名,包名模块名使用运行时动态。 模块设计的原则: 1、防止出现编译时循环依赖(主要是编译器不支持),但运行时是允许循环依赖的,比如GUI应用2、明确模块的边界 几种模块设计: API模块,聚合模块(比如java.base) 可选依赖 两种方...

    李文鹏 评论0 收藏0
  • 那些年我看过的书 —— 致敬我的大学生活 —— Say Good Bye !

    摘要:开头正式开启我入职的里程,现在已是工作了一个星期了,这个星期算是我入职的过渡期,算是知道了学校生活和工作的差距了,总之,尽快习惯这种生活吧。当时是看的廖雪峰的博客自己也用做爬虫写过几篇博客,不过有些是在前人的基础上写的。 showImg(https://segmentfault.com/img/remote/1460000010867984); 开头 2017.08.21 正式开启我...

    xiaoqibTn 评论0 收藏0
  • 后台开发常问面试题集锦(问题搬运工,附链接)

    摘要:基础问题的的性能及原理之区别详解备忘笔记深入理解流水线抽象关键字修饰符知识点总结必看篇中的关键字解析回调机制解读抽象类与三大特征时间和时间戳的相互转换为什么要使用内部类对象锁和类锁的区别,,优缺点及比较提高篇八详解内部类单例模式和 Java基础问题 String的+的性能及原理 java之yield(),sleep(),wait()区别详解-备忘笔记 深入理解Java Stream流水...

    spacewander 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<