j2se学习笔记

j2se基础：
掌握要求：读懂、分析、调试（运行，改数据）、复述、应用（类似编程）、反复的写
从案例出发，要会用，再去考虑为什么
（0530）：java概述 1
(0531): 标识符、关键字、数据类型、变量、常量: 4
（0601）运算符、类型转换： 10
（0602）字符串、String类： 14
（0603）结构语句： 17
(0607):格式化输出、面向对象 20
（0608）：方法对象调用、方法重载、构造器、this、final、printf 22
(0609):静态变量（类变量）、（静态）初始化块、包 24
（0610）： (常用类)基本类型封装类、StringBuffer & StringBuilder、Date、DateFormat、SimpleDateForma、Calendar、Scanner 、GreforianCalendar 27
（0613）：数组、Arrays、正则表达式 36
（0614）：继承（基本结构） 43
（0615）：继承（递归、super） 44
(0617):多态 47
(0618):最终类、最终方法、强制类型转换、抽象类 48
（0620）：接口、自定义接口 49
（0622）：接口与回调、内部类（匿名）、容器（Collection） 52
(0623):Set接口(子接口SortedSet)、List接口及实现类（Collections工具） 56
（0624）：遍历、Map接口（子接口SortedMap）、泛型 62
(0627):异常处理、throws、throw、创建异常类 67
(0629):流与文件 70
(0630):文件字符输入输出流、缓冲流、处理流 76
（0704）：对象流、数据流、转换流、打印流、键盘输入 80
（0705）：Java 多线程机制 89
(0706):网络程序设计 94
一、计算机网络：不同地理范围有独立功能，通过通信介质，在网络操作系统控制下，通信双方遵守共同的通讯规则，实现相互信息的传递，同时达到资源共享的计算机群 94

（0530）：java概述                                                        
一：1、Java、程序以类为单位，一个程序有很多个类组成
class表示一个类
2、英文单词或字母 +（）表示方法，方法是要将内容展示到屏幕上去。（见到小括号就是方法）
如：System.out.println ();
public static void main ( String[] args)
3、public class 指的是公共的类，一个程序中只有一个公共的类，文件名要与公共类名称一致。
4、“文件名”表示按我指定类型存盘
5、cmd（打开命令窗口）
F：（磁盘切换到f盘）
Cd +“文件夹名”切换到此文件夹
Dir（查看目录）
Javac + “文件名”.java（编译此文件）
Java + “文件名”.class （解释执行此文件，但class不能加）
6、JAVA_HOME说明储存java程序的安装路径（安装位置地址）
Path 告诉操作系统按照你指定的路径寻找可执行软件
7、主类：包含了主方法的类称为主类，主方法是程序执行的入口。
8、一个程序中有多少个类，编译后就会产生多少个字节码文件。
二：1、程序执行顺序：加载主类（java Test）、执行主方法、延主方法执行程序
2、java中严格区分大小写、中英文状态标点符号
3、看到“[ ]”表示为一个数组，表示一组数据
4、“（）”里面的都叫参数，数据类型：4类8种
5、“加号”的左边或右边有一个字符串时 其起连接作用。
6、void 表示没有返回值，int+类名表示返回为int型。
7、两个类之间调用规则（类名dian变量名）
如：public class Test {
public static void main (String[] args) {
Second.add(20 , 30);
}
}
class Second {
public static void add(  int a , int b) {

System.out.println(a * b);
}
}

(0531): 标识符、关键字、数据类型、变量、常量:
程序员的要求：第一步：用想到的方法解决问题
第二步：优化（换位作为用户，是否能看懂）
第三步：回头考虑（作为技术人员，所用技术是否符合）
1、 注释：
单行注释：  “//”后跟要注释的内容
多行注释： 以“/*”开头，以“*/”结尾，里面写要注释的内容。
文档注释： 以“/**”开头，以“*/”结尾，里面写要注释的内容。
注释注意：/* */注释不能嵌套。
Java中的注释不会出现在字节码文件中。
单行注释的内容必须在一行上。
注释作用：注释就是程序员为读者作的说明，是提高程序可读性的一种手段。
2、 标识符：指得是以字母或者下划线或者美元符号开头后跟字母，数字下划线美元符号组成的字符串称之为表示符号
作用：作为为变量、方法、类名以及接口名命名的一个规则。
注意：有严格的大小写区分，不能使用关键字
3、 关键字：赋以特定的含义，用做专门用途的字符串
4、数据类型：

byte字节型 【-128，127】 占1B
short短整型【-32768，32767】 占2B
int整型【-2147483648，2147483647】 占4B
long长整型【-2^63,2^63-1】 占8B

char 字符型 【0，65535】 占2B
float 单精度浮点型  占4B
（系统输出2.0-1.1为0.899999999）若避免需用：BigDecimal类
double 双精度浮点型 占8B
boolean 逻辑类型 （布尔型）
是一种特殊的类型，用true表示真，用false表示假。
3、 在java语言中整数有三种表示形式
1）十进制数： 5，36，105
2）八进制数： 用0开头，如：015
3）十六进制：用0x或0X开头，如：0x15，0X3A
4、在java语言中整数默认为int型。
5、特殊情况下，当把一个整数存放到byte short型变量中时，只要不超过他们的范围就是合法的。
例如：byte b1 = 36，byte b2 = 128 //error
6、当把一个整数看成是long型数据时，则必须在该数的末尾加上l或者L。
例如：long a = 125468972456L;
  Long b = 356;
7、float和double用来管着小数。在java语言中，小数默认为double型；若要将小数看成是float型，则必须在其末尾加字母f或者F。
例如：float f1 = 3.56f；

8、在java语言中小数有两种表示形式
1）十进制 如：0.156、7.00
注：在java语言中小数点前后的零在不改变数值大小的情况下可以省略，例如：3.0可以写成3.
2）科学计数法：3.15e6 、315.78e-3
注：在科学计数法中，字母e的前后必须有数，在字母e的后面必须是整数，在字母e的前后不能有空格。
9、字符型char：用一对单引号将一个字符括起来，特殊的除外
例如：‘a’ ‘A’ ‘6’
在java语言中字符型数据占2B，每一个字符都对应着一个编码值，该编码值是一个整数，其范围是【0，65535】。
注意：根据以上特点可知，可将一个整数直接存放到char类型中，可得到该字符的编码值。
如： char c = 21;
System.out.println( c );
了解：一个字符型的变量可以直接给一个整数，也可以直接给一个十六进制编码值，如：char ch = ‘\u0041’;
10、特殊字符：
转义字符：\n 换行
\b 退格：将光标左移一位
\r 回车：让光标左移到本行行头
\t 制表符：让光标跳到下一个制表位
（一个制表位默认为8位）
等等



作业：
1消化所有案例
2自己编写程序测试所有基本类型变量的特性
3自己编写程序测试所有的转移符号特点
4编程测试局部变量与实例变量的特点

11、变量：
1）随着程序的运行其值可以改变
2）组成：类型 变量名 变量声明（赋值 初始化）
3）注意：要先定义后使用
4）按声明位置不同分为：
局部变量：在方法中或语句块中声明 （无默认值）
注：使用时声明后要赋值，否则不可操作
实例变量：方法外部 类的内部 （有默认值）
注：静态方法中（static）不可直接访问实例变量。要通过对象来访问非静态变量。
{1、创建一个本类对象： （类名  新名 = new 类名（）；）
2、使用规则：（新名 dian变量名（非静态））
}
5）：语句块：用一对大括号将一个或多个语句括起来构成一个整体。
12、常量
1）关键字final表示可以对变量赋一次值，且它的值一旦设定，便不可改变。
2）字面常量：见到的是什么，那它本身就是什么
符号常量：用一个标识符来代替某个字面常量
注意：符号常量必须先定义，后使用。
（final 类型 变量名 = 值）
符号常量也称为最终常量或不可变常量。标识符通常均使用大写。
好处：为后期维护提供方便，程序稳定
（0601）运算符、类型转换：
1、命名规范：
1）见名知意
2)表示常量的标识符全部大写
3）表示类名的标识符是以大写字母开头，如果名字有多个单词组成，每个单词的第一个字母都应该大写。如：HelloWorld
4）表示变量的标识符用小写字母开始，后面的描述性词以大写开始。如：getName
“驼峰式”书写
2、运算符：


思考：a、已知一个整数为5864，利用/和%的特点将该数的每一位分离。分离之后分别输出1 2 3 4 或逆着输出为: 4321.
b、利用% /任意一个整数分离，并逆着输出
c、用条件语句写一语句，求三个数的最大值
instanceof：判断某个对象是否属于某类；
关系运算符、逻辑运算符的结果一定为逻辑值即：true或false；

注意：1）“/”除号：当除号两边均为整数时，则结构为整数（即：商）
      2）“%”取膜，取余：两端可以为小数如：1.3%2=0.1
      3）两运算符之间不能有空格。a >= b
      4）“&&”短路与：运算符左边为false时，右边不用运算
      5）“||”短路或：运算符左边为true时，右边不用运算
补充内容：
A. 所有数据在计算机中以二进制方式参与运算及其处理
B. 计算机内数据最高位为符号位1为负（-）
C. 十进制（二、八、十六）进制关系；十进制转成二进制（除以基数取余倒写）基数：目的进制的基础数据个数；其他进制数转成十进制数（按权展开求和）权：目的基数的（n-1）方，n表示所在的位数。
D. 原码：十进制数转成二进制数后，最高位作为符号位得到的编码。如：byte b1 = -5；则为 10000101
（整数只有原码，或者说整数的原码、反码、补码一样）
反码：按位取反，符号位不变；则为11111010
补码：反码 + 1所得的编码； 则为 11111011
由补码求原码：（补码的补码就是原码）
原则：（1）将补码看做原码
（2）求其反码
  （3）求其补码
