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才是相等的

posted @ 2019-06-24 01:22  舒羽倾  阅读(188)  评论(0编辑  收藏  举报