java笔记集

/ <b>Java 语言基础</b>
Java 语言基础 Day01
2011/9/26
====================
1. Linux 简介
1) 文件系统
2) 当前工作目录, 就是当前正在使用的默认文件夹
文件夹=目录
pwd 打印(显示)当前工作目录
3) 用户主目录(user home), 是属于当前登录用户个人的目录
个人主目录, 用户拥有对自己用户主目录全部管理权限.
4) mkdir 创建文件夹
mkdir demo 在当前文件夹(工作目录)里创建文件夹demo
演示任务：
1 显示当前目录，
2 在当前目录下创建子目录，
3 检查目录是否创建成功
5) cd 切换(更改)当前工作目录
.. 代表上层目录, cd .. 切换到上层目录
. 代表当前目录
cd 指定的目录
cd / 到跟目录
cd /home/soft01 到主目录
cd 命令默认返回用户主目录(user home)
6) ls 显示文件夹内容
7) 绝对路径和相对路径
A 以跟(root)"/" 为开始的路径是绝对路径
B 不是以"/" 开始的是相对路径, 相对路径默认相对于当前目录

练习任务：使用 pwd cd ls 漫游系统目录 /opt

8) rm -rf dir 删除目录
命令格式： rm -rf dir1 dir2 dir3 ...
rm file1 file2 ...
-r 表示递归删除子目录
-f 表示强制删除，不确认

9) 启动eclipse
cd /opt/eclipse
./eclipse

2. Java 简介
1) java 特点: 简单, 面向对象, 跨平台, 安全, 多线程支持
2) java 的跨平台
Java 通过JVM 实现了跨平台技术
Java 源代码（*.java）经过Java的编译器编译成
Java字节码（*.class）,执行Java字节码，Java字节码
经过JVM的解释为具体平台的具体指令，并执行。
不同平台有不同的JVM，主流平台都提供了JVM。所以
JAVA字节码可以在所有平台上能够解释执行。在这个
意义上Java是跨平台的。也就是说：Java 的字节码
是跨平台的。
3) Java JDK
JDK java 开发 工具包 /opt/jdk or /opt/jdk_1.6.01
|-- bin 开发工具(命令：java,javac,jar,javad,jar,rmic,jps...)
|-- jre JRE Java运行环境
|-- lib (rt.jar) Java API(应用编程接口，系统类库)
| (java 提供的现成组件)
|-- bin (java_vm)JVM Java虚拟机

3. Java APP
1) HelloWorld.java
package basic.day01;
/**
* eclispe 自动将当前文件编译到：
* workspace/JSD1105/bin/basic/day01/HelloWorld.class
* (工作空间/项目/bin/包文件夹/类文件)
* 执行时候, 执行这个类文件.
* @author teacher
*/
public class HelloWorld {
//java 软件的入口方法
public static void main(String[] args) {
//在控制台输出“Hello World!”
System.out.println("Hello World!");
}
}
2) Java 的编译
project
|--src
|
|--basic.day01
| | |-- HelloWorld.java
| |--basic.day02
| | |-- JFrameHelloWorld.java
|--bin
| |--basic.day01
|

| |-- HelloWorld.class
| |--basic.day02
| | |-- JFrameHelloWorld.class

4. Java 的注释，被Javac(编译器)忽略的部分
1 单行注释 // ...
2 多行注释 /* */
3 文档注释 /** */

5. Eclipse(日食/月食)
1) 来自IBM 开源, 有http://www.77cn.com.cn 基金会维护开发
是主流的Java开发平台,可以开发: PHP, Ruby, Android
SUN对这个软件很有意见.
eclispe 是Java开发的, 需要JDK来运行
2) http://www.77cn.com.cn 下载
3) JDK: http://www.77cn.com.cn

预习: java 变量类型, 运算符等

Java 语言基础 Day02
2011/8/1
====================
1. Java 变量
1) 变量就是自然语言中的代词
Person he; int age = 15;
//age= 00000000 00000000 00000000 00001111
System.out.println(age);//15
2) Java 中的变量, Java是强类型语言，
A 变量必须声明，并且初始化以后使用 int i=0;
B 变量必须有明确的类型
C 变量不能重复定义
3) 变量的作用域
a 在声明的地方开始，到块结束为止
b 离开变量的作用域结束，变量将回收。

2. 进制转换基础
1) 十进制
逢10进1
基数: 10
权: 10^n, 10000 1000 100 10 1
23678(10) = 2*10000+3*1000+6*100+7*10+8*1
= 2*10^4 + 3*10^3 + 6*10^2 + 7*10^1 + 8*10^0
= 23679

2) 二进制
逢2进1
基数: 2
权: 2^n, 128 64 32 16 8 4 2 1
01000001(2) = 1*64 + 1*1
= 65(10)
3) 补码基础
-128 10000000 11111111 11111111 11111111 10000000
10 2进制 ... ...
8421 11110111 11111111 11111111 11111111 11110111
-8 1000 11111000 11111111 11111111 11111111 11111000
-7 1001 11111001 11111111 11111111 11111111 11111001
-6 1010 11111010 11111111 11111111 11111111 11111010
-5 1011 11111011 11111111 11111111 11111111 11111011
-4 1100 11111100 11111111 11111111 11111111 11111100
-3 1101 11111101 11111111 11111111 11111111 11111101
-2 1110 11111110 11111111 11111111 11111111 11111110
-1 1111 11111111 11111111 11111111 11111111 11111111
0 0000 00000000 00000000 00000000 00000000 00000000
1 0001 00000001 00000000 00000000 00000000 00000001
2 0010 00000010 00000000 00000000 00000000 00000010
3 0011 00000011 00000000 00000000 00000000 00000011
4 0100 00000100 00000000 00000000 00000000 00000100
5 0101 00000101 00000000 00000000 00000000 00000101
6 0110 00000110 00000000 00000000 00000000 00000110
7 0111 00000111 00000000 00000000 00000000 00000111
00001000 00000000 00000000 00000000 00001000
.... ...
127 01111111 00000000 00000000 00000000 01111111
补码运算:
-1 111
1
-1 1111
*
----------
1111
1111
1111
1111
1010101
-----------
0001

4) A Java 内部只有二进制补码
B Java 内部采用补码运算, 自动发送上溢出和下溢出
C Java内部没

有10进制! 但是Java尽量按照人类习惯输入输出
D 补码的负数 最高位是 1, 也称作符号位
5) 16进制, 是2进制的简写, 方便专业人员书写2进制数据
16进制
逢16进1
基数: 16
权: 16^n, 256 16 1
16进制数字: 0 1 2 3 4 5 6 7 8 9 a b c d e f
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

41(16) = 4*16 + 1*1
= 65(10)
= 0100 0001(2)
8421 8421
4 1 (16)

