CoreJava基础部分

Java 的配置：
JAVA_HOME 指向JDK的安装目录(可以使用软连接)
PATH 要包含JDK的bin目录
CLASSPATH 可以简单的使用"."

一个Linux 实例：
JAVA_HOME=$HOME/java
PATH=$JAVA_HOME/bin:$PATH
CLASSPATH=.
export JAVA_HOME PATH CLASSPATH

使用source 测试profile 脚本
source .bash_profile

使用命令测试是否成功：
java -version  (应该是1.5的)
mv
cd

经验是需要通过实践(训练)来获得!

编译Java源文件, 生成.class 字节码文件
工具：javac
javac -d 目标目录 filename.java
如： javac -d bin HelloWorld.java
这个命令把HelloWorld.java编译成.class
输出到bin文件夹中，在文件夹bin中还生成包

执行Java 类文件。
进入bin目录。执行:java day01.HelloWorld

包名.类名：全限定名

java 包名.类名
Java类的执行过程：Java会利用CLASSPATH搜索
类(全限定名)，找到类对应的类文件，
加载并执行。

CLASSPATH是Java类的搜索路径


package day01;
public class HelloWorld{
  public static void main(String[] args){
    System.out.println("Hello World!");
  }
}
编译： javac -d bin HelloWorld.java
运行:  cd bin
       java day01.HelloWorld
       cd ..
       export CLASSPATH=.:$HOME/sd1009/bin
       java day01.HelloWorld

jar: Java发布包管理。
jar -cvf jarfile.jar package1 package2...
jar -xvf jarfile.jar

Java可以搜索CLASSPATH上配置的jar文件内容

打包实验
cd bin
jar -cf ../demo.jar day01
cd
export CLASSPATH=.:$HOME/sd1009/demo.jar
java day01.HelloWorld

解包实验，找到rt.jar, 释放开，找到里面的
String.class 文件，在包：java.lang中。

mkdir rt
cd rt
jar -xf $JAVA_HOME/jre/lib/rt.jar
cd java/lang
ls | String.class

Java 注释，是被Javac忽略的部分
经常用来为添加对代码的解释，提高软件的
可读性。还可以取消代码的功能。

1 多行注释 /* ... */
2 单行注释 //...
3 文档注释 /** ... */

可以使用javadoc导出java源代码中的文档注释
，生成Javadoc手册。（简单掌握）
javadoc -d doc String.java

二进制基础

192(10)-> 11000000(2)

128 64 32 16 8 4 2 1 
1    1  0  0 0 0 0 0

计算机处理二进制：采用Byte为单位！
1Byte = 8bit
1(10) -> 00000001

16进制(0~9a~f)
41(16) -> 4*16^1 + 1*16^0 = 65(10)
0100 0001(2)=65(10)
4     1 (16)

16进制是二进制的简写形式！

数字式计算机只认识二进制数字！
16进制是为了方便人类简写二进制提供的
一种编码方案！

中（4e2d）
0100 1110 0010 1101

二进制补码
计算机内部只有二进制补码是数字！
正数的补码就是这个数本身
负数的补码是这个数取反加一
最高位是符号位，0表示正数，1表示负数
二进制补码 可以保证符号位参与运算，
并且保证结果是正确的。

byte:-65(10)-> bf(16)

65(10)-> 0100 0001(2)-> 41(16)
-65(10)-> -100 0001(2)->1011 1111(2)->bf(16)
-1(10)-> - 000 0001(2)->1111 1111(2)->ff

8位补码：
1111 1111(2补)-> - 000 0001(2)=-1
0111 1111 MAX 127 7f
1000 0000 MIN -128 80

16位补码表示
-1：ffff
MAX: 7fff;
MIN: 8000;

32位补码表示
-1：ffffffff
MAX: 7fffffff;
MIN: 80000000;

-97(10)-> - 110 0001(2)
       -> 1001 1111(2补)
       -> 9f(16)
96(10)->0110 0000(2)

  96        01100000
-97        10011111
-----------------------------------
            11111111

  -97        10011111
X  -1        11111111
------------------------------------
             10011111             
            10011111              
           10011111      
          10011111       
         10011111        
        10011111         
       10011111          
      10011111      
------------------------------------
             01100001 -> 97         

package day02;

public class BinDemo{
  public static void main(String[] args){
    int a = (byte)0xbf ;//1011 1111
    System.out.println(a);//-65
  }
}

运算符

数学运算符
1 封闭性：同种数据类型参与运算，
        得到同种类型的结果
2 比int类型小的数据类型运算，
  实际上是int类型运算。
3 常量运算是被Javac优化的运算，
  相当于运算以后的字面量。