注意：在计算机中，如果运算的最高位为1，则它是一个负数且是补码。~a（取反时）按位取反，且符号位参与运算；（如果是一个负数，要以补码参与运算）
如： 求 a = 5;
c = ~a;//取反结果
System.out.println( "~" + a + " 其结果是: " + c  );
/*  注： 在计算机中，运算时得到结果，若它的最高位为1，则它是一个负数且是补码。
   a=5
原码:  00000000 00000000 00000000 00000101
~a得:  11111111 11111111 11111111 11111010/为补码，要求其原码。
反码:  10000000 00000000 00000000 00000101
补码:  10000000 00000000 00000000 00000110
故，所得补码就是原码，即：-6  */
4、 移位运算符
<<左移运算符：每左移一位，将扩大一倍
>>右移运算符：每右移一位，将缩小一倍
>>>无符号右移运算符：（同右移运算符）
5、 扩展赋值运算符
+=、-=、*=、/=、%=、&=、|=、^=、>>=、<<=、>>>=
格式：变量 扩展赋值运算符 表达式；
如：a += 5+6; a = a + (5+6);
注意：扩展赋值赋值运算符中不能有空格。
6、 强制转换
规则：（类型）数据
如：byte b1 = (byte)300;
b1输出时值为44；因为byte型占1B，只有八位，强制转换时只能取后八位即：300 = 100101100 B；
00101100B = 44；
注意(表达式类型判断)：
A：有double型数据时，最终结果为double型；
B：没有double型，但有float型时，最终结果为float型；
C：没有double、float型时，但有long型时，最终结果为long型；
D：没有double、float、long、型时，最终结果为int型；
如：byte b1 = 2;
short s1 = 99;        s1为short，b1为byte其和
s1 =(short) (s1 + b1);     为int型，必强制转换    
（0602）字符串、String类：
1、 字符串：用一对双引号括起来的字符序列称。属于引用类型中的“类”。
2、java中用String类来管理字符串，该类来源：java.lang.String
3、一对联系的“”表示一个长度为0的空串；
null表示字符串不存在；
4、字符串通常由多个字符组成，而每个字符都有一个索引号。
索引号从0至n-1，其中n为字符串中字符的个数，即：字符串长度。例如: "ABCDEFG"  ，其中'A'字符的索引号为0, 'G'索引号为6。该字符串的长度为7。
4、 字符串常用操作方式方法。字符串的连接，可通过”+”实现。
(符号两端中有一个为字符串，另一个自动转换成字符串)如：
String str = “love” +　2011；（输出为：love2011）
String类：
int len = str.length( );求字符串str长度；
char ch = str.charAt( 0 );求字符串str第0个位置的字符；
String sub = str .substring( 0 , 3); 字符串从第零个开始输出三（3 - 0）个字符；
String sub = str.substring( 3 );字符串第三个字符到最后；
boolean flag = str.equals( str1 );比较str与str1字符串是否相等（区分大小写）；
boolean flag = str. equalsIgnoreCase( str1 );比较str与str1字符串是否相等（不区分大小写）；
int loc = str.indexOf( “in” );得出字符串“in”在字符串str中的位置（索引号）；
int loc = str.indexOf( “in” , 3 ); 得出字符串“in”在字符串str中的位置（索引号），并且是从第三个开始搜索；
String newstr = str.replace(‘i’ , ‘I’);将字符串str中的字符“i”替换为“I”得以新串；
String newstr = str.replace(“in” , “IN”); 将字符串str中的字符串“in”替换为“IN”得以新串；
boolean flag = str.startsWith( “in” );判断字符串str是不是以“in”开头
boolean flag = str.endsWith( “in”);判断字符串str是不是以“in”结尾
String newstr = str.toLowerCase( );将字符str中的字符都变成小写生成新串
String newstr = str.toUpperCase( );将字符串str中的字符都变成大写生成新串
String newstr = str.trim( );删除字符串str头部和尾部的空格生成一新串
s4 = s1.concat("  Welcome to Beijing!  ") + 2008;//字符串连接；
int mm = s1.compareTo(s2);//将s1和s2两个串进行大小的比较。（结果大于0为大于，小于0为小于，等于0为等于）（比较时，对应字母从第一个字母开始比较，得出结果后不在比较；）
char[]  chs = s1.toCharArray();//将s1对应的串转换成一个字符数组。
System.out.println("s1对应的串是\"" + s1 + "\"其中包含的字符如下：");
for(char  tem  :   chs  ){（将数组chs中元素挨个输出）
System.out.println("\'" + tem + "\'");}
s1 = String.valueOf( true );//将各种类型的数据转换成字符串
控制流程：
条件语句：
1）有else一定有if，但有if不一定有else
2）if语句中的大括号在控制一个语句时可省略
3）else与最近的未配对的且没有被大括号隔离的if配对
Math类：
1、 类的来源：java.lang.Math
2、 它提供了许多与数学有关的函数，在java语言中称之为方法。
Math.abs ( n ); 求n的绝对值
Math.random（ n ）；产生一随机数，范围【0 ， 1】
Math.sqrt（ n ）；求n的平方根
Math.round（ n ）；对n的四舍五入
Math.pow （ x ，y）；求x的y次方
3、提供PI的值（）

（0603）结构语句：
while、do-while、for循环（嵌套）（符合条件参与循环）
break、continue中断（带标签）
switch选择
1、while循环
格式:
while( 条件 ){
循环体;
}
规则: 先判断条件，若条件成立，则执行循环体一次；之后，再去判断条件，若条件还成立，则继续执行循环体；
2、do -- while 循环
格式:
do {
循环体;
}while( 条件 );（分号不能省略）
规则: 先执行循环体一次，之后，再判断条件，若条件不成立，则立即结束do--while循环；若条件成立，则再执行循环体，之后，再去判断条件，若条件还成立，则继续执行循环体；依次这样下去，直到条件为假而结束整个循环。
3、for循环
格式:
for(表达式1 ;  条件;  表达式3 ){
循环体;
}
规则:先执行表达式1， 再判断条件，若条件成立，则执行循环体一次； 之后，执行表达式3，接着再去判断条件，若条件依然成立，再继续执行循环体；如此下去，直到条件为假而结束整个循环。
for循环的变化： 指的是三个表达式的变化。
1）标准化;
2）三个表达式的省略； (注意: for循环中的 两个分号不可省略 )3）三个表达式的扩展。
注意: 在for循环中，由表达式1定义的变量，其作用域只在for循环中；for循环之外，该变量不存在。（大括号内有效）
如：for( int i = 1 , sum = 0; i <= 100;  sum += i , tem = sum , i++ )  ;（不建议使用）
4、switch( 表达式 ) {
case 值1 : 语句系列1;  [break;]
case 值2 : 语句系列2;  [break;]
case 值3 : 语句系列3;  [break;]
......
case 值n : 语句系列n;  [break;]
default  : 语句系列m;
}
5、 break语句：标签必须放置在最外层的循环之前，并且有一个冒号。
作用：跳出该循环即结束本循环；如有标签则结束标签所指循环。
continue语句：
作用：控制其转移到最内层循环的首部，准备开始新一次循环。
如有标签，则转移到标签所在循环的首部，准备新一次循环。
6、 键盘输入：
1）import java.util.Scanner;(顶部)
2）Scanner scan = new Scanner( System.in );(类体内new新对象)
3）int grade = scan nextInt ( );( 键盘输入数值 )
如：
import java.util.Scanner; //1导入类
public class  KeyBoardInputTest{
public static void main(String[] args){
Scanner  sc = new Scanner(System.in);//2实现键盘输入
System.out.print("请输入你的成绩[0 , 100]>>>");
int grade = sc.nextInt();//3 数据接收
System.out.println("你输入的成绩是: " + grade);
}
}
(0607):格式化输出、面向对象
格式化输出:  System.out.printf();（）
1、它是java5.0新特性;
2、它应用格式 
printf("信息 <格式符号>"  , 数据 );
3、 格式符号有哪些
%d 表示控制十进制整数。
%f  表示控制小数的输出。
%c  表示控制字符的输出。
%s  表示控制字符串输出。
n   表示控制数据输出的位数。
n.m 表示数据占n位，小数位占m位。
0   表示空位补零。
-   表示左对齐。
+   表示显示数据的正负号。
，  表示数据每隔三位加一逗号。
n$  表示格式符号对应第n个数据。
<   表示从前。
%n  只能用格式化输出中，表示换行。
%tT  表示此时的时间
%tF  表示此时的日期
面向对象：
1、 面向对象的思想
2、 面向对象的好处
3、 面向对象的本质：数据+处理数据的过程构成一个整体（属性+方法）即封装
4、 面向对象的核心：如何构造一个类（封装）
5、 面向对象的特性：封装性、继承性、多态性
6、 类的构架结构：(五部分)
1）实例变量（域、字段、属性）
2）构造器（一个方法的方法与类名完全一致，且没有返回值的类型）通常与关键字new配合起来构造成一个对象的初始化。
3）设定器（用来设置或修改对象的属性值）
4）访问器（用来获取对象的属性值）
5）功能性的方法（它体现了对象的特有价值）
7、类的应用
1）声明一个该类型的对象变量并初始化为null；
2）关键字new与构造器配合起来构造一个对象
3）通过设定器让对象拥有实际属性值。
（0608）：方法对象调用、方法重载、构造器、this、final、printf
1、方法：方法是一段用来完成特定功能的代码，用来描述该类对象所共有的功能或行为，进而封装起来构成以整体。    
2、方法调用：static表示静态
1）静态方法可以直接调用静态的方法；非静态的方法可以直接调用非静态的方法和静态方法；即：方法名（）；
2）非静态的方法必须通过对象（或对象变量）被调用；即：类名 新名 = new 类名（）；
3）原因：静态的方法属于类，非静态的方法属于对象；
4）不同类之间的调用：类名.方法（）；
3、结构：
[修饰词][static][返回值类型][方法名]（）{
方法体；
return();
}
4、特殊关键字this的用途？
它有两种使用方式：
1) this.属性或this.方法
2) this();或this(参数列表);
它代表什么？
1) 当this关键字以 “this.” 方式出现时，代表当前对象。
2) 当this关键字以 “this();或this(参数列表);”　方式出现时，代表本类中的某个构造器。
5、在使用特殊关键字this时应注意什么？
1) this关键字不能在静态方法中使用。
2) 当this以 “this();或this(参数列表);”  方式出现时，它必须在本类的构造器中使用，且必须在第一行。
6、最终的实例变量
1)用final修饰的实例变量。
2)它的特点：最终实例变量的值一旦确定，则中途不允许改变。(最终实例变量没有设定器)
最终实例变量在定义时若没有给它赋值，则在每一个构造器中必须进行初始化