128 64 32 16 8 4 2 1
0 1 0 0 0 0 0 1
练习:转换以下十进制为二进制 192(10) 137(10) 145(10)
192(10) = 1100 0000 (2)
c 0 (16)
-8(10) = fffffff8(16)
进制总结:
计算机内存只有 二进制补码
默认输出, 按照人习惯输出10机制结果
16进制是, 二进制的简写, 16进制本质就是2进制
16进制存在的价值: 方便书写2进制!

3. Java 数据类型: 分为引用类型和基本数据类型
1) 基本数据类型: 8种
byte, short, int, long
float, double
char
boolean
2) 整数类型 byte, short, int, long, 都是有符号(补码)整数
byte 8位补码 最大值 0x7f 127 最小值 0x80 -128
short 16位有符号数 0x7fff 32767 0x8000 -32768
int 32位 0x7fffffff 2G-1 2^31-1 21亿 0x80000000 -2G
long 64位 ....
整数字面量(直接量) 默认是int类型, 如果不超出范围, 可以给
小类型直接赋值.
使用整数类型(byte, short, int) 要注意取值范围, 超范围运算
java 底层byte,short 按照32位计算

long 类型的字面量使用"L","l" 后缀

3) 浮点数, 小数 (不必掌握 浮点数的存储方式)
浮点数原理: 10进制浮点数(科学计数法)原理
2356189. = 2.356189 * 10^6
概念: 尾数: 2.356189
指数: 6
基数: 10
pi = 3.14
3.1415926535897932384626433


二进制浮点数:
101001010101. = 1.01001010101 * 2^1011
概念: 尾数: 1.01001010101
指数: 1011
基数: 2

float: 32位 其中: 1位符号位, 8位指数, 23位尾数

精度: 23 位
int max = 01111111 11111111 11111111 11111111
float f = 1.111111 11111111 11111111 1 * 2^00011110

double: 64位 其中: 1位符号位, 11位指数, 52位尾数

浮点数的字面量: 默认是double, D d 后缀是double, f F 是float

4) 字符类型 char, 字符是一个16位无符号整数, 是一个二进制数
数值是一个字符的unicode编码值.
unicode 编码: 是全球范围内的编码方法, 编制了英文, 中,日,韩
阿拉伯, 希伯来, ..... 8万+ 字符

其中英文部分与ASCII 兼容, 英文字符和数字是连续编码的.
ASCII: 0~128
Java char 的范围 0~65535 不能表示全部unicode 但是可以表示
unicode只能够最常用的部分

*最小值:0, 最大值:65535 = 2^16-1
*字符字面

量使用单引号为定界符号:'中' '0'->0 '4'-'0'->4
字面量也是整数常量! 52 48
特殊字符采用转义字符表示:
如: '\n' '\t' '\\' '\b' '\r'
'\'' '\"' '\u4e2d'

char c = '\\';

'X' - 'A' = N
'x' - 'a' = N
X = 'c' - 'a' + 'A'

5) boolean 布尔类型 表达: 真(true)/假(false)
建议使用长变量名定义变量
boolean started = true;
boolean isMan = true;
isMan = false;
boolean used = true;//二手的
if(used){
System.out.println("打八折");
}
不建议 定义没有意义的变量
boolean u = true;//u = you
boolean flag = false;

if(flag){
System.out.println("打八折");
}

4. 数据类型转换
char ->
byte -> short -> int -> long -> float -> double

1) 自动类型转换,正方向,小类型到大类型的转换会自动完成
符号位会自动扩展, 负数补1, 正数补0, 保证补码数值不变
注意, 整数到浮点数转换会损失精确度
自动类型转换也叫"隐式类型转换", 是自动发生的, 一般不需要处理

int i = -1;
long l = i;

2) 强制类型转换(显示类型转换), 需求明确处理, 是按照反方向,进行
的转换, 这种转换会溢出, 或者损失精度. 要注意数据的范围
int i = 128+256;// 00000000 00000000 00000001 10000000
byte b = (byte)i;//-128

long l=0xf80000000L;
int c = (int)l;//负数

l = 8;
int d = (int)l;

float pi = (float)3.1415926535;//损失精度

char c = '0';
char x = (char)(c+2);

作业: 1 复习并且完成 全部 课堂演示代码, 添加适当的
输出语句, 研究输出结果, 添加适当的注释.
2 尝试 计算 10个以上 255 以内的整数转换为 2进制,
16进制,相互转换. 并且编程验证计算结果

提示: System.out.println(Integer.toHexString(234));

3 (选做)定义方法: 参数是一个整数类型, 没有返回值,在
方法中输出这个整数的10进制,2进制
,16进制字符串

4 尝试实现 day02.png 中的案例, 在周末提交结果

5 将人名字符的HEX编码输出, 手工转换为二进制, 并且验证结果

提示: 可以使用Scanner输入用户数据

预习: Java运算符, 流程控制语句. 参考Day03.txt


Java 语言基础 Day03
2011/9/28
====================
1. Java 的方法Method (函数 Function), 功能, 动作
1) 方法就是函数: y=f(x)=3x+6;
2) 方法的语法
(修饰词)(返回值类型)(方法名)(参数列表){
//方法体
}
public stati
c void main(String[] args){}
如:
public static int f(int x){
int y = 3 * x + 4;
return y;
}
4) 如果有返回值定义就必须有return语句, 返回和返回值类型
兼容的数据
5) 方法

的参数和方法内部的变量 都是局部变量,
这些变量作用域只在方法内部!
6) 实参: 方法调用时候实际传递的参数变量
形参: 方法的参数定义,是临时变量.

2. Java 运算符
1) 数学运算符 + - * / %
A 运算的封闭性(补码运算的封闭性):
1.同种类型参与运算(可能需要自动类型转换)
2.返回同种类型(可能发生:上溢出和下溢出)
3.byte, short, char 按照int运算
如: int a = 1 + 'A';
B. 整数的除法是整除
1.除以2相当于移位运算(移动小数点)
C.Java中字面量的运算被Javac优化了, 优化为一个固定的常量.
D. % 计算除法的余数
1. 0 对其他数的 余数 是0
2. n%3 是 周期函数, 函数值 [0,3)
3. 负数的余数是负数(考试可能出现, 工作中很少用)

2) 自增(自减)运算 ++ --
1. 可以将当前变量自我增加(减少)1
2 i++, 后++, 先将i的值作为整个表达的值, 然后将i增加1.
3 ++i, 先++, 先将i增加1, 然后将i的值作为整个表达的值.
int a = i++;
(i++)%3

3) 逻辑与比较运算
1.逻辑运算 与(并且)&& 或(或者)|| 非(否则)!
非短路的逻辑运算 & | , 比较少使用, 逻辑不合理
2. 比较运算, 比较变量的值, 就是逐个"位"比较值: > >= < <= == !=
基本类型变量的值就是基本值如: i=1
引用类型变量的值是对象地址值.(在面向对象阶段详细讲解)