4 四则运算有溢出风险，
  Java不对溢出进行检查

    byte b = 5;
    byte c = 6;
    byte e = 5+6;//被Javac优化为11
    //byte d = b+c;//错，实际上是int运算
    //byte d = (byte)b+c;//错
    byte d = (byte)(b+c); //对
    System.out.println(e);
    System.out.println(d);
    int x = 1024*1024*1024*2;//上溢出
    long l = 1024*1024*1024*2;//上溢
    //long j = 1024*1024*1024*2*2L;//上溢
    long j = 1024L*1024*1024*2*2;//正确
    System.out.println(x);
    System.out.println(l);
    System.out.println(j);
    int g = 3/2;//1,下溢出，舍掉余数，整除
    double f = 3D/2;//1.5


% 求余数，取模运算
取余运算是周期函数
y=f(x)= x%5
x:0 1 2 3 4 5 6 7 8 9 10 11 12 ... n
y:0 1 2 3 4 0 1 2 3 4 0  1  2  ...

//逻辑运算
int age = 18;
char sex = '男';
boolean isChild = age<16;//false
boolean isMan = sex=='男';
boolean isBoy = isChild && isMan;
boolean isGirl = isChild && ! isMan;
boolean isChilden = isBoy || isGirl;

if(isBoy){
  System.out.println("你好，小伙子！");
}

位运算
取反运算
int i = -1;
int j = ~i;//0
i = 0x7fffffff;
i = ~i;//0x80000000

按位与
1&1->1, 0&1->0, 0&1->0, 0&0->0
掩码运算
int mask = 0xf;//   0x0000000f
int c = '中'; //    0x00004e2d;
int l = c & mask;// 0x0000000d;

或运算
1|1-> 1, 0|1->1, 0|1->1, 0|0->0

把中国两个字拼成一个int数据
再拆开
int c1 = 0x4e2d0000;//  0x4e2d0000
int c2 = '国';//        0x0000xxxx
int c3 = c1 | c2;//     0x4e2dxxxx
int mask = 0x0000ffff;
char cx = (char)(c3 & mask);


移位
>> 有符号移位，相当于数学除法,
高位:正数补0，负数补1，保证符号位不变
如: -2 >> 1 结果是 -1，相当于数学 -2/2
-2:11111111 11111111 11111111 11111110
-2 移位以后，高位补1：
-1:111111111 11111111 11111111 1111111

<< 数学乘法 每次乘2
给定n 产生n位的掩码
n=4;
mask = ~(-1<<n);

>>> 无符号右移， 高位永远补0
比较如下表达式：
-1>>>1 -> 0x8fffffff,
-1>>1 -> 0xffffffff,
1>>1 -> 0x00000000

++, --
先++(++a):先将a加1，然后a的值作为整个
          表达式的值。
后++(a++):先将a的值作为整个表达式的值
          然后再将a加1。
int a = 1;
int b = a++;
int c = ++a;
a=a++;
a=++a;

int i = 0;
int x = i++%5;
x = i++%5;
x = i++%5;
x = i++%5;
x = i++%5;
x = i++%5;
x = i++%5;
x = i++%5;
x = i++%5;

条件运算符: ? ：
String msg = isBoy ? "小伙子" : "小姑娘";
计算查询结果显示页数的实例：
int rows = 31;//查询结果数量
int size = 15;//每页数量
int pages =
  rows%size==0 ? rows/size : rows/size+1;

运算符的优先级
运算符的结合型
int a = b+c+d;
int a = b = c = 1;
int a=3;
int b = 2 + (a+=5);

作业：
1 把ABCD字符拼成一个int类型数据
  然后再拆开
2 实现华氏度到摄氏度的转换：

提示：
Scanner console =
  new Scanner(System.in);
int val = console.nextInt(); //读取温度
String t = console.next(); //读取温度类型
char c = t.charAt(0);//获得温度类型的字符
if(c == 'f'){//比较稳定类型

}
double d = 1.78;
int x = (int)(d+0.5)//四舍五入

选择流程控制
1 尽量减少使用否定条件作为条件表达式
2 尽量减少使用else
3 尽量减少嵌套使用！

判断某一天是否有航班（if  位运算）
3
byte 00010101
byte 00001000

for循环
练习：
  从控制台读取数字字符串，转换为整数
  如："23765" -> 23765
提示：
for(int i=0; i<str.length(); i++){
  //每个字符
  char c = str.charAt(i);
  int n = c - '0';
  sum = sum*10 + n;
}

while循环
实例：
输出一个整数的二进制字符串
如：0x15 -> "10101"
提示：
int a = console.nextInt();
int mask = 1;
String s = "";
int last = a & mask;
s = last + s;
a>>>=1; //a = a>>>1;
last = a & mask;
s = last + s;
a>>>=1;
last = a & mask;
s = last + s;
a>>>=1;
//a==0 结束
//...

