自定义博客皮肤VIP专享

*博客头图:

格式为PNG、JPG,宽度*高度大于1920*100像素,不超过2MB,主视觉建议放在右侧,请参照线上博客头图

请上传大于1920*100像素的图片!

博客底图:

图片格式为PNG、JPG,不超过1MB,可上下左右平铺至整个背景

栏目图:

图片格式为PNG、JPG,图片宽度*高度为300*38像素,不超过0.5MB

主标题颜色:

RGB颜色,例如:#AFAFAF

Hover:

RGB颜色,例如:#AFAFAF

副标题颜色:

RGB颜色,例如:#AFAFAF

自定义博客皮肤

-+
  • 博客(226)
  • 收藏
  • 关注

原创 Effective Java 优先考虑泛型

一般来说参数化声明并使用JDK提供的泛型和方法通常并不困难。编写自己的泛型会比较困难一些,但是值得花些时间去学习如何编写。  考虑到第7项中这个简单(玩具)堆栈的实现:// Object-based collection - a prime candidate for genericspublic class Stack { private Object[] elements; private int size = 0; private static final int

2021-01-07 20:35:41 13

原创 Effective Java 优先考虑泛型方法

就如类可以从泛型中受益一般,方法也可以。静态工具方法尤其适合与泛型化。JDK中的Collections泛型中的所有“算法”方法都泛型化了。如:下面这个方法返回连个集合的联合。public static Set union(Set s1,Set s2){ Set result = new HashSet(s1); result.addAll(s2); return result;}为了方法变成类型安全的,要将方法声明修改为声明一个类型...

2021-01-05 21:26:39 16

原创 Effective java 列表优先于数组

看到这个标题的时候,我有个疑惑:是不是优先使用列表,能用列表就尽量用列表吗?我觉得,之所以说列表优于数组,应该是在某些语法设计方面,列表有比较大的优势。但是要具体问题具体分析,数组也有自身的优势(对于固定长度的序列,性能更加高),而且在某些情况下,列表的所谓的优势并不能发挥。数组是协变且可以具体化的;泛型是不可变的且可以被擦除的(不可具体化的)。**协变与不可变类型数组是协变类型,指继承关系的。泛型是不可变类型(也就是final类型),没有继承关系。无限制通配符类型是一个特例。//这段

2021-01-03 18:48:15 12

原创 Effective Java 消除非受检警告

使用泛型编程时,会遇到许多编译器警告,如:非受检强制转化警告,非受检方法调用警告,非受检普通数组创建警告,非受检转换警告。当你越来越熟悉泛型之后,遇到的警告也会越来越少,但是不要期待从一开始用泛型编写代码就可以正确的进行编译。PS:非受检警告就是代码上黄色的感叹号 有许多非受检警告很容易消除,例如:——HashSet是一个原始类型。泛型类型的引用HashSet < E >应该是参数化的——局部变量的值不使用exaltation1-类型安全:表达式类型的HashS...

2021-01-03 10:44:18 16

原创 Effective Java 请不要在新代码中使用原生态类型

声明中具有一个或者多个类型参数(type parameter)的类或者接口,就是泛型。泛型类和泛型接口统称为泛型(generic type)。每种泛型定义一组参数化的类型,构成格式为:先是类或者接口的名称,接着用尖括号(<>)把对应于泛型形式类型参数的实际类型参数列表括起来。原生态类型就像从类型声明中删除了所有的泛型信息一样。实际上,原生态类型List与Java平台没有泛型之前的接口类型List完全一样。如果不提供类型参数,只是使用集合类型和其他泛型的原生态类型仍然是合法的,但是

2021-01-03 10:29:57 9

原创 Effective Java 优先考虑静态成员类

嵌套类指被定义在一个类的内部的类。嵌套类存在的目的应该只是为它的外围类提供服务。如果嵌套类将来可能用于其他环境,它应该是顶层类。嵌套类有四种:静态成员类,非静态成员类,匿名类,局部类。静态成员类的常见用法是作为公有的辅助类,仅当与外部类一起使用才有意义,考虑一个枚举,它描述计算器支持的各种操作,Operation枚举应该是Caculator类的公有静态成员类,然后就可以使用如Caculator.Operation.PLUS这样的名称来引用这些操作。非静态成员类的每个实例都隐含与...