int i = 1;
long l = 1;
System.out.println(i==l); //true
4) 条件运算符(3元运算符)
语法: 条件表达式 ? 表达式1 : 表达式2
当"条件表达式"为true时候, 表达式1作为整个表达式的值,
否则 表达式2作为整个表达式的值
如:
boolean isBoy = true;
int level = isBoy ? 2 : 3 ;// 2

3. 分支流程控制
1) if ... else
语法: if(布尔表达式){
//语句块..
}else{
//语句块
}
嵌套: if(布尔表达式){
//...
}else if(布尔表达式){
//...
}else if(布尔表达式){
//...
}else{
//...
}

2) switch ... case
语法: switch: 开关, case: 情况下
switch(整数表达式){
case 整数常量1:
//语句序列
break;
case 整数常量2:
//语句序列
break;
default:
//语句序列
}
A. switch条件: 只能是整数(int byte char short)表达式
switch 不能处理long 或其他类型
B. case 只能是整数(int byte char short)常量, 不能
使用
变量及表达式. 如: '中'
C. break 跳转到switch结束继续执行, 可以根据业务逻辑是否使用
经常都写break

4. 循环控制
1) While 循环控制
语法:
while(布尔表达式){
//循环体 语句序列
}

作业:
1 复习并

且完成 全部 课堂演示代码, 添加适当的
输出语句, 研究输出结果, 添加适当的注释.

2 实现函数:
A y=g(x)=3*x*x+2*x+4;
B y=f(x)=5*x+9;

3 重构课堂案例, 将参数通过Scanner输入

4 重构课堂案例, 加入while 循环, 增加输入信息合理性判断.

5 (选做)案例练习 输出等额本息还款计划表
如(示例):
月份 本金 利息 归还
第1月 930 712 1642
第2月 940 701 1642
......

预习: 流程控制语句for(),do...while, Java数组.参考Day04.txt

Java 语言基础 Day04
2011/9/29
====================
1. while
While 循环控制

Scanner console = new Scanner(System.in);
while(布尔表达式){
qty = console.nextInt();
if(qty>0 && qty<=5){ //五个以内
break; //打断, 打断当前循环
}
}

2. for 循环(主要用于几次的循环)
循环控制
for(初始化表达式;布尔表达式; 递增表达式){
//循环体
}
for(;;){
}
for(int a=1, b=3;;){
}


Example:
for (int i = 0; i < array.length; i++){
System.out.println(i);
}

3. do ... while
do ... while() 循环控制
do{
//循环体
}while(布尔表达式);
Example:
do{
System.out.print("输入押注数量:");
bet = console.nextInt();
}while(bet <= 0 || bet > balance); //否定条件

4. Java Array
1) 数组变量的声明
int[] ary; 声明了数组变量 ary, 数组变量是代词,
int ary[]; 为了与C语法兼容的写法, 不建议写法,

2) 数组对象动态初始化
ary = new int[4]; //数组变量引用了具体数组对象, 就是代词
指代了具体事务.
数组元素是自动初始化的, 自动初始化为"零"值.
"零"值: 0, 0.0, \u0000, false, null
ary = new int[]{1,2,3}; 直接给出元素的初始化
3) 数组对象的静态初始化, 只能用在声明数组变量时候同时初始化
* 不能用于赋值语句
int[] ary = {1,2,3};
ary = {3,4,5,6};//编译错误

Java关键字: if, public, class, else, while
特殊关键字: goto, const
java中 true, false, null 不是关键字, 是字面量!

4) 数组变量, 数组对象, 数组元素
如: int[] ary = {1,2,3};
ary 是 数组变量 指代一个具体的数组, 同一个变量指代不同的数组
{1,2,3} 数组对象
1,2,3 是数组元素

5) 数组元素的访问, 数组对象的大小是固定的,长度是n,下标: 0~n-1
A 使用[下
标] 访问数组元素
B 越界访问(小于0/大于等于n), 都会发生运行异常
C 使用.length 属性可以获取数组对象长度

5 数组的复制与动态扩展算法
1) 数组对象的复制

2) 数组的扩展问题
1 Java数组对象的大小是固定的, 数组对象是不能扩展的
2 利

用数组复制到方法可以变通的实现数组扩展
3 System.arraycopy() 可以复制数组
4 Arrays.copyOf() 可以简便的创建数组副本
5 创建数组副本的同时将数组长度增加就变通的实现了
数组的扩展

案例1 : 统计一个字符在字符串中的所有位置.
字符串: 统计一个字符在字符串中的所有位置
字符: '字'
返回: {4,7}

6) 数组的迭代: 将每个数组元素重复的处理一遍.
for(int i=0; i<ary1.length; i++){
System.out.print(ary1[i] + " ");
}

作业:
1 复习并且完成 全部 课堂演示代码, 添加适当的
输出语句, 研究输出结果, 添加适当的注释.
2 实现案例:
案例1 : 统计一个字符在字符串中的所有位置.
字符串: 统计一个字符在字符串中的所有位置
字符: '字'
返回: {4,7}
public static int[] count(String str, char key){}

char key = '字';
String str = "统计一个字符在字符串中的所有位置";
int[] count = {};
for(int i=0; i<str.length();i++){
char c = str.chatAt(i);
if(c==key){
//扩展数组,
count = Arrays.copyOf(count, count.length+1);
//添加序号 i
count[count.length-1]=i;
}
}


案例2 : 统计一个字符在字符数组中的所有位置.
字符数组: 统计一个字符在字符串中的所有位置
字符: '字'
返回: {4,7}

案例3: 字符串统计案例:
字符串: "123456789012"
将字符串的奇数位数字相加为 c1 = 1 + 3 + 5 + 7 + 9 + 1
将字符串的偶数位数字相加为 c2 = 2 + 4 + 6 + 8 + 0 + 2

案例4: (选做) 将一个整数数位翻转
如: 整数 56123 int i =56123%10=3
int s=56123/10=5612


返回结果为整数: 32165
提示: 使用 %10 获取最后一位
使用 /10 去除处理完的最后一位

预习: 数组的排序.


Java 语言基础 Day05
2011/9/30
====================
1. 3.
练习使用for循环和
数组, 有些面试题中会出现.在实际工程项目中有现成的优化的排序API
1) 选择排序
原理:a 将数组中的每个元素,与第一个元素比较
如果这个元素小于第一个元素, 就将这个
两个元素交换.
b 每轮使用a的规则, 可以选择出一个最小元素
放到第一个位置.
c 经过n-1轮比较完成排序
简单说: 每轮选择最小的放到前面.
原理说明:
ary={8,2,3,7,1}
ary={1|8,3,7,2}
ary={1,2|8,7,3}
ary={1,2,3|8,7}
ary={1,2,3,7|8}
代码分析:
i 代表第一个数据的位置
j 代码后部每一个数据的位置
ary i j ary[i] ary[j] ary[i]>ary[j] [i]<->[j]
{8|2,3,7,1} 0 1 8 2 true 8<->2
{2|8,3,
7,1} 0 2 2 3 false
{2|8,3,7,1} 0 3 2 7 false
{2|8,3,7,1} 0 4 2 1 true 2<->1
{1,8|3,7,2

} 1 2 8 3 true 8<->3
{1,3|8,7,2} 1 3 3 7 false
{1,3|8,7,2} 1 4 3 2 true 3<->2
{1,2,8|7,3} 2 3 8 7 true 8<->7
{1,2,7|8,3} 2 4 7 3 true 7<->3
{1,2,3,8|7} 3 4 8 7 true 8<->7
{1,2,3,7,8}
for: i= 0 ~ < ary.length - 1;
for: j=i+1 ~ <ary.length
if(ary[i]>ary[j]){
ary[i]<->ary[j]
}