do ... while 循环
实例：
  整数转十六进制字符串
如：20013 -> 4e2d
提示：
do{
  last>9
  last -> 'a'~'f'; 'a' + (last-10)
}while(num != 0);

调试：
1 利用输出语句输出软件的状态（数据）
2 运行软件，把输出的状态和理想数据比较
  找出问题所在。

void listFiles(String path){
  //循环当前目录内容{
    //如果当前项目是目录
    //  再列出这个目录内容listFiles(目录)
  //}
}

数组：

int score1 = console.nextInt();
int score2 = console.nextInt();
int score3 = console.nextInt();
int score4 = console.nextInt();
int score5 = console.nextInt();
//...

int[] score = new int[100];
for(int i=0; i<score.length; i++){
  score[i]=console.nextInt();
}

1 数组长度固定，元素类型相同
2 数组声明：
  int[] ary;//推荐使用
  int ary[];//不建议使用！符合C程序员的习惯
3 初始化：
  int[] ary = {1,3,3,'1'};//{}静态初始化
  直接使用{} 只能在初始化时候使用,
  不能作为赋值语句出现
  int[] ary = new int[]{1,2,4};//动态初始化

  //ary = {2,4}; //错，{}不能作为赋值语句
  ary = new int[]{2,4};//对

  数组初始化必须明确长度！
  int[] ary = new ary[100];
  //int[] ary = new ary[];//错误
  int[] ary = {};//对，0长度
  int[] ary = new int[0];//对，0长度
 
  数组元素默认自动初始化，初始化为“零”值
  “零”值：
  int, long, byte, short, float, double->0
  char -> '\u0000' ==0
  boolean -> false
  引用类型 -> null
 
  int[] ary = new ary[10];
  System.out.println(ary[3]);//0 //对
 
  int[] ary = new ary[4];
  ary[3]=1;
  ary[2]=2;
  //ary[4]=5; //错误，运行时候，越界
  int[] a2 = ary;
  System.out.println(a2[0]);
 
4 如果访问超过数组下标范围，
  运行时会出现数组越界错误

5 数组变量的赋值，是引用地址的复制，
  赋值结果是两个变量引用同一数组对象实例
  int[] a2 = ary;
  
6 如果需要复制一个数组实例，需要如下
  int[] ary = {1,2,4,5};
  int[] ary1 = new int[ary.length];
  for(int i=0; i<ary.length; i++){
    ary1[i] = ary[i];
  }
  ary1 就是 ary的副本了！
 
  Java 提供了数组复制到方法System.arraycopy();
  int[] ary = {1,2,4,5};
  int[] ary1 = new int[ary.length];
  System.arraycopy(ary, 0, ary1, 0, ary.length);

二维数组
初始化：
  int[][] ary = new int[2][3];
  int[] ary1 = ary[0];
  静态初始化
  int[][] ary = {{1,2},{3,4,5},{4,5,6,8}};
  初始化同时指定元素
  int[][] ary = new int[][]{{1,2},{3,4,5},{4,5,6,8}};
  只指定第一维的长度
  int[][] ary = new int[2][];
  ary[0] = new int[5];
  ary[1] = new int[2];

数组实例：
1 EAN-13码的检查码的算法 ，例如假设一EAN-13码各码代号如下：
N1 N2 N3 N4 N5 N6 N7 N8 N9 N10 N11 N12 C
　　检查码之计算步骤如下：
　　C1 = N1+ N3+N5+N7+N9+N11
    C2 = (N2+N4+N6+N8+N10+N12)× 3
　　CC = (C1+C2)　取个位数
　　C (检查码) = 10 - CC　(若值为10，则取0)

2 身份证第18位计算法
   身份证第18位（校验码）的计算方法 

　　1、将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2。
　　2、将这17位数字和系数相乘的结果相加。
　　3、用加出来和除以11，看余数是多少？
　　4、余数只可能有0－1－2－3－4－5－6－7－8－9－10这11个数字。其分别对应的最后一位身份证的号码为1－0－X－9－8－7－6－5－4－3－2。
5、通过上面得知如果余数是2，就会在身份证的第18位数字上出现罗马数字的Ⅹ。如果余数是10，身份证的最后一位号码就是2。
　　例如：某男性的身份证号码是34052419800101001X。我们要看看这个身份证是不是合法的身份证。
　　首先我们得出前17位的乘积和是189，然后用189除以11得出的结果是17+2/11，也就是说其余数是2。最后通过对应规则就可以知道余数2对应的数字是x。所以，可以判定这是一个合格的身份证号码。

3 实现文字的竖排

排序：
1 选择排序：通过n-1轮比较，每轮找到一个最小的放到前面。

2 冒泡排序：每次比较相邻的元素，如果前一个大交换，每轮比较会把最大的交换到最后，完成一个最大的排序。经过n-1轮比较排序完毕。冒泡就是比喻每次有一个大数飘到最后。

