Java

原文见 Josh Hug 为 Berkeley CS61B 编写的教材

Essentials

Static Typing

在 Java 中，每个变量和表达式都有一个 static type 变量可以且只可以包含该类型的值。另外，变量的类型永远不会改变。

Objects

Static Methods

Java 中的所有代码都必须是类（或类似的东西）的一部分，大部分代码都是在 methods 内部编写的。

Instance Variables and Objects Instantiation

类可以进行实例化，实例可以保存数据。注意：

Java 中的 Object 是任何类的实例；
类中自己的变量，也称实例变量或非静态变量，必须在类中声明；
在类中创建的方法没有关键词，我们将这类方法称为实例方法或非静态方法；
要调用该方法，我们必须先使用关键词 new 进行实例化；
一旦对象被实例化，就可以将其分配给适当类型的声明变量；
类的变量和方法也称为类的成员；
类 Bird 的成员使用 Bird.xxx 进行访问；

对象、数组与类等的实例化在电脑操作中表现为创建一个 64 位的指针指向实例化的地址。

Constructors in Java

我们通常使用构造函数在面向对象语言中构造对象，我们只需向类中加一个"constructor"

public class Bird {
    public int beauty;

    //constructor
    public Bird(int w) {
        beauty = b;
    }

    public void sing() {
        if (beauty < 10) {
            System.out.println("yipyipyip!");
        } else if (beauty < 30) {
            System.out.println("ye. ye.");
        } else {
            System.out.println("boooooool!");
        }
    }
}

Array Instantiation, Arrays of Objects

数组在 Java 中同样使用 new 关键词进行实例化，实例化对象的数组也是一样。

public class Array {
    public static void main(String[] args) {
        /* Create an array of five integers. */
        int [] ArrayDemo = new int[5];
        ArrayDemo[3] = 2;
        /* Create an array of two birds. */
        Bird[] birds = new Bird[2];
        Bird[0] = new Bird(9);
        Bird[1] = new Bird(28);
    }
}

Class Methods vs. Instance Methods

Java 允许我们定义两种类型的方法：

类方法，静态方法。例如：
```
x = Math.sqrt(100);
```
实例方法，非静态方法。例如：
```
Math m = new Math();
x = m.sqrt(100);
```

实例方法是只能由类的特定实例执行的操作，静态方法是类自身执行的操作。

Static Variables

静态变量应使用类的名称而不是特定实例来访问。但事实上，Java 在技术上允许通过实例名称访问静态变量。

public static void main(String[ ] args)

args 是一个用于接受命令行输入的字符串数组，它允许用户在运行程序时传递动态值，从而使 Java 应用能根据不同输入执行不同操作。

Testing

Ad Hoc Testing

JUnit Testing

org.junit 库提供了许多有用的方法与功能来简化测试的编写。

我们将 import 语句添加到文件的顶部；

import org.junit.Test;
import static org.junit.Assert.*

然后再每个检测前面加上
```
@Test
```

Intro and interfaces

The Problem

重载的缺点：

非常重复且丑陋，因为代码块几乎相同；
需要维护的代码更多；
如果我们希望添加变量类型，则需要写更多的重载函数。

Hypernyms, Hyponyms, and Interface Inheritance

接口涉及到 Java 中的关系层次，最基础的即为上位词与下位词。现在有 SLList 和 AList 两个 Java 列表类，我们希望创建一个更通用的列表类，命名为 List61B，它就是 SLList 和 AList 的上位词，也是 Java 中所说的接口 interface。我们可以注意到，此处接口的内容中实际上只指定了需要做什么，但没有给出具体的实现。

public interface List61B<Item> {
    public void addFirst(Item x);
    public void add Last(Item y);
    public Item getFirst();
    public Item getLast();
    public Item removeLast();
    public Item get(int i);
    public void insert(Item x, int position);
    public int size();
}

然后，我们还需要指定 AList 和 SLList 是 List61B 的下位词，我们使用关键词 implements。实际的含义是：保证下位词将拥有和定义上位词接口中指定的所有属性和方法。

public class SLList<Item> implements List61B<Item>