(0609):静态变量（类变量）、（静态）初始化块、包
静态变量或类变量
1、用static修饰的实例变量称之为静态变量，也称之为类变量。
2、它的特点：
1) 静态变量（类变量），它是属于类的，而不属于对象。即：
    在没有对象存在时，静态变量是存在的。
当有一个对象或多个对象存在时，静态变量被他们共享。
2) 静态变量（类变量）用来解决或管理共享资源。即：
当一个对象针对共享资源操作时，会影响其他对象。
3) 静态变量通常通过类名来访问，如:  类名.类变量;
4) 静态变量的设定器和访问器通常为静态的方法。
3、在什么情况下将实例变量定义成静态的。
当某个实例变量用来管理共享资源时，将此实例变量用static修饰，使其成为类变量。
静态方法
1、用static 修饰的方法称之为静态方法。
2、静态方法有何特性：
1) 静态方法不属于对象，而属于类。
2) 静态方法通常通过类名去访问，如:  类名.静态方法;
3) 在静态方法中不可直接访问非静态的实例变量。　
4) 在静态方法中不可使用　this 关键字。
3、在什么情况下将方法定义为静态的？
1) 当一个方法只针对静态变量（类变量）操作时。
2) 当一个方法只用来完成特定的业务，且完成业务所需要的数据来源于类的外部，即：它不针对实例变量操作。
初始化块
1、什么是初始化块？
在一个类中，用来对实例变量实现初始化的语句块。
2、实例变量的初始化有三种形式？
1) 显示初始化，即在定义时就给它一个值。
2) 通过构造器实现实例变量的初始化。
3) 通过初始化块实现实例变量的初始化。
3、初始化块在何时被执行？
它在每一次构造对象时被执行，且比构造器先执行。

静态初始化块
１、什么是静态初始化块？
用static修饰的初始化块就称之为静态初始块。
2、静态初始化块有何特点。
1) 它由static关键字修饰。
2) 在静态初始化块中不能处理非静态的实例变量，只能处理类变量（静态变量）。即：它通常用来对静态变量（类变量）作初始化。
3、静态初始化块在何时被执行。
在第一次加载这个类时被执行，且只执行一次。出现类名时。
包
1、什么是包？
在java语言中，将一个或多个类或接口收集起来构成一组，存放在同一个文件夹中。我们把这个文件夹称为包。
2、如何打包？
在java语言中，通常关键字 package 来实现。
格式为:  package  包名; 或 package  包名[.子包名][.子包名]....注意: 该语句必须放在java源程序的第一行。
3、为什么要打包？
原因: 在java语言中，规定同一个位置（同一个文件夹）下类名或接口名是唯一的。
4、如何使用包中的类或接口。
需要通过关键字 import 导入。
如:  import java.util.Scanner;
#5、在命令窗口下如何编译打包的源程序，如何运行打包的字节码文件？

6、java5.0及以上版本的新特性：　静态导入（指的是导入类中的静态方法和静态变量）import  static  包名.类名.静态方法名；
或import  static  包名.类名.静态变量；
（0610）： (常用类)基本类型封装类、StringBuffer & StringBuilder、Date、DateFormat、SimpleDateForma、Calendar、Scanner 、GreforianCalendar

一、基本类型封装类：
基本类型的封装类：８个类。
1、它们均来源于 java.lang.*;
2、基本类型的数据可通过它们构造成对象，从而可处理其它业务。
3、java5.0新增的特性：自动装箱和自动拆箱。
功能举例：
Integer  iObj = new Integer(100);
double x = iObj.doubleValue();（将100封装为一个对象，然后将其转换成double型）
Double  dObj = new Double(3.95678);
int y = dObj.intValue();（将3.95678封装成一个对象，然后将其转换成int型）
int max = Integer.MAX_VALUE;
int min = Integer.MIN_VALUE;（获取int型的最大值、最小值）
Integer  jObj = new Integer("156");//将数字字符串封装成一个Integer类的对象。
int y = jObj.intValue();//将jObj对应对象中的整数取出。
int y = Integer.parseInt("365");//直接将数字字符串转换成int型整数。
int x = Double.parseDouble("15.3678");将\"15.3678\"数字字符串转换成double型数；
float f1 = Float.parseFloat("21.578");将\"21.578\"数字字符串转换成float型数；
自动装箱：先将1563整数封装成一个Integer类的对象，再将对象的地址赋给tt储存。
Integer  mm = new Integer(1563); //人为封装成对象
int tt = mm;
boolean flag = tt.equals( mm );//比较两个对象是否相等。
自动拆箱：先将对象中的数据取出，再将其赋给变量储存。
int tem = mm; //将mm对象中的数据取出，再赋给tem存储。
int temp = 1563;//比较两对象是否相等（拆箱成功）
String s1 = Integer.toBinaryString(11);
s1 = Integer.toOctalString(11);
s1=Integer.toHexString(11); //将11转换成二进制（八进制、十六进制）数组成的串


二、可变字符串类:  StringBuffer 或 StringBuilder
1、它们来源于 java.lang.*;
2、它们构建的对象是一个可变的字符串，或可看成是一个用来存储字符序列的容器。
3、它们有一些方法针对可变字符串操作，如：添加，插入，删除，修改，查找，逆序等。
用法举例：
StringBuilder  vs = new StringBuilder();//构一个可变字符串对象
vs.append("ABC");//将数据添加到vs容器中。
vs.delete(3, 7); //（从第3个开始删除达7个）
vs.insert(0, "中国");//在vs的第0个位置上插入字符串"中国"
vs.setCharAt(1, '华');//将第一个位置上的字符修改为'华'
vs.delete(0, vs.length()); //将vs中的可变字符串（所有字符）删除
vs.reverse();//将vs中的可变字符串逆续，即：头变尾，尾变头。
vs.replace(0, 5, "Beijing");//将0至5-1位置上的所有字符替换为"Beijing"
vs.deleteCharAt(0).deleteCharAt(0).deleteCharAt(0);
//连续删除第0个位置上的字符
int loc = vs.indexOf("321");//查出vs中含321的位置；
loc = vs.indexOf("jing", 3);//从指定的第3个位置查找“jing”


三、与日期时间相关的类:   Date类：
1、它来源于　java.util.Date;
2、它用来获取系统日期和时间，或在给定一个参数情况下创建一个Date类的对象。
3、日期和时间的格式化输出？
1) System.out.printf();
2) String.format(); //它与 1)使用的格式完全一样，只不反馈的是字符串。
3) 借助其它类实现。
应用举例：
import java.util.Date;//1 导入类
Date  d1 = new Date();//2 构建一个对象
System.out.printf("%tF  %<tT" , d1 ); 输出日期时间
long dt = d1.getTime();//将d1对应的时间转换成毫秒数
Date d2 = new Date( dt-1000 );//将时间提前1s
boolean flag = d1.after(d2);//判断d1是在d2之后吗？
flag = d1.equals(d2);//判断d1与d2是否相等；
String str = String.format("现在日期是: %tF\n",  new Date());
（格式化输出当时时间，反馈字符串）
SimpleDateFormat类实现日期和时间的灵活格式化。
1、它来源于 java.text.*;
2、它可创建一个对象并可预先指定日期和时间的格式。
import java.text.DateFormat; //1导入类
Date d1 = new Date();//获取当前系统的日期和时间
String str = DateFormat.getDateInstance().format( d1 ); //使用DateFormat类的方法实现其格式化输出 ；//得到日期
str = DateFormat.getTimeInstance().format( d1 );//得到时间
str = DateFormat.getDateTimeInstance().format( d1 );得到日期时间
String dt = "2008-8-8";           (设定日期)
//parse()方法有一个要求: 你给定的字符串必须符合"yyyy-MM-dd"格式；否则，转换失败。//
Date date1 = DateFormat.getDateInstance().parse( dt );
dt = "20:08:08";      （设定时间）
//要求你给定的时间必须符合"hh:mm:ss"格式; 否则转换失败。
Date date2 = DateFormat.getTimeInstance().parse( dt );
dt = "2008-8-8  20:08:08";   （设定日期时间）
Date date3 = DateFormat.getDateTimeInstance().parse( dt );

四、日历类: Calendar类 和 其子类 GregorianCalendar类.
1、它们用管理日历（包含过去、现在和未来的日期和时间）.
2、Calendar类是一个抽象的类，而其子类GregorianCalendar不是。
3、在日历类中提供的常用方法有：
get(); 从日历中获取所需要的年、月、日、时等信息。
set(); 将当前日历中的某个时间（如：年）修改为指定的时间（年）。
add(); 将当前日历中的某个时间使其增加一个量。
4、注意：
在日历中用0----11分别表示1----12月。
在日历中用1----7 分别表示星期日、星期一、二、...、六。
应用举例：
import java.util.Date;
import java.util.Calendar;
import java.util.GregorianCalendar;（类的导入）
Calendar  dt = new GregorianCalendar();//构建了一个日历对象,当前正好定位在系统对应的日期上。
int year = dt.get( Calendar.YEAR );//获取年份
int month = dt.get( Calendar.MONTH )+1; //获取月份
int today = dt.get( Calendar.DAY_OF_MONTH );//当月的几号
int weekday = dt.get( Calendar.DAY_OF_WEEK )-1;//获取当前日期对应的星期几
dt.add(Calendar.DAY_OF_MONTH, 11);//定位到当前日历中当前的日子再加11天上。
//直接让当前的日历定位到2008-8-8上？
dt.set(Calendar.YEAR, 2008);
dt.set(Calendar.MONTH, 7);//由于日历中用7来表示8月，所以在设定时需要实际月份减１。
dt.set(Calendar.DAY_OF_MONTH,;
五、Scanner
键盘输入，java5.0新增的功能。
* １、通过Scanner类实现，它来源于java.util.*;
* ２、该提供了各种基本类型数据输入的方法。
* nextByte(); nextInt();
*
* ３、输入字符串的方法: 
* next();
* nextLine(); 

应用举例：
import java.util.Scanner;//1
Scanner  sc = new Scanner(System.in);//2
System.out.print("请输入你的成绩[0 , 100]>>>>");
int score = sc.nextInt();//3
String str = sc.next ();//可输入字符串，空格为界
String str = sc.nextLine();//可输入字符串，看为一串





（0613）：数组、Arrays、正则表达式
一、数组
1、什么是数组？
2、数组的特性？
1) 数组中所有元素的类型相同，有不同的位置编号，该编号是从0至n-1;
2) 数组有一个属性为 length ，表示数组的长度，即元素的个数。
3) 数组一旦确定，其元素个数就固定了，不可更改。
4) 在访问数组元素值时要注意：不要超出范围:a[0] 至 a[n-1],假设数组名为a.
5) 数组通常与循环语句配合使用。
6) 数组的元素，其类型可以是基本类型，也可是引用类型。3、数组的声明和创建(以一维数组为例)？
声明数组的格式:
类型[]  数组名 ;   或  类型  数组名[];