2) 冒泡排序
原理: a 逐一比较数组中相邻的两个元素, 如果后面
的数字小于前面的数字, 就交换先后元素.
b 经过一个轮次的比较, 一定有一个最大的排
在最后的位置.
c 每次比较剩下的元素, 经过n-1次比较, 可以
实现排序
简单说: 比较相邻元素,大的向后交换
原理说明:
ary={8,2,3,7,1}
ary={2,8,3,7,1}
ary={2,3,8,7,1}
ary={2,3,7,8,1}
ary={2,3,7,1|8}
ary={2,3,7,1|8}
ary={2,3,7,1|8}
ary={2,3,1|7,8}
ary={2,3,1|7,8}
ary={2,1|3,7,8}
ary={1,2,3,7,8}
i代表次数
j代表比较位置
ary i j j+1 ary[j] ary[j+1] [j]>[j+1] [j]<->[j+1]
{8,2,3,7,1} 0 0 1 8 2 true 8<->2
{2,8,3,7,1} 0 1 2 8 3 true 8<->3
{2,3,8,7,1} 0 2 3 8 7 true 8<->7
{2,3,7,8,1} 0 3 4 8 1 true 8<->1
{2,3,7,1|8} 1 0 1 2 3 false
{2,3,7,1|8} 1 1 2 3 7 false
{2,3,7,1|8} 1 2 3 7 1 true 7<->1
{2,3,1|7,8} 2 0 1 2 3 false
{2,3,1|7,8} 2 1 2 3 1 true 3<->1
{2,1|3,7,8} 3 0 1 2 1 true 2<->1
{1,2,3,7,8}
for: i = 0~ < ary.length-1
for: j = 0~ < ary.length - i -1;
if([j]>[j+1]){
[j]<->[j+1]
}

3) 插入排序
原理: a 将数组分为两部分, 将后部分的第一张逐一
与前部分每一张比较, 如果当前元素小, 就
一点被比较元素.
b 找到合理位置插入.
原理说明:
temp = 1
{8|2,3,7,1}
{2,8|8,7,1}
{2,3,8|7,1}
{2,3,8|8,1}
{2,3,7,8|8}
{2,3,7,7|8}
{2,3,3,7|8}
{2,2,3,7|8}
{1,2,3,7|8}

temp 代表取出的待插入元素
i 代表后组待插入元素 位置
j 代表前组每个元素的位置
(移动) 插入
ary i t j ary[j] t<[j] [j]->[j+1] t->[j+1]
{8|2,3,7,5} 1 2 0 8 true 8->[j+1]
{8|8,3,7,5} 1 2 -1 2->[j+1]
{2,8|3,7,5} 2 3 1 8 true 8->[j+1]
{2,8|8,7,5} 2 3 0 2 false 3->[j+1]
{2,3,8|7,5} 3 7 2 8 true 8->[j+1]
{2,3,8|8,5} 3 7 1 3 false 7->[j+1]
{2,3,7,8|5} 4 5 3 8 true 8->[j+1]
{2,3,7,8|8} 4 5 2 7 tru
e 7->[j+1]
{2,3,7,7|8} 4 5 1 3 false 5->[j+1]
{2,3,5,7|8}
i= 1 ~ <ary.length, i++
t = [i];
j= i-1 ~ >

=0, j--
if(t<[j]){
[j]->[j+1] //移动 ary[j+1]=ary[j]
}else{
break j;
}
t->[j+1]//插入


2. java 系统排序 Arrays.sort(), 排序算法性能很好


3. 方法的递归调用
1) java 的栈: 是Java进程启动时候在内存中开辟的存储空间
栈内存的利用方式LIFO(后进先出).
A Java所有局部变量都在栈中分配(压入)方法的参数也是局部变量
B 局部变量在离开作用域时候回收 就是从栈中弹出(删除).
2) Java方法调用使用栈实现, 递归调用就是栈实现的
3) 递归时候要按照递归深度分配全部临时变量, 栈开销很大, 性能
不好, 要注意不要超过栈的大小, 并且一定要给出结束条件, 否则
会造成栈溢出错误.

案例：1+2+3+...+n=f(n)=n+f(n-1) && (n>0, f(1)=1)
注意事项: 解决问题简练，性能很差。一定给出结束条件。

作业：
1 复习并且实现全部案例，找出全部的疑问，并解决。
2 实现递归代码：
//案例：n!=1*2*3*...*n=f(n)
// =n*f(n-1) && f(1)=1;

//案例：1+3+5+...+n=f(n)
// =n+f(n-2) && f(1)=1;

//案例：1/1+1/2+1/3+...+1/n=f(n)
// =1/n+f(n-1) && f(1)=1;

3 案例

实现随机生成双色球号码: [02 22 13 16 18 12] [12]
红球 33 个球 (01~33) 取 六
蓝球 16 个球 (01~16) 取 一

提示:
蓝球池 {"01", "02", "03", "04", ... "16"}
红球池 {"01", "02", "03", "04", ... "33"}
使用标记{ f, f, f, f, ... f}

结果采用一个数组存储, 数组可以利用数组扩容追加新的"球号"
处理逻辑参考如下过程:

1 随机生成红球序号
2 检查"红球序号"是否使用过(取出过)
如果使用过 返回 1
3 取出一个红球, 设置使用标记为true
4 是否取出了6个红球
如果没有到6个, 返回 1
5 对红球结果排序
6 取出一个篮球到结果中


4 案例: 生成4位网站验证码,
1 不能重复
2 数字和大小写字符, 但是不能包含1,0,o,O,l,L,Z,2,9,g等



案例4: (选做) 将一个整数数位翻转
如: 整数 56123
返回结果为整数: 32165
提示: 使用 %10 获取最后一位
使用 /10 去除处理完的最后一位

num sum n=num%10 sum*10+n -> sum num/10 -> num
56123 0 3 3 5612
5612 3 2 32 561
561 32 1 321 56
56 321 6 3216 5
5 3216 5 32165 0
0 32165


<b>Unix</b>
Unix Day01
2011/10/8
====================
目标任
务
管理(CRUD, 增删改查)文件夹
管理(CRUD)文件
文件属性和授权管理, 以及隐藏
理解标准输出
打包备份
熟悉Java的配置
理解CLASSPATH