Overriding

在子类中实现接口中指定的方法时，可以在方法的顶部加入标签

@Override

Interface Inheritance

接口继承指的是子类继承超类的所有方法/行为的关系，这种继承可以是多代的。

Implementation Inheritance

上面的接口中我们没有进行任何方法的实现，倘若在接口中进行方法的实现，则为实现继承，需要包含关键词 defalut，所有实现该超类的子类都可以使用该方法。

default public void print() {
    for (int i = 0; i < size(); i += 1) {
        System.out.print(get(i) + " ");
    }
    System.out.println();
}

同时若我们在 SLList 重新实现这个方法并覆盖，那么当我们在 SLList 上调用该方法，都会调用覆盖后的方法。

@Override
public void print() {
    for (Node p = sentinel.next; p != null; p = p.next) {
        System.out.print(p.item + " ");
    }
}

总结（接口）：

所有方法必须是 public；
所有变量必须是 public static final；
无法实例化；
默认情况下，所有方法都是抽象的，除非指定为 default；
可以为每个类实现多个接口。

Extends, Casting, Higher Order Functions

Extends

如果我们想定义类之间的层次结构关系，例如我们想构建一个 RotatingSLList，它具有与 SLList 相同的功能，但有一个额外的操作 rotateRight 将最后一项带到列表的前面。因此，我们希望可以继承 SLList 中的代码，使用关键词 extends

public class RotatingSLList<Item> extends SLList<Item>

现在，extends 让我们保留了 SLList 的基础功能，并可以进行修改和添加其他功能。实际上，通过该关键词，子类将继承父类的所有成员，包括：

所有实例和静态变量
所有方法
所有嵌套类

需注意的是，构造函数不能继承，private 成员也不能由子类直接访问。但是，Java 要求所有构造函数都必须调用其超类的构造函数之一开始。

The Object Class

Java 中的每个类实际上都是 Object 类或 Object 类的子类。而 Object 类主要提供了每个 Object 都能执行的一些操作。

Encapsulation

封装是我们对抗复杂性的重要手段之一，也是模块化的重要手段。我们首先来讨论继承如何破坏封装。假设我们在 Dog 类中有两个方法如下：

public void bark() {
    System.out.println("bark");
}

public void barkMany(int N) {
    for (int i = 0; i < N; i += 1) {
        bark();
    }
}

或者我们可以这样实现：

public void bark() {
    barkMany(1);
}

public void barkMany(int N) {
    for (int i = 0; i < N; i += 1) {
        System.out.println("bark");
    }
}

从用户角度看，二者的功能是完全相同的。但倘若用户想定义一个子类并覆盖 barkMany 的方法

@Override
public void barkMany(int N) {
    System.out.println("As a dog, I say: ");
    for (int i = 0; i < N; i += 1) {
        bark();
    }
}

程序将进入无限循环。

Type Checking and Casting

强制类型转换强大却十分危险。

Higher Order Functions

高阶函数是将其他函数视为数据的函数，在 Java 中，我们可以利用接口继承来实现。

Subtype Polymorphism vs. HoFs

Subtype Polymorphism

多态性的核心意思是“多种形式”，指对象具有多种形式或类型。假设我们想编写一个 python 程序，它打印两个对象中较大的字符串表示，那么有两种方法可以解决这个问题。

显式 HoF 方法

def print_larger(x, y, compare, stringify):
 if compare(x, y):
     return stringify(x)
 return stringify(y)

亚型多态型方法

def print_larger(x, y):
 if x.largerThan(y):
     return x.str()
 return y.str()

假设我们想编写一个函数 Max，该函数接受任何数组（无论类型），并返回数组中的最大项目。这在 python 或者 C++中或许可以通过重新定义运算符的含义实现，但在 Java 中，我们的思路是创建一个接口来保证任何实现类都包含一个比较方法。

public interface OurComparable {
    public int compareTo(Object o);
}

我们这样定义实现：

如果 this < o，则返回-1；
如果 this = o，则返回 0；
如果 this > o，则返回 1。

public class Bird implements OurComparable {
    private String name;
    private int beauty;