2021-01-02 19:57:02 11

原创 Effective Java 用函数对象表示策略

有些语言支持函数指针(function pointer)、代理(delegate)、lambda表达式(lambda expression),或者支持类似的机制,允许程序把“调用特殊函数能力”存储起来并传递这种能力。这种机制通常用于允许函数的调用者通过传入第二个函数,来指定自己的行为。例如,C语言标准库中的qsort函数要求用一个指向comparator(比较器)函数的指针作为参数,它用这个函数来比较待排序的元素。比较器函数有两个参数,都是指向元素的指针。如果第一个参数所指的元素小于第二个参数所指的元素,则

2021-01-02 19:46:19 19

原创 Effective Java 类层次优于标签类

有时候,可能会遇到带有两种甚至更多风格的实例代码的类,并包含表示实例风格的标签(tag)域。例如,考虑下面这个类,它能够表示圆形或者矩形:// Tagged class - vastly inferior to a class hierarchy!class Figure{ enum Shape{RECTANGLE,CIRCLE}; //Tag field - the shape of this figure final Shape shape; //There field are

2021-01-02 19:35:17 13

原创 Effective Java 接口只用于定义类型

当类实现接口时,接口就充可以引用这个类的实例的类型。因此,类实现了接口,就表明客户端可以对这个类的实例实施某些动作。为了任何其他目的而定义接口是不恰当的。有一种接口被称为常量接口(constant interface),它不满足上面的条件。这种接口没有包含任何方法,它只包含静态的final域,每个域都导出一个常量。使用这些常量的类实现这个接口,以避免用类名来修饰常量名。下面是一个例子:1 public interface PhysicalConstants {2 static final

2020-12-29 22:31:46 25

原创 Effective Java 接口优于抽象类

Java有两种机制来定义允许多个实现的类型:接口和抽象类。 由于在Java 8 [JLS 9.4.3]中引入了接口的默认方法(default methods ),因此这两种机制都允许为某些实例方法提供实现。 一个主要的区别是要实现由抽象类定义的类型,类必须是抽象类的子类。 因为Java只允许单一继承,所以对抽象类的这种限制严格限制了它们作为类型定义的使用。 任何定义所有必需方法并服从通用约定的类都可以实现一个接口,而不管类在类层次结构中的位置。现有的类可以很容易地进行改进来实现一个新的接口。 你只需添加

2020-12-28 22:25:25 41

原创 Effective Java 要么为继承设计,并提供文档说明,要么就禁止继承

首先,该类的文档必须精确地描述覆盖每个方法所带来的影响。换句话说,该类必须有文档说明他可覆盖(overridable)的方法的自用型(self-use)。对于每个共有的或受保护的方法或构造器,他的文档必须指明该方法或者构造器调用了哪些可覆盖的方法,是以什么顺序调用的,每个调用的结果又是如何影响后续的处理过程的。更一般的,类必须在文档中说明,在哪些情况下会调用可覆盖的方法。(例如:后台的线程或者静态的初始化可能会调用这个方法)按惯例,如果方法调用了可覆盖的方法,在他的文档注释的末尾应该包含关于这些调用的描

2020-12-27 19:52:26 16

原创 Effective Java 复合优先于继承

继承是实现代码重用的有力手段,但是使用不当会导致软件变得脆弱。在包的内部使用继承是非常安全的,子类和超类的实现都处在同一个程序员的控制之下。对于专门为了继承而设计、并且具有很好的文档说明的类来说,使用继承也是非常安全的。然而们对于进行跨越包边界的继承,则要非常小心。“继承”在这里特指一个类扩展另一个类。public class InstrumentedHashSet<E> extends HashSet<E> { private int addCount =.

2020-12-26 17:38:45 20

原创 Effective Java 使可变性最小化

不可变类是实例不能被修改的类。每个实例中包含的所有信息都必须在创建该实例的时候就提供,并在对象的整个生命周期内固定不变。Java平台包含的不可变类:String、基本类型的包装类、BigInteger、BigDecimal。不可变类比可变类更容易设计、实现和使用。为了使类成为不可变,要遵循五条规则:1.不要提供任何会修改对象状态的方法。2.保证类不会被扩展,为了防止恶意子类假装对象状态被改变,从而破坏不可变。3.使所有的域都是final的。4.使所有的域都成为私有的,防止客户端获得.

2020-12-26 13:33:56 18

原创 Effective Java 在公有类中使用访问 方法而非公有域

Class Point { public double x; public double y;}如上面Point类的数据域是可以直接被访问的,这样的类没有提供封装。如果不改变API,就无法改变它的数据表示法(比如,使用一个比double更高精度的类来表示x和y),也无法强加任何约束条件(比如以后我们可能会希望x和y不会超过某个值)。Class Point { private double x; private double y; public..

2020-12-24 20:27:36 9

原创 Effective Java使类和成员的可访问性最小化

要区分精心设计的组件和设计不好的组件的最重要的因素在于,这个组件对于其他组件而言,是否隐藏了其内部数据和其他市县细节。设计良好的组件会隐藏其所有实现细节,把它的API与它的实现完全分离。组件之间只能通过它们的API进行通信,并且不知道彼此之间内部的工作细节。这种被称为信息隐藏(information hiding )或封装(encapsulation)的概念是软件设计的基本原则[Parnas72]。  信息隐藏之所以非常重要是有许多原因的,其中大部分原因在于它将构成系统的组件解耦,允许它们单独开发、测试

2020-12-24 20:12:40 11

原创 考虑实现Comparable接口

考虑实现Comparable接口与本章中讨论的其他方法不同,compareTo方法并没有在Object 类中声明。相反,它是Comparable 接口中唯一的方法。compareTo方法不但允许进行简单的等同性比较,而且允许执行顺序比较,除此之外,它与Object的equals方法具有相似的特征,它还是个泛型(generic)。类实现了 Comparable接口,就表明它的实例具有内在的排序关系 (natural ordering)。为实现Comparable接口的对象数组进行排序就这么简单:Array

2020-12-20 19:21:50 11

原创 Effective Java 谨慎的覆盖clone()方法

一个类要想实现克隆,需要实现Cloneable接口,表明这个类的对象具有克隆的功能。Cloneable接口是一个mixin接口,它里面并没有任何的抽象方法,类似的接口有Serializable接口,表明该类的对象可以序列化。首先应该明确通过一个对象克隆出另一个对象的概念:通过一个对象克隆出另一个对象,简称对象1和对象2,这两个对象就成为两个独立的对象,那么对对象1做任何的修改,对象2应该不受影响;对对象2做任何的修改的,对象1就不应该受影响。这样就要求对象1与对象2的实例域各自是独立的。那么我们知道

2020-12-20 18:07:22 14

原创 Effective Java始终要覆盖toString()方法

Object类提供的toString()方法如下:public String toString(){return getClass().getName() + “@” + Integer.toHexString(hashCode());}如果我们直接打印一个对象,就会调用这个对象的toString()方法,如果我们没有为该类覆盖toString()方法,我们可以看出toString()方法,返回的是 “类名@散列值的十六进制”。toString()方法的通用约定是:返回当前对象“简洁,但信息丰

2020-12-19 20:48:54 44 3

原创 Effective Java 覆盖equals时总要覆盖hashCode

一. Object.hashCode通用约定1. 在应用程序执行期间,只要对象的equals方法的比较操作所用到的信息没有被修改,那么对这同一个对象调用多次,hashCode方法都必须始终如一地返回同一个整数. 在同一个应用程序的多次执行过程中,每次执行所返回的整数可以不一致 2. 如果两个对象根据equals(Object)方法比较是想等的,那么调用两个对象总任意一个对象的hashCode方法都必须产生同样的整数结果 3. 如果两个对象根据equals(Object)方法比较是不想等的,那么

2020-12-19 20:33:38 23 1

原创 Effective java 覆盖equals时请遵守通用约定

该篇博客主要阐述1、不需要覆盖equals的情景2、需要覆盖equals的情景3、对5条通用约定的理解4、实现高质量equals的诀窍5、注意点一、不需要覆盖equals的情景1、类的每个实例本质上都是唯一的对于代表活动实体而不是值(value)的类来说确实如此,比如Thread2、不关心类是否提供了“逻辑相等”的测试功能书本上的例子是java.util.Random覆盖equals,以检查两个Random实例是否产生相同的随机数序列,但是设计者并不认为客户需要或者期望这样的功能。在这种

2020-12-19 18:10:48 8 1

原创 Effective Java 避免使用终结方法和清空方法

终结方法是不可预测的,通常很危险,一般情况下是不必要的(Finalizers are unpredictable, often dangerous, and generally unnecessary.)。使用 终结方法会导致行为不稳定,降低性能,以及可移植性问题。当然,终结方法也有可用之处,我们将在本项的最后再做介绍;但是,作为一项规则,我们应该避免使用它们。在Java 9 中,终结方法已经过时了,但是在Java库中还在使用。Java 9中替代终结方法的方式是清理方法。清理方法比终结方法危险性更低,但仍然

2020-12-15 21:49:45 45

原创 Effective Java 清除过期对象的引用

当你从手工管理内存的语言(比如C或者C++)转换到具有垃圾回收功能的语言的时候,程序猿的工作就会变得更加容易,因为当你用完了对象之后,他们就会被自动回收。当你第一次经历对象回收功能的时候,会觉得这简直有点不可思议。这很容易给你留下这样的印象,认为自己不再需要考虑内存管理的事情了,其实不然。  考虑下面这个简单的栈实现的例子:// Can you spot the "memory leak"?public class Stack { private Object[] elements;

2020-12-14 22:13:55 48 2

转载 Effective Java 避免创建不必要的对象

《Effective Java》第二章创建和销毁对象第5条提到,在开发过程中,需要避免创建不必要的对象,最好能重用对象而非在每次需要的时候就创建一个相同功能的新对象。如果对象是不可变的,它就始终可以被重用,而不用创建新的实例,从而降低内存占用和垃圾回收的成本。例如,创建字符串// Don't do this!String s = new String("stringette");// 优化版String s = "stringette"; 第二行代码每次被执行的时候都创建一个...

2020-12-14 21:13:23 15

转载 Effective Java——通过私有构造器强化不可实例化的能力

有时候你会想要编写一个只包含一组静态方法和静态字段的类。这种类名声很不好,因为有些人为了避免使用面向对象的思维方式而滥用这样的类(some people abuse them to avoid thinking in terms of objects),但是他们确实有它们特有的用处。我们可以使用这种类,以java.lang.Math或者java.util.Arrays的方式对原始值或数组的相关方法组织起来。它们还可以用于以java.util.Collections的方式,把实现特定接口的对象上的静态方法(.

2020-12-11 22:23:44 10

转载 Effective Java——用私有构造器或者枚举类型强化Singleton属性

Singleton指仅仅被实例化一次的类 [Gamma95]。Singleton通常代表无状态的对象,例如函数(第24项)或者本质上唯一的系统组件。使类称为Singleton会使它的客户端测试变得十分困难,因为除非它实现了作为其类型的接口,否则不可能将模拟实现替换为单例。  实现单例的方法有两种。 两者都基于保持构造函数私有并导出公共静态成员以提供对唯一实例的访问。 在一种方法中,该成员是final字段:// Singleton with public final fieldpublic cla

2020-12-11 22:13:26 13

转载 Effective Java——构建器(Builder)

Java构建器(Builder)在设计模式中对Builder模式的定义是用于构建复杂对象的一种模式,所构建的对象往往需要多步初始化或赋值才能完成。那么,在实际的开发过程中,我们哪些地方适合用到Builder模式呢?其中使用Builder模式来替代多参数构造函数是一个比较好的实践法则。考虑用一个类表示包装食品外面现实的营养成分,这些标签通常有许多的参数,如果用重叠构造器模式,就必须写多个构造器(constructor):不带参数的构造器 一个参数的构造器 二个参数的构造器 …下面我们使

2020-12-11 21:58:12 7

转载 Effective Java——静态工厂方法

1. 序:什么是静态工厂方法在 Java 中,获得一个类实例最简单的方法就是使用 new 关键字,通过构造函数来实现对象的创建。就像这样: Fragment fragment = new MyFragment(); // or Date date = new Date();不过在实际的开发中,我们经常还会见到另外一种获取类实例的方法: Fragment fragment = MyFragment.newIntance(); // or ..

2020-12-09 21:45:40 26

转载 六大设计原则

一、单一职责原则定义:不要存在多于一个导致类变更的原因。通俗的说,即一个类只负责一项职责。问题由来:类T负责两个不同的职责:职责P1,职责P2。当由于职责P1需求发生改变而需要修改类T时,有可能会导致原本运行正常的职责P2功能发生故障。解决方案:遵循单一职责原则。分别建立两个类T1、T2,使T1完成职责P1功能,T2完成职责P2功能。这样,当修改类T1时,不会使职责P2发生故障风险;同理,当修改T2时,也不会使职责P1发生故障风险。说到单一职责原则,很多人都会不屑一顾。因为它太简单了。稍有经验

2020-11-16 17:22:16 18

原创 设计模式总结

一、创建型模式1 抽象工厂定义就是对一组具有相同主题的工厂进行封装(维基百科解释的很到位);例如:生产一台PC机,使用工厂方法模式的话,一般会有cpu工厂,内存工厂,显卡工厂...但是使用抽象工厂模式的话,只有一个工厂就是PC工厂,但是一个PC工厂涵盖了cpu工厂,内存工厂,显卡工厂等要做的所有事;结构图适用场景当需要创建的对象是一系列相互关联或相互依赖的产品族时,便可以使用抽象工厂模式。说的更明白一点,就是一个继承体系中,如果存在着多个等级结构(即存在着多个抽象类),并且分

2020-11-12 16:48:06 16

转载 设计模式——访问者模式

访问者模式,是行为型设计模式之一。访问者模式是一种将数据操作与数据结构分离的设计模式,它可以算是 23 中设计模式中最复杂的一个,但它的使用频率并不是很高,大多数情况下,你并不需要使用访问者模式,但是当你一旦需要使用它时,那你就是需要使用它了。访问者模式的基本想法是,软件系统中拥有一个由许多对象构成的、比较稳定的对象结构,这些对象的类都拥有一个 accept 方法用来接受访问者对象的访问。访问者是一个接口,它拥有一个 visit 方法,这个方法对访问到的对象结构中不同类型的元素做出不同的处理。在对象结构

2020-11-09 16:14:46 12

转载 设计模式——解释器模式

一、什么是解释器模式  解释器这个名词想必大家都不会陌生,比如编译原理中,一个算术表达式通过词法分析器形成词法单元,而后这些词法单元再通过语法分析器构建语法分析树,最终形成一颗抽象的语法分析树。诸如此类的例子也有很多,比如编译器、正则表达式等等。  如果一种特定类型的问题发生的频率足够高,那么可能就值得将该问题的各个实例表述为一个简单语言中的句子,这样就可以构建一个解释器,该解释器通过解释这些句子来解决该问题。  就比如正则表达式,它就是解释器模型的一种应用,解释器为正则表达式定义了一个文法,如

2020-11-09 10:05:46 8

转载 设计模式——亨元模式

简介享元模式也被称为“蝇量模式”,属于结构型设计模式的一种,该模式的主要作用就是通过运用共享技术促使大量细粒度的对象可以被复用。该模式常用于系统底层开发,解决系统性能问题。像我们常用的数据库连接池,字符串常量池等……都是使用享元模式来完成的。“池”中存储了我们创建好的对象,当需要时进行判断,如果“池”中有就可以直接从中取出,如果没有就创建一个对象并放到池中。通过使用这些“池”就可以避免重复创建对象而导致内存浪费的问题,从而提高系统的效率。外部状态和内部状态使用享元模式就必须要学会区分对象

2020-11-06 15:55:37 15

转载 设计模式——中介者模式

前言 中介者模式又称为调停者模式,作为行为型的模式之一,本身是个很低调的模式,因为应用场合有限,所以不那么被人熟知 下文我将举例介绍中介者模式的作用,以及中介者模式应用的意义,文末我会总结一下中介者模式的一些特点 实例引入 假设现在科技发达之后,家里所有设备都是智能化的,而小明在家洗澡的时候有个习惯就是喜欢听歌,而且洗澡时候还要把窗帘拉上。因此就有这种情形,小明要拉窗帘可能就是要洗澡,当然也要听歌,因此我们希望小明家的洗浴设备,音响设备和窗帘设备都能协同合作,不管操作哪种...

2020-11-06 15:21:02 13

转载 设计模式——职责链模式

什么是链1、链是一系列节点的集合。2.、链的各节点可灵活拆分再重组。职责链模式使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合关系,将这个对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理他为止。角色抽象处理者角色(Handler):定义出一个处理请求的接口。如果需要,接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。具体处理者角色(ConcreteHandler):具体处理者接到请求..

2020-11-06 14:49:06 8

转载 设计模式——命令模式

零零碎碎的了解过部分设计模式,但没有系统的学习过,最近晚上有点时间,就买了本程杰的《大话设计模式》,最近想系统的学习下。当看到命令模式的时候,感觉并不是太好理解,于是上网搜索了些资料。发现对设计模式的看法多少很多文章都有些不一样,于是想写下自己对命令模式的一些看法,以加深理解。要是文章有不对的地方,希望大家能提出改进建议。目的:任何模式的出现,都是为了解决一些特定的场景的耦合问题,以达到对修改封闭,对扩展开放的效果。命令模式也不例外:命令模式是为了解决命令的请求者和命令的实现者之间的耦合关系。

2020-11-06 10:40:02 2

转载 设计模式——桥接模式

生活中的一个例子: 就拿汽车在路上行驶的来说。即有小汽车又有公共汽车,它们都不但能在市区中的公路上行驶,也能在高速公路上行驶。这你会发现,对于交通工具(汽车)有不同的类型,然而它们所行驶的环境(路)也在变化,在软件系统中就要适应两个方面的变化?怎样实现才能应对这种变化呢?概述:在软件系统中,某些类型由于自身的逻辑,它具有两个或多个维度的变化,那么如何应对这种“多维度的变化”?如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化,而又不引入额外的复杂度?这就要使用Bridge模式。意图:...

2020-11-05 17:22:54 10

转载 设计模式——单例模式

1:java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍两种:懒汉式单例、饿汉式单例单例模式有以下特点:    1、单例类只能有一个实例。  2、单例类必须自己创建自己的唯一实例。  3、单例类必须给所有其他对象提供这一实例。目的  单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机,但

2020-11-05 16:27:34 13

转载 设计模式——迭代器模式

迭代器模式定义迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中的各种元素,而又不暴露该对象的内部表示。迭代器模式的角色构成(1)迭代器角色(Iterator):定义遍历元素所需要的方法,一般来说会有这么三个方法:取得下一个元素的方法next(),判断是否遍历结束的方法hasNext()),移出当前对象的方法remove(),(2)具体迭代器角色(Concrete Iterator):实现迭代器接口中定义的方法,完成集合的迭代。(3)容器角色(Aggregate): 一.

2020-11-05 10:16:01 11

转载 设计模式——组合模式

简介组合模式(Composite Pattern),这种模式你或许没有听说过,但是一定用过,他是23种设计模式总比较常用的模式。组合模式又叫部分整体模式,是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象,用来表示部分以及整体层次。这种类型的设计模式属于结构型模式,它创建了对象组的树形结构。组合模式的基本结构组合模式有三个基本部件: 即抽象部件、叶子部件、树枝部件,这三个部件组成的一颗树形结构。抽象构件(Component):叶子构件和容器构件继承的抽象类,包含叶子

2020-11-04 17:31:00 24

转载 设计模式——备忘录模式

前言网上搜索备忘录设计模式,基本上均是在一个GoF,基础上衍生下来的。为了避免重复造轮子,这里会结合网上demo,和自己理解进行总结定义:备忘录(Memento)模式又称标记(Token)模式。GOF给备忘录模式的定义为:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。角色分类: 1)备忘录(Memento)角色:备忘录角色存储“备忘发起角色”的内部状态。“备忘发起角色”根据需要决定备忘录角色存储“备忘发起角色”的哪些内.

2020-11-04 16:18:16 13

空空如也

空空如也

空空如也

TA创建的收藏夹 TA关注的收藏夹

TA关注的人 TA的粉丝

提示
确定要删除当前文章?
取消 删除