插入式排序：把后半部的每个元素插入到前
  半部已经排序的序列中。

eclipse：日食、月食

www.eclipse.org

Eclipse 是用Java开发。不是纯Java开发
图形界面使用SWT 包含一定的C代码，不是绝对
的跨平台的。
SWT 提供了几乎全部的主流平台的支持
Eclipse可以在所有主流平台(OS)上运行
下载要注意平台(OS)版本

下载：Java 开发版本。

Eclipse就是一个压缩包。释放就可以
Linux 安装实例：
tar -xzf /opt/eclipse-SDK-3.2.2-linux-gtk.tar.gz
./eclipse/eclipse

Eclipse 中的概念：
  workspace: 一个项目默认保存目录
    默认： /home/soft01/workspace
  Project: 代表一个软件工程

类：逻辑上用来描述具体实体概念的。
如：图书馆中的书，一卡通
具体概念（类）是一个系统所管理的事务的抽象。

具体概念的实例叫：对象。

引用（变量）：用来操作对象的句柄。

构造器：描述创建一个对象的过程。
构造器的参数，是创建一个对象依赖的条件
默认构造器：如果类没有声明任何构造器
  Javac 默认提供一个无参数构造器，反之
  如果声明了任何的构造器，Javac将不再提供。

Java 调用方法，一定的存在。Java根据“方法
签名” 识别调用方法
方法签名: 方法名称和参数列表。

方法的重载：方法名相同，方法参数不同(参数
类型，参数顺序，和参数名称无关！)
构造器可以重载，经常重载

不能在空（null）引用上访问属性和方法
否则的话会出现空指针异常。
Debug 提示： 找在那个引用
调用了方法或者属性，研究这个引用在哪里
赋值的对象！

一个Java源文件只能有一个共有类，文件名必须和公有类名一致
  1 一个Java文件可以有多个类
  2 如果没有公有类文件名和任意类名一致
  3 建议一个文件一个类，并且都是公有类
 
文件中的关键字顺序：
  1 有包的话，必须在首行
  2 import 有的话必须在package之后
  3 class 在 import之后
  4 方法要声明在类中。
  5 语句要写在方法中。
  6 类中可以声明变量，但是不是语句！

 
this 的用法：
  1 引用当前对象本身
  2 this() 调用当前类的其他构造器，根据参数类型选择，
    合适的构造器。经常用来进行重载构造器代码的重用。
    this()必须写在构造器的第一行！

访问修饰：
  默认修饰： 类内部和同包内部可以访问，包外部不可见。
  私有的： 只在类的内部可以访问。
  公有的：在任何地方都可以访问。
  保护的：在子类和同包中可以访问
 
  1 习惯上属性，方法，尽可能私有的。
  2 提供适当是属性访问方法（getXXX, setXXX）
    XXX 被称为Java Bean属性
  3 建议一个文件一个类，并且都是公有类
  4 在继承中为了子类准备的资源，使用保护的修饰。
 
关于Java Bean:
  1 是一个普通的Java类, 但是要符合一些语法约定
  2 需要有package
  3 需要有无参数构造器
  4 需要实现序列化接口(在IO中仔细学习)
  5 可以包含由getXxx 和 setXxx 说明的Bean属性
    boolean Bean属性 的getXxx 可以是 isXxx
    Bean属性的名称： xxx
  6 JavaBean 有时候也被称为POJO(老Java对象)


继承： 语法： class A extends B
  1 A类是B类的扩展，其中A叫子类，B叫父类。
  2 子类继承父类的特征和行为。
  3 语义上表达A是B的字类型，就是：A是一种B
    如： 蟑螂是昆虫
  4 Java只允许单继承
    只有一个父类
    父类有多个子类
  5 如果类没有继承任何类，默认继承于Object
   
继承中的实例构造
  1 构造器是不能继承的！
  2 子类构造器默认递归调用父类无参数构造器。
  3 创建子类实例默认先递归分配父类空间
  4 子类实例默认是父类型的实例
  5 如果父类没有无参数构造器，必须显示的调用
    父类有参数构造器，使用super() 调用父类构造器
  6 为了减少麻烦，建议所有类都提供无参数构造器。
  7 super() 必须写在构造器第一行，和this()互斥
    在构造器的第一行默认存在super();

super:
  1 调用父类的构造器： super()
  2 明确访问当前实例父类中的声明属性或方法： super.name
    super.isRuning();

属性 <=> 字段(Field)

覆盖（重写）Override:
  1 子类修改父类的行为
  2 子类提供一个与父类一样方法签名的方法
 
Object（东西）对象