    public Bird(String n, int b) {
        name = n;
        beauty = b;
    }

    public void sing() {
        System.out.println(name + " says: wow");
    }

    public int compareTo(Object o) {
        //需强制类型转换为Bird
        Bird littleBird = (Bird) o;
        if (this.beauty < littleBird.beauty) {
            return -1;
        } else if (this.beauty == littleBird.beauty) {
            return 0;
        }
        return 1;
    }
}

那么现在我们可以将函数推广到接受对象，并确保所有对象都实现了该方法。下面的方法返回 OurComparable 类型的对象

public static OurComparable max(OurComparable[] items) {
    int maxDex = 0;
    for (int i = 0; i < items.length; i += 1) {
        int cmp = items[i].compareTo(items[maxDex]);
        if (cmp > 0) {
            maxDex = i;
        }
    }
    return items[maxDex];
}

Libraries, Abstract Classes, Packages

Abstract Data Types (ADTS)

以上文接口部分的代码为例，我们称 List61B 为 Abstract 数据类型。因为它只附带实现而并未以任何具体方式展示这些实现。

Java Libraries

Java 中具有一些内置的 Abstract 数据类型在 Java 库中。java.util 库中有三个最重要的 ADT：

List：项的有序集合，常用实现是 ArrayList；
Set：严格唯一的项的无序集合（无重复），常用实现是 HashSet；
Map：键值对的集合，可以通过 key 访问该值，常用实现是 HashMap。

Abstract classes

抽象类可以理解成介于 interfaces 和 concrete 类之间的新类，总体来说，它可以做所有 interfaces 可以做的，甚至更多。它的特征如下：

方法可以是 public 或者 private；
可以包含任何类型的变量；
无法实例化；
默认情况下，方法是具体的，除非指定为 abstract；
每个类只能实现一个。

Packages

Autoboxing

Industrial Strength Syntax

Autoboxing and Unboxing

Java 只有 8 个基元类型，其他都是引用类型。在 Java 语法中，我们不能提供原始类型作为泛型的实际类型参数，而需要使用相应的 reference type。不过幸运的是，Java 可以在原始类型和包装类型之间进行隐式转换，即会在原始类型和相应引用类型之间"box"和"unbox"值。

Primitive

Class

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

boolean

Boolean

char

Character

但需要注意的是：

数组是永远不会自动进行 boxing 或者 unboxing 的；
box 和 unbox 会对性能产生可衡量的影响，运行速度会变慢；
包装类型使用的内存比基元类型多很多。

Widening

类似的，Java 也会在代码需要时自动短值赋长值进行加宽。

Immutability

不可变数据类型，即其实例在实例化后无法以任何可观察的方式进行改变。任何具有非私有变量的数据类型都是可变的，除非用 final 进行了声明。但需要注意的是，将引用声明为 final 并不会使引用指向的对象不可变，例如：

public final ArrayDeque<String>() deque = new ArrayDeque<String>();

变量 deque 初始化后，始终指向同一个 ArrayDeque 实例，但可以修改这个 ArrayDeque 的内容，如添加、删除和更改元素。同时使用 Reflection API 甚至可以对私有变量进行更改。

Generics

Creating Another Generic Class

package Map61B;

import java.util.List;
import java.util.ArrayList;

/***
 * An array-based implementation of Map61B.
 ***/
public class ArrayMap<K, V> implements Map61B<K, V> {

    private K[] keys;
    private V[] values;
    int size;

    public ArrayMap() {
        keys = (K[]) new Object[100];
        values = (V[]) new Object[100];
        size = 0;
    }

