软构学习-56-设计规约抽象数据类型(ADT)

Posted blogstb

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了软构学习-56-设计规约抽象数据类型(ADT)相关的知识,希望对你有一定的参考价值。

5 设计规约

本章大纲:

  • 方法的规约
  • 前置/后置条件
  • 欠定规约、非确定规约
  • 陈述式、操作式规约
  • 规约强度及其比较
  • 如何写出好的规约

规约只说明“能做什么”,
而不讲“怎么实现”

行为等价性

站在客户端的角度看待行为等价性

Spec 结构

  • 前置条件:
    对客户端的约束,在使用方法时必须满足的条件
  • 后置条件
    对开发者的约束,方法结束时必须满足的条件
  • 例外

除非条件中要求,否则尽量避免修改可变数据类型

Spec 强度比较

Spec强度变大的依据:

  • 前置条件更弱
  • 后置条件更强

可以使用强度更大的Spec替代强度更小的Spec

Diagramming specifications

  • 点:代表方法的具体实现
  • 圈:代表Spec

若方法满足规约$\\rightarrow$则落在Spec的范围内。

更强的规约表达为更小的圈

6 抽象数据类型(ADT)

本章大纲:

ADT的特性:

  • 表示泄露
  • 抽象函数AF
  • 表示不变量RI

操作的抽象类型分类:

  • Creators 构造器
    create new objects of the type,
    A creator may take an object as an argument,but not an object of the type
    being constructed.
  • Producers 生产器
    create new objects from old objects of the type.
  • Observers 观察器
    take objects of the abstract type and return objects of a different type.
  • Mutators 变值器,改变对象属性的方法
    change objects.

各个特征:

  • Creator 可能实现为构造函数或静态函数。
  • Creator 实例比如:工厂方法。
  • Mutator 通常返回值为 void,但也可能返回非空类型。

Representation Independence

表示独立性:client使用ADT时无需考虑其内部如何实现,ADT内部表示的变化不应影响外部spec和客户端。
除非 ADT 的操作指明了具体的pre-和post-condition,否则不能改变ADT的内部表示——spec规定了client和implementer之间的契约。

软件构造第三章第三节 抽象数据型(ADT)

第三章第三节 抽象数据型(ADT)

       3-1节研究了“数据类型”及其特性 ; 3-2节研究了方法和操作的“规约”及其特性;在本节中,我们将数据和操作复合起来,构成ADT,学习ADT的核心特征,以及如何设计“好的”ADT。

Outline

  • ADT及其四种类型
    • ADT的基本概念
    • ADT的四种类型
    • 设计一个好的ADT
  • 表示独立性
  • 不变量和表示泄露
  • 抽象函数AF和表示不变量RI
    • AF与RI
    • 用注释写AF和RI

Notes

## ADT及其四种类型

【ADT的基本概念】

  • 抽象数据类型(Abstract Data Type,ADT)是是指一个数学模型以及定义在该模型上的一组操作;即包括数据数据元素,数据关系以及相关的操作。
  • ADT具有以下几个能表达抽象思想的词:
    • 抽象化:用更简单、更高级的思想省略或隐藏低级细节。
    • 模块化: 将系统划分为组件或模块,每个组件可以设计,实施,测试,推理和重用,与系统其余部分分开使用。
    • 封装:围绕模块构建墙,以便模块负责自身的内部行为,并且系统其他部分的错误不会损坏其完整性。
    • 信息隐藏: 从系统其余部分隐藏模块实现的细节,以便稍后可以更改这些细节,而无需更改系统的其他部分。
    • 关注点分离: 一个功能只是单个模块的责任,而不跨越多个模块。
  • 与传统类型定义的差别:
    • 传统的类型定义:关注数据的具体表示。
    • 抽象类型:强调“作用于数据上的操作”,程序员和client无需关心数据如何具体存储的,只需设计/使用操作即可。
  • ADT是由操作定义的,与其内部如何实现无关!