创建数组的格式:
数组名 = new 类型[元素个数];
声明与创建数组同时完成，格式为:
类型[]  数组名 = new 类型[元素个数];
*
注意：数组一旦创建，其元素拥有默认值，不同类型的数组其默认值不同。
4、显示数组的所有元素的值
往往与for循环配合实现
5、对数组的所有元素进行初始化。
往往通常for循环来实现。
6、对数组进行排序？
往往通过双重for循环来实现。
7、以直接赋值的方式创建数组
类型[]  数组名 = {值1, 值2, 值3, ... , 值n};
8、数组的复制
1) 将一个数组的引用直接赋给另一个数组名。
2) 通过System.arraycopy();方法实现复制。
9、命令行的参数？
在运行应用程序时，所给定的数据且由主方法main的args数组来接收的参数。
注意：命令行的参数用空格隔开；
当参数本身包含空格时，则该参数必须用一对双引号括起来。
命令行的参数由args接收后，均变为字符串类型。
应用举例：

for( int  tem :  a ) {    //数组输出
System.out.printf( "%3d " , tem );
}
for(int i = 0;  i < a.length;  i++ ){ //一维数组初始化
a[i] = (int)(30 * Math.random())-6;
}
for(int i = 0;  i < a.length;  i++ ){ //一维数组由大到小排序
for(int j = i+1;  j < a.length;  j++ ){
if( a[i] < a[j] ){
int tem = a[i];
a[i] = a[j];
a[j] = tem;
}
}
}
1）int[] a = {32,12,98,78,23,65};//数组的复制
int[] b = null;
b = a; //将数组a的引用（地址）直接赋给数组b存放。
2）int[]  c = new int[a.length];//真正的复制
System.arraycopy(a, 0, c, 0, a.length);


二、对数组操作的工具类:  Arrays
1、它来源于  java.util.Arrays;
2、它提供了针对数组操作的常用方法：
toString(数组名);  将数组的所有元素值转变成一个字符串。
sort(数组名);  对给定的数组进行由小到大排序
eqauls(数组1 , 数组2); 对给定的两个数组进行比较相等判断。binarySearch( 数组名, 要找的数 );
//采用二分查找法在指定的数组中查找指定的数。
若找到了，其结果定是大于等于零的数。若找不到，其结果定是一个负数。
1、多维数组是指什么？
具有相同类型，相同名称，不相同的多个下标的多个变量的有序集合。
2、以二维数组为例讲解多维数组的声明与创建及其应用。
1) 二维数组的声明
int[][]  a;   或  int  a[][];
2) 二维数组的创建
a = new int[n][m];
或
a = new int[n][];
3、二维数组的特性：
1) 在java语言中，多维数组实质上是由多个一维数组构成。 2) 在声明数组时，不能指定下标。如： int[3][4] a; //error
3) 在创建多维数组时，应先创建高维后创建低维。
如:  a = int[][4]; //error
4、二维数组的输出：
往往通过嵌套的for来实现
5、二维数组的初始化
往往通过嵌套的for来实现
6、不规则的二维数组，如何创建？
先创建行数，再针对每一行创建其元素个数。
如：
int[][]  b = new int[3][];
b[0] = new int[2];
b[1] = new int[3];
b[2] = new int[1];
7、通过直接赋值的方式创建一个二维数组
int[][] a = {{3,2},{1,4,9},{8,7,6,5}};
8、思考：用java5.0新增的for循环如何实现二维数组的输出?
先将二维变量一维，再将一维变成普通变量。
通过嵌套循环实现。
9、思考：用工具类Arrays 与 新增的for 循环结合实现二维数组的输出。

应用举例：
System.out.println(Arrays.toString(x));/打印数组x[];
String str = Arrays.toString( a );//将数组a的元素转变成一字符串
Arrays.sort( a );//对数组a的元素进行由小到大排序
boolean flag = Arrays.equals( a, b );//判断两个数组是否完全相等。
int loc = Arrays.binarySearch( a, temp );//查找字符temp在数组a中的位置
for(int r = 0;  r < a.length;  r++){ //二维数组元素输出
for(int c = 0;  c < a[r].length;  c++){
System.out.printf( "%3d" , a[r][c] );
}
System.out.println();
}
for(int[] aa : c){ //采用新增的for循环实现二维数组c的输出
for(int  bb :  aa){
System.out.printf("%3d" , bb);
}
System.out.println();//换行
}
for(int i = 0;  i < a.length;   i++){ //二维数组的初始化
for(int j = 0;  j < a[i].length;   j++){
a[i][j] = (int)(10 * Math.random());
}
}
int n = (int)(6 * Math.random());//创建不规则二维数组（未初始化）
int[][]  b = new int[n][];
for(int i = 0;  i < b.length;  i++){
int m = (int)(10 * Math.random());
b[i] = new int[m];
}
三、特殊方法: String类中的split( String s1 );
它可以将一个大的字符串按照给定的分隔符将其分成多个字符串组成的数组。
1、什么是正则表达式？
2、正则表达式的作用？
3、正则表达式的特殊符号：
1）预定义符号:  \d \D \w \W  \s  \S 等
2）没有预定义的符号通常用一对中括号括起来。
3）量词： *  +  ?
4、正则表达式的应用方式
1) split(String regex);
2) String类的matches()方法，如：str.matches(regex);
或
Pattern.matches(regex, str);方法来实现
3) 先导入Pattern和Matcher这两个类；
再准备一个正则表达式regex;
接着通过Pattern.compile( regex );方法将正则表达式转换成一个编译模式；
再通过编译模式调用matcher( str );方法将字符串转换成一个匹配器。
然后通过Matcher类的find()进行查找，
若查找成功，则调用group()方法获取匹配的字符串。
若查找失败，表示结束。
应用举例：
1) String[]  words = str.split("[\\s\\d;!?]{1,}");
2) String regex = "[a-zA-Z]\\w*[@]\\w+[.]\\w{2,}";
  boolean flag = email.matches(regex);
或flag = Pattern.matches(regex, email);

（0614）：继承（基本结构）

1、什么是继承？
注意：
1）Java语言中的类都有一个父类，boject类除外。
2）java语言中只支持单继承，一个类只有一个亲父类。
3）java语言中尽管不支持多继承但可通过接口实现多继承。
2、如何实现继承？
通过关键字 extends 来实现。
格式为：
public class SubClass  extends  SuperClass{
}
3、为什么要继承？
实现代码的重用性，提高生成类的效率。
4、 重写：从父类继承的方法，由于当前业务的需要将该方法实现重写，往往只改变方法的方法体，方法头部通常不变。
为什么：当前业务需要。
注意：
通过一个现存的类扩展生成一个新类（子类）
//若实现了继承，则在子类中只要将子类的个性描述出来即可。
（0615）：继承（递归、super）
特殊关键字:  super
1、它的使用方式有两种形式：
1) super.属性
或
super.方法
2)  super();  或  super(参数列表);
2、super关键字代表什么？
1) 当它以 "super." 方式出现时，代表父类的。
2) 当它以 "super(); 或 super(参数列表); " 方式出现时，
代表父类的某个构造器。 注意： 这种方式必须在子类构造器的第一行使用。
3、注意事项：
super关键字一定是在子类中使用。
"super.方法;" 往往是在子类的重写方法中使用，表示调用父类的方法。
4、在子类的构造器，若没有人为调用其它构造器，则会自动调用父类的默认构造器。
super();它代表父类的默认构造器。
super(参数);它代表父类的有参数的自定义构造器。
5、super.方法; 和 super();及super(参数); 这三种现象使用较多。
而 super.属性; 这种现象使用较少。

1、什么是递归？
在一个方法的方法体出现了调用本身的现象。
2、递归在解决问题时比较巧妙，但效率较低。
3、递归的案例
1+2+3+...+100 = ?
1+2+3+...+99 = ?
假设 f(n) 为: 1+2+3+...+n 的一个函数。
f(100) = 100 + f(99);
f(n) = n + f(n-1);
同时，当n= =1时，则f(1) 结果为 1;


!n ===>>> 1*2*3*...*n
!(n-1) ===>>>1*2*3*...*(n-1)
得:  !n == n * !(n-1);
假设 f(n) 为 !n 的函数
则有: f(n) == n * f(n-1);
再根据数学规则可知:  n == 1 ，则有 f(1) == 1
!0 == 1
//编写一个方法求1+2+3+...+n = 的结果
public static int f(int n){
if( n = = 1 ){
return 1;
}else{
return  n + f( n-1 ); //在方法体中出现调用本身的现象
}
}
(0617):多态
java语言的第三大特性:  多态性
1、什么是多态性？
多个对象在接收到同一个消息时，却产生了不同的反映和效果。
2、在java语言中多态有两种形式.
1) 静态的多态。 如：方法的重载。
当你在调用重载的方法时，可通过实际参数的个数或类型与
形式参数的个数和类型进行对比即可知调用了那个方法。
2) 动态的多态。 如: 方法的重写。
一个父类有多个子类。
在每一个子类中都对继承自父类的同一方法实现了重写。
在应用时通过父类的对象变量调用了重写的方法。
多态通过指的是： 对象变量是多态的。即：父类的对象变量引用了不同的子类对象。
3、为什么要实现多态？
目的就是实现业务的统一性，高效性。
动态绑定：通过父类的对象变量去调用重写的方法。
在源程序中无法直接判断调用了哪个重写的方法，需要在程序运行期间，根据as[i]所引用对象来确定。动态绑定实现了多态的价值。因为，所有的子类对象可由父类的对象变量来统一管理。
(0618):最终类、最终方法、强制类型转换、抽象类
1、最终类是指什么？
由关键字final修饰的类。只要在生成类时的class前面增加一个final。
2、最终类的特性？
最终类不可以被继承，即：它不可能有子类。
3、最终方法？
由关键字final修饰的方法。
4、最终方法的特性？
最终方法不可被重写。即：用来防重写。
注意：最终类不可以有子类。不可被继承。防继承。
最终方法可以被继承，但不可被重写。