1. 命令控制台
1) Linux / Unix 命令格式
command [-选项...]

[参数...]
如: ls -a ~
mkdir .demo //创建隐藏目录
ls
ls -a

2)标准输出: 就是在控制台(终端, 命令行)的默认输出
ls pwd cat 等命令的默认输出都是标准输出
">" 输出重定向, 可以将标准输出重新定向到一个文件上.
如: ls > abc.txt //将 ls 默认的标准输出结果定向到abc.txt
cat abc.txt //查看abc.txt文件内容

3) "|" 是管道符号, 可以连接两个命令, 将前一个命令
的输出作为后一个命令的输入

4) grep 是过滤输入信息 留下指定的行

2. 目录 与文件操作
1)cd 改变当前工作目录
默认的cd 相当于 cd ~ : 返回"主目录"
. 表示当前目录
.. 表示上级目录(父目录)
~ 代表"主目录"
以"/" 开始的目录路径表示: 绝对路径, 反之: 相对路径
相对路径: 是相对于当前目录. ".", ".." 都是相对路径
以"." 为开头的文件/目录是隐藏的
2) ls 列目录命令
如:
ls /
ls /etc
ls /opt
ls ~
ls workspace
ls -a ~ 显示全部的内容(包括隐藏文件和目录)


3) 创建目录
mkdir .photo 创建隐藏文件夹 ".photo"
4) mv 移动/改名文件夹/文件
mv .photo photo //改名
mkdir mm
mv mm photo //移动
ls photo
mv passwd passwd.bak

5) rm 删除文件/目录
删除文件: rm file1 file2 file3 ...
删除目录: rm -rf dir1 dir2 ...
选项: -r 递归删除所有子目录和文件
-f 强制删除, 不进行任何的交互确认(linux 默认 -f)

6) cp 复制文件/目录, 注意第二个参数
复制文件 cp /etc/passwd ~
赋值文件夹 cp -r workspace workspace.bak
mkdir demo
cp -r workspace demo

选项-r 表示递归赋值所有的子目录和文件内容

7) 文件的授权
ls -al 查看长格式结果
d rwx rwx rwx liucs liucs com
-rwxrwx--- liucs liucs Hi.java

chmod 660 test.txt
rw- rw- ---
rwx
421 421
000 0 ---
001 1 --x
010 2 -w-
011 3 -wx
100 4 r--
101 5 r-x
110 6 rw-
111 7 rwx


8) windows 命令
dir == ls
mkdir == mkdir
cd == cd
del == rm
cls = clear
more = more
type == cat
move = mv
copy, xcopy = cp

help == man


3 文件的创建 与 修改
1) echo 回显命令
echo abc 将abc回显到控制台
2) ">" 输出重定向, 将命令的"标准输出" 结果重新定向到
新的目标.
">>" 表示追加输出
ls />rootlist.txt
echo abc>test.txt
echo abc>>test.txt
3) cat 查看文件内容
4) touch 创建新空白文件, 修改文件访问时
间

4 创建和修改文本文件 vi
1 打开 vi [filename] -> 命令状态
命令状态: 任何键盘输入都是命令
命令状态: [esc] 总是回到命令状态
编辑状态: 对文本进行编辑, 任何的输入都是编辑内容
vi [filename] ->

i o a ->
命令行 命令状态 编辑状态
<- :q 退出命令 <- [esc]
<- :q!强制退出命令
<- :wq保存退出命令
:w保存
:w [filename]
:w! [filename]
/ ? n 查找

5 打包备份与恢复(相当于winrar)
1) tar打包:
tar -cf workspace.tar workspace ....
gzip workspace.tar
或:
tar -czf workspace.tar.gz workspace ....

释放当前文件夹:
tar -xzf workspace.tar.gz (Linux)
或:
gzip -d workspace.tar.gz
tar -xf workspace.tar

2) zip 打包与释放:
zip -r file.zip file1 file2 file3 ...
unzip file.zip


6 系统环境变量PATH
1) 环境变量PATH: 操作系统可执行命令的搜索路径.
2) 可以使用$PATH引用变量的值.
3) 查看环境变量: echo $PATH
4) 设置环境变量: export PATH=$PATH:/sbin

7 Java的安装与环境的配置
1) Oracle下载JDK, http://www.77cn.com.cn
linux 版本的JDK是自释放压缩包
2) 安装JDK 以Java1.5 为例:
chmod +x jdk-1_5_0_09-linux-i586.bin (增加执行授权)
./jdk-1_5_0_09-linux-i586.bin (执行释放)

自动释放安装到 ~/jdk1.5.0_09

3) 配置JDK, 以JDK安装到 /opt/jdk为例:
/opt/jdk
|- bin 开发工具(命令: javac, java, jar, rmic, jps...)
|- lib 开发工具实现类tools.jar
|- jre (Java运行环境)
| |- bin (JVM)
| |- lib (Java API 类库)
| |- rt.jar ( 核心类库, zip压缩,
| 包含java.util.Random)
|- src.zip (Java API 类库的源文件)


A 配置PATH, 使PATH包含JDK安装目录下的bin目录
目的: 将JDK带来的开发工具(命令)扩展到OS中.
如: export PATH=/opt/jdk/bin:$PATH


B 配置JAVA_HOME, JAVA_HOME指向JDK的安装目录
JAVA_HOME 的作用: 是指导"某些Java软件"找到JDK
如: tomcat 服务器 就使用 JAVA_HOME
实例: export JAVA_HOME=/opt/jdk

C 配置CLASSPATH, 指向Java类的部署目录或者Jar文件
用来为JVM 指明Java类的搜索路径, Java在执行类的时候
在CLASSPATH指示的路径下查找类文件.
实例: export CLASSPATH=.

Windows 参考 Java配置命令:
set JAVA_HOME=C:\Program Files\Java\jdk1.6.0_01
set CLASSPATH=.
set PATH=C:\Program Files\Java\jdk1.6.0_01\bin;%PATH%

8 package 与 CLASSPATH:
1) 是java中对类进行分类的
2) 包映射为系统的文件夹
3) java的类的全名: 全限定名=包名+类名
4) 使用Java执行类时候要指定到 "全限定名"

5)Java 的 编辑
与编译实例:
cd demo
vi HelloWorld.java (编辑(edit)Java源文件)
mkdir bin (创建输出目录bin)
javac -d bin HelloWorld.java (编译(Compile) 源文
件到bin文件

夹, 在bin中生成包)
(下面设置 Java的类文件搜索路径, java执行时候利用这个
路径搜索Java的包和类文件)
export CLASSPATH=/home/soft01/demo/bin
java unix.day01.HelloWorld (执行java类, Java命令会
到CLASSPATH指定的系列路径中寻找包corejava.day01
寻找包中HelloWorld.class 的字节码文件 )