    /**
    * Returns the index of the key, if it exists. Otherwise returns -1.
    **/
    private int keyIndex(K key) {
        for (int i = 0; i < size; i++) {
            if (keys[i].equals(key)) {
            return i;
        }
        return -1;
    }

    public boolean containsKey(K key) {
        int index = keyIndex(key);
        return index > -1;
    }

    public void put(K key, V value) {
        int index = keyIndex(key);
        if (index == -1) {
            keys[size] = key;
            values[size] = value;
            size += 1;
        } else {
            values[index] = value;
        }
    }

    public V get(K key) {
        int index = keyIndex(key);
        return values[index];
    }

    public int size() {
        return size;
    }

    public List<K> keys() {
        List<K> keyList = new ArrayList<>();
        for (int i = 0; i == size; i++) {
            keyList.add(keys[i]);
        }
        return keyList;
    }
}

ArrayMap and Autoboxing Puzzle

Type upper bounds

在泛型中使用 extends 时，与类继承不同，此处表明的是限制与约束。

public class Box<T extends Comparable<T>> {
    //内容
}

这意味着类型 T 必须实现 Comparable 接口，即任何传递给 Box 的类型必须可以进行比较。

Lists, Sets, and ArraySet

Lists in Real Java Code

之前我们学习的是自己创建 AList 和 SLList，Java 库实际上提供了关于列表的一些内置接口和实现，我们可以使用全名进行访问：

java.util.List<Integer> L = new java.util.ArrayList<>();

也可以通过导入 Java 库的方式

import java.util.List;
import java.util.ArrayList;

public class Example {
    public static void main(String[] args) {
        List<Integer> L = new ArrayList<>();
        L.add(5);
        L.add(10);
        System.out.println(L);
    }
}

Sets

import java.util.Set;
import java.util.HashSet;

Throwing Exceptions

隐式异常会导致正常的控制流停止，我们可以使用 throw 关键词引发自己的异常，这样可以提供自己的错误消息，还可以将信息提供给程序中的错误处理代码，这样就是一个我们故意抛出的显式异常

Catching Exceptions

通过 catch 异常，我们可以防止程序崩溃，关键词 try 和 catch 会中断程序的正常流程，从而保护程序免受异常的影响。例如：

Dog d = new Dog("Lucy", "Retriever", 80);
d.becomeAngry();

try {
    d.receivePat();
} catch (Exception e) {
    System.out.println("Tried to pat: " + e);
}
System.out.println(d);

此代码的输出是

$ java ExceptionDemo
Tried to pat: java.lang.RuntimeException: grrr... snarl snarl
Lucy is a displeased Retriever weighing 80.0 standard lb units.

我们还可以使用 catch 语句来采取纠正措施

Dog d = new Dog("Lucy", "Retriever", 80);
d.becomeAngry();

try {
    d.receivePat();
} catch (Exception e) {
    System.out.println(
    "Tried to pat: " + e);
    d.eatTreat("banana");
}
d.receivePat();
System.out.println(d);

输出为：

$ java ExceptionDemo
Tried to pat: java.lang.RuntimeException: grrr... snarl snarl
Lucy munches the banana

Lucy enjoys the pat.

Lucy is a happy Retriever weighing 80.0 standard lb units.

Checked vs Unchecked Exceptions

同时，也存在一些必须处理才能通过编译器编译的异常，我们将这些称为"checked"异常，必须选中。如下图所示：

而处理它们的方式有两种：

catch
specify

// catch
public static void main(String[] args) {
    try {
        gulgate();
    } catch(IOException e) {
        System.out.println("Averted!");
    }
}

// specify
public static void main(String[] args) throws IOException {
    gulgate();
}

Iteration

Java 允许我们使用一种方便的语法（有时称为"foreach"或者"enhanced for"）来循环遍历 List，例如：

List<Integer> friends =
new ArrayList<Integer>();
friends.add(5);
friends.add(23);
friends.add(42);
for (int x : friends) {
    System.out.println(x);
}

此方法我们可以自己实现，使用迭代器，首先定义一个返回迭代器对象的方法

public Iterator<E> iterator();

然后使用它遍历列表

List<Integer> friends = new ArrayList<Integer>();
Iterator<Integer> seer = friends.iterator();

while (seer.hasNext()) {
    System.out.println(seer.next());
}

这个方法的效果与上面完全相同。

Packages

Creating a Package

将包名称放在此包中每个文件的顶部

 package jason.tinuvile.bird;