1、强制类型的转换： 父类的身份还原成子类的身份。
2、要实现强制转换，必须具备以下几个前提：
1) 父类的对象变量引用了子类对象。
2) 要调用子类对象特有的方法。
3、强制类型的转换的格式如下：
(子类名称)父类的对象变量;
或
子类名 子类的对象变量 = (子类名称)父类的对象变量;
4、在进行强制转换时，往往先判断一下。
boolean flag = 父类的对象变量 instanceof 子类名;


注意: f1表面的身份是 Father类型，而它的实际身份（它引用的对象）是Son类型。
//f1.sub( a, b ); //以表面的身份去调用实际身份拥有的方法是不可以的，是错误的。

//若要调用实际身份所拥有的方法，则必须将表面身份去掉，还原它的实际身份。
//办法就是:  强制转换
boolean flag = f1 instanceof Son;//判断f1所引用的对象是Son类型吗？
（0620）：接口、自定义接口
1、如何理解接口？
2、什么是接口？
抽象方法和静态常量的集合和抽象。接口是一种标准，是一种规则。
是对所有实现类的要求。
3、在java语言中为什么要出现接口？
目的是实现多继承。
4、在java语言中接口有两种形式
1) 现存的接口（该接口由专家提供，存放在库中。）
2) 自己定义接口（通过interface关键字来定义）
5、接口的特性
1) 接口中的方法全部是抽象的。
2) 接口中没有实例变量。
3) 接口中还可有公共的、静态的、最终的变量。即：常量。
4) 接口是一种标准，是一种规则。
5) 接口必须被实现，且在实现类中必须对继承自接口中的所有方法要一一实现其功能。
6) 接口永不能实例化。
6、如何应用现存的接口？
1) 导入现存的接口(import)
2) 编写一个类实现该接口(implements)
3) 在实现类中对继承自接口中的所有抽象方法要一一实现其功能（即:重写这些方法）
4) 编写一个测试类（应用程序）测试应用。
案例1：对所有学生按入学成绩进行排序。
要排序就必须比较大小，java语言规定对象比较大小
由Comparable接口提供的int compareTo(Object obj);方法来实现，但该的具有过程由用户决定。
7、如何自定义接口并应用它？
1) 自定义接口(interface)
2) 导入自定义接口(import)
3) 编写一个类实现该接口(implements)
4) 在实现类中对继承自接口中的所有抽象方法一一实现其功能，即:重写这些方法。
5) 编写一个测试类（应用程序)测试应用。
6) 在测试类中必须人为调用重写后的方法。
注意：
1、 接口是一标准，都按此标准是一种规则，是对所有现实类的要求。
2、 抽象方法和静态常量的集合
3、 对象比较大小用compareTo，如没有则必用comparable接口重写comparTo接口。
4、 当某类型无法比较大小时要将其转换成自己知道的类型。
inty=String.valueOf(this.sex).compareTo(stu2.sex+"");（性别无法比较大小，需将其转换成字符串）
a、 在自定义接口时，接口允许有父接口，也允许有多个父接口，还允许没有父接口。
对比：任何一个类有且只有一个父类；
通过关键字 interface 来生成一个接口
B、在接口中，定义的常量可省略public static final
这些修饰词。
在接口中，定义的方法可省略public abstract 这些修饰词。
原因是：接口中只能包含常量和抽象方法。
接口要发挥它的作用，则它必须被类实现。、
一个类可以实现一个接口，也可实现多个接口。
（0622）：接口与回调、内部类（匿名）、容器（Collection）
接口与回调
1、什么是回调？
当某事件发生时，自动调用某方法执行动作。
2、通过设置一个报时器来理解回调.
报时器要具备的备件是
1) 要设定一个时间间隔，该时间以毫秒为单位。
2) 要设定一个触发对象，即：当设定的时间到达时会触发的对象。
3) 要让报时器发挥它的作用，必须有一监听对象，而这个监听往往与接口相关。
ActionListener  aObj = new TimePrinter();
Timer  t1 = new Timer(5000, aObj); //创建一个定时器对象
t1.start();//启动定时器



内部类
1、什么是内部类？
定义在一个类的类体中的类。
2、什么是外部类？
包含内部类的类。
3、在内部类的方法中是否可以直接访问外部类的成员（属性和方法）？
答案是： 肯定的。
4、在外部类的方法中是否可以直接访问内部类的成员（属性和方法）？
答案是： 否定的。 若要访问必须通过内部类的对象来实现。
5、在外部类之外的类的方法中如何访问内部类的成员？
1) 先创建外部类的对象；
如:  OutClass  a = new OutClass();
2) 再通过外部类的对象去创建一个内部类的对象；
如:  OutClass.InnerClass  b = a.new  InnerClass();
3) 最后通过内部类的对象去访问内部类的成员。
如:  b.innerPrintXY();
6、匿名的内部类？
1) 没有名字的内部类。
2) 如何生成一个匿名的内部类。
在构造某类的对象时，在构造器之后，分号之前加一对大括号；
然后，在大括号内重写该类的某个方法。这样生成的一段代码、称之为匿名的内部类。
容器：Collection接口
set接口：元素无序不重复；
SortedSet接口：可将元素自动按大小排序；
List接口：元素在位置上有序，可以重复；
Map接口：构造的容器有键和值构成；键是唯一的，其内元素无序；
SortedMap接口：可自动将案件排序；
1、记住本章中接口图1
2、记住本章中接口及其实现类的图2
3、理解本章接口及其实现类出现的原因。
4、掌握接口的特性。
5、掌握Collection接口提供的方法。
6、注意事项：
1) 容器中存放的元素均为对象。
2) 不同种类的对象存放到容器中后，均变为Object类型。
掌握Colleciton接口所提供方法的应用
Collection接口来源于 java.util.*;
应用举例：
Collection con1 = new HashSet();
con1.add();//添加元素
con1.size();//统计con1容器中的元素个数
con1.remove（）；删除某元素
flag = con1.contains（）；//判断con1容器中包含了该元素？
con1.clea();//清空
flag = con1.isEmpty（）；//判断con1是否为空
flag = con2.containsAll( con1 );//判断con2是否包含con1的所有元素
con2.addAll （ con1）；//con1中的元素都加到con2中去
con2.removeAll （con1）；//从con2中删除con1的所有元素
con2.retainAll （con1）；//从con2中删除不被con1包含的元素
Object [] obj = con1.toArry( ); //把容器所有元素构成一个数组。


(0623):Set接口(子接口SortedSet)、List接口及实现类（Collections工具）
Set子类接口的特性: 元素无序，且不重复（若添加重复元素时采用屏蔽技术不添加重复元素）
1、Set接口的实现类:  HashSet 。
2、HashSet实现类的特性:
1) 元素无序；
2) 元素不重复，即：重复的元素添加不进去。
3) 判断元素相等不仅依赖equals()，同时依赖hashCode()，这两个方法。（需重写两方法）
应用举例：
Set s1 = new HashSet();
S1.add();//添加元素；（不可添加重复元素自动判断）
S1.add(new Book(“JAVA”, 55 ));//添加自定义对象不可重复；
（不可以重复，需要重写equals（）方法与hashCode（）方法提供判断标准）
public boolean equals (Object obj){
book bb = (book)obj;
(判断语句！！)
}
public int hashCode（）{
teturn 154；
或：
return this.name.hashCode() + String.valueOf(price).hashCode();
}
3、Set接口的子接口 SortedSet:  元素会自动排序，且不重复。
4、SortedSet子接口的实现类:  TreeSet。它的特性:
1) 元素会自动排序；
2) 元素不重复;
3) 判断元素相等表面依赖equals()，实质上依赖compareTo()。因此，当元素为自定义类的对象时，在该类必须实现Comparable接口,重写compareTo()方法指定比较大小的规则。（只需重写compareTo）
应用举例：
Set s2 = new TreeSet();
S2.add(“Welcome”);//添加新元素
S2.add（new Dog（“name”，555））；//添加自定义对象
boolean flag = s2.add（new Dog（ ， ， ））；
//判断是否可以添加重复自定义对象，需重写compareTo
Public int compareTo（Object o）{}；
1、List接口的特性：
1) 元素在位置上是有序的，即：每一个元素均有一个位置编号，从0至size()-1。
2) 元素可以重复。
3) 它比父接口多了一些与位置相关的操作方法，如：插入，删除，修改，获取指定位置上的元素等方法。
应用举例：
List alist = new ArrayList（）；
alist.add(“Hello”);//添加新元素；
alist.set(0, “Beijing”);//将第0个位置上元素替换为北京
Object obj = alist.get(0);//获取第0个位置上的元素；
alist.set(alist.size()-1, “AAA”);//将最后一个位置上的元素改为AAA；
alist.remove(alist.size()-1);//删除最后一个元素；
int loc = alist.indexof(“Hello”);//在alist中查找“Hello”的位置并记录；
2、List接口的常用实现类有: ArrayList和LinkList.
A、ArrayList实现类的特性:
1) 它采用队列的原理来管理元素。
2) 元素在位置上是有序的，即：每个元素均有一个位置编号。
3) 元素可重复。
4) 判断元素相等依赖equals()方法。
5) 它的查询效率较高，而它的插入、删除效率较低。这是由队列的原理决定的。
应用举例：
List alist2 = new ArrayList();
alist2.add(“Hello”);//添加新元素；
alist2.add（new Dog （ ， ））；//添加自定义对象；
boolean flag = alist.comtains(new Dog( , ));
//判断容器中是否包含此自定义对象
public boolean equals(Object o){};//重写equals方法
B、LinkedList实现类的特性:
1) 它采用链表的原理来管理元素。
2) 元素在位置上是有序的，即：每个元素均有一个位置编号。
3) 元素可重复。
4) 判断元素相等依赖equals()方法。
5) 它的查询效率较低，而它的插入、删除效率较高。这是由链表的原理决定的。
应用举例：
List alist3 = new LinkedList();
alist3.add(“  ”);//添加新元素；
long l1 = System.currentTimeMillis();
//获取该语句开始或结束时间；
C；如何对 List接口相关的容器中的元素进行排序?
答案：它需要借助 工具类 Collections 。
该类提供了相应的常用方法如下:
sort( alist ); 对alist进行排序
List alist = new ArrayList();
alist.add(“ ”);
Object key = alist.get(n);//获取容器第n个位置上的元素；
Collections.sort( alist );//将alist内的元素进行排序；
Collections.shuffle(alist);//将alist内的元素随机排序；
Colletions.reverse(alist);//将alist内的元素逆序；
int c = Collections.binarySearch(alist, “ ”);//利用二分法在容器中查找元素；