9 系统初始化脚本
1) 初始化脚本 是指在开机过程中自动执行的系统脚本文件
一般用来初始化系统环境
2) 系统级初始化脚本文件: /etc/profile 所有当前系统的用户
登录时候都执行
作业:
1 复习所有的Linux命令
2 使用VI编辑, 几个java 源文件
3 目录浏览 jdk 目录, 找到文件: java javac rt.jar src.zip
4 创建目录src在src目录中释放src.zip, 找到其中的Random.java
Scanner.java 等
4 创建目录bin在bin目录中释放rt.jar, 找到其中的Random.class
Scanner.class 等


预习: java 面向对象知识: 类, 对象, 引用

<b>Core Java</b>
Core Java Day01
2011/10/9
====================
1 面向对象(OO)
1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例
2) 面向对象, 面向客观事物之间的关系.
4) OOA面向对象分析/OOD 面向对象设计
客人来了(来了一个客人类型的某人)

5) 面向对象概念
A 类型: 名词概念, 如: 客人, 菜品, 厨师
B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
D 行为(方法)
基本特征:
A 多态: 行为/引用, 在具体情形下发生了变化的现象
一盏灯: 多态的
打: 根据宾语发生变化
B 封装: 任何对象实例都是尽可能封装, 减少暴露
C 继承: 概念的继承关系

2 Java 类型, 引用变量 与 堆对象
1)Java 类, 是用来描述事物类型的. 如: 书
<图书馆管理系统>中的概念: 书 Book
书的特征: 书号, 书名, 编号, 作者, 价格...
2) 类的声明:
public class Book{
long id;
String name;
String isbn; //书号
String[] authors; //作者
double price;
}
3) 引用变量与对象的创建过程:
A Java的内存管理与分配:
栈是一块Java使用内存区域, 使用的方式:LIFO(后来者居上)
堆也是一块Java使用内存区域, 使用方式: 无需随机分配
B 局部变量 与 堆对象空间分配
Java 局部变量在栈中分配, 是按照变
量的类型分配
对象在堆中分配, 按照类的属性(实例变量)分配空间
C 变量类型与分配
变量分为: 基本类型和引用类型
基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
的值
引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
对象.引用类型变量

的占用空间大小和值管理是"透明的(不可看见)",
由Java系统管理: 变量占用空间以及值的管理, 都是透明的.

4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
5) 在null引用上调用属性或方法, 会发生运行时异常

案例:
平面绘图坐标系中的一个点(Point),定义合理的属性
坐标是int类型.
O+-----------------------------> X
|
|
|
|
| . p(x,y)
|
|
|
|

Y

3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
1)
如: 月饼实例的创建, 使用面和馅创建.
制作(构造器)
月饼模子(类) -----> 月饼(对象)
原料(构建参数)

点类型 --------> 原点
坐标(1,2)

2) Java中的构造器: 声明在类内部, 方法名与类名一致
的方法叫构造方法, 构造方法不能声明返回值类型.
构造方法可以包含参数, 参数一般是创建对象实例
必须依赖的条件(前提条件).
public class Point {
int x;
int y;
/** 构造器 */
public Point(int x, int y){
this.x = x;
this.y = y;
}
}

3) 对象实例化过程:
new运算: 创建对象实例
1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
2 根据参数类型调用构造器.
3 new运算返回对象的引用地址.

4) this 关键字
this 是对当前对象的引用, 是运行期间当前对象本身.
可以使用this明确的访问当前对象的属性或者方法
类似于"我".
this() 是调用本类的其他构造器, 可以使用构造器的重用,
简化代码的实现.
* this() 必须写在构造器的第一行!

5) 构造方法重载: 参数不一样的构造器
案例: Point.java
方法签名 = 方法名+参数类型列表
方法重载:a 方法名一样 b 方法参数不一样
也可以说: 方法名一样, 方法签名不同的方法

6) 默认构造器
1 java 类一定有构造器
案例: ConstructorDemo.java
2 如果类没有声明任何构造器,Javac自动提供一个
默认构造器, 无参数默认构造器
3 如果提供构造器声明, Javac将不再提供默认构
造器.

4 对象的方法
1) 表示对象的功能, 依赖于对象存在.
案例: Point.java
如: p1.distance() 和 p2.distance()
方法是动作,是功能,一般用动词声明.
2)方法也经常重载, 重载:方法名一样, 参
数不一样重载体现了,
功能的多态.重载的方法经常互相重用.

对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
实例变量(对象属性)对堆对象中分配(如: 书的名字)
引用变量的值是地址值(透明管

理,不可见), 通过这个地址
值引用了一个堆对象.

不确切说法: 引用的值是对象
引用变量在栈中分配
类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
对象的样子.

想着对象写类型: 面向对象, 类是对象的抽象化

方法的重载: 体现了行为的多态现象


作业:
1 练习课题案例
2 绘制PointDemo.java 的运行内存原理图
实现方法 public double distabce(int x, int y)
3 实现习题案例: 圆类, 矩形和Person类

案例1: 圆(Circle), 矩形(Rectangle)

圆: 包含 圆心和半径两个属性
矩形: 包含 顶点和宽,高三个属性
提供合理的构造器
提供方法, 计算当前图形的面积
计算当前图形是否包含(contains(Point))指定的点
重载方法 contains(int x, int y) 图形是否包含坐标x,y
案例2: 定义民政业务类 Person
定义属性: 编号,名字,性别,年龄, 婚否, 身份证号, 地址, 电话,
伴侣
提供方法: 结婚, 参数是另外一个人
定义合理的结婚规则
结婚结果, 如果成功就合理更新双方的属性 婚否和伴侣,
返回true, 代表结婚成功, 结婚失败就返回false

4 预习: 类的继承

Core Java Day02
2011/10/10
====================
1 方法签名(方法的识别关键字)
方法签名 = 方法名+参数类型列表
Java 类中不能存在相同方法签名的方法

方法重载: 方法名一样, 方法签名不同的方法

char[] chs = {'A','B','C'};
int[] ary = {'A','B','C'};
System.out.println(chs);//ABC// println(char[])
System.out.println(ary);//[[@34ADCD//println(Object)
System.out.println(ary.toString());// [[@34ADCD
System.out.println('A');//A // println(char) 打印字符
System.out.println(65);//65// println(int) 打印整数
打人
打牌
方法重载就是: 动词的多意现象, 打人, 打牌, 打酱油, 打车

洗衣服, 洗手, 洗照片

保存联系人, 保存通话记录, 保存访问过的地址
save(Contact) save(Log) save(Url)

Java 的关键字:
true, false, null 不是java关键字, 是字面量!
goto, const 是关键字, 但是不使用!

挑选Java的关键字
A.do B.true C.sizeof D.goto


2 java方法参数的传递规则: 基于值的传递, 是变量值的
复
制,
1) 基本类型就是其中值的复制,
2) 引用类型是引用值(地址)的复制.
案例: ParamaterDemo.java
* 变量的值: a 基本类型的值是其本身,
b 引用变量的值是一个地址值,是被引用对象的首地址.
为了避免引用参数传递的副作用, 建议一切结果使用

