Java 基础

基础编程模型

我们把描述和实现算法所用到的语言特性、软件库、和操作系统特性总称为基础编程模型。

Java程序的基本结构

一段 Java 程序或者是一个静态方法库，或者定义了一个数据类型。
要创建静态方法库和定义数据类型，会用到下面七种语法：

语法	解释
原始数据类型	整数、浮点数和布尔值等；它们的定义包括取值范围和能够对相应的值进行的操作，能够被组合为类似于数学公式定义的表达式
语句	六种语句：声明、赋值、条件、循环、调用和返回
数组	多个同种数据类型的值的集合
方法	方法可以封装并重用代码，使我们可以用独立的模块开发程序
字符串	字符串是一连串的字符，Java内置了对它们的一些操作
标准输入/输出	程序与外界联系的桥梁
数据抽象	封装和重用代码，使我们可以定义非原始数据类型

运行 Java 程序需要和操作系统或开发环境打交道。我们把这种输入命令执行程序的环境称为虚拟终端。

编译 Java程序：

javac className.java

运行 Java 程序：

java className filename

原始数据类型与表达式

数据类型就是一组数据和对其所能进行的操作的集合。只要能够指定值域和在此值域上的操作，就能定义一个数据类型。

Java 使用的是中缀表达式，我们在代码用应该尽量使用括号来消除表达式对于优先级规则的依赖。

• 基础编程模型未完，感觉有点简单，不想写了。

数据抽象

定义和使用数据类型的过程被称为数据抽象。

抽象数据类型是一种能够对使用者隐藏数据表示的数据类型。用 Java 类来实现抽象数据类型和用一组静态方法实现一个函数库并没有什么不同。抽象数据类型的主要不同之处在于他将数据和函数的实现关联，并将数据的表示方式隐藏起来。

###使用抽象数据类型
要使用一种数据类型并不一定非得知道它是如何实现的。

抽象数据类型的API

我们使用应用程序编程接口(API)来说明抽象数据类型的行为。它将列出所有构造函数和实例方法并简要描述它们的功用。(构造函数可有多个，以不同的参数来区分)
尽管数据类型定义的基础是一组值的集合，但在 API 可见的仅是对它们的操作，而非它们的意义。

继承方法

任意数据类型都可以从 Java 的内在机制中继承方法。
例如，Java 中的所有数据类型都会继承 toString() 方法来返回用 String 表示的该类型的值。（Java 会在用 + 运算符将任意数据类型的值和 String 值连接时调用该方法）但该方法并不实用，它会返回用字符串表示的该数据类型值的内存地址，因此，我们往往在类中提供该方法的实现以重载默认实现。此类方法的例子还有：equals()、compareTo() 和 hashCode()。

对象

对象是能够承载数据类型的值的实体。
所有的对象都有三大重要特性：状态、标识和行为。

接口继承

• 接口继承的概念，待完成

在某些情况下 Java 的习惯用法鼓励我们使用接口：我们用它们进行比较和迭代，如下表所示：

	接口	方法
比较	java.lang.Comparable java.util.Comparator	compareTo() compare()
迭代	java.lang.Iterable	iterator()
迭代	java.util.Iterator	hasNext() next() remove()

java.lang.Comparable

1. 如果想要自定义类有比较功能，那就要实现 Comparable 接口，并重载 compareTo(T o) : int 方法。
2. 其升降序策略与原始数据类型相同。举例，现对int[]排序，sort() 方法依赖的是 compare() 方法。（对自定义类型排序，sort() 方法默认使用 compareTo() 方法）

		compare(int x, int y)
		{
 	     	    if (x < y) return -1;
 	     	    if (x > y) return +1;
		}

按照上述 compare() 方法的逻辑，排序后的 int[] 是升序。所以我们重载的compareTo() 方法的逻辑与上述compare() 方法相同，则排序后的自定义数据类型为升序，否则为降序。

示例：

public class Date implements Comparable<Date>
{
    private final int day;
    private final int month;
    private final int year;
    
    public Date(int d, int m, int y){}
    ...
    ...
    ...
    // 排序后为升序，this 类比为 X，that 类比为 y。
    public int compareTo(Date that) {
        if (this.year > that.year) return +1;
        if (this.year < that.year) return -1;
        if (this.month > that.month) return +1;
        if (this.month < that.month) return -1;
        if (this.day > that.day) return +1;
        if (this.day < that.day) return -1;
        return 0;
    }
}

java.util.Comparator

1. Comparator 适合于对不宜重写 compareTo() 方法的类做瞬时的排序扩展。这一功能是十分有必要的，试想，有一群学生，我们需要对其按学号、身高、体重排序，compareTo() 方法只能解决一种排序，此时我们就需要构建比较器来扩展 sort() 方法的功能。
2. 具体扩展方式是重写 Comparator 接口里的 compare() 函数。
3. 只要将 Comparator 对象传递给 sort 方法（如 Collections.sort 或 Arrays.sort），就可以扩展 sort 的功能。

构建比较器示例：

public Comparator<Point> slopeOrder() 
{
    /* YOUR CODE HERE */
    return new SlopeOrder();
}
private class SlopeOrder implements Comparator<Point>
{
    public int compare(Point p1,Point p2){
        double p1Slope = slopeTo(p1);
        double p2Slope = slopeTo(p2);

        if(Double.compare(p1Slope, p2Slope) == 0) return 0;
        else if (Double.compare(p1Slope, p2Slope) < 0) return -1;
        else return 1;
}
...
Arrays.sort(points, aux[i].slopeOrder());

将得到的比较器 new SlopeOrder() 传递给 sort() 方法，扩展 sort 的功能。后面会结合具体实例分析 Comparator 的功能。

java.lang.Iterable & java.util.Iterator

示例：

public class Deque<Item> implements Iterable<Item>
{
...
public Iterator<Item> iterator() { return new ListIterator(); }
...
private class ListIterator implements Iterator<Item>
{
    private Node current = first;
    public boolean hasNext() { return current != null; }
    public Item next()
    {
        if (current == null) throw new java.util.NoSuchElementException("there are no more items to return");
        Item item = current.item;
        current = current.right;
        return item;
    }
}

在本示例中，Deque 类型实现了可迭代 implements Iterable<item> 。即可以使用以下语句迭代输出 collection 中的元素。

Deque<String> collection = new Deque<String>;
...
for (String s : collection)
	StdOut.println(s);
...	

要实现类型可迭代，我们要在类中添加一个方法 iterator() 并返回一个迭代器Iterator 。迭代器是什么？它是一个实现了 hasNext() 和 next() 方法的类的对象，由以下接口定义：

public interface Iterator<Item>
{
	boolean hasNext();
	Item next();
	void remove();
}

在本节开头的示例代码中，我们将这些方法实现在 Deque 类的一个嵌套类中。完成以上内容，Deque 就成为了一个可迭代类型。

泛型

集合类的抽象数据类型的一个关键特性是我们应该可以用它们存储任意类型的数据，一种 Java 机制能做到这一点，它 被称为泛型，也叫做参数化类型。类名后的 <item> 记号将 Item 定义为一个类型参数，它是一个象征性的占位符，表示的是用例将会使用的某种具体数据类型。可以将 Stack<Item> 理解为某种元素的栈。

示例：

public class Stack<Item> implements Iterable<Item>
{
	private Item[] a = (Item[]) new object[1];
}

• Java基础部分先写这么多，以后学习官方文档的过程中，有值得做笔记的知识的话，会再补充。