工具类　Collections 的应用
1、它只针对 与　List 接口相关的容器操作。
2、当容器存放的是自定义类型的对象时，应注意该类必须实现Comparable接口，重写compareTo()方法，指定比较大小的规则。同时，注意在重写compareTo()方法时，要对对象的所有属性一一比较大小。
3、注意1:Collections.binarySearch(alist5, key);采用二分查找法查找元素；它在查找时，依赖compareTo()方法给定的标准。
注意2:List接口提供的 indexOf()方法也是用来查找，但它在查找前元素不需要排序，它判断元素相等依赖equals()方法。
结论：在List接口相关的容器存储自定义类的对象时，该类必须做到：
1) 实现Comparable接口，重写compareTo()方法。
2) 在重写compareTo()方法时，要对对象的属性一一比较大小。
3) 在类中要重写toString()方法便于反馈对象信息。
4) 在该类中要重写equals()方法便于indexOf()方法实现查找。
应用举例：
Collections.sort( list ); //对列表中的元素升序排序
Collections.sort( list, Collections.reverseOrder() );
//对列表中的元素降序排序（按其制定顺序排序），Collections.reverseOrder()为反馈一个反自然的顺序即逆序；
Collections.shuffle( list );//随机排序列表中的元素
Comparator  comp=new   HeightComparator(); //创建比较器对象      
Collections.sort( list, comp); //根据比较器comp对列表对象排序（如下：）     
static class HeightComparator implements Comparator {
        int  heightCompare;//按高比较时返回负整数、零或正整数，以遍确定大小
        Person   p1, p2;//比较器要比较的两个Person对象
      public int compare( Object object1, Object object2 ) {//实现接口中的方法
           p1 = ( Person ) object1; //强制转换
           p2 = ( Person ) object2;
         //比较两个对象的height大小，将他们包装为Double对象后比较
         heightCompare = new Double(p1.height).compareTo(new Double(p2.height) );
         return heightCompare;//返回表示两个对象大小的标志：正数表示前一个大
}
}
（0624）：遍历、Map接口（子接口SortedMap）、泛型

遍历：
专门针对List接口相关的容器进行遍历的 ListIterator 该迭代器不仅可以正向遍历所有元素，还可逆向遍历所有元素。
//使用Iterator接口 对alist容器进行遍历
Iterator  it = alist.iterator(); //1
while( it.hasNext() ){ //2
Object obj = it.next();//3
System.out.println( obj );}
//使用ListIterator接口 对alist容器进行遍历(正向遍历)
ListIterator  lit = alist.listIterator(); //1
while( lit.hasNext() ){ //2
Object obj = lit.next();//3
System.out.println( obj );//4}
泛型(java5.0及以上版本新增加的特性)
1、什么是泛型？
2、泛型产生的背景？
3、泛型的应用格式？
1、类型名<元素的类型>  变量名 = new  类型名<元素的类型>();
例如:  List<String>  alist = new ArrayList<String>();
2、class  类名  implements  接口<类名> {}
Class Dog implements comparTo<Dog>{};
4、应用泛型有何好处？
应用举例：
//使用了泛型，明确了bb容器只能存放String类型的元素。
List<String> bb = new ArrayList<String>();
bb.add("365");
ListIterator<String> lit = bb.listIterator();
while( lit.hasNext() ){
String str = lit.next();//遍历时直接用该类型接收
System.out.println( str );}

if ( iterator1.next() instanceof Integer )
    iterator1.remove();//遍历过程中删除某种类型对象；
iterator1.set(((String)obj).toLowerCase());//将对象改为小写，替换源对象；


1、Map接口的特性：　
1) 元素由键和值构成。
2) 元素的键是唯一，判断元素相等依据元素的键。
3) 元素是不重复的(依据键来判断)。若添加相等的元素时，则采用覆盖技术，新元素的值覆盖旧元素的值。
2、Map接口提供的常用方法有哪些？
put(key, value); 添加
3、Map接口相关的容器中的元素如何遍历？
通过keySet()方法反馈一个Set接口的对象来实现。
应用举例：
Map map1 = new hashMap();
map.put(  “西瓜”,  55);//添加元素
Double dou =（Double） map1.get(“西瓜”);//获取指定键的元素值；
map1.remove(“西瓜”);//删除该键的元素；
boolean flag = map1.containsKey（“”）；
//判断map1中是否有为该键的元素；
Boolean flag = map1.containsValue(12);
//判断map1中是否含为该值的元素；
flag = map1.isEmpety();//判断容器是否为空；
map1.putAll(map2);/将map2中的元素全添加到map1中；
Set  keys = map1.keySet(); //1 将map1中所有元素的键收集后构成一个集合。
Iterator it = keys.iterator();//2 通过Set接口的方法iterator()反馈一个迭代器
while( it.hasNext() ){ //3 判断遍历过吗
Object obj = it.next(); //4
String key = (String)obj; //5
Double value1 = (Double)map1.get(key);//6
System.out.println("元素的键为: " + key + " 而元素的值为: " + value1 );}}
4、Map接口实现类: HashMap的特性
1) 元素是无序的（看：键是否有序）。
2) 元素不重复，在添加相同元素时，采用覆盖技术用新元素的值覆盖旧元素的值。
3) 判断元素相等（判断键是否相等）依赖equals()和hashCode()两个方法。
注意：当元素的键是自定义类型时，该类中必须重写equals()和hashCode()方法。也要重写toString()便于反馈对象信息。
5、Map接口的子接口SortedMap，其实现类为: TreeMap，它的特性:
1) 元素是有序的，元素会按键自动排序。
2) 元素不重复，在添加相同元素时，采用覆盖技术用新元素的值覆盖旧元素的值。
3) 判断元素相等（判断键是否相等）表面依赖equals()，但实质上依赖compareTo()方法。
注意： 当元素的键是自定义类型时，该类必须实现Comparable接口，重写compareTo()方法，并且尽量对对象的所有属性一一比较大小。
思考: 如何产生十个不同的随机整数？

(0627):异常处理、throws、throw、创建异常类
一、常见异常：
java.lang.NullPointerException   空指针异常
java.lang.ArrayIndexOutOfBoundsException  数组下标越界
java.lang.ArithmeticException   算数异常；
java.lang.NumberFormatException  数据格式异常
java.lang.ParseException    转换异常；
FileNotFoundException     文件找不到的异常
IoException         无法读取文件，或损坏；
二、main方法中异常处理：
Try{
}catch (Exception e) {
e.toString（）；//获取异常对象的名称和异常的原因
e.getMessage（）；//获取异常的原因
e.printStackTrace();//将异常的所有信息（异常的名称，原因，异常发生位置）打印到屏幕上。
}
一个try后面可以跟多个catch；
Arguments 命令行给定参数；
三、文件读取：
import java.io.FileInputStream;//文件的字节输入流: 以字节方式读取文件的内容。
或import java.io.FileReader;//文件的字符输入流：以字符方式读取文件的内容。
String path = "d:\\a1.java";
FileInputStream  fis = null;
try {
fis = new FileInputStream( path );
int n = fis.read();
while( n >= 0 ){
System.out.print( (char)n );
n = fis.read();
}


四、在重写方法时如何抛出异常，它必须遵循两个原则。
1、在重写方法时，不可抛出比原方法还要高级的异常。
2、在重写方法时，不可抛出比原方法还要多的异常，但不一定指个数。
1) 当多出来的异常属于原异常的子异常时，则是合法的。
2) 当多出来的异常属于未检查的异常时，则也是合法的。
3) 当多出来的异常属于已检查的异常且不属于原异常的子异常时，则是非法的。
五、finally语句：
1、一个try可以跟上一个catch或多个catch，而catch是有顺序的，顺序是：先子后父。
2、一个try后面要么跟catch，要么跟finally，要么同时跟catch和finally。
3、finally语句块，其中的代码一定会执行，不论是否有异常。
4、finally语句块中的代码通常用来关闭已打开的文件或断开已连接的数据库等操作。
六、Throw自定义异常（声明）:
不带s的关键字 throw ， 它一定是用在方法的内部。
1、它以语句的方式出现在方法体中，它通常后跟一个异常对象。
2、它表示在方法体产生了一个指定的异常。
3、在使用throw关键字时，通常在该方法的头部使用带s的throws关键将异常抛到方法的外面去（即：方法调用处）。
举例：
public void setAge(int age)  throws IOException {// 2 人为抛出异常
if( age > 0  && age <= 150 ){
this.age = age;
}else{
throw  new IOException(age + ", 这个给定的年龄是非法的。");//1 人为产生一个异常
}
}



七、关键字Throws：
1、它一定用在方法的头部，将异常抛出（抛到该方法的调用处）。
2、建议：在编写方法时，方法体中若有异常产生，则通常在该方法的头部用throws关键字将产生的异常抛出去。
案例： 编写一个方法用来读取指定文件的内容。
3、throws关键字一定是用在方法的首部，将异常抛出。
4、在非main方法中产生了异常，通常都在方法的头部用throws将异常抛出去。（都抛到main方法中集中处理）

