零基础 Java 学习笔记
N久以前在中软学习的Java笔记，排版什么的没时间~凑合看吧
2015/1/22
Day01—————————————————————————————————————————————————————
1、下载JDK和Eclipse
2、安装JDK并配置环境变量，安装位置最好选择为默认位置
环境变量配置：
(1)JAVA_HOME：JDK安装文件目录，如“C:\Program Files\Java\jdk1.7.0_75”；
(2)CLASSPATH：“.”（意义：在当前目录寻找）；
(3)Path：在原变量值最后添加“;%JAVA_HOME%\bin;”（%表示引用）；
检测是否配置完成，DOS指令下使用javac指令比java指令更准确
3、安装Eclipse程序
JDK=JRE+JVM+TOOLS
JDK:Java开发工具；JRE:运行环境；JVM:虚拟机；TOOLS:工具，如：JAVAC,JAVA,DEBUG等等；
JAVA版本/体系
**年更名为Java Platform2
J2SE：标准版 学习的重中之重，是全部学习的基础，编写C/S和桌面级的应用程序；
J2EE：企业版 市场需求大，用于开发B/S架构应用程序；
J2ME：微型版 针对开发非智能机，有被淘汰的趋势；
J2SE的体系结构：
1、编码规范：标示符，变量，注释，数据类型，关键字，运算符，数组
2、类：属性，构造方法，方法
3、类与类的关系：依赖，关联，继承+没有关系；继承，多态，封装，抽象；
4、异常
5、常用的API：数学类，日期类，日历，随机数
6、线程，I/O流，网络编程，GUI
WIN+R 启动计算机“运行”
公开的类名必须与该文件名相同
Java虚拟机的运行过程：
.java文件→编译→.class文件→(运行类加载器→字节码校验→解释器+代码生成器)→操作系统→硬件
Java程序的运行流程：UE/ED/记事本→javac(加载编译器)→java(加载虚拟机)
操作实例：WIN+R，然后CMD，然后E:，然后dir,然后javac 文件名.java(编译命令，生成.class文件)，然后java 文件名(运行命令，注意：没有文件后缀名.java)
.jar文件是用来连接数据库的，由数据库厂商提供
java代码到驱动，驱动到数据库，驱动加载需要.jar文件，由数据库厂商提供
包结构一旦生成就不能更改其内部文件关系，其任何子文件的移植的最小单位都是包本身
com.chinasot.工程名.项目名，包名必须是小写的
cmd指令：
cd:路径切换；dir：查看文件；cd ..查看上一级；tab键补全文件名；
set 查看，set 且赋值= 则会更改属性，但只影响当次的属性值；cls清屏；unzip解压文件指令；
-classpath指定引用类的路径；-d生成包结构，并指定包存储的路径
1、对于拥有包结构的在编译时必须使用-d指令
如：c:\users\adminers>javac -d ( . 默认为本地路径/指定路径) Student.java
2、对于拥有包结构的，在运行时需要完整的限定名（全限定名），即路径的完整性
如：c:\users\adminers>java student1.student2.student3.Student
具体来说：
c:\users\adminers>javac -classpath D:\Temp -d F:\TempE:\temp\Student.java
引用类的路径 生成类的路径 原类路径
c:\users\adminers>java -classpath D:\Temp;H:\Temp student1.student2.student3.Student
是jar 文件成为可执行的文件，在压缩文件中添加文本文件，文本文件内容格式
Main-Class:(一个空格)文件名
（1个空行）
（1个空行）
jar压缩命令：
jar -cvf jar文件名.jar 文件1.class 文件2.class
-cvmf和-cvfm是不同的
解压命令：
unzip jar文件名.jar
—————————————————————————————————————————————————————
1//单行注释
2/*
*多行注释(不能被JavaDoc提取)
*
*/
3/**
*文本注释(能够被Javadoc提取)
*语法：javac -d ./doc Student.java
*/
—————————————————————————————————————————————————————
Java语言区别大小写
—————————————————————————————————————————————————————
标识符
一、概念：类，方法，属性，变量的命名
二、命名规则：
1、字母/数字/下划线/$
2、数字不能作为首字母
3、不能使用系统关键字
4、见名知意，可读性强
5、长度无限制
三、约定俗成：
1、类名：首字母大写，其后每个单词首字母大写
2、方法名：首单词首字母小写，采用驼峰式书写规则
3、变量名：基本用小写，采用驼峰式书写规则
4、常量：全大写；
关键字（小写，50个）：类，对象，包，数据类型，分子，循环，方法，异常，修饰符，保留字
—————————————————————————————————————————————————————
数据类型
1、基本类型：
(1)整数型：(8种)byte（1个字节，-128到127，^7） short（2个字节，-2^15到2^15-1，约正负3W2）
int（4个字节，^31，约正负21亿） long（8个字节，^31，约正负9百万亿）
在整数型中，默认为int，规则上定义long a=1234567890l 或者a=1234567890L，数字后需要一个类型标识
(2)浮点型：float（4个字节，） double（8个字节）
在浮点型中，默认为double，规则上定义double a=1234567890d 或者a=1234567890D，数字后需要一个类型标识
double精度高，有效数字16位，float精度7位，但double消耗内存是float的两倍，double的运算速度比float慢得多
(3)其他： char（2个字节） boolean（true/false，没有1/0）
2、引用类型：类、接口、数组、枚举
1字节=8位
对于计算机来说，存储方式有两种，一种是精确存储(整型)，一种是近似存储(浮点数)
—————————————————————————————————————————————————————
数据类型方面与C不同的方面：
1、Java中的数字首字母为0，会被默认为8进制，与C不同，值得注意
2、int和double类型是默认类型
数据类型转换
1、自动类型转换(隐式类型转换)：弱的基本数据类型可以直接转换成强的基本数据类型，byte-short-int-long-float-double
(1)小转大
(2)整型转换成浮点型
(3)字符型转换成整型
小转大属于自动类型转换，大转小因为存在精度损失，不能通过编译
2、强制类型转换：强的基本数据类型到弱的基本数据类型，或整数型对字符型数据的转换
(1)浮点型转换成整型，略去尾数
(2)整型转换成浮点型，自动补.O
(3)整型转换成字符型
特殊的：1“System.out.println(2>3?1.0:9);”输出结果是9.0而不是9
2在运算时，如果各运算数据类型不同，运算结果取强数据类型
—————————————————————————————————————————————————————
Java字符型数据类型使用的是Unicode码来编码的，不是ASCII码
—————————————————————————————————————————————————————
2015-1-25
Day03
面向对象的特点：继承，多态，封装，抽象
Java语言的特点：面向对象，跨平台(一次编译，处处运行)，健壮性
—————————————————————————————————————————————————————
运算符
1、算数运算符：+、-、*、/、%、++、--
i++与++i的区别：i++先操作后运算，表达式的值等于i的初值，i的值自增1；++i先运算后操作，表达式的值等于i+1，i的值自增1
2、关系运算符：>、<、>=、<=、==、！=
3、逻辑运算符：逻辑与&，逻辑或|，逻辑非！，逻辑异或^,条件与&&，条件或||
逻辑运算符前后连接的必须都是布尔类型的数据
4、位运算符:按位与&、按位或|、按位异或^、按位取反~、左移<<、有符号右移>>、无符号右移>>>
A B A&BA|B ~A A^B
0 000 1 0
0 101 1 1
1 001 0 1
1 111 0 0
原码：数对应的二进制；反码：除符号位其余取反；补码：原码+1
~某数，即该数加1，取反，如~3为-4
>>运算，相当于除2运算
<<运算，相当于乘2运算
5、赋值运算符=、+=、-=、*=、/=、%=、&=、^=、|=、<<=、>>=、>>>=
6、条件运算符（三目运算符）：条件？结果1：结果2
当条件满足，整个表达式的值取结果1；当条件不满足，整个表达式的值取结果2
7、对象运算符：new、instanceof
—————————————————————————————————————————————————————
流程控制:
1、顺序执行
2、分支结构：
(1)if-else：if(条件判断句){
}
else{
}
(2)switch-case：switch(条件表达式){
case 常量1：语句1；
break;
case 常量2：语句2；
break;
case 常量3：语句3；
break;
……
default:语句;
break;
}
条件表达式的值类型：byte,short,int,char,String,enum(枚举)
(布尔类型是不可以的)
各常量不能相同
3、循环语句：
(1)for语句：for(初始化语句；循环条件句；自增/减运算){
循环体语句
}
(2)while语句：while(条件判断句){ 循环体语句}
(3)do-while语句：do{
循环体语句；
}while(条件判断句);
for是知道循环次数，while不知道循环次数；
4、跳转语句：break和continue
(1)break：跳出整个循环
break-标记：标记N:循环语句{
break 标记N;
}
break用于：switch、while、do-while、for
(2)continue：表示结束continue后面的语句，返回循环条件，进入下一次循环
(3)System.exit(0);返回0表示正常退出，返回为其他值表示不正常退出
break结束整个循环，后面有永远不能被访问的代码，编译器不能通过；
System.exit(0);语句是结束整个main方法,停止虚拟机，其后面有代码是被允许的，编译器可以通过；
(4)return：标志方法体的结束，并且返回方法体的返回值类型相同
—————————————————————————————————————————————————————
数组
1、概念：相同数据类型元素的集合
2、作用：数据类型为引用数据类型，即对象，可以存储基本数据类型，也可以存储引用数据类型
3、声明方式：int[] a和int a[]，建议使用第一种
a的数据类型为int 的数组类型
4、创建：
(1)动态创建：声明的同时指定数组长度，分配内存，数组值取默认值
(int的默认值为0，char的默认值为\u0000)
char[] array = new char[10];
(2)静态创建：声明并初始化，分配相应内存
int[] array= new int[]{1, 2, 3, 4, 5};
(3)同方式2，简略写成
int[] array = {1, 2, 3, 4, 5};
数组名为一个引用，虚地址，数组名，指针放在栈里，而数组元素的值放在堆里
5、数组的赋值
(1)C语言数组间是不能互相赋值的，Java中允许数组间的赋值，但是!只表示将赋值数组首地址赋给被赋数组，不新建内存空间指向相同的内存空间
(2)方法一：import java.util.Arrays;后使用数组对象.copyOf();
方法二：System.arraycopy();
6、数组的长度是数组的属性，而不是方法，可以使用array.length获得值，绝不要出现array.length()
数组长度一旦定义就不被改变，内存分配了length+1个空间，除了存储了数组的各值，还存储了一个array.length值
7、索引(数组下标)从0到length-1，数据类型为整型
8、数组的迭代
(1)下标取值：下标0到length-1
(2)for语句
(3)增强for语句(for each)：for(数组元素类型 临时变量名：数组名){}
等同于 for(i=0;i<数组.length;i++){临时变量=数组[i];}
二维数组
1、声明方式：int[][] a、int[] a[]和int a[][];
2、创建：int[][] a=new int[3][];第一个数不能省略
3、二维数组中数组名（指针）放在栈里，而数组的值放在堆里，堆被分成两个部分，一部分存储每行首地址，一部分存储元素值
4、二维数组的迭代：for(int i=0;i
}
}
—————————————————————————————————————————————————————
排序
1、冒泡排序
(1)逐次比较临近的两个数，如果前者大于后者，则交换数据，直至将最大数排列到队尾，这便是所谓的冒泡
将冒泡出的数排除比较队列，剩下的数重复以上操作，以此类推，直到完成所有数据的排列
int[] array={……};
for(int i=0;i
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
2 651 0 8 439 7（原始的随机排列）
2 510 6 4 387 9（第一轮排序后）
2 105 4 3 678 9（第二轮排序后）
1 024 3 5 678 9（第三轮排序后）
0 123 4 5 678 9（第四轮排序后）
0 123 4 5 678 9（第五轮排序后）
0 123 4 5 678 9（第六轮排序后）
0 123 4 5 678 9（第七轮排序后）
0 123 4 5 678 9（第八轮排序后）
0 123 4 5 678 9（第九轮排序后）
(2)优化：冒泡排序中，进行到某轮后所有数在实际上已经排列完成，无需进行到array.length-1轮
int[] array={……};
for(int i=0;i
for(int j=0;j
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
flag=false;
}
}
if(flag){break;}//判断前n个数在实际上是否已经排列完成
}
2 651 0 8 439 7（原始的随机排列）
2 510 6 4 387 9（第一轮排序后）
2 105 4 3 678 9（第二轮排序后）
1 024 3 5 678 9（第三轮排序后）
0 123 4 5 678 9（第四轮排序后）
（break;）
(3)再优化：当遇到队列尾部若干数已经排列完成(顺序合理，且大于前面未排序的所有数)
int[] array={……};
int index=array.length-1;
for(int i=0;i
int p=0;
for(int j=0;j
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
flag=false;
p=j+1;
}
}
if(flag){break;}
index=p;
}
2、快速排序(挖坑填坑法)：Arrays.sort(int[] a);
思想：把第一个数字赋给临时变量，自右而左依次取数与临时变量比较，将第一个出现的比临时变量还小的数赋到第一个数的位置，把临时变量赋值到该数的位置上
自左而右的查询第一个比临时变量还大的数，并将该数赋值到临时变量的位置，将临时变量的值赋值到该数原先的位置
依次类推，直至临时变量左侧的全部都比其小，右侧的全部都比临时变量大
全体数字以临时变量的位置分段，各段如上比较，直至排序完成
—————————————————————————————————————————————————————
Arrays类
1、import java.util.Arrays;
2、(1)binarySearch():使用二分法搜索数组中的指定值；
(2)copyOf(元素类型[] 原数组名, int 复制长度)：复制指定数组，截取或扩容（不足补0）；(与system中arraycopy功能相同；)
(3)equals(类型[] 数组1，类型[] 数组2):判定两数组是否相等；
(4)sort(类型[] 数组名 ):数组元素升序排列(可指定序列范围)；
(5)toString():数组内容的字符串显示；
(6)deepToString():深层显示数组内容以字符串形式，针对的是多维数组
—————————————————————————————————————————————————————
字符串
1、java.lang是内置的基础包，包含多个常用的类，默认下，自动导入java程序，无需显示调用
2、String是引用数据类型，字符串是String类的对象，字符串一旦被创建就不能被更改
3、String类的构造方法
(1)String():创建一个空字符串
(2)String(String original):新建一个字符串作为指定字符串的副本
(3)String(char[] value):根据字符数组构造一个新字符串
(4)String(byte[] tytes):通过转换指定的字节数组新建一个字符串
4、字符串的length是方法，调用时是字符串名.length();数组的length是属性，调用时是数组名.length;
5、==与equals()方法的区别：==比较的是字符串首地址是否相同；equals()比较的是字符串内容是否相同；返回值均为布尔类型的true/false
6、String string1="abc"与String string2=new String("abc")的不同：
(1)String string1的存储路径是在“字符串常量池”里的，建立"abc"字符串时，系统现在字符串常量池里查找该字符，当该字符串已存在于常量池里就把地址赋给字符串名，使之指向该地址，如果在常量池中找不到该字符串，就开辟新空间存储该字符串
（字符串常量开辟的空间在该字符不再使用后被系统自动回收机制检测到，并销毁）
(2)String string2使用new方法，在堆内开辟一个新空间存储该字符串，如果再new一个与string2内容一致的字符串string3，其存储路径与string2不同
7、字符串比较
(1)boolean equalsIgnoreCase(String anotherString):判断字符串anotherString是否与当前字符串相等，忽略大小写形式
(2)int compareTo(String anotherString):根据ASCII码比较字符串anoterString和当前字符串的大小，返回值为两个字符串中第一个出现不同的字符的ASCII码差值，anotherString-当前String
(3)boolean startsWith(String prefix):判断当前字符串是否以字符串prefix为开头
(4)boolean endsWith(String suffix):判断当前字符串是否以字符串suffix为后缀
8、字符串元素搜索
(1)int indexOf(char cha):搜索字符cha在当前字符串中第一次出现的索引，没有出现则返回-1
(2)int indexOf(String str):搜索字符串str在当前字符串中第一次出现的索引，没有出现则返回-1
(3)int lastIndexOf(char cha):搜索字符cha在当前字符串中最后一次出现的索引，没有出现则返回-1
(4)int lastIndexOf(String str):搜索字符串str在当前字符串中最后一次出现的索引，没有出现则返回-1
9、字符串元素提取、连接和替换
(1)char charAt(int index):用于从指定位置提取单个字符，该位置由index指定，索引值必须为非负
(2)String substring(int index):用于提取从index指定的位置开始直到结尾的字符串部分
(3)String substring(int begin,int end):用于提取begin和end位置之间的字符串部分
(4)String concat(String str):用于连接两个字符串，并新建一个包含调用字符串的字符串对象
(5)String replace(char oldChar,char newChar):用于将调用字符串中出现oldChar指定的字符全部都替换为newChar指定的字符
(6)String replaceAll(String oldString,String newString):用于将调用字符串中出现oldString指定的字符串全部都替换为newString指定的字符串
(7)String trim():用于返回一个前后不含任何空格的调用字符串的副本
10、字符串大小写转换
(1)String toUpperCase():返回当前字符串的全大写形式
(2)String toLowerCase():返回当前字符串的全小写形式
11、格式转换
(1)byte[] getBytes():返回当前字符串转化成byte型数组的形式（即字符串在内存中保存的最原始的二进制形态）
(2)char[] toCharArray():返回当前字符串的字符数组形式，类似于C语言中字符串的保存形式
—————————————————————————————————————————————————————
1、类的结构
(1)属性：成员变量，实现对数据的描述，声明在类内的为成员变量，在方法体内的为局部变量/临时变量；
(2)方法：成员函数，类实现方法；
分静态方法和非静态方法,静态方法可用类名直接调用，非静态方法要用对象调用
(3)构造方法：在建立对象时，初始化类成员变量；
(4)内部类：inner class,在类内声明一个类；
(5)块：分为静态块和实例块；
2、类的声明：[访问权限] [修饰符] class 类名{
}
3、成员变量声明：[访问权限] [修饰符] 数据类型 成员变量名；
4、成员函数声明：[访问权限] [修饰词] 返回类型 成员名（形参列表）{
……
return 返回值；
}
5、(1)访问权限：public，protected，default，private；(2)修饰符：final，synchronized，abstract
6、方法若没有返回值，则用关键字void表示，如果return语句在该方法最后一行则可省略不写
—————————————————————————————————————————————————————
1、方法重载
(1)方法名相同
(2)参数不同：数量不同、类型不同、顺序不同
(3)同一作用域(类域)
2、访问权限：权限从大到小为public>protected>default>private
(1)公共权限public:修饰类、属性、方法可以被任意类访问
(2)受保护权限protected:修饰属性、方法可以被同包类及其子类访问
(3)同包权限(default):修饰类、属性、方法只能被同包的类访问
(4)私有权限private:修饰属性、方法只能在本类中访问
本类 同包子类不同包(其他类)
public OK OK OKOK
protected OK OK OK
(default) OK OK
private OK
3、共有类名必须与该文件名相同
—————————————————————————————————————————————————————
1、包的概念：物理上是文件夹；逻辑上是有逻辑关系的类的集合
2、包的作用：避免类重名；控制访问权限
3、包(package)的命名规范：在包名中，可以使用.号来区分包的级别；包名一般情况下是小写
(1)指该项目的类型，如com,org,gov等
(2)指项目开发或者运行的公司名称，如：chinasofti,icss,huawei等
(3)指项目的名称，如：corejava,bcms,oa,erp等
(4)指项目模块的名称，如：bean,action,exception,chapter01等
4、导入外部包的类，关键字“import”
—————————————————————————————————————————————————————
构造方法
1、声明：类名 对象名=new 构造方法();
2、创建：[访问权限] 类名(形参列表){ }
3、方法名与类名相同;没有返回值类型;对类初始化，在创建对象同时系统自动调用构造方法;
无参构造方法，只有在该类没有声明任何构造方法的时候，才是默认存在的；只要声明了其他带参的构造方法，无参的构造方法将不会默认存在，而是必须声明才可以使用
4、this.name=name;中的this表示当前对象的引用，第一个name为类的属性名，第二个name为方法的形参
—————————————————————————————————————————————————————
对象
1、创建：类名 对象名=new 构造方法(参数列表);
2、创建了两个实体，(1)对象引用变量，即对象名，存储在栈里(2)对象本身，用new 构造方法名()创建对象，将对象的属性值存储在堆内
—————————————————————————————————————————————————————
封装性是一种信息隐藏技术
1、含义：(1)对象的全部属性和全部方法结合在一起，形成一个不可分割的独立单位；(2)尽可能隐藏对象的内部结构
2、表现：属性使用private权限,方法使用public权限
public class Trainer{
private String name;
public void setName(String name) {
this.name = name;
}
public String getName (){
return name;
}
}
—————————————————————————————————————————————————————
基本数据类型与引用数据类型的区别：
(1)意义上：基本数据类型是变量，是单纯的值；引用数据类型是对象，是引用；
(2)存储方式上：基本数据类型在栈内存储值本身；引用数据类型在栈内存储引用，在堆内存储值本身；
(3)赋值方式：基本数据类型可直接赋值；引用数据类型的赋值要使用到new()方法，但！String和包装器类作为特殊的引用数据类型，也可直接赋值
赋值：
(1)基本数据类型之间赋值，是将值进行拷贝
(2)引用数据类型之间赋值，是虚地址之间的赋值，要使用到new()方法
==运算
在判断引用数据类型时判断的是地址，即虚地址一样才返回true
在判断基本数据类型时判断的是数值，即二进制一样才返回true
成员变量与局部变量的区别：
(1)定义：在类内声明的变量或常量称为属性，是成员变量；在方法内声明的变量为局部变量，亦称为临时变量；
(2)权限修饰：成员变量可以使用四种权限修饰符修饰，而局部变量不可以；static可修饰成员变量，不能修饰局部变量；final既可以修饰成员变量，又可以修饰局部变量；
(3)作用域：成员变量(属性)可以在整个类中使用，局部变量只在当前方法中使用；如果局部变量与属性重名，则遵守就近原则，可以使用this区分
(4)生命周期：成员变量的生命周期很长，随着类加载或者创建对象被初始化，直到没有对象引用才回收；局部变量生命周期很短，执行某个方法时临时被初始化，方法结束即被回收。
(5)其他：属性都有默认的初始化值，如引用类型都是null，整型是0等，局部变量不被自动初始化，必须手工初始化
—————————————————————————————————————————————————————
SVN的在Eclipse下的集成与使用
1、集成：将集成文件解压到Eclipse下的dropins文件，重启Eclipse
2、使用
(1)Eclipse窗口-显示视图-其他-SVN-SVN资源库-指定SVN服务端地址(如:https://192.168.5.92:8443/svn/JavaSE)
在控制台附近出现“SVN资源库”对话框;
(2)在SVN资源库右键建立“资源库位置”，并指定地址
(3)在已建立的Eclipse项目上右键-Team-项目分享-SVN-资源库位置信息
(4)Eclipse本地文件在修改后需要将更新内容与服务端同步，项目-Team-提交；SVN服务端文件更新后与本地信息的同步，项目-Team-更新
—————————————————————————————————————————————————————
static属性、方法、块
1、概念
(1)如果类的某个属性与实例无关，不管创建多少个对象，属性的存储空间都只有一个，而与对象没有关系，则应该定义为静态属性
(2)如果类的某个方法与实例无关，不管创建多少个对象，都执行相同的操作，与对象没有关系，则应该定义为静态方法
(3)用static修饰的静态代码块，在Java虚拟机加载该类时执行该代码块，无论是否创建对象，创建多少个对象，都仅仅只执行一次
2、意义：
(1)与对象无关，只与类有关，能够让多个对象共享数据、方法，提高效率
(2)一个类中可以有多个静态块，按照顺序执行
3、使用
(1)private static String name;
(2)public static void main(String[] args){}
(3)static{
System.out.println("123");
System.out.println("456");
System.out.println("789");
}
4、静态成员函数与非静态成员函数的互相调用
(1)非静态成员方法间可以互相调用，静态成员方法间可以互相调用
(2)静态成员方法不可直接调用非静态成员方法，需创建对象，以调用该方法
—————————————————————————————————————————————————————
final属性、方法和类
1、定义
(1)属性:定义就必须直接赋值，并且后期都不能修改
(2)方法:定义必须有实现代码，并且子类里不可被覆盖
(3)类:不能被定义为抽象类或是接口,不可被继承
2、使用
(1)final修饰的成员变量的赋值
编译器常量：声明时同时赋值，往往与static一起使用，private static final double pi=3.14;
运行期常量：声明时不赋值，但要在构造方法中赋值，private final int level;
public Test(){
level=0;
}
静态常量：final修饰的方法参数的赋值，public void Test(final int a){a=12;}
—————————————————————————————————————————————————————
包装器类
1、Java提供一系列的包装类，以便将基本数据类型当作对象进行操作
基本数据类型 对应的包装器类型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
2、每个包装类都有一个静态的valueOf()方法，用于将字符串转换成相应包装类的对象
String str="110";
Interger objectInt=Interger.valueOf(str);
System.out.println(objectInt);
3、除了Character和Boolean类以外，其他的包装类都有静态的parseXxx()方法，用于将字符串转换成相对应的基本数据类型值
String str="110";
int digitInt=Interger.parseInt(str);
4、Character类中的一些方法(以下全为静态方法，可以直接用类名.方法名调用)
boolean isLetter(char ch)判断字符ch是否为英文字母
boolean isDigit(char ch)判断字符ch是否为0~9之间的数字
boolean isUpperCase(char ch)判断字符ch是否为大写形式
boolean isLowerCase(char ch)判断字符ch是否为小写形式
boolean isWhitespace(char ch)判断字符ch是否为空格或换行符
5、自动装箱、拆箱操作
(1)概念：int i1=0;Interger objectInt=i1;//装箱
int i2=objectInt;//拆箱
(2)特殊的池操作：
整型常量池：-128~127域值，在域值内的整型数存储在常量池内，超出的需要使用到大整型来存储
public static void main(String[] args){
Integer i1=1;
Integer i2=1;
System.out.println(i1==i2);//true
Integer i3=128;
Integer i4=128;
System.out.println(i3==i4);//false
}
—————————————————————————————————————————————————————
值传递与引用传递
1、值传递的本质是赋值,是把实际参数赋值给形式参数的过程
(1)基本数据类型的参数传递是值之间的赋值
(2)引用数据类型的参数传递是虚拟地址之间的赋值
2、修改形参对实参的影响
(1)基本数据类型在传递过程中形参改变实参不改变
(2)引用类型在传递过程中形参改变实参也改变
(3)String和包装器类作为特殊的引用数据类型，其传参规律遵循基本数据类型的传参规则
—————————————————————————————————————————————————————
类与类的关系
1、关联关系(has-a)
(1)意义：表示对象与对象之间的连接，存在“有”的关系，在代码表现形式上为一个类(B)作为另一个类(A)的属性而存在；
(2)分类：
1)弱关联(类的聚合)：销毁A类的对象对B类的对象无影响，代码表现为
public class A{
private B temp;
}
public class B{}
创建A对象时B对象可以不创建,当A对象销毁时B不销毁
2)强关联(类的组合)：A类的对象在销毁时必须同时销毁B类的对象，代码表现为
public class A{
private B temp=new B();
}
public class B{}
创建A对象的时B类同样创建，A对象销毁时，B对象也销毁
(3)关联关系的方向：单向关联、双向关联
单向关联
public class A{
private B temp;
}
public class B{}
双向关联
public class A{
private B temp;
}
public class B{
private A temp;
}
(4)关联关系的多重性：一对一、一对多
一对多（使用数组或集合)：public class A{
private B[] temp;
}
public class B{}
2、依赖关系(use-a)
(1)意义：表示类与类的关系，存在“使用到”的关系，在代码表现形式上为一个类(B类)作为另一个类(A类)的某个方法的参数而被使用；
public class A{
public void method(B temp){};
}
public class B{}
(2)依赖与关联的生命周期
如果A类关联B类，那么创建A类的对象时实例化B类的对象，直到A类对象被销毁，所关联的B类对象也被销毁。即只要A类对象存在，B类对象就存在。而如果A类依赖B类，那么只有当A类对象调用到相应方法时，B类对象才被临时创建，方法执行结束，B类对象即被回收，A类和B类之间的依赖关系是一种瞬时的、偶然的、非常弱的关系。
3、继承关系(is-a)
4、实现关系
5、没有关系
—————————————————————————————————————————————————————
继承
1、概念：所谓继承是指一个类的定义可以基于另外一个已经存在的类，即子类基于父类，从而实现父类代码的重用，子类能吸收已有类的数据属性和行为，并能扩展新的能力。
2、使用：[访问权限修饰符] class修饰符子类类名 extends 父类类名{类体}
3、构造方法的调用顺序：子类构造方法总是先调用父类构造方法，默认情况下，自动调用父类无参构造方法；可手动调用有参构造
4、其他
(1)在声明一个有参构造方法时最好也必须同时显式声明一个无参构造方法，因为在继承关系上，子类无法调用有参构造方法时会自动调用无参构造方法，但父类如果声明了有参构造方法，系统将不再自动提供无参构造方法，这会导致子类的构造方法无法访问父类的构造方法
(2)子类的构造方法必须在第一行使用super()是因为“子类有责任保证所继承的父类尽快进入到一个稳定的、完整的状态中去”，父类的某些成员变量很可能被修改而造成子类的某些不可预料的麻烦；
—————————————————————————————————————————————————————
this
1、使用方法
(1)类内使用this关键字引用本类的成员变量
(2)类内使用this关键字引用本类的成员方法
(3)在构造方法中用this引用本类的其他构造函数
(4)使用this关键字代表自身类的对象
换句话说，每个类内部都有一个隐含的成员变量，该成员变量的类型是该类的类型，该成员变量的名称是this
2、其他：this不能在静态方法中使用
——————————————————————————————————————————————————————
super
1、this通常指代当前对象，super通常指代父类
2、子类的构造方法必须在第一行使用super()是因为“子类有责任保证所继承的父类尽快进入到一个稳定的、完整的状态中去”，父类的某些成员变量很可能被修改而造成子类的某些不可预料的麻烦；
—————————————————————————————————————————————————————
方法覆盖/重写
1、子类修改从父类继承到的方法的方法体，而不改变参数类型、返回值类型，使用方法覆盖/方法重写
2、要点：同方法名+同参列表+同返回值类型+访问权限不能缩小
—————————————————————————————————————————————————————
抽象
1、概念
(1)抽象类：如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类
(2)抽象方法：如果一个类定义了一个方法但没有给出明确的方法体，由其继承子类给出方法体，那么该方法为抽象方法
2、使用
(1)抽象类：[访问权限] abstract class 类名{}
(2)抽象方法：[访问权限] abstract 返回值类型 方法名(参数列表);(说明：访问权限必须为public)
3、其他
(1)抽象类可以有成员属性和非抽象的成员方法
(2)具有抽象方法的类一定是抽象类，但抽象类未必一定有抽象方法
(3)抽象类不可被实例化，但可以有构造方法
(4)抽象类只能作为基类而被子类继承，其子类可以依然是抽象类，也可以是非抽象类，但其非抽象子类必须实现其所有抽象方法
(5)abstract不可以修饰构造方法和静态方法
—————————————————————————————————————————————————————
多态
1、多态的含义是：对外一种表现形式，内在有多种具体实现。
2、多态的具体体现：方法重载+方法覆盖+多态参数
3、编译期类型和运行期类型[详见……]
4、多态参数
(1)父类的引用指向子类的对象
public class Animal{……}
public class Cat extends Animal{……}
Animal ac = new Cat();
(2)多态参数:方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象
public class Animal{ public void show(){System.out.println("This is Animal");}; }
pubilc class Cat extends Animal{ public void show(){System.out.println("This is Cat");}; }
public static class Test{
public void menthod(Animanl ani){
ani.show();
}
public static void main(String[] args){
Cat c=new Cat();
menthod(c);//结果：This is Cat
}
}
5、多态环境下对成员方法、静态方法、成员变量的调用
(1)多态环境下对成员方法的调用
public class Animal{public void show(){System.out.println("Animal");} }
public class Cat extends Animal{public void show(){System.out.println("Cat");} }
Animal ac=new Cat();
ac.show();//输出结果：Cat
总结：编译看左，运行看右
(2)多态环境下对静态方法的调用
public class Animal{public static void show(){System.out.println("Animal");} }
public class Cat extends Animal{public static void show(){System.out.println("Cat");} }
Animal ac=new Cat();
ac.show();//输出结果：Animal
总结：编译、运行都看左
(3)多态环境下对成员变量的调用
public class Animal{int i=0; }
public class Cat extends Animal{int i=1; }
Animal ac=new Cat();
ac.i;//输出结果：0
总结：因为成员变量不存在覆盖的概念，被定义为Animal类的ac其值必然为其本类的值，编译、运行都看左
6、多态环境下的对象造型
(1)向上造型/自动类型提升
public class Animal{ public void a(){} }
public class Cat extends Animal{ public void b(){} }
Animal ac=new Cat();
ac.a();//允许
ac.b();//不被允许，不能使用子类的方法
(2)向下造型/向下转型
public class Animal{ public void a(){} }
public class Cat extends Animal{ public void b(){} }
Animal ac=new Cat();
Cat ca=(Cat) ac;//强制类型转换
ca.a();//允许
ca.b();//允许
—————————————————————————————————————————————————————
编译期类型和运行期类型
1、概念：A a=new A();
(1)声明a的时候，使用到的类型A表示对象的类型，被称为编译期类型。在编译期，虚拟机认为a的类型是A，对于a所使用的属性和方法的有效性将到类A中去验证。
(2)构造方法A()中的A是运行期类型。在运行期，将执行运行期类型中的方法。
2、情况：
(1)编译期类型与运行期类型一致
A a=new A();
(2)编译期类型与运行期类型不同
当有继承关系时，可能发生编译期类型和运行期类型不同的情况，即编译期类型是父类类型，运行期类型是子类类型
A ab=new B();
对象ab的编译期类型为父类A类，运行期类型为子类B类
ab对象使用的方法，在编译期到类A中去校验，而运行则执行B类的方法
3、强制类型转换：如果一个对象的编译期类型是父类，运行期类型是子类，可以对该对象进行强制类型转换，将其编译器类型转换为与运行期类型相同的类型，即：B b=(B)ab;
—————————————————————————————————————————————————————
instanceof
1、意义：判断某一对象是否为某类的实例，返回值为布尔类型
对象名 instanceof 类型名
2、要点内涵：instanceof运算符判断该对象在【运行期】的类型是否为该类型，通常在判断成立后若要使用该对象的所有的成员方法还需进行一次向下转型(原理参考编译期类型和运行期类型)；
—————————————————————————————————————————————————————
单例模式，具备以下三个条件：
(1)建立私有的静态的类的对象，并初始化
(2)私有的构造方法
(3)提供一个公开的静态的获得该类实例的方法
private static Person p = new Person();
private Person(){
}
public static Person getPerson(){
return p;
}
—————————————————————————————————————————————————————
Object类
1、概念：Object类是所有类的父类(包括数组)，存在于java.lang包下，是所有类的根
拓展：方法中的参数是Object和Object[]之间的区别
方法中的形参是Object类型时，任何类型的参数都可以传进去执行。
方法中的形参是Object[]类型时，只有对象数组可以传入执行。
public static void arrayTest(Object[] obj){
}
public static void main(){
int[] array=new int[4];
arrayTest(array)//错误出现
}
2、Object类中的常用方法
(1)equals():
Object类中的equals()方法用以比较两个引用的虚地址，当且仅当两个虚地址相同才返回true
（String中的equals()方法比较的是内容，因为String重写了Object中的该方法）
（两个对象存储地址相同，哈希码值相同；哈希码值相同，存储地址未必相同）
(2)toString():
Object类中的toString()方法输出结果为“类名+@+哈希码值”
—————————————————————————————————————————————————————
接口
1、概念：所有方法都为抽象方法的抽象类称为接口
public interface 接口名 [extends 父接口名列表]{
public static final 常量;
public abstract 方法名();
}
(1)接口的访问修饰符只能为public，即使不写依然默认为public
(2)接口名同类名要求，首字母大写
(3)父接口名列表中各父类接口以","号隔开
(4)接口中没有变量，只能存在常量，用"public static final"修饰
(5)接口的抽象方法的访问权限必须为public，不写依然默认为public
2、类对接口的实现
[访问修饰符] class <类名> [extends 父类名] [implements 接口列表]{
}
(1)类实现接口，本质上与类继承类相似，区别在于“类最多只能继承一个类，即单继承，而一个类却可以同时实现多个接口”，实现类需要覆盖所有接口中的所有抽象方法，否则该类也必须声明为抽象类
(2)接口是抽象的，接口中没有任何具体方法和变量，所以接口不能进行实例化。接口定义的是多个类都要实现的操作，即“WHAT TO DO”；类可以实现接口，从而覆盖接口中的方法，实现“HOW TO DO”
3、接口对接口的继承
(1)接口的继承是多向的，称为多重继承，而类的继承是单一的，只能是单一继承，这是Java所特定的
接口名 extends [父接口1]，[父接口2]……;
(2)接口可实现多继承的原因：
类不能多继承的原因：类A同时继承类B和类C，若B和C有同一方法，A不知道该继承B、C类中的哪个类中的该方法
接口的多重继承的原因：接口中只存在抽象方法，无论继承哪个父类中的方法，都不会出现继承对象混乱的现象
4、接口与抽象类的比较
抽象类 接口
属性 不用限制必须是静态常量
构造方法 可有可无没有
普通方法 可以有必须是抽象方法
子类 单一继承多重实现
5、接口的作用
(1)拓展抽象概念
(2)实现多态性
(3)实现多重继承
6、面向接口编程
(1)面向接口编程和面向对象编程并不是平级的，它并不是比面向对象编程更先进的一种独立的编程思想，而是附属于面向对象思想体系，属于其一部分,甚至可以认为它是面向对象编程体系中的思想精髓之一
(2)接口是一组规则的集合，它规定了实现本接口的类或接口必须拥有的一组规则，体现了自然界“如果你是……则必须能……”的理念
—————————————————————————————————————————————————————
异常
1、异常与错误的概念区别
(1)异常是正常程序流程所不能处理或没有处理的异常情况或事件，它中断指令或程序的正常执行
(2)错误是无可挽回的，一旦发生往往直接导致程序的终止
异常与错误的主要区别是，异常是可控的，错误的不可控，无可挽回的
2、异常与错误体系结构
(1)*java.lang.Throwable(implements java.io.Serializable)
(2)*java.lang.Error(错误)
(3)*java.lang.VirtualMachineError(虚拟机错误)
(4)*java.lang.OutOfMemoryError(内存不足错误)
(4)*java.lang.StackOverflowError(堆栈异常错误)
(4)*java.lang.UnknownError(未知错误)
(2)*java.lang.Exception(异常)
(3)*java.lang.ClassNotFoundException(未找到异常类异常)
(3)*java.lang.RuntimeException(运行期异常)
(4)*java.lang.ArithmeticException(数学异常)
(4)*java.lang.IndexOutOfBoundsException(下标边界异常)
(5)*java.lang.ArrayIndexOutOfBoundsException(数组下标越界异常)
(4)*java.lang.NullPointerException(空指针异常)
(3)*java.io.IOException
(4)*java.io.EOFException(试图读取文件尾后数据异常)
(4)*java.io.FileNotFoundException(文件未找到异常)
3、异常分为运行期异常(RuntimeException)和检测异常(CheckedException)编译期异常
(1)编译期异常：1)程序正确，但因为外在的环境条件不满足引发异常；
2)编译器强制要求处理这类异常，如果不捕获这类异常，程序将不能被编译；
(2)运行期异常：编译器不强制处理的异常，在运行期才处理的异常，一般因为程序中有错误，需要修改；
4、try-catch-finally语句
(1)try{ }:检测不安全的代码块,try块中任何一条语句发生异常，该语句下面的所有代码将不会被执行，而直接跳转到异常处理代码块中，即catch块或finally
(2)catch(异常类 异常实例对象){ }:紧随try语句块，捕获异常并处理；一个try语句块可以跟随多个catch块，各catch块需要按照一定次序排列，即子类异常优先于父类异常排列，否则编译器不通过；当异常被一个catch块捕获并处理，其后的catch语句将不被执行；
(3)finally{ }:语句块是必须被执行的，即使try块内没有异常语句，即使catch块捕获到异常并执行处理，即使try块内有retrun语句，即使catch块内有return语句，finally块的语句都必须被执行；【丧心病狂】
(4)try-catch-finally组合模式可分为：try-catch、try-finally和try-catch-finally
5、Throwable中的主要成员方法
getMessage()：用来获得与异常或错误相关的错误信息；
printStackTrace()：显示异常发生地方的堆栈状态；
toString()：显示异常信息以及getMessage()返回信息；
6、throws与throw语句
(1)throw：用于方法体内，抛出一个异常【对象】,程序执行到该语句时将立即停止，其后面的语句不被执行
使用：throw new MyException();这里的MyException是自定义异常，当继承系统异常类；
(2)throws：用于方法【声明】，指定可能发生的异常，可指定多个异常，用逗号分隔；当发生异常时，该方法本身不会对异常进行处理，而是交给方法调用者；当该方法发生方法覆盖，子类的该方法不能声明抛出一个比父类的该方法更大的异常
使用：public void test() throws 异常名{ }
(3)对于throw抛出异常的处理，1交由try-catch捕获并处理，2交给方法调用者，但该方法必须用throws声明
7、层层抛出异常
概念：对throw抛出的异常由try-catch捕获并处理，而catch块再次抛出异常
8、自定义异常
根据需要自己定义一个异常类，即Exception的直接或间接子类，使用方法同系统异常类
—————————————————————————————————————————————————————
常用API
1、java.lang包
(1)Object类
1)Object类是Java程序中所有类的直接或间接父类，处在类的最高层次；
2)一个类在声明时若不包含extends，系统默认该类为Object的直接子类；
3)Object包含所有Java类的公共属性和方法
*equals(Object obj)方法采用的是“==”运算，比较的是两个引用变量的地址
*toString()方法返回对象的描述信息，即对象的类名及地址
(2)System类
1)Java不支持全局函数和全局变量，因此Java设计者将一些与系统相关的重要的方法和变量搜集到System类中，而System类中的所有成员都是static且final的，可以直接通过类名调用
2)常用方法：exit()、arraycopy()等
3)常用变量：in、out、err等
(3)String类
1)String类：不可变类；
2)StringBuffer类：字符串缓冲区类，字符串可变，线程安全，适用于多线程；
3)StringBuilder类：可变字符序列，线程不安全，适用于单线程；
(4)Math类
1)Math类包含许多用来进行科学计算的类的方法，涉及大多数数学函数，这些方法可以直接通过类名调用；Math类还提供了PI圆周率和E自然对数的底数
2)Math类为final的，不能被继承；Math中的类和属性全部为静态的，不允许在类外创建该类的对象
3)主要方法：abs()绝对值、sin()正弦函数、sqrt()平方根、exp(x)自然对数的x次幂、pow(a,b) a的b次幂、max(i1,i2)较大者、min(i1,i2)较小者
(5)Runtime类
1)Runtime封装了Java命令本身所启动的实例进程；
2)Java虚拟机本身就是Windows上的一个进程，这个进程可以启动其他Windows程序，通过这种方式启动的Windows程序实例称为子进程；
3)Runtime不能被实例化
2、java.util包
(1)Date类
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdf.format(date));
(2)Calendar类
日历类
(3)Random类
1)Random类中实现的随机算法是伪随机，也就是有规则的随机，在进行随机时，随机算法的起源数字称为种子，在种子数的基础上进行的一定的变换，从而产生需要的随机数；(相同的种子数，随机相同次数所生成的随机数字是完全相同的)
2)常用方法：nextBoolean()生成一个随机的布尔值；
nextDouble()生成一个[0,1.0)区间的浮点数；
nextInt()生成一个-2^31到2^31-1之间的整数；
nextInt(n)生成[0,n)区间的整数；
(4)集合类
—————————————————————————————————————————————————————
大整型
为了解决Integer存储数据的局限性，特引入大整型以存储更大的整型数据对象
—————————————————————————————————————————————————————
泛型
1、概念：Java允许在定义类、接口、方法时使用类型形参，“模糊的”指定类、接口、方法的参数类型，类型形参将在创建对象、调用方法、使用变量时动态的指定
(1)使用：(类型形参可以为任意大写英文字母，如E)
1)泛型类：访问权限限定修饰符 class 类名
2)泛型接口：public interface 接口名
3)泛型方法：访问权限限定修饰符
注意：！访问权限限定修饰符 void 方法名(E abc){} 不是泛型方法，其本身是错误的，需要将该方法所在的类声明为泛型类，也就是说该方法只是泛型类中的普通方法
！！泛型方法的类型形参必须在返回值类型之前，访问限定修饰符后(紧邻且位于返回值类型之前)
泛型方法中的返回值类型可以为该泛型类型，即下面的方法是正确的
public
E abc=null;
renturn abc;
}
(2)泛型类在实例对象时其泛型参数必须被指定
(3)泛型参数可以有多个，以逗号分隔
(4)泛型参数必须为类类型，不能为基本数据类型
2、泛型类的派生
泛型类是可以被继承的，具体的继承方式如下
public class Animal
public class Cat
public class Cat extends Animal<类型实参>{}//正确但不推荐
3、泛型通配符？
(1)泛型通配符在声明方式上与泛型参数相同，但泛型通配符不能用于限定泛型类、接口内的成员属性和方法，不能用于限定泛型方法中的成员变量
(2)Java认为 某类 是 该类
4、泛型通配符的上边界/下边界
(1)下边界： extends 某类
(2)上边界： super 某类
—————————————————————————————————————————————————————
集合
1、集合框架的三大接口：Iterator、Collcetion、Map
Iterator
┃
Collcetion
┎────────╂───────┒
List QueueSet Map
┎───┸───┒ ┎───┸───┒ ┎───┸───┒
ArrayList LinkedListTreeSet HashSetTreeMapHashMap
2、Iterator接口
(1)Iterator接口仅用于遍历Collection集合中的元素，本身不提供盛装对象的能力
(2)Iterator接口的抽象方法
hasNext()：如果仍有元素可以迭代，则返回true
next()：返回迭代的下一个元素
remove()：从迭代器指向的collection中移除迭代器返回的最后一个元素
！关于iterator()方法：除了Iterator接口没有该方法声明，Collcetion、List、Queue、Set等接口都有该方法声明，ArrayList、LinkedList、TreeSet、HashSet等类都有该方法实现
(3)实现
……
User u=new User();
ArrayList arrayList=new ArrayList();
arrayList.add(u);
Iterator i=arrayList.iterator();
while(i.hasNext()){
System.out.prinln(i.next().getName());
}
……
3、Collection接口
Collection接口是List、Set和Queue接口的父接口，它定义了集合操作的通用API
主要方法：
1)add()：确保此 collection 包含指定的元素
2)remove()：从此 collection 中移除指定元素的单个实例，如果存在的话
3)size()：返回此 collection 中的元素数
*Collections类是集合操作的实用类，它封装实现了Collection接口中的很多方法，如排序，逆序，搜索，同步等
(1)List集合：可视为“可变长数组"，其存储的各数据是依序排列的，可重复的
1)ArrayList类：以数组的形式存储数据，其空间随着元素的增加自动扩容，利于数据查找而不利于数据增减；
2)LinkedList类：以链表的形式存储数据，其数据结构是一种双向的链式结构，每一个对象除了数据本身，还有两个分别指向前一元素和后一元素的引用，链表是一种利于增、删、改而不利于查找的数据结构；
3)Vector类
(2)Set集合：存储的数据是无序的，不依存储顺序排列，各数据不可重复
1)HashSet类：以Hash表(散列表)的形式储存数据，各数据在存储上是不连续的，相互间没有前后关系
【了解：当一个数据要存储到HashSet集合中，HashSet首先会调用hashCode()方法计算该数据的Hash码值，然后根据Hash码值定位该数据的储存位置，当该存储位置上没有存储任何数据，则实施数据存储，当该位置上已存储数据，则比对两者的equals()方法，当equals()方法返回true则不允许数据添加，当返回false则在该位置上以链式结构存储多个数据】
HashSet集合的最大优点是对数据的迅速而准确的定位，利用于数据的查询
2)TreeSet类：以树结构的形式储存数据，各数据在存储上是不连续的，相互间没有前后关系
【了解：当一个数据要存储到TreeSet集合中，TreeSet首先会调用compareTo()方法比较该数据对象的大小，然后根据比较结果将该数据以升序的形式存储到树结构中去，当该数据与已有数据相同则拒绝添加】
TreeSet集合支持自然排序和定制排序两种
3)LinkedHashSet类
(3)Queue接口
4、Map集合：用以存储具有映射关系的数据，该集合里存储了2组数据，一组作为区别于其他数据而唯一存在的key值，一组作为与key相映射的value值，在Map集合里key值不能重复，而value值可以重复
(1)HashMap类
HashMap的遍历：
Map map = new HashMap();
Iterator iter = map.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
Object key = entry.getKey();
Object val = entry.getValue();
}
(2)TreeMap类
Comparable接口与sort()方法
Comparable接口强行对实现它的每个类的对象进行整体排序，这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法
集合中Set、Map接口的实现类在排序时需要手动实现该接口
—————————————————————————————————————————————————————
Swing
【说明】model下拉内容的枚举；accelerator添加快捷键；font设置字体及大小；
【关于Socket通信部分参见网络通信部分的笔记】
1、匿名内部类方法添加事件监听
【触发事件源】.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
方法体
}
});
2、JTextArea文本域
(1)setText()：设置文本内容
(2)getText()：获得文本内容
(3)cut()：剪切文本中选中的字符串
(4)copy()：复制文本中选中的字符串
(5)paste()：黏贴字符串到文本中
(6)append("字符串")：在文本中追加字符串
(7)select(index1, index2)：显示字符串被选中的状态
3、JOptionPane标准对话框
(1)showMessageDialog(Frame对象, "字符串")：显示文本信息的对话框，它以Frame为父级
(2)showConfirmDialog(Frame对象, "字符串")：询问一个确认问题，如Yes/No/Cancel，它以Frame为父级
(3)showInputDialog(Frame对象, "字符串")：提示要求某些输入，它以Frame为父级
4、JComboBox下拉框
(1)getSelectedItem()：获得下拉选择的内容
5、显示一个查找文件地址的对话框
JFileChooser fileToSave = new JFileChooser();
fileToSave.setDialogTitle("打开文件");
int result = fileToSave.showSaveDialog(null);
if (result == JFileChooser.APPROVE_OPTION) {
myFile = fileToSave.getSelectedFile();
}
6、对话框可见
【对话框对象】.setVisible(true);
7、布局
(1)流式布局(FlowLayout)
(2)边界布局(BorderLayout)
(3)网格布局(GridLayout)
(4)卡片布局管理器(CardLayout)
(5)网袋布局管理器(GridBagLayout)
文件
1、File类是java.io包下代表与平台无关的文件或目录，File类的对象仅能对文件或目录的属性进行操作，而无法操作文件的具体数据，即不能实现对文件的读和写
2、File类的构造方法
(1)File(String pathname)
(2)File(String parent, String child)
(3)File(URI uri)
注意：
1)File filename=new File("e:\\abc.txt");仅仅只是代表创建了File类的一个对象，即在程序级上创建了一个可操作对象，但并不意味着已经在物理上创建了该文件或文件夹，创建需要使用到成员方法createNewFile()
2)路径指引符号'\'在程序上与转意符'\'相同，需要使用'\\'指示路径('\\'中第一个'\'是转意符，第二个'\'是路径指引符)
3、主要的成员方法
(1)boolean createNewFile();当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件
(2)boolean mkdirs();创建此抽象路径名指定的目录，包括所有必需但不存在的父目录
(3)boolean delete();删除此抽象路径名表示的文件或目录
(4)String getAbsolutePath();返回此抽象路径名的绝对路径名字符串
(5)String getName();返回由此抽象路径名表示的文件或目录的名称
(6)boolean isFile();测试此抽象路径名表示的文件是否是一个标准文件
(7)boolean isDirectory();测试此抽象路径名表示的文件是否是一个目录
(8)long length();返回由此抽象路径名表示的文件的长度
4、文件的遍历
(1)public String[] list();将目录下的子目录及文件的名字，返回到String数组中
(2)public File[] listFiles();将目录下的子目录及文件的实例返回到File数组中
5、文件过滤器
(1)文件名过滤器接口FilenameFilter(常用于过滤不符合规格的文件名)
重写接口的accept方法：boolean accept(File dir,String name)
File类中的使用过滤器的方法：String[] list(FilenameFilter filter)、File[] listFiles(FilenameFilter filter)
(2)文件过滤器接口FileFilter(常用于检测文件是否存在)
重写接口的accept方法：boolean accept(File dir,String name)
File类中的使用过滤器的方法：File[] listFiles(FilenameFilter filter)
IO流及其分类
1、概念：Java中的流又称为数据流，是从源到目的的字节(符)的有序序列，是数据的传输通道
2、分类
(1)输入/输出流：按照数据的传输方向分类
(2)字节流/字符流：按照数据的编码方式分类
(3)节点流/处理流：
3、流的类层次
(1)字节流的类层次
(1)*java.lang.Object
(2)*InputStream
(3)*FileInputStream
(3)*FilterInputStream
(4)*BufferedInputStream
(4)*DataInputStream
(2)*OutputStream
(3)*FileOutputSteam
(3)*FilterOutputStream
(4)*BufferedOutputStream
(4)*DataOutputSteam
(4)*PrintStream
(2)*File
(2)字符流的类层次
(1)*java.lang.Object
(2)*Reader
(3)*BufferedReader
(3)*InputStreamReader
(4)*FileReader
(2)*Writer
(3)*BufferedWriter
(3)*OutputStreamWriter
(4)*FileWriter
(3)*PrintWriter
字节流和字符流
1、字节流：流处理单元为一个字节，常用于处理音频、图片、视频等二进制文件
(1)InputStream及其子类【输出显示】
1)FileInputStream构造方法及其成员方法
FileInputStream(File file) ：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定
FileInputStream(String name) ：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定
read() 从此输入流中读取一个数据字节
read(byte[] b)：从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中，返回读入的字节数
read(byte[] b, int off, int len) ：从此输入流中将最多 len 个字节的数据读入一个 byte 数组中
close() ：关闭此文件输入流并释放与此流有关的所有系统资源
2)案例分析：(建立指定路径的文件对象file)—将文件转换成文件流fis—fis流读操作(得到b数组内容，使用String(b,0,读取的字节数)方法把直接数组转换成字符串，以便输出显示)
……
FileInputStream fis=null;
fis=new FileInputStream("c:\\file.txt");
byte[] b=new byte[100];
int length=0;
while((length=fis.read(b))!=-1){System.out.println(new String(b,0,length));}
//length=fis.read(b);含2个操作，1读取fis流的一部分内容并保存到了b数组内，2将读取内容的字节长度赋给length
//System.out.println(new String(b,0,length));含2个操作，1把数组b内容转换成字符串，2输出字符串
……
(2)OutputStream及其子类【写入文件】
1)FileOutputStrem构造方法及成员方法
FileOutputStream(File file) ：创建一个向指定 File 对象表示的文件中写入数据的文件输出流
FileOutputStream(File file, boolean append) ： 创建一个向指定 File 对象表示的文件中写入数据的文件输出流
write(byte[] b) ：将 b.length 个字节从指定 byte 数组写入此文件输出流中
write(byte[] b, int off, int len) ： 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流
close() ：关闭此文件输出流并释放与此流有关的所有系统资源
2)案例分析：(建立指定路径的文件对象file)—将文件转换成文件流fos—┐
得到文件内容的字符串str—将str存储到字节数组b里—【fos流写操作】
……
FileOutputStream fos=null;
fos=new FileOutputStream("c:\\file.txt");
String str="file文件的文本内容";
byte[] b=str.getByte();
fos.write(b);
……
2、字符流：流处理单元为一个字符，常用于处理纯文本文件
(1)Reader及其子类【输出显示】
1)FileReader构造方法及成员方法
FileReader(File file) ：在给定从中读取数据的 File 的情况下创建一个新 FileReader
FileReader(FileDescriptor fd) ： 在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader
FileReader(String fileName) ： 在给定从中读取数据的文件名的情况下创建一个新 FileReader
read() ： 读取单个字符
read(char[] cbuf) ：将字符读入数组，返回读入的字符数
read(char[] cbuf, int off, int len) ：将字符读入数组的某一部分，返回读入的字符数
close() ：关闭此文件输入流并释放与此流有关的所有系统资源
2)案例分析：(建立指定路径的文件对象file)—将文件转换成文件流fr—fr流读操作(得到c数组内容，使用String(c,0,读取的字符数)方法把直接数组转换成字符串，以便输出显示)
……
FileReader fr=null;
fr=new FileReader("c:\\file.txt");
char[] c=new char[100];
int length=0;
while((length=fis.read(c))!=-1){System.out.println(new String(c,0,length));}
//length=fis.read(c);含2个操作，1读取fis流的一部分内容并保存到了c数组内，2将读取内容的字节长度赋给length
//System.out.println(new String(c,0,length));含2个操作，1把数组c内容转换成字符串，2输出字符串
……
(2)Writer及其子类【写入文件】
1)FileWritre构造方法及成员方法
FileWriter(File file)：根据给定的 File 对象构造一个 FileWriter 对象
FileWriter(File file, boolean append)：根据给定的 File 对象构造一个 FileWriter 对象
FileWriter(String fileName) ：根据给定的文件名构造一个 FileWriter 对象
FileWriter(String fileName, boolean append) ：根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象
write(int c) ：写入单个字符
write(String str) ：写入字符串
write(String str, int off, int len) ： 写入字符串的某一部分
close() ：关闭此文件输出流并释放与此流有关的所有系统资源
2)案例分析：(建立指定路径的文件对象file)—将文件转换成文件流fw—┐
得到文件内容的字符串str—(将str存储到字符数组c里)—【fw流写操作】
……
FileWriter fw=null;
fw=new FileWriter("c:\\file.txt");
String str="file文件的文本内容";
fw.write(str);
……
节点流和处理流
1、节点流：流封装的是某种特定的数据源，如文件、字符串、字符串数组等
FileInputStream、FileOutputStream、FileReader、FileWriter等都是节点流
2、处理流：流封装的是其它流对象；处理流提供了缓冲功能，提高读写效率
BufferedOutputStream、BufferedInputStream、BufferedReader、BufferedWriter都是处理流(包装流)
(1)缓冲区作用：要对操作的数据进行临时的缓存，提高了读写效率
(2)BufferedWriter
1)BufferedWriter构造方法及其成员方法
BufferedWriter(Writer out)：创建一个使用默认大小输出缓冲区的缓冲字符输出流
write(String s, int off, int len)：写入字符串的某一部分
newLine()：写入一个行分隔符
【flush() ：刷新该流的缓冲】
close()：关闭此流，但要先刷新它
2)案例分析：
(建立指定路径的文件对象file)—将文件转换成文件流fw—将fw流封装成bw流—┐
得到文件内容的字符串str—(将str存储到字符数组c里)—【bw流写操作】
……
FileWriter fw=null;
fw=new FileWriter("c:\\file.txt");
BufferedWriter bw=new BufferedWriter(fw);
String str="file文件的文本内容";
bw.write(str,0,str.length);
bw.newLine();
……
(3)BufferedReader
1)BufferedReader构造方法及其成员方法
BufferedReader(Reader in)：创建一个使用默认大小输入缓冲区的缓冲字符输入流
readLine()：读取一个文本行
close() ：关闭该流并释放与之关联的所有资源
2)案例分析：略
字节流与字符流的转换
1、字节流→字符流：InputStreamReader
InputStream is=new InputStream("c:\\file.txt");
InputSteamReader isr=new InputStreamReader(is);
isr是文件file.txt的字符流
2、字符流→字节流：OutputStreamWriter
IO总结：
1、流程：确定是输入还是输出—确实是用字符流还是字节流—确定是否需要缓冲操作
2、流的声明和实例一般要分开写，流的实例需要检测异常，若将流声明与实例同时写，必然会将流的声明放到了try块里，这会造成块外无法调用该流
线程
1、概念
(1)进程
……
(2)线程
……
2、创建线程
(1)继承Threm类
……
(2)实现Runnable接口
……
3、线程优先级
……
4、匿名内部类
……
5、常用方法
……
6、线程同步
……
7、线程通信
……
8、状态转换
……
—————————————————————————————————————————————————————
序列化
……
—————————————————————————————————————————————————————
映射
……
—————————————————————————————————————————————————————
国际化
……
—————————————————————————————————————————————————————
数据库1、DB和DBMS
(1)数据库（Database,简称DB）是按照数据结构来组织、存储和管理数据的仓库。
(2)数据库管理系统(Database Management System,简称DBMS)：管理数据库的软件。
数据库的典型特征包括：数据的结构化，数据间的共享，减少数据的冗余度，以及数据的独立性。
2、关系型数据库
关系是一个数学概念，描述两个元素间的关联或对应关系。所以关系型数据库，即是使用关系模型把数据组织到数据表(Table)中。现实世界可以用数据来描述。
3、主流数据库产品：Oracle（Oracle甲骨文）、MySQL（Oracle甲骨文）、SQL Server（MS微软）、DB2（IBM）、Access(MS)
4、SQL（概述）：SQL(Structured Query Language) 是结构化查询语言的缩写。SQL是在关系数据库上执行数据操作、检索及维护所使用的标准语言,可以用来查询数据，操纵数据，定义数据，控制数据，所有数据库都使用相同或者相似的语言。
SQL的分类：数据定义语言(DDL)、数据操作语言(DML)、数据查询语言(DQL)、数据控制语言(DCL)、事物控制语言(TCL)。
5、表的概念
在关系数据库中，数据被存放于二维数据表(Table)中。一个关系数据库由多个数据表组成，数据表是关系数据库的基本存储结构，由行和列组成，行（Row）也就是横排数据，也经常被称记录(Record)，列（Column）就是纵列数据，也被称作字段(Field)。表和表之间是存在关联关系的。
6、Oracle数据类型
(1)char/varchar2：char不可变字符串，长度为定值；varchar2可变字符串，长度根据具体存储的字符长度而定，节约空间；
(2)number：number(前一位,后一位)，前一位表示有效的数字总个数，后一位表示小数位的个数
(3)date：Oracle 数据类型date对格式敏感
7、表字段约束
(1)主键约束：primary key
(2)外键约束:foreign key
(3)非空约束:not null
(4)唯一性约束:unique
(5)检查约束：检查值是否在此区间内check()『如：check(性别 in ('男','女'))』
8、SQL分类
(1)数据定义语言（DDL）：用于建立、修改、删除数据库对象，包括创建语句(CREATE)、修改语句(ALTER)、删除语句(DROP)，比如使用CREATE TABLE创建表，使用ALTER TABLE修改表，使用DROP TABLE删除表等动作。这类语言不需要事务的参与，自动提交。
I、表 table
1)创建表语句：
create table 表名(
column1 数据类型(),
column2 数据类型()
);
2)删除表语句:
drop table 表名;
3)修改表语句：
alter table 表名......;
4)查看表语句：
desc 表名;
II、视图 view
(1)视图的创建：
create view 视图名 as select 字段1，字段2...... from 表名;
(2)视图的使用
select * from 视图名;
(3)删除视图
drop view 视图名;
(4)视图在表中数据修改，自动修改
insert into s_emp(id,first_name,last_name,dept_id,salary) values (28,'zhang','san',42,4000);
select * from s_emp;
select * from v_emp;
insert into v_emp(id,first_name,last_name,dept_id,salary) values (29,'li','si',42,4000);
(5)查看视图
desc 视图名;
III、索引 index
相当于给数据库建立一个目录方便数据的搜索；索引的维护依靠数据库自动完成；一般会给经常做查询条件的字段建立索引；但是索引的个数不能太多，依据需求来创建；
(1)索引的创建：
create index 索引名 on 表名（字段名）;
(2)索引的删除：
drop index 索引名;
IV、序列 sequence
一般用来作为主键的增长方式，用于产生一系列唯一数字的数据库对象；
(1)序列的创建：
create sequence 序列名 start with ? increment by ? ;
(2)序列的使用：
nextval、currval
(3)序列的删除：
drop sequence 序列名;
(2)数据操作语言（DML）：用于改变数据库数据，包括INSERT、UPDATE、DELETE三条语句。其中，INSERT语句用于将数据插入到数据库中，UPDATE语句用于更新数据库中已存在的数据，DELETE用于删除数据库中已存在的数据。DML语言和事务是相关的，执行完DML操作后必须经过事务控制语句提交后才真正的将改变应用到数据库中。
1)插入数据：
插入所有数据：insert into 表名 values(各个字段对应的值);
插入对应字段的数据：insert into 表名(字段名) values(各个字段对应的值);
2)删除数据：
删除所有数据：delete from 表名;
删除指定数据：delete from 表名 where 限定条件;
3)更新数据
对所有数据修改：update 表名 set 字段名=值;
对指定数据修改：update 表名 set 字段名=值 where 限定条件;
(3)数据查询语言（DQL）：用来查询所需要的数据。select使用最广泛，语法灵活复杂。
1)整表查询
查看表结构：desc 表名;
查看表的全部内容：select * from 表名;
2)限定查询
限定查询：select 字段名 from 表名 where 限定条件;（多条件限定以and、or、between and、in(?)、any(?)、all(?)等关键词连接）
字符匹配：select 字段名 from 表名 where 字段名 like '匹配格式';
(占位符：_；通配符：%；转义符：/『使用时要以escape '/'加以说明』；全选：*；不等于：<>或！=或^=；)
结果排序：select 字段名 from 表名 where 限定条件 order by 字段名 desc（降序）或asc（升序）；
Oracle函数：字符函数、数值函数、日期函数、转换函数、组函数等
字符小写：lower('字符串')
字符大写：upper('字符串')
字符串截取：substr('字符串'，开始下标，结束下标)
子串位置查询：instr('字符串'，'子字符串')
忽略空格：trim('字符串');
字符串长度：length('字符串')
舍入截取：round(数，截取位数)『说明：截取位数为正，截取到小数点右侧的位置；截取位数为负数，截取到小数点左侧的位置』
无舍入截取：trunc(数，截取位数)
日期-字符串：to_char(字段名,'yyyy-mm-dd hh24:mi:ss')
字符串-日期：to_date('2012-12-12 12:12:12','yyyy-mm-dd hh24:mi:ss')
字符串-数值：to_number(数字字符)
总和：sum(字段名)
平均值：avg(字段名)
最大值：max(字段名)
最小值：min(字段名)
记数：count(字段名)
分组：group by 字段名 having 分组条件
详尽参见http://www.educity.cn/develop/404123.html
3)联表查询
内连接：等值连接、交叉连接、自连接、自然连接
等值连接：select ？ from 表1，表2 where 表1某字段=表2某字段;
自连接：select ? from 某表 别名A，该表 别名B where 表A某字段=表B某字段;
……
外连接：左连接、右连接、满连接
4)子查询、多列子查询
select ? form 表名 where 字段=(
//子查询部分
);
5)其他：TopN与分页实现
(4)数据控制语言（DCL）：用于执行权限的授予和收回操作、创建用户等，包括授予(GRANT)语句，收回(REVOKE)语句，CREATE USER语句，其中GRANT用于给用户或角色授予权限， REVOKE用于收回用户或角色已有的权限。DCL语句也不需要事务的参与，是自动提交的。
脚步初始化
1)CMD命令进入管理员账户：
对于Oricle数据库：sqlplus 用户名/密码 @数据库名(as sysdba);
对于MySQL数据库：mysql -u root -p;
2)创建用户：create user 用户名 identified by 密码;
修改用户：alter user 用户名 identified by 密码;
删除用户：drop user 用户名 cascade;
3)用户授权：
权限查看：
权限收回：
(5)事务控制语言（TCL）：用来维护数据一致性的语句，包括提交(COMMIT)、回滚(ROLLBACK)、保存点(SAVEPOINT)三条语句，其中COMMIT用来确认已经进行的数据库改变， ROLLBACK语句用来取消已经进行的数据库改变，当执行DML操作后(也就是上面说的增加、修改、删除等动作)，可以使用COMMIT语句来确认这种改变，或者使用ROLLBACK取消这种改变。SAVEPOINT语句用来设置保存点，使当前的事务可以回退到指定的保存点，便于取消部分改变。
1)事务的概念：事务开始，隐式的，一直到执行commit,或者是rollback,事务结束
2)事务的特性ACID：
原子性（Atomicity）：指在事务中包含所有操作，要么都做，要么都不做；
一致性（Consistency）：数据的改变保证一直；
隔离性（Isolation）：数据库允许多个并发事务同时对其数据进行读写和修改的能力；
持久性（Durability）：事务处理结束之后，对数据的修改是永久的，即便你的系统出现故障，也不会丢失；
3)多个事务同时处理，会遇到的现象：
脏读：用户读了修改后未提交的数据；
不可重复读：读取同一条记录，但是两次数据不一样；
幻读：读取同一张表，两次记录数不一样；
4)事务的隔离级别：
读未提交：允许幻读和不可重复读，脏读；
读提交（Oracle支持）：允许幻读和不可重复读，但是不允许脏读；
重复读：允许幻读，但是不允许不可重复读和脏读；
串行化读（Oracle支持）：都不允许幻读和不可重复读，脏读；
9、JDBC
JDBC是用以解决Java语言对数据库数据访问的，起到沟通Java与数据库的桥梁作用。JDBC包括两个部分，一部分是面向Java语言的，由JDK提供相应类库（API），另一部分是面向具体数据库的，由数据库厂商提供相应类库(SPI)
(1)API
1)DriverManager类
DriverManager类能够自动在内存中找到符合需求的的驱动类，主要用来获得与数据库的链接对象
2)Connection接口
Connection是与特定数据库的链接对象，通过DriverManager类取得。通常使用链接对象获得语句对象，常用的语句对象有两种，所以有两个方法获得
3)Statement/PreparedStatement
Statement对象可以用来执行SQL语句，使用executeQuery执行查询语句，返回结果集，使用executeUpdate执行增删改，返回操作的行数
Statement对象可以用来执行SQL语句，使用executeQuery执行查询语句，返回结果集，使用executeUpdate执行增删改，返回操作的行数
4)ResultSet接口
ResultSet对象用来封装查询得到的结果集，常用的方法有next以及getXXX方法。注意：必须使用next()方法，才能处理结果集
(2)SPI：使用上直接将驱动包导入到项目里就可以了
(3)JDBC编程实现步骤
使用Class.forName加载驱动类，每个数据库驱动类不同
使用DriverManager.getConnection获得连接对象，每个数据库的连接串不同
使用Connection中的createStatement方法获得Statement对象；或者preparedStatement方法获得PreparedStatement
使用语句对象中的方法执行SQL语句，查询使用executeQuery方法，增删改使用executeUpdate方法
查询返回ResultSet结果集，使用next方法进行迭代
关闭资源：连接对象、语句对象、结果集对象
10、数据库连接池
由于以前每次连接都需要占用资源和消耗时间
解决方案：
创建一个池子，把已经创建好的多个连接放入池子中，每次需要使用的时候从池子中直接拿去，用完后必须放回。
Util层代码：
public class ConnectionFactory {
// 公有的静态连接方法
private static Connection conn = null;
public static Connection getConnection() {
try {
// 1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
// 2、获得连接
conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/mybbs", "root", "123456");
System.out.println("【数据库连接池 连接成功】");
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
// 公有的关闭连接方法
public static void closeConnection() {
if (conn != null) {
try {
conn.close();
System.out.println("【数据库连接池 连接关闭】");
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
Dao层代码：
public static User getUserDao(String userID,String password){
User user=null;
Connection conn=ConnectionFactory.getConnection();
PreparedStatement ppst=null;
ResultSet res=null;
try {
String str="select * from User where User_ID=? and User_Password=?";
ppst=conn.prepareStatement(str);
ppst.setString(1, userID);
ppst.setString(2, password);
res=ppst.executeQuery();
if(res.next()){
System.out.println("【getUserDao查询成功】");
user=new User(res.getString(1),res.getString(2),res.getString(3),
res.getString(4),res.getString(5),res.getString(6),
res.getString(7),res.getString(8),res.getString(9),
res.getString(10),res.getString(11));
}else{
System.out.println("【getUserDao查询失败】");
user=new User();
}
} catch (SQLException e) {
e.printStackTrace();
}finally{
ConnectionFactory.closeConnection();
}
return user;
}
网路通信
XML
1、XML，即可扩展标记语言(Extensible Markup Language)，它可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。它非常适合万维网传输，提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。
2、XML与HTML的区别
(1)XML被设计为传输和存储数据，其焦点是数据的内容
(2)HTML被设计用来显示数据，其焦点是数据的外观
3、XML的特点：(1)仅仅只是纯文本；(2)没有预定义标签，允许用户自定义标签【简单来说就是允许用户自定义标签的纯文本文件】
4、XML的语法规则
(1)对标签敏感
(2)必须正确的嵌套，关闭标签不允许省略
(3)必须有根元素
(4)属性必须加引号
(5)空格被保留
5、实例
6、使用DOM方法读取/创建XML(原始且繁琐，略)
7、使用Dom4j操作XML数据
示例：将字符串
项目中导入dom4j-1.6.1.jar，主方法中如下代码：
String xmlString="
Document document=DocumentHelper.parseText(xmlString);
System.out.println(document.asXML());
以上代码即完成了对XML文件的创建
JSON
1、JSON即JavaScript对象表示法(JavaScript Object Notation)，是存储和交换文本信息的语法
JSON是轻量级的文本数据交换格式，独立于语言和平台，具有自我描述性，更易理解
2、JSON类似XML，但比XML更小、更快、更易解析，与XML主要存在以下几个区别：
没有结束标签，更短，读写速度更快，使用数组，不适用保留字
3、JSON的语法：
(1)数据是以键值对形式存储的，数据间以逗号分隔
(2)用花括号保存对象，用方括号保存数组
示例1：{//对象
"username":"张三",//属性与值的对应关系
"password":"123456"
}
示例2：{
"user":[//数组
{"username":"张三","password":"123456"},//对象作为数组的属性
{"username":"李四","password":"123456"}
]
}
4、JSON的数据类型：数字、字符串、布尔类型值、数组、对象、null
5、Java读取JSON数据
(1)下载google-gson.zip，并解压该文件，将json.jar导入项目lib文件中去
(2)项目所需的JSON文件，以.json结尾
示例3：本示例的根对象有3个属性，其中两个是普通数据，一个是数组数据
{
"product":"phone",
"flag":"true",
"user":[
{"username":"张三","password":"123456"}
{"username":"李四","password":"123456"}
]
}
(3)主方法中的代码如下：(注意导包及捕获异常)
JsonParser parser=new JsonParser();
JsonObject object=(JsonObject)parser.parse(new FileReader("文件路径，如user.json"));
System.out.println("product="+object.get("product").getAsString());
System.out.println("flag="+object.get("flag").getAsBoolean());
JsonArray array=object.get("user").getAsJsonArray();
for(int i=0;i
System.out.println("username="+arrObj.get("username").getAsString());
System.out.println("password="+arrObj.get("password").getAsInt());
}
6、Java创建JSON数据
(1)导入相应包
(2)主方法中的代码如下：
JsonObject object=new JsonObject();
object.addProperty("product","phone");//添加前两个属性
object.addProperty("flag","true");
JsonArray array=new JsonArray();
JsonObject user1=new JsonObject();
user1.addProperty("username","张三");
user1.addProperty("password",123456);
array.add(user1);
JsonObject user2=new JsonObject();
user2.addProperty("username","李四");
user2.addProperty("password",123456);
array.add(user2);
object.add("user",array);//添加数组属性
System.out.println(object.toSring());//在控制台上输出显示
HTTP通信
get方式与post方式的最明显直观的区别是get方式传输的参数在地址栏中显示，post方式传输的参数不在地址栏显示
1、get方式交互网路数据
2、post方式交互网络数据
Socket通信
1、Socket又称“套接字”，用以向网络发起请求或对网络请求产生响应
Socket同时用于服务端和客户端，而ServerSocket仅用于服务端。用于服务端与客户端上的Socket是完全相同的，不存在优先级上的差别。
2、Socket通信特点：基于TCP链接，数据传输安全可靠；数据链接的维持是长时间的(而HTTP链接在数据传输完成后立刻关闭)；【由以上两个特点决定了Socket在即时通信上的优势】
3、建立Socket链接的步骤：服务器监听—客户端发出请求—创建和确认链接—通信实现
……
Web方面的知识
—————————————————————————————————————————————————————
HTML
1、Hyper Text Markup Language 超文本标记语言，是一种可以展现出关于文档结构和数据处理细节的文字编码。
2、HTML的页面结构
3、HTML的标签
(1)常用标签
1），input标签的type属性非常丰富，如下：{
text文本：用户可输入文本的单行输入字段
button按钮：
submit提交按钮：把表单数据发送到服务器，必须与form表单结合使用，数据提交的方向是form表单的actoin属性
reset重置按钮：清除表单中的所有数据
checkbox复选框：
radio单选框：使用方法同上，同组的多个单选框的name属性必须相同
file文件：输入字段和 "浏览"按钮，供文件上传
image：图像形式的提交按钮，必须与src、alt属性联合使用
password密码字段：字段中的字符被实心圆掩码
hidden：隐藏字段，用户不可视，其值可谓JS所用
}
2）下拉列表
3）form表单：表单属性action、method
4）
5）
6）
7）
8）
9）链接提示文字
10）
子标签等
【块级元素】11）子标签等【行内元素】
12）
换行
13）
水平线
(2)文本格式标签
加粗
字体放大
字体缩小
强调
语气更强的强调
斜体文本
下标文本
上标文本
下划线文本
(3)HTML5新增智能表单
input标签的type属性：email、date、url、number、range、color
4、表格
| 列1表头单元格 | 列2表头单元格 | 列3表头单元格 |
|---|---|---|
| 行1列1单元格 | 行1列2单元格 | 行1列3单元格 |
| 行2列1单元格 | 行2列2单元格 | 行2列3单元格 |
设置表格的边宽：
设置单元格内边距：
设置单元格外边距(单元格间距)：
设置表格背景色：
设置表格背景图片：
5、列表
(1)无序列表
- 列表项1
- 列表项2
设置ul的type属性：
- …
(2)有序列表
- 列表项1
- 列表项2
设置ol的type属性：
- …
type值默认为阿拉伯数字，也可以取A、a、I、i，分别表示以大写英文字母、小写英文字母、大写罗马数字和小写罗马数字排序；
start可以指定从多少开始计数；
(3)嵌套列表
使用标签
- 、
- 等实现无序列表与有序列表的互相嵌套
(4)自定义列表
使用标签：- 、
- 、
- 一级列表项
- 二级列表项
- 一级列表项
- 二级列表项
—————————————————————————————————————————————————————
CSS
……
1、文字水平垂直居中：文字父级元素声明样式style="height: N px;line-height: N px;text-align:center;"
【tvertical-align: middle;图片等垂直居中，同样要声明行高heigh】
2、列表实心圆取消：li中声明样式style="list-style-type :none;"
3、字体大小声明：style="font-family:'微软雅黑';font-size:*px;"
4、边框颜色及宽度：style="border-top:1px solid #d9d9d9;"
5、input和textarea选中边框样式消失：input样式style="outline:none;"，textarea样式style="resize:none;"
6、背景颜色声明：style="background-color:#f2f2f2;"
7、HTML5输入框提示语句：placeholder="输入提示";
8、行内块级转换：display:inline;或display:block;
9、定位
(1)相对定位（相对于父级元素）：position: relative;left:*px;top:*px;
(2)绝对定位（相对于整个窗口）：position:absolute;left:*px;top*px;
10、a标签无下划线：text-decoration: none;
11、文字不换行（不受屏宽影响）：style="width: N px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;"【书写顺序一定，width必须被声明】
*、标签属性名称在.cs和.js文件中有区别，如在.cs中背景色名称为background-color，在.js文件中背景色为backgroundColor
另外，在.cs中样式属性名称与值间用冒号分隔，在.js中则以等号分隔
*、样式顺序的书写规范（个人规范）：标签特有属性+盒子样式及位置控制+标签整体性样式
盒子样式及位置控制：height+width+margin+padding+border+float
整体样式：font-family+font-size+background-color
—————————————————————————————————————————————————————
Java Script
1、JavaScript的组成：
核心(ECMAScript)：基本语法操作
文档对象模型(DOM) ：用JS操作元素
浏览器对象模型(BOM) ：用JS操作浏览器
2、数据类型： var
内置对象：Object、Array、Date、Math
3、基本语法：if、switch、for、while、do-while
4、函数：function 函数名(){函数体};需要返回值时，在函数体内return即可
function(){};无函数名的函数为匿名函数
支持数学类函数：sin()、cos()、abs()、max(a,b)、min(a,b)、pow(a,b)、random()、round()、sqrt()
5、DOM操作
(1)文档树的介绍
获取对象的方法：getElementById()、getElementsByClassName()、getElementsByName()、getElementsByTagName()
(2)DOM高级操作
document.forms; //获取文档中
- 、
……
框架部分知识
—————————————————————————————————————————————————————
Structs2
1、导入Structs2支持
(1)手动导入Sturts2支持
1)下载struts-2.3.24-all.zip
2)解压zip下的apps中的任意war文件
3)拷贝WEB-INF下的lib文件中的所有jar文件到项目的lib中
4)拷贝WEB-INF下的classes文件中的structs.xml文件到项目的src中
5)配置web.xml，如下
6)配置sturts.xml
(2)自动导入Struts支持
项目名右击，选择MyEclipse，选择Project Facets下的Install Struts2，修改相关文件内容
2、属性驱动：用于数据的自动获得，属性名要和表单中的标签名保持一致，并用Get和Set方法获得相应属性值
3、模型驱动：用于数据封装，getModel方法具体实现数据的封装操作
注意：(1)要实现ModelDriven接口，并指定泛型类型；(2)创建实体类的实例，不能仅声明实体类；
4、标签实现模型驱动
—————————————————————————————————————————————————————
Spring
1、概念：轻量级控制反转(IOC)和面向切面(AOP)的容器框架;
功能：使用JavaBean代替EJB
优点：低侵入式，代码污染极低；一处编译，处处使用；通用任务的集中管理；ORM和DAO简化数据库访问；高度开放性；
好处：有效组织中间层对象(减少了对单例模式的依赖)；使用统一的配置文件；促进良好的编程习惯，减少冗余代码；易于单元测试；是EJB成为备选；为数据的存储提供一致的框架；
特点：方便解耦，简化开发；AOP编程的支持；声明事物的支持；方便程序测试；方便的集成了各种优秀的框架；降低了JavaEEAPI的使用难度；Spring的源码是非常精妙的学习范例；
Spring的核心框架：核心容器(Spring Core)、应用上下文(Spring Context)、AOP模块(Spring AOP)、JDBC和DAO模块(Spring DAO)、对象实体映射(Spring ORM)、Web模块(Spring Web)、MVC模块(Spring Web MVC);
总结：简化开发；轻量级的IOC容器；为企业应用提供一站式解决方案；(高并发应用慎用)
2、IOC：控制反转，是Spring的核心，贯穿始终；
IOC的另外的名字叫依赖注入，所谓DI就是由IOC容器在运行期间，动态的将某种依赖关系注入到对象中。
IOC和DI是从不同角度对同一事件的描述，就是通过引入IOC容器，利用依赖注入的方式，实现对象间的解耦；
IOC在编程过程中不会对业务对象构成很强的侵入式，使用IOC后，对象具有更好的可实行性，可重用性和可拓展性；
IOC降低组件之间的耦合度；提高开发效率和产品质量；统一标准，提高模块的复用性；模块具有热插拔性；
IOC的通俗理解：IOC控制反转：创建对象的实例的控制权从代码控制剥离到IOC容器控制；DI依赖注入：创建对象实例时，注入属性值或其他对象实例；
3、AOP：面向切面的编程，AOP将应用分为两个部分，核心应用和横向的通用应用
OOP：面向对象的编程，从静态角度考虑程序结构，即对业务处理过程中的实体以及属性和行为进行了抽象的封装以获得更加清晰高效果的逻辑划分，研究的是一种静态的领域；
AOP：从动态的角度考虑程序结果，即针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，研究的是一种动态的领域；
AOP的功能：日志记录、事物处理、性能统计、异常处理；
AOP把常用的功能进行模块化，并用声明的方式将这些组件使用到其他组件中去，这样的结果就是每一个组件只用关心自己的业务逻辑，不用考虑其他业务，有效的防止代码混乱；
AOP专门用于处理系统中分布于各个模块中的交叉关注点的问题，JavaEE中常通过AOP来处理一些具有横切性质的系统服务
AOP的关键概念如下：
切面：关注点的模块化，这个关注点可能横切多个应用
连接点：程序执行中的某个特点的点
通知：在切面上的某个连接点的动作，如拦截器
切入点：匹配连接点的断垣
引入：类型声明额外的方法、属性
目标对象：别一个或多个切面所通知的对象
AOP的代理：AOP框架所创建的对象
织入：把切面连接到其他的应用之上，并创建一个被通知的对象
4、Spring环境搭建：JDK+Eclipse+Spring Framework
Spring开发包的介绍：
Spring Core(基本的核心工具类)
Spring Beans(包含访问控制文件，创建和管理Bean，以及控制反转和依赖注入操作相关的所有类)
Spring AOP(包含使用Spring AOP所特定的类)
Spring Context
其他业务组件包：
Spring Aspects+Spring Context Support+Spring Expresion+Spring Framework Bom+Spring Instrument+Spring Instrument Tomcat+Spring JDBC+Spring JMS+Spring orm+Spring oxm+Spring Struts+Spring test+Spring tx+Spring web+Spring webmvc+Spring webmvc portlet
5、IOC的注入类型：构造函数注入，属性注入，接口注入，Spring支持前2个注入方式
Spring作为一个容器，通过配置文件或者注解描述类与类之间的依赖关系，自动完成类的初始化和依赖注入的工作。
6、Java的反射机制：对象实例—类—类属性及方法
7、弥补JDK访问资源功能不足的缺点，Spring设计了一个Resource接口，提供更为强大的访问底层资源的能力
资源访问工具类：
主要方法：
boolean exists()：判断资源是否存在；
boolean isOpen()：判断资源是否存在；
URL getURL()：如果底层资源可以表示成URL，则返回URL对象；
File getFile()：如果底层资源对应一个文件，则返回文件对象；
InputStream getInputStream()：返回对象资源的输入流；
主要实现类：
ByteArrayResource：二进制数组表示的资源；
ClassPathResoure：类路径资源；
FileSystemResoure：文件系统资源；
InputStreamResource：；
ServletContextResource：；
UrlResource：；
Spring支持的资源类型地址前缀：classpath/file/http/ftp/无前缀
Ant风格的匹配符：？匹配一个字符，*匹配任意多字符，**匹配多层路径
8、Spring通过配置文件描述Bean与Bean之间的关系，并用反射机制实例化Bean与Bean之间的关系。
BeanFactory是Spring框架的核心接口，它提供了高级IOC的配置机制。
ApplicationContext建立在BeanFactory基础之上，提供了更多面向应用的功能，比如它提供了国际化支持和框架事件体系，更易于创建实际应用。
BeanFactory是Spring框架的基础设施，面向Spring本身的，ApplicationContext面向的是使用Spring框架的开发者，几乎所用的应用中我们都直接使用ApplicationContext而非底层的BeanFactory。
BeanFactory是类对象的通用管理工厂，它创建对象并管理对象，将这些被创建和管理的对象称为Bean。
BeanFactory初始化顺序：创建配置文件—Spring通过BeanFactory装载配置文件—启动IOC容器—获取Bean的实例
Spirng装载BeanFactory配置文件：BeanFactory bf=new ClassPathXmlApplicationContext("配置文件名，以.xml结尾");
实例化Bean：接口名 实例对象名=new bf.getBean(接口实现类名.class);
接口名 实例对象名=new bf.getBean("Bean的name或id",接口实现类名.class);
9、Spring配置文件是用于指导Spring工厂进行Bean的生产、依赖关系注入及Bean实例分发的“图纸”，它是一个或多个标准的XML文档。
Spring的默认配置文件是ApplicationContext；
Spring配置文件的一般结构：
Spring容器启动的基本条件：
Spring框架类包的准确导入+Bean的配置信息+Bean的实现类
Bean的元数据信息：
Bean的实现类+Bean的属性信息+Bean的依赖关系+Bean的行为配置+Bean的创建方式
Spring的配置文件是基于XML格式的，Spring1.0的配置文件采用DTD格式，Spring2.0以后使用的是Schema格式，后者让不同类型的配置拥有自己的命名空间，使配置文件更具拓展性,Spring3.0的配置Schema文件分布在各模块类包中，如果模块拥有对应的Schema文件，则可以在模块类包中找到一个config目录，Schema文件就位于其中。
Schema的配置方式，文件头的声明更复杂，如下：
xmlns:p="http://www.springframework.org/schema/p"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
10、SpringBean的命名：Bean的ID在IOC中必须是唯一的，满足XML对ID的命名规范,每个Bean可以有一个或多个ID，第一个ID称为“标识符”，其余ID叫做“别名”，这些ID在IOC中必须为唯一的
Bean id的命名方式：
配置全限定名：
指定name：
同时指定id和name，同上
指定多name的，以分号分隔：
指定别名，同上
BeanFactory初始化顺序：创建配置文件—Spring通过BeanFactory装载配置文件—启动IOC容器—获取Bean的实例
Spirng装载BeanFactory配置文件：BeanFactory bf=new ClassPathXmlApplicationContext("配置文件名，以.xml结尾");
实例化Bean：接口名 实例对象名=new bf.getBean(接口实现类名.class);
接口名 实例对象名=new bf.getBean("Bean的name或id",接口实现类名.class);
11、Bean的实例化
(1)构造方法实例化
无参构造方法：
有参构造函数：
(2)静态工厂实例化
要独立创建这样的静态工厂类，并提供具有调用{Bean对象的类中的方法，返回值类型为Bean对象的类的接口}的静态工厂方法体（好复杂的样子）
(3)实例化工厂：使用实例化工厂方式不能指定class属性，此时必须使用factory-bean属性来指定工厂Bean，factory-method属性指定实例化Bean方法，而且使用实例工厂方法允许指定方法参数，方式和使用构造器方式一样
12、Bean的作用域
13、配置文件整合：利用import属性整合配置文件
……
装载配置文件时：
ApplicationContext ap=new ClassPathXmlApplicationContext("总的配置文件的全路径，以.xml结尾");
—————————————————————————————————————————————————————
Spring MVC
……
—————————————————————————————————————————————————————
Habernate(备选框架，因为太重)
……
—————————————————————————————————————————————————————
Maven管理项目
Maven下载地址：http://maven.apache.org/download.cgi
Maven环境变量配置：MAVEN_HOME：文件安装地址，如C:\Maven；Path：添加；%MAVEN_HOME%\bin;到变量值尾部
CMD命令测试是否安装成功：mvn -v出现版本号表示安装成功
—————————————————————————————————————————————————————
MyBatis
1、概述
MyBatis特点：开源的优秀持久层框架；SQL语句与代码分离；面向配置的编程；良好支持复制数据映射；动态SQL；
2、环境搭建
MyBatis下载地址：https://github.com/mybatis/mybatis-3/releases
导包需求：mybatis-3.3.0.jar+MyBatis中lib中的辅助包+mysql-connector-java-5.1.35-bin.jar
导包方式：项目名右击Build Path—Libraries—Add External Jars
日志配置：MyBatis的SQL语句输出是通过日志来完成的，而MyBatis的SQL输出必须在Debug级别下才能输出显示，所以要修改相应的日志信息。
log4j.properties的文件内容如下：
log4j.rootLogger=DEBUG,Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d[%t]%-5p[%c]-%m%n
log4j.logger.org.apache=INFO
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
3、MyBatis工作流程：读取配置文件—生成SqlSessionFactory—建立SqlSession—调用MyBatis中的API—查询Map配置—返回结果—关闭SqlSession
配置文件分为基本配置文件和映射配置文件(Map)
4、MyBatisConfig基本配置文件：
"http://mybatis.org/dtd/mybatis-3-config.dtd">
5、MyBatisMap映射配置文件：
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
6、注解文件InterfaceMap接口：
public interface InterfaceMap {
//注解方式存储SQL语句，用以代替Map配置文件
@Delete ("delete from MaBatisUser where username=#{username}")
public void deleteUser(String username);
}
7、主测试方法中的流程：创建SessionFactory—打开Session—开始事务—持久化操作—事务提交—关闭Session
public class Main {
public static void main(String[] args) {
String resource="com/js/map/MyBatisConfig.xml";//基本配置文件的路径
Reader reader=null;
try {
reader=Resources.getResourceAsReader(resource);
} catch (IOException e) {
e.printStackTrace();
}
SqlSessionFactory sqlMapper=new SqlSessionFactoryBuilder().build(reader);
SqlSession session=sqlMapper.openSession();
//User user=session.selectOne("selectAllByUsername", 1);//执行SQL语句
//System.out.println(user.getUsername()+"/"+user.getPassword());
InterfaceMap im=session.getMapper(InterfaceMap.class);
im.deleteUser("zhangsan");
session.commit();
session.close();
}
}
—————————————————————————————————————————————————————
JavaSE学习结束