【ADT的四种类型】

  • 前置定义:mutable and immutable types
    • 可变类型的对象:提供了可改变其内部数据的值的操作。Date
    • 不变数据类型: 其操作不改变内部值,而是构造新的对象。String

  • Creators(构造器):
    • 创建某个类型的新对象,⼀个创建者可能会接受⼀个对象作为参数,但是这个对象的类型不能是它创建对象对应的类型。可能实现为构造函数或静态函数。(通常称为工厂方法)
    • t* ->  T
    • 栗子:Integer.valueOf( )
  • Producers(生产器):
    • 通过接受同类型的对象创建新的对象。
    • T+ , t* -> T
    • 栗子:String.concat( )
  • Observers(观察器):
    • 获取抽象类型的对象然后返回一个不同类型的对象/值。
    • T+ , t* -> t
    • 栗子:List.size( ) ;
  • Mutators(变值器):
    • 改变对象属性的方法 ,
    • 变值器通常返回void,若为void,则必然意味着它改变了对象的某些内部状态;当然,也可能返回非空类型 
    • T+ , t* -> t || T || void
    • 栗子:List.add( )
  • 解释:T是ADT本身;t是其他类型;+ 表示这个类型可能出现一次或多次;* 表示可能出现0次或多次。
  • 更多栗子:

【设计一个好的ADT】

设计好的ADT,靠“经验法则”,提供一组操作,设计其行为规约 spec

  • 原则 1:设计简洁、一致的操作。
    • 最好有一些简单的操作,它们可以以强大的方式组合,而不是很多复杂的操作。
    • 每个操作应该有明确的目的,并且应该有一致的行为而不是一连串的特殊情况。
  • 原则 2:要足以支持用户对数据所做的所有操作需要,且用操作满足用户需要的难度要低。
    • 提供get()操作以获得list内部数据
    • 提供size()操作获取list的长度
  • 原则 3:要么抽象、要么具体,不要混合 —— 要么针对抽象设计,要么针对具体应用的设计。

【测试ADT】

  • 测试creators, producers, and mutators:调用observers来观察这些 operations的结果是否满足spec;
  • 测试observers: 调用creators, producers, and mutators等方法产生或改变对象,来看结果是否正确。

 

## 表示独立性

  • 表示独立性:client使用ADT时无需考虑其内部如何实现,ADT内部表示的变化不应影响外部spec和客户端。
  • 除非ADT的操作指明了具体的前置条件/后置条件,否则不能改变ADT的内部表示——spec规定了 client和implementer之间的契约。

【一个例子:字符串的不同表示】

  让我们先来看看一个表示独立的例子,然后考虑为什么很有用,下面的MyString抽象类型是我们举出的例子。下面是规格说明:

 1 /** MyString represents an immutable sequence of characters. */
 2 public class MyString { 
 3 
 4     //////////////////// Example of a creator operation ///////////////
 5     /** @param b a boolean value
 6      *  @return string representation of b, either "true" or "false" */
 7     public static MyString valueOf(boolean b) { ... }
 8 
 9     //////////////////// Examples of observer operations ///////////////
10     /** @return number of characters in this string */
11     public int length() { ... }
12 
13     /** @param i character position (requires 0 <= i < string length)
14      *  @return character at position i */
15     public char charAt(int i) { ... }
16 
17     //////////////////// Example of a producer operation ///////////////    
18     /** Get the substring between start (inclusive) and end (exclusive).
19      *  @param start starting index
20      *  @param end ending index.  Requires 0 <= start <= end <= string length.
21      *  @return string consisting of charAt(start)...charAt(end-1) */
22     public MyString substring(int start, int end) { ... }
23 }

  使用者只需要/只能知道类型的公共方法和规格说明。下面是如何声明内部表示的方法,作为类中的一个实例变量:

private char[] a;

  使用这种表达方法,我们对操作的实现可能是这样的:

 1 public static MyString valueOf(boolean b) {
 2     MyString s = new MyString();
 3     s.a = b ? new char[] { \'t\', \'r\', \'u\', \'e\' } 
 4             : new char[] { \'f\', \'a\', \'l\', \'s\', \'e\' };
 5     return s;
 6 }
 7 
 8 public int length() {
 9     return a.length;
10 }
11 
12 public char charAt(int i) {
13     return a[i];
14 }
15 
16 public MyString substring(int start, int end) {
17     MyString that = new MyString();
18     that.a = new char[end - start];
19     System.arraycopy(this.a, start, that.a, 0, end - start);
20     return that;
21 }

执行下列的代码

MyString s = MyString.valueOf(true);
MyString t = s.substring(1,3);

 

  我们用快照图展示了在使用者进行 subString 操作后的数据状态:

  这种实现有一个性能上的问题,因为这个数据类型是不可变的,那么 substring 实际上没有必要真正去复制子字符串到⼀个新的数组中。它可以仅仅指向原来的 MyString 字符数组,并且记录当前的起始位置和终⽌位置。

   为了优化,我们可以将这个类的内部表示改为:

private char[] a;
private int start;
private int end;

   有了这个新的表示,操作现在可以这样实现:

 1 public static MyString valueOf(boolean b) {
 2     MyString s = new MyString();
 3     s.a = b ? new char[] { \'t\', \'r\', \'u\', \'e\' } 
 4             : new char[] { \'f\', \'a\', \'l\', \'s\', \'e\' };
 5     s.start = 0;
 6     s.end = s.a.length;
 7     return s;
 8 }
 9 
10 public int length() {
11     return end - start;
12 }
13 
14 public char charAt(int i) {
15   return a[start + i];
16 }
17 
18 public MyString substring(int start, int end) {
19     MyString that = new MyString();
20     that.a = this.a;
21     that.start = this.start + start;
22     that.end = this.start + end;
23     return that;
24 }

   现在运行上面的调用代码,可用快照图重新进行 substring 操作后的数据状态:

  由于 MyString 的使用者仅依赖于其公共方法和规格说明,而不依赖其私有的存储,因此我们可以在不检查和更改所有客户端代码的情况下进行更改。 这就是表示独立性的力量。  

 

##  不变量(Invariants)与表示泄露

  一个好的抽象数据类型的最重要的属性是它保持不变量。一旦一个不变类型的对象被创建,它总是代表一个不变的值。当一个ADT能够确保它内部的不变量恒定不变(不受使用者/外部影响),我们就说这个ADT保护/保留自己的不变量。

【一个栗子:表示泄露】

 1 /**
 2  * This immutable data type represents a tweet from Twitter.
 3  */
 4 public class Tweet {
 5 
 6     public String author;
 7     public String text;
 8     public Date timestamp;
 9 
10     /**
11      * Make a Tweet.
12      * @param author    Twitter user who wrote the tweet
13      * @param text      text of the tweet
14      * @param timestamp date/time when the tweet was sent
15      */
16     public Tweet(String author, String text, Date timestamp) {
17         this.author = author;
18         this.text = text;
19         this.timestamp = timestamp;
20     }
21 }

  我们如何保证这些Tweet对象是不可变的,(即一旦创建了Tweet,其author,message和 date 永远不会改变)

  对不可变性的第一个威胁来自使用者可以直接访问Tweet内部数据的事实,例如执行如下的引用操作:

1 Tweet t = new Tweet("justinbieber", 
2                     "Thanks to all those beliebers out there inspiring me every day", 
3                     new Date());
4 t.author = "rbmllr";

   这是一个表示泄露(Rep exposure)的简单例子,这意味着类外的代码可以直接修改表示。像这样的表示暴露不仅威胁到不变量,而且威胁到表示独立性。如果我们改变类内部数据的1表示方式,使用者也会相应的受到影响。

  幸运的是,java给我们提供了处理表示暴露的方法:

 1 public class Tweet {
 2     private final String author;
 3     private final String text;
 4     private final Date timestamp;
 5 
 6     public Tweet(String author, String text, Date timestamp) {
 7         this.author = author;
 8         this.text = text;
 9         this.timestamp = timestamp;
10     }
11 
12     /** @return Twitter user who wrote the tweet */
13     public String getAuthor() {
14         return author;
15     }
16 
17     /** @return text of the tweet */
18     public String getText() {
19         return text;
20     }
21 
22     /** @return date/time when the tweet was sent */
23     public Date getTimestamp() {
24         return timestamp;
25     }
26 }

  在private和public关键字表明哪些字段和方法可访问时,只在类内部还是可以从类外部访问。所述final关键字还保证该变量的索引不会被更改,对于不可变的类型来说,就是确保了变量的值不可变。

  但这不能解决全部的问题:表示仍然会泄露!考虑这个完全合理的客户端代码,它使用Tweet:

1 /** @return a tweet that retweets t, one hour later*/
2 public static Tweet retweetLater(Tweet t) {
3     Date d = t.getTimestamp();
4     d.setHours(d.getHours()+1);
5     return new Tweet("rbmllr", t.getText(), d);
6 }

  

  retweetLater 希望接受一个Tweet对象然后修改Date后返回一个新的Tweet对象。

  这里有什么问题?其中的 getTimestamp 调用返回一个一样的 Date 对象,它会被t、t.timestamp 和 d 同时索引。因此,当日期对象被突变,d.gsetHours( ) 被调用时,t 也会影响日期,如快照图所示。

  

  这样,Tweet的不变性就被破坏,Tweet将自己内部对于可变对象的索引“泄露”了出来,因此整个对象都变成可变的了,使用者在使用时也容易造成隐藏的bug。

  我们可以通过使用防御性拷贝来修补这种风险:制作可变对象的副本以避免泄漏对代表的引用。代码如下:

public Date getTimestamp() {
    return new Date(timestamp.getTime());
}

  可变类型通常具有一个专门用来复制的构造函数,它允许创建一个复制现有实例值的新实例。在这种情况下,Date的复制构造函数就接受了一个timestamp值,然后产生一个新的对象。

  复制可变对象的另一种方法是clone(),某些类型但不是全部类型支持该方法。然而clone()在Java中的工作方式存在问题,更多可参考 Effective Java , item 11

   现在我们已经通过防御性复制解决了 timestamp 返回值的问题。但我们还没有完成任务!还有表示泄露。考虑这个非常合理的客户端代码:

 1 /** @return a list of 24 inspiring tweets, one per hour today */
 2 public static List<Tweet> tweetEveryHourToday () {
 3     List<Tweet> list = new ArrayList<Tweet>(); 
 4     Date date = new Date();
 5     for (int i = 0; i < 24; i++) {
 6         date.setHours(i);
 7         list.add(new Tweet("rbmllr", "keep it up! you can do it", date));
 8     } 
 9     return list;
10 }

 

  此代码旨在创建24个Tweet对象,为每个小时创建一条推文。但请注意,Tweet的构造函数保存传入的引用,因此所有24个Tweet对象最终都以同一时间结束,如此快照图所示。

  但是,Tweet的不变性再次被打破了,因为每⼀个Tweet创建时对Date对象的索引都是⼀样的。所以我们应该对创建者也进⾏防御性编程:

1 public Tweet(String author, String text, Date timestamp) {
2     this.author = author;
3     this.text = text;
4     this.timestamp = new Date(timestamp.getTime());
5 }

  通常来说,要特别注意ADT操作中的参数和返回值。如果它们之中有可变类型的对象,确保你的代码没有直接使⽤索引或者直接返回索引。

  你可能反对说这看起来很浪费。为什么要制作所有这些日期的副本?为什么我们不能通过像这样仔细书写的规范来解决这个问题?

/**
 * Make a Tweet.
 * @param author    Twitter user who wrote the tweet
 * @param text      text of the tweet
 * @param timestamp date/time when the tweet was sent. Caller must never 
 *                   mutate this Date object again!
 */
public Tweet(String author, String text, Date timestamp) {

   这种方法一般只在特不得已的时候使用——例如,当可变对象太大而无法有效地复制时。但是,由此引发的潜在bug也将很多。除非迫不得已,否则不要把希望寄托于客户端上,ADT有责任保证自己的不变量,并避免表示泄露。

   最好的办法就是使用immutable的类型,彻底避免表示泄露,例如 java.time.ZonedDateTime 而不是 java.util.Date

 

## 抽象函数AF与表示不变量RI

【AF与RI】

  

  • 在研究抽象类型的时候,先思考一下两个值域之间的关系:
    • 表示域(rep values)里面包含的是值具体的实现实体。一般情况下ADT的表示比较简单,有些时候需要复杂表示。 
    • 抽象域(A)里面包含的则是类型设计时支持使用的值。这些值是由表示域“抽象/想象”出来的,也是使用者关注的。
  • ADT实现者关注表示空间R,用户关注抽象空间A 。
  • R->A的映射特点:
    • 每一个抽象值都是由表示值映射而来 ,即满射:每个抽象值被映射到一些rep值
    • 一些抽象值是被多个表示值映射而来的,即未必单射:一些抽象值被映射到多个rep值
    • 不是所有的表示值都能映射到抽象域中,即未必双射:并非所有的rep值都被映射。

 

  • 抽象函数(AF):R和A之间映射关系的函数
AF : R → A 
  • 表示不变量(RI):将rep值映射到布尔值
RI : R → boolean  
    • 对于表示值r,当且仅当r被AF映射到了A,RI(r)为真。 
    • 表示不变性RI:某个具体的“表示”是否是“合法的”
    • 也可将RI看作:所有表示值的一个子集,包含了所有合法的表示值
    • 也可将RI看作:一个条件,描述了什么是“合法”的表示值
    • 在下图中,绿色表示的就是RI(r)为真的部分,AF只在这个子集上有定义。

  

  • 表示不变量和抽象函数都应该记录在代码中,就在代表本身的声明旁边,以下图为例 

public class CharSet {
    private String s;
    // Rep invariant:
    //   s contains no repeated characters
    // Abstraction function:
    //   AF(s) = {s[i] | 0 <= i < s.length()}
    ...
}

 

public class CharSet {
    private String s;
    // Rep invariant:
    //   s[0] <= s[1] <= ... <= s[s.length()-1]
    // Abstraction function:
    //   AF(s) = {s[i] | 0 <= i < s.length()}
    ...
}

 

public class CharSet {
    private String s;
    // Rep invariant:
    //   s.length() is even
    //   s[0] <= s[1] <= ... <= s[s.length()-1]
    // Abstraction function:
    //   AF(s) = union of {s[2i],...,s[2i+1]} for 0 <= i < s.length()/2
    ...
}

【用注释写AF和RI】

  • 在抽象类型(私有的)表示声明后写上对于抽象函数和表示不变量的注解,这是一个好的实践要求。我们在上面的例子中也是这么做的。
  • 在描述抽象函数和表示不变量的时候,注意要清晰明确:
    • 对于RI(表示不变量),仅仅宽泛的说什么区域是合法的并不够,你还应该说明是什么使得它合法/不合法。
    • 对于AF(抽象函数)来说,仅仅宽泛的说抽象域表示了什么并不够。抽象函数的作用是规定合法的表示值会如何被解释到抽象域。作为一个函数,我们应该清晰的知道从一个输入到一个输入是怎么对应的。
  • 本门课程还要求你将表示暴露的安全性注释出来。这种注释应该说明表示的每一部分,它们为什么不会发生表示暴露,特别是处理的表示的参数输入和返回部分(这也是表示暴露发生的位置)。
  • 下面是一个Tweet类的例子,它将表示不变量和抽象函数以及表示暴露的安全性注释了出来:
 1 // Immutable type representing a tweet.
 2 public class Tweet {
 3 
 4     private final String author;
 5     private final String text;
 6     private final Date timestamp;
 7 
 8     // Rep invariant:
 9     //   author is a Twitter username (a nonempty string of letters, digits, underscores)
10     //   text.length <= 140
11     // Abstraction function:
12     //   AF(author, text, timestamp) = a tweet posted by author, with content text, 
13     //                                 at time timestamp 
14     // Safety from rep exposure:
15     //   All fields are private;
16     //   author and text are Strings, so are guaranteed immutable;
17     //   timestamp is a mutable Date, so Tweet() constructor and getTimestamp() 
18     //        make defensive copies to avoid sharing the rep\'s Date object with clients.
19 
20     // Operations (specs and method bodies omitted to save space)
21     public Tweet(String author, String text, Date timestamp) { ... }
22     public String getAuthor() { ... }
23     public String getText() { ... }
24     public Date getTimestamp() { ... }
25 }

  注意到我们并没有对 timestamp 的表示不变量进行要求(除了之前说过的默认 timestamp!=null)。但是我们依然需要对timestamp 的表示暴露的安全性进行说明,因为整个类型的不变性依赖于所有的成员变量的不变性。

 

以上是关于软构学习-56-设计规约抽象数据类型(ADT)的主要内容,如果未能解决你的问题,请参考以下文章

软件构造第三章第三节 抽象数据型(ADT)

抽象数据类型(ADT)和面向对象编程(OOP)3.2规约

软构学习-4-数据类型与类型检验

20172320 2017-2018-2 《Java程序设计》第十周学习总结

软构笔记-7-面向对象的编程

2019-2020-1学期 20192426 《网络空间安全导论》第四周学习总结