继承中多态现象： 父类型引用子类实例， 会出现多态现象
  重载和覆盖会造成行为的多态。
  如：问题有多种实例，可能是单选或者多选
     汽车是有多种的。

引用类型转换：
1 父类型可以引用子类型实例。子类型实例一定是父类型实例。
2 子类型的引用可以赋值给父类型引用，发生自动类型转换
3 反之需要强制类型转换，如果不成功，会抛出异常。
4 小到大自动完成，大到小需要强制类型转换
5 类型转换也叫“造型”

属性静态绑定(声明时候确定)，方法动态绑定(覆盖的结果)
以上现象造成同一个对象上
1 同名属性值会出现不同的结果
2 方法的调用都是同一个结果。
解决方案：
1 习惯上子类尽量不定义与父类相同的属性。
2 属性尽量私有，使用属性访问方法存取属性。

总之：按照JavaBean习惯定义任何一个类！

动态：在运行期分配的资源都是动态的：如对象的属性和方法。
静态：是指在对象创建之前存在的属性，方法，是属于全体类的。

static 静态修饰
  1 可以修饰变量，表示属于类的属性，全体实例共享一份静态
    变量。
  2 静态变量可以使用类名访问。
  3 静态变量可以修饰方法，表示属于类的方法。
  4 静态方法可以使用类名访问。静态方法属于类全体的公共
  方法，一般都是不依赖对象工具方法。
  5 静态方法只能访问静态资源（属性和方法）
  6 静态代码块，在类的加载后执行, 可以用来初始化一些
     配置信息，应用的不是非常广泛的。
  静态属性实例：Math.PI, Math.E, Integer.MAX_VALUE
  静态方法实例：Math.sqrt() Integet.parseInt()

类的加载：
  1 在第一次使用时候加载，按需加载。
  2 类加载以后分配类的静态变量。
  3 加载以后立即执行静态代码块。

final （最终的）
  1 final修饰属性，不能修改！
  2 final修饰的局部变量/方法型参数 只能初始化
  3 final修饰类，类不能再继承
  4 final修饰方法，方法不能再被覆盖（写出测试代码）
  5 强烈不建议使用 3，4 ！
 
关于常量：
  1 Java中没有真正的语言意义的常量
  2 使用static final 声明的成员变量，代表常量。
  3 习惯上 ”static final 声明的是常量“

abstract 抽象
  1 abstract 修饰抽象方法，抽象方法不能有方法体
  2 包含抽象方法的类，一定是抽象类，使用 abstract修饰
  3 抽象类不能直接实例化，使用抽象概念可以声明引用变量，
    抽象概念的引用变量可以引用具体的子类实例。
  4 抽象类只能被继承，子类需要实现抽象类的抽象方法。  
 
接口（interface）
  1 所有方法都是抽象的类可以声明成接口。
  2 接口表达是纯抽象的概念。
  3 接口中声明的变量只能是常量。默认就是常量(static final)。
  4 接口中的方法默认都是公有抽象的（public abstract）
  5 接口不能实例化，只能被实现
  6 实现一个接口，必须实现所有方法。
  7 如果不全部实现，这个类一定是抽象类。
  8 接口可以定义变量，可以引用实现类的实例
  9 接口相当于实现类的父类型！
  10 接口之间可以继承，一定是概念的具体化
  11 类可以实现多个接口，实现多继承，表达：也是概念

在商业软件中，实体概念之间不推荐使用继承。
在软件的体系结构中会大量的使用接口，抽象类，继承，实现
等“继承关系” 维护一个可以扩展到架构。

关于接口：
1 接口的是约定
   系统分析员定义了接口，程序员实现接口，要实现接口
   所有的方法，这样分析员就通过接口约束了程序员的实现！
   接口就是分析员与程序员之间的约定！
  
   OOA/OOD -> OOP
2 接口也是标准
   JDBC、JSP/Servlet, DOM ...
  

关于equals
1 默认是==比较，
2 建议覆盖equals，根据对象内容(属性)进行比较
自反性：对于任何非空引用值 x，x.equals(x)
都应返回 true。
对称性：对于任何非空引用值 x 和 y，
当且仅当 y.equals(x) 返回 true 时，
x.equals(y) 才应返回 true。
传递性：对于任何非空引用值 x、y 和 z，
   如果 x.equals(y) 返回 true，并且 y.equals(z)
   返回 true，那么 x.equals(z) 应返回 true。
一致性：对于任何非空引用值 x 和 y，多次调用
x.equals(y) 始终返回 true 或始终返回 false，
前提是对象上 equals 比较中所用的信息没有被修改。
     对于任何非空引用值 x，x.equals(null)
     都应返回 false。
    
