SC || Chapter 3

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

基本数据类型 && 对象数据类型

基本数据类型（int char long） 在栈中分配内存，不可变

对象数据类型（String BigInteger） 在堆中分配内存，有些可变有些不可变

    String a = "a";
    String b = "a";
    System.out.println(a == b); // true

    String a = "a";
    String b = new String("a");
    System.out.println(a == b); // false

    String a = "a";
    String b = new String("a");
    System.out.println(a.equals(b)); // true

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

【快照图 snapshot diagram】

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

静态类型语言：编译时检查（编译器自动报的错）——语法错误 函数参数错误 final变量被更改【类型相关】

动态类型语言：运行时检查 ——非法的参数值（如除0） 非法的返回值 空指针 【值相关】

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

final关键字：

final类：无法产生子类

final变量：无法改变值/引用

final方法：无法被子类重写

必须显式的初始化一次（在if和try啥的里初始化都布星）

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

mutable && immutable

防御性拷贝

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

spec

一个完整的方法 == 规约spec + 实现implementation

spec由以下构成：如果前置条件满足了，后置条件必须满足，如果不满足则抛出异常

　　·前置条件（precondition）

　　·后置条件（postcondition）

　　·异常行为（exception）

规约的强度：

如果规约的强度 S2>=S1，就可以用S2代替S1，一个更强的规约包括更轻松的前置条件和更严格的后置条件；越强的规约，意味着实现者(implementor)的自由度和责任越重，而客户(client)的责任越轻。

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

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

行为等价性：站在客户的角度看两个方法是否可以互换

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

抽象数据类型（ADT）

Creator（构造器）：Integer.valueOf( )

Producer（生产器）：String.concat( ) -- 接受同类型

Observer（观察器）：List.size( )

Mutator（变值器）：List.add( )

区分：

谢谢小姐姐QWQ

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

表示独立性：用户使用ADT时无需考虑内部实现，ADT内部的变化不应影响外部spec和客户端

　　　　（感觉是改ADT内部的代码 不影响用户方的情况）

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

不变量（Invariants）与表示泄露

get返回值的时候

以及创建的时候都会出现

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

24个date指向了同一时刻

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

抽象函数（AF）表示不变量（RI）

AF：计算机中数据到现实含义的映射

RI：数据是否合法，通过RI设计checkRep，计算机中数据到boolean的映射

rep：

用注释表示

// Immutable type representing a tweet.
public class Tweet {

    private final String author;
    private final String text;
    private final Date timestamp;

    // Rep invariant:
    //   author is a Twitter username (a nonempty string of letters, digits, underscores)
    //   text.length <= 140
    // Abstraction function:
    //   AF(author, text, timestamp) = a tweet posted by author, with content text,
    //                                 at time timestamp
    // Safety from rep exposure:
    //   All fields are private;
    //   author and text are Strings, so are guaranteed immutable;
    //   timestamp is a mutable Date, so Tweet() constructor and getTimestamp()
    //        make defensive copies to avoid sharing the rep's Date object with clients.

    // Operations (specs and method bodies omitted to save space)
    public Tweet(String author, String text, Date timestamp) { ... }
    public String getAuthor() { ... }
    public String getText() { ... }
    public Date getTimestamp() { ... }
}

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉

【对象】 状态（fields）+ 行为（method）

【类】一类对象的状态 + 行为

类成员变量(class variable)又叫静态变量；类方法(class method)又叫静态方法

实例变量(instance variable)和实例方法(instance method)是不用static形容的实例和方法

类方法和实例方法的区别：类方法不能访问实例变量和实例方法

类创建第一个对象时，实例方法才分配入口地址，再创建其他对象时不再分配了，也就是说，方法的入口地址被所有对象共享

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉

【接口】interface -> implements

一个接口可以扩展其他接口，一个类可以实现多个接口；一个接口也可以有多重实现

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

举例：（静态检查使用接口类型时，只使用接口中定义的方法）

若类A实现了接口B 如果在客户端里的一个实例b的类型是B 就算它的真正类别是A  ->  B b = new A();

也不能使用A中定义了但B中没有定义的方法

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉

【抽象类】abstract - 父类知道有这个功能，但父类不知道怎么写，要写多少个功能适合，所以交给子类写

抽象类不能实例化对象，必须被继承才能被使用

单继承，多接口

如果一个类包含抽象方法，那它一定是抽象类

任何子类必须重写父类的抽象方法，或将自身定义为抽象类

构造方法、static方法不能是抽象方法

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉

【继承和重写】

重写——返回值和形参都不变，子类可以根据自己的需要实现父类的方法

重写不能抛出新的异常

访问权限不能比父类低，如父类是private，子类不能是protected

父类的成员方法只能被子类重写

final方法不能重写，也不能继承

static方法不能重写，但能再次声明

构造方法不能重写

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉

【多态与重载】

多态——同一行为的不同表现形式

重载的方法参数列表必须不同，返回值可以都不同，可以改变访问修饰符，可以声明新的异常

在编译时根据参数列表选择用哪个重载版本

public class Pair<E> {
    private final E first, second;
    public Pair(E first, E second) {
        this.first = first;
        this.second = second;
    }
    public E first() {
        return first;
    }
    public E second() {
    return second;
    }
}
Client:
Pair<String> p = new Pair<>("Hello", "world");
String result = p.first();

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉

重载 && 重写

搬截图QWQ 谢谢大佬

理解：方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉

【泛型】

泛型方法可以接受不同类型的参数

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉ ┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉

【等价性】 -> "==" || equals()

equals判定为相同， hashCode一定相同。equals判定为不同，hashCode不一定不同

equals中要考虑 类.equals(Object)的情况，直接比会调用Object中的equals，所以在类中重写equals时要判一下参数的类型，然后强转

重载equals一定要重载hashCode，必须重载equals(Object object)

可变类不应重载equals和hashCode

┉┉∞ ∞┉┉┉┉∞ ∞┉┉┉∞ ∞┉┉┉

可变类型的等价性 -> 观察等价性 行为等价性

注：当用可变类型作为集合的元素时，改变类型值时会改变hashCode，使得contains出问题

因此对于可变类型，实现行为等价性，只有指向相同空间的Object才是相等的