返回值带回.

3 继承 用来表达概念上具体化延续的具体概念.
1 * 子类继承父类的属性和方法
2 * 构造器不能继承！
3 实例化子类，会递归分配所有父类的空间
4 子类构造器一定调用父类构造器

* 类一定有构造器

4 关于继承中的构造器：
1 * 子类构造器中, 一定调用父类构造器。
2 子类构造器 默认调用父类无参数构造器！
3 如果父类没有无参数构造器，就必须在子类中明确指定调用
父类的有参数构造器！
4 使用super()调用父类构造器，必须写在子类构造器第一行
this() 必须写在子类构造器第一行
5 编程建议：所有的类都提供无参数构造器！减少继承时候的
麻烦。

5 关于对象的实例化过程：
new SingleQuestion()...
1 检查类是否加载，如果没有加载就加载这个类，
要加载所有父类。
* 懒惰式加载（按需加载）：如果第一次用到就加载，
只加载一次。通过CLASSPATH指定的路径寻找类文件(.class)，
加载以后是一个对象，类型是Class。
获得这个类对象：Student.class-> Class 实例
2 在内存堆中分配对象空间。递归分配所有父类和子类属性空间。
属性默认自动初始化。自动初始化为“0”值。
3 进行属性的赋值。
4 递归调用父类构造器。(默认调用父类无参数构造器！)
5 调用本类构造器。

6 访问控制修饰符
1 public
2 protected
3 default 很少使用，很少使用package作为访问控制的边界
4 private

* 一般自然现象: 都是尽可能的封装典型.

声明属性和方法尽可能私有。这样才能做到尽可能的封装。
提供适当的属性访问方法，适当的开放属性的访问。

一个源文件可以有多个类, 但是只能有一个public类,
文件名要与Public类一致. 如果有其他类, 就只能是默认修饰

不建议使用非公有类。就是说所有类都应该是公有的，并且
一个源文件一个类。

7 继承中的语法现象
1 父类型变量可以引用子类型的实例，父类型的实现是多态的！
2 子类可以覆盖父类的方法，修改父类的行为。
* 方法覆盖：子类覆盖了父类“相同方法签名”的方法。
方法的覆盖是由方法动态绑定实现的，就是Java虚拟机运行
时候确定执行那个那个对象那个方法，java最终执行子类的方法。

8 引用类型转换（是引用变量的类型的转换！）
1 向下转型（隐式/自动类型转换），是小类型到大类型的转换
如：
Circle c = new Circle(1,2,3)
;
Shape s = (Shape) c;//表示圆一定是图形

2 向上造型（强制类型转换），是大类型到小类型。
如：
Shape s = (Shape) new Circle(1,2,3);
Cirlcle c = (Circle)s; //当s实际引用圆时候，能够转换

成功
s = new Rectangle(1,1,2,2);
Circle c2 = (Circle) s;//出现类型转换异常，因为
// s引用的是Rectangle 不是圆实例。
3 instanceof 运算符，用来检查引用对象的类型。
经常与“引用类型强制转换”配合，实现安全的类型转换，
避免类型转换异常。

作业:
1 练习课题案例
2 实现如下案例:
设计图形（Shape）类及其子类（Circle、Rectangle）
（Shape 有属性: Point location 是图形位置,
1）Shape提供计算面积方法area，子类覆盖
2) Shape提供检查是否包含指定坐标的方法，子类覆盖
3) Circle 继承与Shape 继承属性location作为圆心
扩展属性 int r 作为圆的半径, 覆盖技术面积的方法和包含指
定点的方法
4) Rectangle继承与Shape 继承属性location作为位置,
扩展属性 int w, int h 作为宽高

3 试题(Question), 单选题(SingleChoice)和
多选题(MultiChoice)之间的继承关系
要求:
1) Question 包含题干属性(text)
2) Question 包含检测标准答案的方法
boolean check(int[] answers)
answers 是用户提供的答案, 是单选就应该只有一个答案
3）MultiChoice和SingleChoice是Question类的子类，
MultiChoice 包含属性
选项: String[] options
多选标准答案: int[] answers

SingleChoice 包含属性
选项: String[] options
单选标准答案: int answer

4) 在MultiChoice实现参数为(String text,
String[] options, int[] answers)的构造方法，
其中:
text 是题干,
options 是选项,
answers 是多选标准答案, 是正确选项的序号
5) 在SingleChoice实现参数为(String text,
Stirng[] options, int answer)的构造方法。
其中:
text 是题干,
options 是选项,
answer 是标准答案, 是正确选项的序号
6）在MultiChoice和SingleChoice类中重写
Question类check方法 提供具体的检查用户答案的逻辑

预习: final static Object

Core Java Day03
2011/10/11
====================
1 Java Bean
关于JavaBean规范
1) JavaBean 不是语法规范，是习惯性编程规范，用这个规范
写的类使用方便。有时候JavaBean的类也称为:POJO
Plan Old Java Object

2) 简化规范：
a 必须有包.
b Java类，具有无参数构造器。
c 有用getXxx() 和 setXxx() 声明的Bean属性。
如：getName() 和 setName(String n) 声明的
Bean属性为：name, 与是否有实例变量name无关.
boolean类型的get方法可以有两种形式：

getMarried() 或者 isMarried()
d 必须实现序列化接口(在学习IO的时候具体学习。)
e JDK提供的API类几乎都符合JavaBean规范。
如：String

3) JavaBean 最大的好处：“使用方便”

2 static 静态 关键字

, 修饰: 属性, 方法, 内部类, 代码块
static修饰的资源属于类级别, 是全体对象实例共享的资源
(属性, 方法, 内部类)
1) 静态属性, 使用static修饰的属性, 是在类的加载期间初始化
是属于类的, 全体类的实例共享的变量, 使用类名访问属性.
实例变量: 属于对象的属性.
2) static 方法, 使用static声明的方法, 属于类的方法, 一般
用来表示工具方法. 在类加载以后就可以自己调用, 不需要创建任何
类的实例.
3) 静态代码块，是在类加载期间运行的代码块，由于类只加载
一次，所以静态代码块只执行一次！
用途不是很常见,一般用来在类加载以后初始化一些静态资源
时候使用，如：加载配置文件。

4) 静态内部类（在内部类专题讲解）

3 final 最终的
1) final 修饰的类，不能再被继承。
Java 的String就是final类，不能被继承！
Math 也是final
Integer (包装类)
在实际项目开发中，原则上不允许使用final类, 和final方法！
Spring, Hibernate,Struts 2, 这些框架会使用"动态代理技术"
动态代理技术: 动态继承类, 并且覆盖所有方法, 在覆盖方法中插入功能
final的类和方法或阻止动态代理技术的实现, 影响框架的运行.

2) final修饰的方法，不能再被覆盖。
在实际项目开发中，原则上不允许使用final方法！