方法：hashCode()
1 如果覆盖了equals方法，就必须一同覆盖hashCode（）
2 如果两个对象 equals 比较为true，他们的hashCode返回
结果必须一样
3 如果两个对象 equals 比较为false，他们的hashCode返回
结果必须不一样
4 值是一个整数。
5 一个对象创建以后，hashCode() 结果要稳定不变！
6 在Object中默认的hashCode的值是与堆对象地址对应的一
   个整数

JDK 类库中的类，一般都覆盖了equals() 和 hashCode()
如：String 覆盖了equals， 两个相同内容的String，
  hashCode（） 一定一样。

toString() 方法
1 返回当前对象的"文本描述",按照“习惯”书写. 如：方块A，(x,y)
2 默认的输出语句和字符串连接会调用toString() 方法，作为结果
3 Object 默认的toString() 的值是：
   全限定名@hashCode
4 Java建议覆盖toString() 提供合理是值。
5 Java的类库基本都覆盖了toString().

0～n 对应X的运算可以采用数组完成：
//char[] c = {'0', '1', '2'... 'f'};
    //char[] ch = {'零','壹', ... , '玖'};
    //char[] cx = {'元','拾','佰'... , '玖'};
    //String[] rankName =
    {"2", "3","4", "5", "6", "7", "8", "9"
        , "10", "J", "Q", "K", "A"};

clone() 克隆方法， 就是复制
1 需要覆盖父类提供的clone方法，要开放为公共的。
2 Object 提供的clone方法 是保护方法，默认不能公共调用
3 覆盖时候经常把异常处理掉
4 如果需要使用父类的clone()方法，必须实现Clonable接口
5 Object 提供的clone() 方法是浅层复制。
6 object克隆提供对象的浅层复制，
7 * java 系统提供的复制， 基本都是浅层复制
8 clone方法不是经常被覆盖！

finalize() 方法
1 和垃圾收集器有关。
2 finalize()在对象销毁之前由垃圾收集器调用。
3 可以被覆盖，但是不推荐覆盖
4 如果要覆盖，必须在代码中调用super.finalize()
5 Object .finalize() 方法会执行一些重要的内存回收操作
6 垃圾回收：一个对象不被任何引用所引用的时候。这个对象就是
   内存垃圾，垃圾回收器会在系统空闲，或者特定时机（可以配置）
7 垃圾回收可以通过JVM的配置进行优化。
8 System.gc() 可以让JVM 尽快启动 GC（垃圾回收器）
9 不推荐在finalize() 里面写一些逻辑，执行不是很可靠

String 类，StringBuffer(旧)，StringBuilder(新)
1 关于静态String，一般情况下相同内容的静态String(字面量)
  是同一个对象。
2 大多数字符串运算返回的都是新String 实例
3 静态String 是指静态字面量，动态字符串是指运行期分配的String
4 String 使用“不变模式” 设计，字符串对象一旦创建了，
内容永远不变！字符串对象不变，不是引用不可改变。
引用值不变使用final 修饰
5 因为String是不变模式，所以String的方法返回都是新对象
  （除了toString（））

关于“不变模式”
1 保证任何情况下对象一旦创建，对象的属性就再也不能修改了
   通过语法来约束实现。

使用第三方的API
1 获取API，并且释放到一个目录下
2 把API的类库（.jar 文件）配置到CLASSPATH
   在eclipse: Project(右键)->Properties->
     Java Buide Path->Libraries->Add Jar
3 查看API手册
4 根据手册,导入到代码中使用

字符的编码
关于编码方案：
1 ASCII 128个英文+符号, 后来扩展到256字符，如：A->65
2 IS0_8859-1 就是 ASCII， 如：A:41
3 GB2312中文编码（6000+汉字），是变长编码(1~2Btye)
   其中1Byte时候和ASCII兼容，没有：玥，喆，镕，焗
   常用艺术的字库都是（GB2312）的, 如：中：d6d0  A:41
4 GBK扩展了GB2312标准（兼容），1～2Byte编码，定义了
   20000+汉字，几乎包括所有汉字，包括全部的CJK
   WIN XP 中文采用是GBK，如：中：d6d0  A:41
5 UNICODE 是国际化组织 全球范围内文字，和ASC兼容
   超过80000，包括CJK。Unicode 定义了多种编码方案
   UTF-16BE, 采用16位定长编码，任何文字都一样。
   能够表示 65535字
   如：A= 0041 中: 4e2d
   UTF-8, 采用：1~4Byte 的变长编码，表示全部的80000+字
   英文采用，1Byte编码，与AscII一致，中文是3个Byte
   如：A:41, 中：e4 b8 ad

1 Java的字符串内部编码Unicode(UTF-16BE),
  Java 经常需要将GBK->UTF-16BE, 一般情况下Java会默认支持
  本地编码到Java内码的转换
  如： byte[] gbk = {(byte)d6,(byte)d0,41,42};
      String str = new String(gbk);