(0629):流与文件
输入／出流
1、流的特征？
2、在java语言中，IO流有三种分类？
3、在java语言中，所有的流均来源于java.io包。同时，它们继承自四个抽象的类。
4、四个抽象的类: InputStream和OutputStream , Reader和Writer两对。
5、InputStream　称以字节为单位的输入流，它的常用方法如：
int read(); 以字节为单位读取数据，反馈一个整数。当反馈是-1时，表示读完了。
void close(); 关闭输入流，释放所占资源。
6、OutputStream　 称为以字节为单位的输出流，它的常用方法如：
void write(int x); 以字节为单位存储数据。
所以要注意给定的x应小于或等于255，若大于255，存储数据会失真。
void flush(); 将缓冲区中的数据一次性写到存储的目的地(文件)去. 确保存盘成功。void close(); 关闭输出流，释放所占资源。
7、Reader 称为以字符为单位的输入流，它的常用方法如：
int read(); 以字符的方式读取数据，反馈一个整数。当反馈-1时，表示读完了。
void close(); 关闭输入流，释放所占资源。
8、Writer 称为以字符为单位的输出流，它的常用方法如： void wirte(int x); 以字符为单位存储数据。
void close(); 关闭输出流，释放所占资源。
void flush(); 将缓冲区中的数据一次性写到存储地(文件)中去。确保存盘成功。
9、File文件类，它的作用：用来管理(创建，删除，修改，查看等)文件和目录。
该类的常用方法：　
案例1：　将指定位置下的所有文件名、目录名及其相关属性列出。
应用举例：
//1 准备一个路径
String path = System.getProperty("user.dir"); //获取当前用户的当前工作路径
(System.getProperty(“line.separator”);文件中换行、换段)
//2 构建一个File类的对象来管理此路径
File  f1 = new  File( path );
//3 通过File类对象的list()方法获取指定路径下的文件名和目录，构成一个数组。
String[] fileDirNames = f1.list();
//4将路径信息与文件名和目录存放在File类中，一一取出；
File  f2 = new File( path + "\\" + fileDirNames[i] );
long dt = f2.lastModified();//5获取修改日期（毫秒数）
Date d1 = new Date（dt）；//转换成日期类
long len = f2.length（）；//获取文件大小；
1) 什么是路径？
2) 绝对路径和相对路径？
3) ./ 当目录 ;   ../ 表示当前目录上一级，即：父目录。
案例2：　在用户当前的工作位置下创建一系列目录和一个文件。
应用举例：
String  path = System.getProperty("user.dir");
//获取用户当前的工作位置
//1 准备要创建的文件名和一系列目录名。
String  fileName = "MyFileasdfasdf.java";
String  dirs = "目录1" + File.separator + "目录11";
//构造一个File类的对象。注意：这里dirs, fileName在磁盘上是不存在的。
File  f1 = new File( dirs, fileName );
f1.getParentFile().mkdirs(); //创建一系列目录，即：创建"目录1\目录11"
f1.createNewFile();//创建MyFile.java文件
File类常用方法：
boolean canRead()；boolean canWrite（）；可读可写吗？
boolean exists（）；存在吗？
boolean isFile（）;是文件目录吗？
boolean isHidden（）；是隐藏的吗？
long lastModified（）；获取最后的修改时间；
long length（）；获得文件长度；
String getName（）；获得文件目录或名称；
String getPath（）；获得文件的路径；
boolean createNewFile（）；创建一个文件或目录；
boolean delete（）；删除文件或目录；
void boolean deleteOnExit（）；jvm退出时删除；
boolean mkdir（）；创建单个目录；
boolean mkdirs（）；创建在路径中的一系列目录；
String【】 list（）；列出该目录下的所有文件名及目录名放在字符串数组中；
System path = System.getproperty(“use.dir”);获取当前用户的工作路径；
File f1 = new File();
f1.getAbsolutePat();获取文件的绝对路径；
二、以字节方式读取文件或存盘文件的操作类: FileInputStream 和 FileOutputStream
1、FileInputStream : 文件的字节输入流。
int read(); 以字节方式读取文件的内容，当反馈-1时表示结束了。
void close(); 关闭输入流，释放所占资源。
案例1: 以字节的方式读取文件的内容并显示在屏幕上。
//1 准备要读取的文件
String  path = "d:\\a1.txt";
//2 声明FileInputStream类的对象变量
FileInputStream  fis = null;
//3 创建该类对象实现文件内容的读取
fis = new  FileInputStream( path );//3
int x = fis.read();//4 读取
while( x != -1 ){// 判断读完了吗？

fis.close();//文件关闭
2、FileOutputStream : 文件的字节输出流。
void write(int x);
void close();
void flush();
案例2 : 以字节方式将数据（26个字母）存储到文件中。
//1准备要存储的文件
String  path = "d:\\char26.txt";
//2声明FileOutputStream类的对象变量
FileOutputStream  fos = null;
//3创建该类对象实现文件内容的存储
fos = new FileOutputStream( path );//3
fos.write( “要写的内容” );
fos.flush(); //确保存盘成功。
if( fos != null )//文件关闭
将FileInputStream 和 FileOutputStream 两者合起实现文件的复制。

(0630):文件字符输入输出流、缓冲流、处理流
一、文件字符输入输出流
FileReader : 文件的字符输入流。
１、它以字符的方式读取文件的内容。
２、它的常用方法:
int read(); 以读取文件内容的一个字符，
反馈该字符的编码值，若为-1则表示结束了。
void close();
３、案例：读取指定文件的内容并显示在屏幕上。
FileWriter : 文件的字符输出流。
1、它以字符方式将数据存盘。
2、它的常用方法:
void write( int x );
void flush();
void close();
3、案例：　将26个大写字母或多个汉字存盘到指定的文件中。
将FileReader 和 FileWriter 两者合起实现文件的复制。
思考2:  对于文本文件，能否从某个百分数（如：50%处）开始复制。
对FileWriter类提供特有方法:
void  writer(String str); 用来存储一个字符串。
二、缓冲流
缓冲流有两对：
1、缓冲的字节输入／出流。
BufferedInputStream  : 缓冲的字节输入流。
BufferedOutputStream : 缓冲的字节输出流。
2、缓冲的字符输入／出流。
BufferedReader  : 缓冲的字符输入流。
BufferedWriter  : 缓冲的字符输出流。
3、缓冲流必须套接在节点流上。
4、缓冲流出现的目的是: 提高输入／出效率。
案例：提高复制文件的速度。
5、缓冲流的特性:
1、提高输入或输出的速度，即：效率。
2、缓冲流的特有方法:
1) mark(); 用来作标记，便于中途返回到该标记处。
2) reset(); 它与mark();方法配合使用，用来返回到标记处。
3) BufferedReader类的 readLine()方法，用来读取整行内容。
4) BufferedWriter类的 newLine()方法，用来产生一个新行，即: 换行。
应用举例：
bis.mark(365); //作标记（365作为标记可变）
bis.reset(); //返回到标记处。

str = br.readLine();//读取一行, 当遇到\r或\n时表示一行结束了。
bw.write( str );//将读取的一行内容存盘到bw对应的文件去。
bw.newLine(); //bw.write("\r\n"); //在文件中换行。
文件加速复制（利用缓存）：
FileInputStream   fis = null;
FileOutputStream  fos = null;
////////////////////
BufferedInputStream   bis = null;
BufferedOutputStream  bos = null;
////////////////////
fis = new FileInputStream( path1 );
fos = new FileOutputStream( path2 );
//将节点流(文件字节输入流)作为参数创建缓冲流。
bis = new BufferedInputStream( fis ); //提高读取的速度
bos = new BufferedOutputStream( fos );//提高存盘的速度
int x = bis.read(); //fis.read();
bos.write( x ); //fos.write( x );
bos.flush();  //fos.flush();
bis.close();
fis.close();
bos.close();
fos.close();
三、处理流：
处理流:  LineNumberReader 类，它以行的方式读取文件的内容。
以上类还有具有：读取行号的功能。
LineNumberReader  lnr = null;
fr = new FileReader( path );
lnr = new LineNumberReader( fr );//创建以行的方式处理文件内容
String str = lnr.readLine();
int row = lnr.getLineNumber(); //读取行号






（0704）：对象流、数据流、转换流、打印流、键盘输入
对象流：ObjectInputStream 和 ObjectOutputStream 一对。
1、它们以对象为单位，将对象实现存盘或读取。
2、方法：writeObject(); 和 readObject(); 实现对象的存盘和读取。
3、对象流的使用必须做到以下几点：
1) 自定义类必须实现java.io.Serializable; 使对象串行化。
2) 在自定义类往往需要重写 toString();方法。
3) 在创建对象流时，必须套接在FileOutputStream(path)和FileInputStream(path)对象上。
4) 通过writeObject(Object obj);方法将对象存盘。
5) 通过readObject();方法读取对象。
应用举例：
//准备一个文件用来存储对象
String path = "d:/Objects.txt";
//准备对象输出流的对象变量
ObjectOutputStream  oos = null;
//准备对象输入流的对象变量
ObjectInputStream  ois = null;

//准备要存盘的对象
Person p1 = new Person("张三", true, 21);
Person p2 = new Person("李四", false, 19);
Person p3 = new Person("王二", true, 22);

try {
//创建对象输出流的对象，实现将对象存盘到文件中。
oos = new ObjectOutputStream( new FileOutputStream(path) );
oos.writeObject( p1 ); //将对象存盘
oos.writeObject( p3 );
oos.writeObject( p2 );
oos.flush();//确保存盘成功。
//创建对象输入流的对象，实现读取指定文件中的对象
ois = new ObjectInputStream( newFileInputStream(path) );
//显示这三个对象的内容。
Person pp = (Person)ois.readObject();
while( pp != null ){
System.out.println( pp );
pp = (Person)ois.readObject();
}
oos.close();
}