 public class Bird {
     private String name;
 }

将文件储存在具有相应文件夹名称的文件中，该文件夹的名称应该与包匹配

<your_project_root>
│
└───jason
    └───tinuvile
        └───bird
            └───Bird.java

Default packages

任何文件顶部没有明确包名的 Java 类都将被自动视为 default 包的一部分。

JAR Files

Access Control

private 私有成员只有给定类中的代码才能访问，子类、包和其他外部类都无法访问；
package private 意味着属于同一个 package 的类可以访问，但子类不可以；
protected 只有同一包和子类可以访问；
public 访问权限对所有人打开。

Encapsulation, API, ADT

封装：如果一个模块的实现是完全隐藏的，只能通过接口访问，则称该模块是封装的。
API：ADT 的 API 是构造函数和方法的列表以及每个方法的简短描述，由语法和语义规范组成。
- 编译器验证是否符合语法，即 API 中定义的内容都存在；
- 测试验证语义是否正确，即功能实现，语义规范常用英文写作；
ADT

PreviousCheckpoint0: networking warmup NextData Structure

Last updated 10 months ago

hashtagEssentials

hashtagStatic Typing

hashtagObjects

hashtagStatic Methods

hashtagInstance Variables and Objects Instantiation

hashtagConstructors in Java

hashtagArray Instantiation, Arrays of Objects

hashtagClass Methods vs. Instance Methods

hashtagStatic Variables

hashtagpublic static void main(String[ ] args)

hashtagTesting

hashtagAd Hoc Testing

hashtagJUnit Testing

hashtagIntro and interfaces

hashtagThe Problem

hashtagHypernyms, Hyponyms, and Interface Inheritance

hashtagOverriding

hashtagInterface Inheritance

hashtagImplementation Inheritance

hashtagExtends, Casting, Higher Order Functions

hashtagExtends

hashtagThe Object Class

hashtagEncapsulation

hashtagType Checking and Casting

hashtagHigher Order Functions

hashtagSubtype Polymorphism vs. HoFs

hashtagSubtype Polymorphism

hashtagLibraries, Abstract Classes, Packages

hashtagAbstract Data Types (ADTS)

hashtagJava Libraries

hashtagAbstract classes

hashtagPackages

hashtagAutoboxing

hashtagIndustrial Strength Syntax

hashtagAutoboxing and Unboxing

hashtagWidening

hashtagImmutability

hashtagGenerics

hashtagCreating Another Generic Class

hashtagArrayMap and Autoboxing Puzzle

hashtagType upper bounds

hashtagLists, Sets, and ArraySet

hashtagLists in Real Java Code

hashtagSets

hashtagThrowing Exceptions

hashtagCatching Exceptions

hashtagChecked vs Unchecked Exceptions

hashtagIteration

hashtagPackages

hashtagCreating a Package

hashtagDefault packages

hashtagJAR Files

hashtagAccess Control

hashtagEncapsulation, API, ADT

Essentials

Static Typing

Objects

Static Methods

Instance Variables and Objects Instantiation

Constructors in Java

Array Instantiation, Arrays of Objects

Class Methods vs. Instance Methods

Static Variables

public static void main(String[ ] args)

Testing

Ad Hoc Testing

JUnit Testing

Intro and interfaces

The Problem

Hypernyms, Hyponyms, and Interface Inheritance

Overriding

Interface Inheritance

Implementation Inheritance

Extends, Casting, Higher Order Functions

Extends

The Object Class

Encapsulation

Type Checking and Casting

Higher Order Functions

Subtype Polymorphism vs. HoFs

Subtype Polymorphism

Libraries, Abstract Classes, Packages

Abstract Data Types (ADTS)

Java Libraries

Abstract classes

Packages

Autoboxing

Industrial Strength Syntax

Autoboxing and Unboxing

Widening

Immutability

Generics

Creating Another Generic Class

ArrayMap and Autoboxing Puzzle

Type upper bounds

Lists, Sets, and ArraySet

Lists in Real Java Code

Sets

Throwing Exceptions

Catching Exceptions

Checked vs Unchecked Exceptions

Iteration

Packages

Creating a Package

Default packages

JAR Files

Access Control

Encapsulation, API, ADT