正则表达式：
 
字符
x 字符 x
\\ 反斜线字符
\0n 带有八进制值 0 的字符 n (0 <= n <= 7)
\0nn 带有八进制值 0 的字符 nn (0 <= n <= 7)
\0mnn 带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh 带有十六进制值 0x 的字符 hh
\uhhhh 带有十六进制值 0x 的字符 hhhh
\t 制表符 ('\u0009')
\n 新行（换行）符 ('\u000A')
\r 回车符 ('\u000D')
\f 换页符 ('\u000C')
\a 报警 (bell) 符 ('\u0007')
\e 转义符 ('\u001B')
\cx 对应于 x 的控制符

字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）

预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]

POSIX 字符类（仅 US-ASCII）
\p{Lower} 小写字母字符：[a-z]
\p{Upper} 大写字母字符：[A-Z]
\p{ASCII} 所有 ASCII：[\x00-\x7F]
\p{Alpha} 字母字符：[\p{Lower}\p{Upper}]
\p{Digit} 十进制数字：[0-9]
\p{Alnum} 字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct} 标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph} 可见字符：[\p{Alnum}\p{Punct}]
\p{Print} 可打印字符：[\p{Graph}\x20]
\p{Blank} 空格或制表符：[ \t]
\p{Cntrl} 控制字符：[\x00-\x1F\x7F]
\p{XDigit} 十六进制数字：[0-9a-fA-F]
\p{Space} 空白字符：[ \t\n\x0B\f\r]

java.lang.Character 类（简单的 java 字符类型）
\p{javaLowerCase} 等效于 java.lang.Character.isLowerCase()
\p{javaUpperCase} 等效于 java.lang.Character.isUpperCase()
\p{javaWhitespace} 等效于 java.lang.Character.isWhitespace()
\p{javaMirrored} 等效于 java.lang.Character.isMirrored()

Unicode 块和类别的类
\p{InGreek} Greek 块（简单块）中的字符
\p{Lu} 大写字母（简单类别）
\p{Sc} 货币符号
\P{InGreek} 所有字符，Greek 块中的除外（否定）
[\p{L}&&[^\p{Lu}]] 所有字母，大写字母除外（减去）

边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾

Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

Reluctant 数量词
X?? X，一次或一次也没有
X*? X，零次或多次
X+? X，一次或多次
X{n}? X，恰好 n 次
X{n,}? X，至少 n 次
X{n,m}? X，至少 n 次，但是不超过 m 次

Possessive 数量词
X?+ X，一次或一次也没有
X*+ X，零次或多次
X++ X，一次或多次
X{n}+ X，恰好 n 次
X{n,}+ X，至少 n 次
X{n,m}+ X，至少 n 次，但是不超过 m 次

Logical 运算符
XY X 后跟 Y
X|Y X 或 Y
(X) X，作为捕获组


实验：
  1 控制台输入验证方法实现：
   1.1 定义方法
     Location read(String msg)
    Loaction 包含一个位置坐标: i, j
    msg: 是输入提示信息，如： “输入坐标位置i,j”
   1.2 要求：
       如果输入错了要求反复输入
      ij是一个16进制字符，
      ij之间是“,”或者“空格”
   
    ^[0-9a-f](\s+|,)[0-9a-f]$
    1,2
    a,b
    a b
    a  b
   
StirngBuilder 和StringBuffer
1 StirngBuilder 是Java5以后提供的，是一个新版本
   性能好于StringBuffer。因为：StringBuffer 是线程
   安全对象，方法需要检查线程的安全性，速度稍慢。
   Java5 以后推荐使用StirngBuilder。
2 String 类的动态链接（+）的底层是使用StringBuilder
   的append（）实现。
   Stirng a = "5";
   String b = a+a+a+a;
   String b = new StringBuilder(a).append(a)
   .append(a).append(a).toSting();
    字符串的动态会参数一个垃圾对象（StringBuilder）
   问题代码：
   Stirng a = "5";
   a+=a;
   a+=a;
   a+=a;
   优化：
   Stirng a = "5";
   StringBuilder buf = new StringBuilder(a);
   buf.append(a);
   buf.append(a);
   buf.append(a);
   a = buf.toString(); 
  
Java 包装类
1 实现基本类型<->对象类型的转换
int i=1;
Integer d = new Integer(i);
Object o = d;
2 提供一些工具方法
3 Java5 以后提供了自动包装(auto boxing)
  Integer i = 1;// Integer i = new Integer(1)
  Object o = 5;
  Object o1 = 2.5;// new Double(2.5)
4 自动拆包（unboxing）
  Integer i = 5;
  int x = i+5;// x=i.intValue() + 5