3) final 修饰的变量，初始化以后不允许再修改了。
a final 局部变量
b final 方法参数
c final 的成员变量
4) final static -- Java使用final static修饰的变量作为常量。
一般要求常量名都有大写字母。
常量不是: const


4 abstract class 抽象类--不具体的类

abstract: 抽象的, 是指不够具体, 概念性的

1) 抽象方法，只有行为的概念，没有具体的行为实现。
使用：abstract 关键字修饰，并且没有方法体。
2) 包含抽象方法的类，就一定是抽象类。
使用： abstract 关键字修饰，包含抽象方法。
如：平面图形一定可以计算面积。

3) 抽象类不能直接创建实例。可以定义引用变量。
4) 抽象类只能被继承，一个具体类继承一个抽象类，必须实
现所有抽象方法。
5) 抽象方法和抽象类非常适合作为系统的分析和设计的工具。
public class abstract CRMSystem{
public abstract Client add(Client newGuy);
public abstract Event add(Event e, Client guy);
public abstract Event[] todayEvents();
}

5 接口, 相当于纯抽象类(cpp纯虚类)
1 接口：全部的方法都是抽象方法，全部的属性都是常量。

接口用来表示纯抽象概念，没有任何具体的方法和属性。
public interface CRMSystem{
Client add(Client newGuy);
Event add(Event e, Client guy);
Event[] todayEvents();
}

2 不能实例化，可以定义变量。
3 接口变量可以引用具体实现类的实例。
4 接口只能被实现(继承)，一个具体类实现接口，必须使用全部的
抽象方法。
5 接口之间可以继承。
6 一个具体类可以实现多个接口，实现多继承现象，表示：
一个概念即是XXX也是XXX.
7 接口中的属性，默认是常量 public static final
8 接中的方法一定是:public abstract
9 实现一个接口，使用关键字implements, 实现实际上是
一种继承关系。接口和实现类是父子类型的关系

5 Object
1) Java 类默认继承于Object! 继承了Object 的属性和方法
如: toString(), hashCode(), equals()
2) toString() 方法, 经常有系统默认调用, 用来输出当前对象的
文本描述, Object默认返回: 全限定名@hashCode
建议覆盖为: 当前对象的文本描述


作业:
1 复习并且全部使用课堂案例代码
2 实现抽象类 Shape, 和Shape具体实现类Circle, Rectangle
3 (选做) 实现扑克牌类Card
实现
1 创建54张扑克牌,
2 洗牌
3 发牌到3个Player人
Player属性: String name, Card[] cards = {};
人每次接收拍时候需要扩展cards数组
4 实现抽取5张牌的算法
4 完整实现单选与多选题

预习: Object, Stirng, StringBuilder


注意: RegexTestHarnessV5.java 是明天上课用的

Core Java Day04
2011/10/12
====================

5 接口, 相当于纯抽象类(cpp纯虚类)
1 接口：全部的方法都是抽象方法，全部的属性都是常量。
接口用来表示纯抽象概念，没有任何具体的方法和属性。

2 不能实例化，可以定义变量。
3 接口变量可以引用具体实现类的实例。
4 接口只能被实现(继承)，一个具体类实现接口，必须使用全部的
抽象方法。
5 接口之间可以继承。
6 一个具体类可以实现多个接口，实现多继承现象，表示：
一个概念即是XXX也是XXX.
7 接口中的属性，默认是常量 public static final
8 接中的方法一定是:public abstract
9 实现一个接口，使用关键字implements, 实现实际上是
一种继承关系。接口和实现类是父子类型的关系

1 Object
1) Java 类默认继承于Object! -> 啥都是东西
继承了Object 的属性和方法
如: toString(), hashCode(), equals()
2) toString() 方法, 经常有系统默认调用, 活动当前对象的
文本描述, Object默认返回: 全限定名@hashCode
建议覆盖为: 当前对象的文本
描述
3) equals 是用来比较两个对象是否相等的方法。
区别：引用相等 与 对象相等
引用值相等： 使用 “==”
对象的内容相等： .equals() 方法
equals在Object类中声明，默认的比较规则是：比较引用
建议覆盖，实现对象的比较(比较对象的状态，就

是比较对象
的数据)。
* 覆盖规则：
a 自反性：对于任何非空引用值 x，x.equals(x)
都应返回 true。
b 对称性：对于任何非空引用值 x 和 y，当且仅当
y.equals(x) 返回 true 时，x.equals(y)
才应返回 true。
c 传递性：对于任何非空引用值 x、y 和 z，如果
x.equals(y) 返回 true，并且 y.equals(z) 返回
true，那么 x.equals(z) 应返回 true。
d 一致性：对于任何非空引用值 x 和 y，多次调用
x.equals(y) 始终返回 true 或始终返回 false，
前提是对象上 equals 比较中所用的信息没有被修改。
e 对于任何非空引用值 x，x.equals(null) 都应返回
false。
4) hashCode()
A hashCode()方法要与equals方法一同覆盖
a 当两个对象equals比较为true时候，这两个对象应该
具有相同的hashCode()值
b 当两个对象equals比较为false时候，这两个对象应该
具有不相同的hashCode()值
c hashCode() 值要稳定（一致性），一个对象创建以
后就不应该再变化
B 默认的hashCode() 值是当前堆对象地址转换的一个整数
这个整数不是内存地址。
C 一般使用对象的OID值作为hashCode的值。
OID 对象的唯一编号，在工程项目中一般采用数据库来
生成OID，也就是数据库中的“主键”


2 String 字符串
String 字符串 = char[] + 操作(toUpperCase(), concat())
类: 数据+相关的操作
char数组只是数据, 没有操作
一串字符就是字符串: char[] , String, StringBuilder
1 字符串"字面量(直接量)"都是String类型实例
"字符串常量"
public static final String TYPE = "car";
///////// 常量 字面量/直接量
Stirng 内部就是一个char[].
2 String API 有一个实现原则: 对象内容永远不变
也就是说: String对象永远不变.
3 String 字面量(直接量), 如果相同, 会替换为同
一个String对象的引用, 常量连接的结果也被优化
为一个字符串.
String s = new String("abc");
4 String 的比较, equals, hashCode()
5 String API (字符串的常用方法)
这些方法如果返回String 一般是一个新String对象
toString() 除外.
字符串中的字符有序号, 从0开始.
API 方法:
charAt()
length()
trim()
indexOf()
lastIndexOf()
endsWith()
startsWith()
substring(int start, int end)
substring(int start)

String str = new String(new char[]{'1','2','3'});
char[] chs = str.toCharArray();

3 正则表达式: 负责的
字符串匹配处理规则, 应用广泛.
学习建议: 1 要能够读懂"正则表达式"
2 能够写出简单的"正则表达式"
3 不要过多的分配学习时间!
可以应用于: java grep vi
1 字符集: [1234] 表示 1,2,3,4 之一

本文来源：https://www.bwwdw.com/article/mbqi.html