Java 05

/* video 12 */

Enumeration 枚举 （ 想象成组合在一起的项 )

public static final int ONE = 1;  //  java 一般用以前的方式，就是这种，而不是新的枚举类型
switch (num) {
    case ONE: println("one"); break;
} 使用这种方法
在 Java 5 版本里，有了 enum 类型，但是还是使用之前的方式最多
public enum WeekDAY { SUN, MON, TUE, WED, THU, FRI, STA };

char -- character
char ch = 'a'; 必须用单引号 只能放单个字符，对于计算机来说，char 类型只不过是枚举，象以上的定义，比如 public static final char a = 1;
ASCII 对应了转换( 标准枚举 )
\ 比较特殊，可以不是单个字符
char ch = S.charAt(0) ; 读 字符串 S 中的第一个字符
因为字符顺序已经定下来了。所以可以做数值运算 if ( ch>= 'A' && ch <= 'Z' ) 得到的就是大写字母，因为顺序
return ( ch-'A') + 'a'); 将大写字母转换成小写， 首先 ch - 'A' 是找到位序, 'a' + 位序就是对应的小写字母。
还可以用来记数，
for ( char ch='A'; ch <='Z'; ch++)

String
string str = readLine(); “hello” 这个是字符串常量，不能修改
对比 string , char

char                               string
标量类型                            类
字符可以自己转换成大写字母

str.toUpperstring(); 因为在 java 中，字符串不能改变所以，必须写成 str = str.toUpperCase(); 这样将 str 转换成大写 说白了是创建了一个新的 str
不可以判断 if ( str1 == str2 ) , 因为 例如: str1 = "Hello" , str2 = "Hello" , 虽然，都是 Hello, 但是它们在内存中却是存在于两个内存地址中，所以判断 str1== str2,

因为这两个都是指针，所以，肯定不相等。 假设, 虽然程序中很少有人这么用   ， String str1, str2 ;   str1 = str2 = "Hello";  这个时候因为 str1 和 str2 指向的是同一块内存，所以，

就可以使用 if ( str1 == str2 ) , 并且 str1 也确实等于 str2. ( 还是想内存结构 )
用类方法 if ( str1.equals(str2) ) {
for (int i=0; i<str.length(); i++) {    // 将字符串转换成大写字母
    char ch = str.charAt(i);
    result += character.toUpper(ch);
}

/* video 14 */
内存地址是16进制数 例如 : A000

static variables / constant ( 特殊地方存储 )
dynamic variables ( new , 堆 )
local variables ( stack 栈 )

分层
1. 特殊内存
2. 堆 （ 向下 )
3. 栈 ( 向上 ）
如果栈和堆的分配空间重合了，那么程序就费了 （ 待作图 )

堆和栈中的内存都在 动态的增加或减少，如果都增加到，在内存中 堆和栈的内存重合了，那么程序就崩溃了。

/* video 15 */

函数传递时，如果传递的是实例变量，比如 Point p = new Point(1,1); 然后将这个 p 传递给了一个函数，其实，传递的就是指针，该指针指向堆内存，所以，
此函数传递，跟 C 中的指针传递具有同样效果，那就是在函数内部更改的东西，在函数外部同样有效。但是，其实 它也是在传递值，只不过这个值是个间接的内存地址。
基本类型    类类型
int         Integer
double      Double
...

FILES
import java.io.*;
1. OPEN
    object->file
2. reading file
    line by line
3. close

EXCEPTION
例如 读取一个档案时，如果突然档案被别人删除了。那么这就是个 异常
throw 如果没有捕获异常，程序结束
try {
    code for file access. // 上边的例子, 引发异常后，后边的代码就不会被执行，而是到 catch 段执行
} catch ( IOException ex ) {
    deal with exception
}

private BufferReader ( String prompt ) {
    BufferReader rd = null;
    while ( rd == null ) {
        try {
            string name = readline( prompt );
            rd = new BufferReader( name );
        } catch ( IOException ex ) {
            println("bad time");
        }
    }
    return rd;
}

危险操作使用 try , 使用的越少越好
reading file 就很危险，因为如果此时删除了该文档，就费了。
throw new ErrorException(ex); 将该异常再次抛出

/* video 16 */

数组
- ordered
- 同一类型
定义
int[] myArr = new int[5];
默认都被初始化了

数组的初始化:

1. 直接初始化, int[] arr = {1, 2, 3, 4, 5};

2. 通过 for 循环来一个一个的赋值
myArr[0] 引用第一个元素
GOval[] circles = new GOval[4];    // 只是分配了数组空间用来存放引用-指针，但是，只是个位置，里边指针的具体指向还没有分配空间。所以里边存储的内容是 null
cicle[0] = new GOval(0, 0, 100, 100); 这样，就分配了堆存储空间，并将数组内的指针指向正确的位置。
数组的有效尺寸和实际尺寸，实际尺寸是声明时数组的长度，而有效尺寸是指实际使用情况。
动态尺寸数组 数组.length 这个长度是声明长度，有效常数不知道

int[] arr = {2, 4, 6, 8    };

ArrayList 数组表,  ( template )
import java.util.*;

ArrayList<String> strlist = new ArrayList<String>();
strlist 调用无参数的构造函数。构造函数名字 ArrayList<String>

ArrayList 是java实现链表的一个很好的工具.

ArrayList<T> tlist = new ArrayList<T>(); 符号 <T> 是类型参数, 称为模板或参数化类.

String line = "hello";
strList.add(line);    //动态增加
strList.add("there");    // 第2个元素就会存储 there
strList.size();    // 有效长度
strList.get(i);    // i index 的 string

double[] scores = new double[N-JUDGES] 内存结构

由图可知, scores 是栈变量, 里边存放的是堆内存地址, 而每个数组元素存放在堆中

Student[] topStudents = new Student[5];

topStudents[0] = new Student(“Hermione Granger” 314159);

可以看到每个数组元素里也存放的是该元素的首地址, 有点类似指针数组, 或二级指针。

<T>表示的类型模板, 实际是什么类型, 就是什么类型.