数据流: DataInputStream和DataOutputStream　一对。
1、DataInputStream 数据字节输入流。专门用来处理八种基本类型的数据及字符串的输入。
2、DataOutputStream 数据字节输出流。专门用来处理八种基本类型的数据及字符串的输出。
3、它们通常用来网络中实现基本类型数据的输入输出。
4、它们的方法是配对使用的。如:
readInt();  与 writeInt();  等。
readUTF();  与 writeUTF(); 用来处理字符串。
5、它们在使用时，要注意输出与输入的顺序及其配对方法的应用。
6、数据流属于处理流，它在使用必须套接在节点流。
应用举例：
案例：将八种基本类型的数据及字符串存盘到某个文件中；之后，读取它们并显示在屏幕上。
//准备
String  path = "d:/datas.dat";
//准备一个数据输出流的对象变量
DataOutputStream  dos = null;
//准备一个数据输入流的对象变量
DataInputStream   dis = null;
try {
//构建一个数据输出流的对象实现基本类型数据的存盘
dos = new DataOutputStream( newFileOutputStream(path) );
//以下是将八种基本类型的数据存盘。
dos.writeByte(127);


//将字符串存盘。
dos.writeUTF( "今天是个好天气！" );
dos.flush();//确保存盘成功。
System.out.println("八种基本类型的数据及字符串存盘成功。存在" + path + "文件中了。");
//创建一个数据的输入流实现八种基本类型数据及字符串读取。
dis = new  DataInputStream( newFileInputStream(path) );

//以下是读取八种基本类型的数据。
byte b1 = dis.readByte();
///与存储顺序一一对应。
short s1 = dis.readShort();


//读取字符串。
String str = dis.readUTF();
System.out.println( b1 );
System.out.println( s1 );

System.out.println( str );
System.out.println("读取" + path + "文件内容结束了。");
dos.close();

dis.close();

转换流：字节流转换成字符流　或　字符流转换成字节流。
1、InputStreamReader : 字节转换成字符的一个以字符方式读取内容的转换流。
它通常套接在字节流上，如: new FileInputStream(path);
2、OutputStreamWriter : 字符转换成字节的一个以字节的方式存盘的转换流。
它通常套接在字节流上，如: new FileOutputStream( path );
3、在转换流上，还可指定字符的编码集，即：指定字符的编码方案。
4、案例1: 以字符的方式读取文件的内容，但给你的是文件的字节输入流。 (输入流：　由里到外。)
FileInputStream fis = null;
//创建一个缓冲的字符输入流对象.注意：中间要有一个转换流.
br=newBufferedReader( new InputStreamReader(fis) );
（以指定的字符编码集读取：）
InputStreamReader  isr = null;
FileInputStream  fis = null;
//由isr转换流需要套接在 fis上，所以先创建fis的对象。
fis = new FileInputStream( path );
//创建一个转换流，指定以utf-8方式读取文件的内容
isr = new InputStreamReader( fis , "utf-8");

5、 案例2: 以字节的方式存储数据，但你给的是字符串（或多个字符）。 (输出流：　由外到里。)
//创建一个缓冲的字符输出流对象.注意：中间要有一个转换流.
//bw = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream(path)));
（已指定的编码集输出：）
OutputStreamWriter  osw = null; //2
FileOutputStream  fos = null; //3
//由osw转换流必须套接在 fos文件流上。
fos = new FileOutputStream( path );//4
//创建转换流同时指定字符编码方案为utf-8
osw = new OutputStreamWriter( fos , "utf-8"); //5
//将给定的串以utf-8编码方案存盘到osw所套接fos上，即存盘到path文件中。
打印流：　它一定是输出流。它有: PrintStream 字节的打印流和PrintWriter字符的打印流。
1、打印流具有自动刷新功能。
2、它还具有自动的字符转换成字节流的功能。
即：当使用PrintStream字节打印流打印汉字(字符)时，中间不需要转换流。
3、打印流的常用方法为:
* print();
* println();
而且以上两个方法都是重载的方法。
4、在创建打印流对象，它需要套接节点流上。如:  FileOutputStream 或 FileWriter上。
当然，也可直接把　path 作为参数创建打印流对象。(　<<<< 这是打印流的特点。)
(１: 将一些字符以字节打印流的方式打印输出到文件中。)
String path = "printChars.txt";
//准备一个字节的打印流
PrintStream  ps = null;
//创建一个字节的打印流对象
ps = new PrintStream( path ); //new PrintStream( new FileOutputStream(path) );
(2使用字符打印流将多个字符打印到文件中。)
PrintWriter  pw = null;
pw = new PrintWriter( new FileWriter(path) ); for(int i = 0; i < chs.length;  i++){
pw.print( chs[i] );
}

（3改变默认输出：System.out();）
ps = new PrintStream( path );
PrintStream old = System.out; //照像
System.setOut( ps );
// 改变。将系统默认的输出设备改为 ps（即将内容写在path内）
System.setOut( old ); //还原 默认（即将内容显示在屏幕上）
System.out.println("程序到此结束了！");




键盘输入：
//在没有Scanner类时如何从键盘输入数据
BufferedReader  br = null;//1创建缓存对象
br = new BufferedReader(newInputStreamReader(System.in));   
//2从键盘输入，转换成字符流
System.out.print("请从键盘上输入一个字符串(exit退出)>>>>>");
try {
String str = br.readLine();//3读取
while( !str.equals( "exit" ) ){
System.out.println("你输入的是: " + str );
System.out.print("请继续输入>>>");
str = br.readLine();
}
System.out.println(" End. ");
}





（0705）：Java 多线程机制
1、理解并掌握三个概念: 程序、进程和线程？
程序+数据+文档= 软件；
程序是静态的软件的核心；
正在执行的程序就叫进程；动态的
线程是进程的单一的连续的执行流，一个进程可以有多个线程构成；
2、在java语言中，通过java.lang.Thread线程类来管理线程。
3、每一个线程对象都有五个状态：
新生状态，就绪状态，执行状态，[阻塞状态]，死亡状态，
4、线程的新生状态是通过 new + 线程的构造器　来实现。
5、线程由新生状态　通过Thread类提供的 start() 方法使其进行就绪状态。
6、在java语言中，任何一个线程对象都有一个run()方法，即：线程体。
它用来完成线程的主要任务，而且该方法是在线程进入就绪状态后由cpu自动决定调用的，不是人为调用的。
7、在java语言中，创建线程类有两种方法:
（当所构建的类已有一个普通类作为他的父类时要用实现Runnable接口创建线程类；（java语言支持单继承））
1) 通过Thread类扩展生成一个线程子类。
public class Thread1 extends  Thread {
//重写线程体
@Override
public void run() {}
}
（测试类）
//创建两个Thread1的线程对象。
Thread1  t1 = new Thread1("AAA");
Thread1  t2 = new Thread1("BBB");
//让t1,t2线程对象进行就绪状态
t1.start();
t2.start();
}
2) 通过实现java.lang.Runnable接口来创建一个线程子类。
注：为什么要出现第二种方法。(java支持单继承，为了实现多继承)
public class Thread2 extends Person  implements  Runnable {
//重写线程体
@Override
public void run() {}
}
（测试类：）
Thread2  t1 = new Thread2("ABC");
Thread2  t2 = new Thread2("CBA");
//在第二种创建子线程类的方法中，无法让线程对象进入就绪状态。
//将t1作参数目的是用t1的run()方法去覆盖Thread类对象的run()方法。
Thread  t11 = new Thread( t1 );
Thread  t22 = new Thread( t2 );
t11.start();
t22.start();
}



3） 人为干预线程对象的结束。
String name = Thread.currentThread().getName();
//获取当前线程对象的名称.

//重写线程体。
public void run() {

}
//控制线程对象的停止的方法。
public void isStop(){
this.isStop = true;
}
（测试类：）
public static void main(String[] args) {
//明白：主方法main也是一个主线程，其名称就是 main 。
String  na = Thread.currentThread().getName(); //获取当前线程对象。
SubThread3  t1 = new SubThread3();
t1.setName( "AAA" );//通过Thread类的setName()方法为t1线程取名称。
t1.start();//使程序进入就绪状态；


* 这个循环的作用：拖延main线程的时间，从而让t1.isStop()在一段时间后执行。* 即：使得t1线程有一定时间去工作。
for(int i = 1;  i <= 1000000;  i++){
System.out.print("");
}
t1.isStop(); //调用此方法的目的是什么？
让程序停止，调用自定义类中的停止方法；
}

常用方法：
t1.start();
t1.
线程同步：
Synchronized修饰方法时往往用wait（）让当前线程进入等待状态；
notify（）表示当前线程去唤醒等待者，配合他使用，两个方法来自于Object类
当方法对共享资源进行操作时，要用synchronized进行限制，要求其达到同步。





(0706):网络程序设计

一、计算机网络：不同地理范围有独立功能，通过通信介质，在网络操作系统控制下，通信双方遵守共同的通讯规则，实现相互信息的传递，同时达到资源共享的计算机群
资源：硬件资源，软件资源，信息资源
网络协议：通信规则；
OSI：开放的虚拟模型
Arpn网络起源 阿帕网
传输层：遵守规则
路由：为数据传输选择最佳路径
路由器：实现路由的设备
Link：链路层，电气设备匹配
相邻层不认识，每经过一层，加上每一次控制协议，最终统统转换为2进制数据，控制电流，然后相反拆包。
Ip：网络地址，表示网络的唯一编号。
Tcp：传输控制协议，需连接，像打电话
Udp：无需连接，不可靠的连接。
url：统一资源定位器，域名，（协议 主机名 端口 文件信息）
单机编程
c/s局域网编程（客户端/服务器）
b/s远程化编程（j2EE）(浏览器/服务器)
对等网
Ipconfig/all查看本机ip
WINDOWS\system32>ipconfig/all
Cooke:字符串 跟踪服务器
127.0.0.1表示本机；



UDP通讯：
1、UDP是什么？
2、UDP的特点是什么？
3、UDP通讯的必要条件？
1) DatagramSocket(数据报套接字类) 和DatagramPacket(数据报包类)
2) InetAddress (网络地址类)
3) 需要一个字节类型的数组用来接收来存储信息。
4、如何在服务器上实现UDP通讯？
1) 构建一个DatagramSocekt类的对象，并开放一个端口。
2) 准备一个接收数据的接收数据报包(通过DatagramPacket类创建)。
3) 调用receive()方法接收客户端发来的信息。
4) 在接收数据报包上获取客户端的地址和端口号。
5) 将客户端的地址和端口号及要发送的数据封装成一个发送数据报包。
6) 调用send()方法将发送数据报包发送给客户。
7) 重复 2)至6) 步骤可反复实现数据的接收与发送。
5、如何在客户端上实现UDP通讯？
1) 构建一个DatagramSocekt类的对象。
2) 将服务器公开的地址和开放的端口号以及要发送的数据封装成一个发送数据报包。
3) 调用send()方法将发送数据报包发送给服务器。
4) 准备一个接收数据的接收数据报包。
5) 调用receive()方法接收服务器发来的信息。
6) 从接收数据报包上获取信息并做相关的处理（如：显示）。
7) 通讯完毕，要关闭DatagramSocket对象。[/size][/size]