Java中的时间
1 基本的时间表示：long
2 java.util.Date 是对long的包装。提供了时间的处理方法
   getYear()
   Date 类是Java早期的时间表示，Calendar(日历，历法)是新的
   时间表示，Java推荐使用。
   不过Date还是很普遍的在使用！
3 long <-> Date <-> Calendar
4 默认的日期创建，都是当前时间。
5 日期的输出与输入
6 Calendar 可以通过工厂方法 Calendar.getInstance()
   来创建实例。
   工厂方法：能够创建对象的方法都叫工厂方法。
     经常用工厂方法创建接口或者抽象类实例。
   工厂方法好处，可以屏蔽复杂的创建过程。
7 日期的计算
   计算下个月的今天
   计算这个月的第一天

class Person{
Calendar birthday;
}

大数运算
1 java.math.BigInteger 大整数

内部类
  1 静态内部类：使用static修饰，声明在类体中，可以使用
   外部类类名访问，在类内部可以省略类名。静态内部类中
   可以访问外部类的静态成员。
  2 成员内部类: 声明在类体中，不使用static，具有类的成员特征
   也就是，必须有类的实例才能创建内部类实例。内部类实例
   可以访问共享外部类的成员变量。很常用。
   如：链表的节点就可以定义为内部类
  3 局部内部类：把类声明在方法中，就是局部内部类，作用域
   类似局部变量。很少见。
  4 匿名内部类，匿名类：非常常见，可以写在任何地方,就行一般的语句。
    语法更象是创建对象：
    Date d = new Date(){};
    匿名类是对原类的一个继承，同时创建了实例，{} 就是继承
    以后的类体。类体中可使用机会所有类的语法。
    被继承的类必须有无参数构造器！匿名类不能写构造器。
    匿名类可以从抽象类或者接口继承，必须提供抽象方法的实现。
  5 任何内部类都编译成独立的class文件
  6 最大的作用：封装！
  
List 线性表
1 使用集合（List）作为属性时候，一般都直接实例化为空集。
2 可以使用泛型约束集合中元素的类型。线性表推荐使用泛型
   List<Card> cards = new ArrayList<Card>();
3 ArrayList vs Vector 都是用数组实现的线性表
   Vector 旧（Java 1.1）性能稍差，线程安全，内部数组成倍增长
   ArrayList 新 （Java 1.2以后）非线性安全，性能好，增长50%
4 LinkedList 也是线性表实现， 采用双向循环链表实现。
  private class Unit{
    Object data;
    Unit next;
    Unit prev;
    public Unit(int data) {
      this.data = data;
    }
  }

HashMap 与 Hashtable
1 提供快速的散列查找实现。
2 初始化容量与加载因子。
   初始化容量是散列空间大小，加载因子是指散列空间的充满率
   如果超过充满率，HashMap会进行扩容并且重新散列。
3 HashMap 新的(1.2)，非线程安全的，性能稍好，
   可以保存在一个null的Key
   Hashtable 旧的（1.1）,线程安全，性能稍差，不允许存null。

Iterator 接口
1 是迭代器接口，是一个对集合进行遍历处理的模型。
   就是，把集合中的元素从头数一遍。
2 非常适合与while、for组成模式化的迭代处理代码。

一定合理覆盖实现hashCode和equals，保证集合API的工作正常

排序二叉树
1 TreeSet TreeMap

自然排序：
1 类实现了Comparable表示这个类实例是可以比较大小的。
   可以比较大小的对象List集合，可以利用Collections.sort
   进行自然顺序排序。
2 Comparable 的实现，要实现compareTo方法。
   这个方法要与equals和hashCode方法的实现一致:
   compareTo 返回结果为0时候，equals的结果一定是true
   hashCode值一定一样！
3 Java提供的很多类都实现了Comparable, 如：String，
   包装类，StringBuilder，Date，等。

@Override 是JDK5以后提供的注释语法，可以告诉Java编译器
检查随后的方法是否符合方法覆盖的语法。

在List中交换元素：
1 Collections.swap(cards, i, j);
2  Card c = cards.get(i);
    c = cards.set(j, c);
    cards.set(i, c);
3 cards.set(i, cards.set(j, cards.get(i)));

Collections 是集合的工具类
  1 排序
  2 查找
  3 填充
  4 交换
  5 洗牌

Java GUI
1 Swing 图形界面包：javax.swing.*  java.awt.*
2 JFrame 代表图像界面窗口
3 JPanel 是窗口中的一个矩形区域，一般需要指定布局管理
4 Layout 是布局, 布局：是指界面中组件元素的相对位置
  布局的具体实现有：BorderLayout 边框布局
  FlowLayout: 顺序流式布局
5 在窗口中显示内容必须放置一个JPanel实例
6 如果需要复杂的姐妹布局，一般采用Panel中套Panel实现

关于事件监听

事件源对象，是事件发生时候的触发对象。