计算机高级编程语言：
解释型语言：asp php 解释一句执行一句
编译型语言：c c++
java 是两者的结合体 （编写 编译 运行）,属于强类型语言
（平台无关性）JVM 隐藏了不同平台之间的具体差异，实现了跨平台可移植性
一次编写，随处运行

包含关系：
JDK >JRE>JVM

java的三大特性
平台无关性 安全性 网络移动性
面向对象特性
封装 继承 多态 抽象

静态引入类包，就不用写类名，直接调用其方法

javadoc解决GBK映射问题
更为彻底的办法就是修改eclipse.ini文件，在末尾加入如下两行内容：
-Dfile.encoding=UTF-8
-Dsun.jnu.encoding=UTF-8

========================================================
java 规范
包名：一律小写 如：com.tools.jdbc

接口名类名：每一个首字母大写 缩写的单词每一个字母都要大写 如：XMLConstants

方法名：第一个单词的字母小写，后面的每一个单词的首字母大写 如：setName

变量名：第一个单词的字母小写，后面的每一个单词的首字母大写 如：personName

常量名：每一个字母都要大写 若多个单词就用_连接 如：MAX_VALUE

public class 和class的访问权限不一样，前者可以被任意类访问，后者只能被同一个包里的类访问

====================================================
int 正数比负数少一个 因为0为正数
0是正数 1是负数
字符型的编号里面不包含负数
字符型的默认值是编号为0 的字符，而不是字符0

double 型的加减
方法一（BigDecimal）
subtract减法 doubleValue()转换为double型
方法二 （强制转换为整型）
double*倍数(如100)=整型数，加减后再除以倍数（如100.0）

long型声明一定要加后缀L

类型转化
byte----char-------int--------long---float-------double
short------

任意类型的数据都可以向String转换
赋值运算符= 关系运算符==
对象实例化的对象，即使值相同，但是指向了不同的内存地址，所以==判断会为false
‘A’对应65
逻辑运算符 & | ！^
以下比较*（前两个为短路运算，效率高，推荐使用）
||用于逻辑运算时，表达式第一个为true 则不用比较第二个表达式的值
&&用于逻辑运算时，若第一个表达式为false 则不用再比较第二个表达式的值
| 用于逻辑运算时，表达式第一个为TRUE，也要再比较第二个表达式的值
&用于逻辑运算时，表达式第一个为false，也要再比较第二个表达式的值

16%-3 结果1
-16%3 结果-1 表明结果数的符号由左侧操作数决定，与右侧的数无关
6.0%4.5 结果 1.5 表明浮点数可以做取模运算
16.0%0 结果 NaN表明不知道结果是什么

==============================================================
最有效率的方法算出2乘以8等以几(同理可以用于除法)
2<<<3 和8<<1

顺序，选择（分支），循环
控制语句 break 配合标签功能跳出多重循环
lable01:
循环语句
lable02：
循环语句
{ break lable01； }//跳出整个大的循环

return 退出当前方法，回到调用处
===============================================================

数组 是引用型数据，所以存储在堆内存
先声明，后使用

引用数据类型有数组，接口 类 初始化值为null

栈内存保存的只是数组的名称，即使用数据类型 数组名[ ] 即可开辟栈内存，但这样的数组不可以使用
堆内存是用来存放数组的实体的， 用 new 开辟堆内存，然后把堆内存的控制权交给相应的栈内存，一个堆内存可以被多个栈内存引用

冒泡排序
遍历整个数组，遍历中依次比较相邻元素，如果次序不对，就交换位置
for(int i=0 ;i<length-1;i++)
for(int j=0;j<length-1;j++)
if( [j]与[j+1])
{交换}

插入排序
把要排序的数组分为有序部分和无序部分，每次从无序部分取一个元素插入到有序部分适合位置
for(int i=0 ;i<length-1;i++)
for(int j=i;j>0;j--) //有序部分
if( [j] 与[j-1]比较)
{交换}

选择排序
每一趟都从待排序的数组元素中选择最大（或者最小），放到已排序好的数列后面
for(int i=0 ;i<length-1;i++)
int lowIndex=i;
for(int j=i+1;j<length-1;j++) //有序部分
if( [j] >[lowIndex])
{lowIndex=j}
交换[i]与[lowIndex]

希尔排序
直接插入算法的改进，又称缩小增量排序，将整个无序列分割成若干个子序列后，再分别进行插入排序，然后缩减增量再排序，待到增量足够小时，对全体元素直接进行插入排序
三层for（）

===========================================================

main(string arg[]) 中的arg[]用来保存运行main时输入的参数，命令行参数

方法的重载
指允许在一个类里面具有多个方法名相同但参数列表不同的方法，在API文档中大量体现了重载的机制

形参个数可变的方法
public static void print(int x,string ... str){ } 传入的参数是以数组形式保存的，同main 函数
所以等同于
public static void print(int x,string [ ] str){ }
不同点，是可变形参一个方法只有一个，却可以有多个数组形参

if{}块里面的return 语句只是为了结束块代码，并不是返回方法结果，所以方法如果不定义自己的return语句，任然是void无返回值类型；

==============================================================

string new的和直接初始化的区别
缓冲池机制：直接赋值时，java编译器会到缓冲池里寻找是否有相同内容的字符串，如果有直接使用
new关键字调用构造方法的方式，每次调用都会生成一个新的String 对象
判断是否是同一个对象（地址值）（str1==str2）
而比较内容是否相同str1.equals(str2)

equals()区分大小写 equalsIgnoreCase( )忽略大小写
String.toUpperCase()转换为大写 trim()去除头尾的空格
获取一段换中所有的单词 使用StringTokenizer(str).nextToken();
string 是一个不可变类，对象一旦创建，对象中的字符串的修改，如果改变了变量引用的字符串，那么只是放弃了对原先字符串的引用，改为新的字符串地址（适合静态使用字符串）
stringbuffer 可变的string类 可以直接被修改 必须使用new关键字创建
字符串反转 reverse（）
因为stringbuffer没有重写object类的equals方法，所以需要用tostring方法转换为string字符串 ，再使用equals（）；
===============================================================
类和对象的关系
静态成员一经创建的生命周期就是所在类的生命周期
创建对象时，成员变量会自动初始化
如引用数据类型会初始化为null boolean 初始化为false
int byte short 初始化为0 char 初始化为‘\u0000’(表示为空)
对象实例化防止空指针（new 创建）
匿名对象 只是使用一次或者作为实际参数使用

23种设计模式
单例模式 可以防止 数据的冲突，节省内存空间
单例模式：通常将其构造方法声明为private，所以不能通过构造方法创建对象，从而保证单例类只有一个 实例（如windows系统中所有的盘符都只是引用一个回收站实例）

static 承担的是java中全局变量的角色（被所有实例共享，增加实例之间的交互性）
静态方法中不能有this和super关键字，不能访问实例变量实例方法
静态方法只能访问静态变量和静态方法
static和访问控制符修饰局部变量是没有意义的，java也不允许

====代码块
在同一代码块中，变量只能定义一次
普通代码块：
构造块：{ } 优于构造函数先执行
静态代码块：static{ }先于主方法执行，即也快于构造块，，更快于构造方法，静态代码块只执行一次

=====值传递和引用传递
所有函数的本质都是值得传递
值传递不会改变实参的值
引用传递不能改变对象本身，但可以改变对象的属性 String是不可变的字符串，引用不能改变它的值

==============================================================

print与println有区别，后者自动换行

java不支持宏，因为宏代换不能保证类型安全。
如果你需要定义常量，可以将它定义为某个类的staticfinal成员
java里面没法用const。你可以用final关键字

标识符不能以数字开头，大小写敏感
在一个软件生命周期里，有80%的时间用于代码维护，编码规范可以改善代码的可读性和可维护性

Override和Overload有什么不同？

答：Override是指父类和子类之间方法的继承关系，这些方法有着相同的名称和参数类
型。
Overload是指同一个类中不同方法（可以在子类也可以在父类中定义）间的关系，
这些方法有着相同的名称和不同的参数类型。
用super.xxx()可以在子类中调用父类方法

不确定a是不是B的实例，能不能分情况处理？
答：可以使用instanceof操作符

string比较如何做
答：比较String一定要使用equals或equalsIgnoreCase方法，不要使用==！

.class字节码文件
.Java对大小写敏感
; 是必须的，在Java中，一个完整的语句都要以“;”结束！

“=” 把=右边的表达式的值赋值给左边的变量；
“/” 除
“%” 取余

数据类型转换：①两种类型要兼容；
②目标类型大于源类型。

i++ 先执行 输出 a ，后执行 ++
++i 先执行 ++ ， 后执行 输出 a

♦ 关系运算符
== 等于
♦ 优先级
最高优先级：小括号，即（）；
最低优先级：赋值，即 = ；
优先级顺序：！> 算数运算符 > 比较运算符 > && > ||

♦ switch 选择结构
case 常量：
代码块；
break；

default:
代码块；
break；

表达式为 int 型 或 字符型 ；
case后面的常量跟表达式类型是一样的。
若没有 break；则代码会一直从上往下运行直到有break为止；
若表达式中不等于常量，则只运行default代码块。default与case上下顺序没有关系。

=============================================
♦ if选择结构和switch结构的联系和区别
=============================================
相同点：都是用来处理分支条件的结构
不同点：
switch：只能处理等值条件判断的情况，而且条件必须是整型变量或字符型变量。
if：没有switch选择结构的限制，特别适合某个变量处于某个连续区间的情况。

=======================================================
♦ break：break 语句用于终止某个循环，使程序跳到循环块外的下一条语句。在循环中位于break后的语句将不再执行，循环也停止执行。
♦ continue：continue 语句是跳出本次循环，进入下一次循环。

===============数组======================================
♦ 使用数组的步骤：
①、声明数组
数据类型[ ] 数组名；
或 数据类型 数组名[ ] ;
int[ ] scores = new int[ ]{60,70,80,90};
或
int[ ] scores;
scores = new int[ ]{60,70,80,90} ;

Arrays.sort(数组名); //升序排序

♦ 引用数据类型：赋值是把原对象的引用传递给另一个引用。对数组而言，当一个数组引用赋值给另一个数组引用后，这两个引用指向同一个数组，也就是指向同一块内存空间。传递的是地址。
==========================================================

==============类和对象=======================================
♦ 类：具有相同属性和方法的一组对象的集合。
对象：用来描述客观事物的一个实体，由一组属性和方法。又叫做类的实例。
♦ 对象分为：特征 --> 属性
行为 --> 方法

♦ 常见的错误：
①、方法的返回值类型为void，方法中不能有return返回值。
②、方法不能返回多个值。
③、多个方法不能相互嵌套定义。
④、不能在方法外部直接写程序逻辑代码。

成员变量在Java中会有一个默认值，基本数据类型是0，引用数据类型是null

♦ 带参方法语法：
<访问修饰符> 返回类型 <方法名>(参数列表){
//方法的主体
}

==================字符串=============================
♦ String是一个类。例：String s = new String();
♦ boolean con = s.equals(“ABC”); //判读字符串s是否与“ABC”相等
con = s.equalsIgnoreCase(“ABC”); //同上，但忽略大小写
♦ String a = s.toLowerCase(); //把s中的英文字母全变成小写
a = s.toUpperCase(); //同上，但是全部改成大写
♦ String b = s.concat(“ABC”); //在字符串s的末尾加上字符串“ABC”
♦ int c = s.indexOf(‘a’); //搜索出出现第一个字符a的位置 若s中不含“a”，则c = -1 ;
int c = s.indexOf(“b”,3); //从s的位置3开始搜索“b”。
c = s.lastIndexOf(‘a’); //最后出现字符a的位置
♦ String d = s.substring(3); //提取从位置3开始包括位置3以后所有的字符
注：字符串位置的数字从0开始
d = s.substring(3,6); //提取从3到6之间的字符，包括3，不包括6.
♦ String e = s.trim(); //去掉s前面和后面中所有的空格

♦ String[ ] a = s.split(“.”,int 6); //int 6 可有可没有
以“ . ”为标准分割字符串，返回给一个数组；限制这个数组有6个元素。
♦ StringBuffer 类：
StringBuffer sb2 = new StringBuffer(“good”); //只能这么写
sb2.append(…) 在sb2后面加上…; 不需要重新赋值。
♦ 字符串1.insert(位置，参数); //将参数插入到字符串1的指定位置后并返回

=================================================
input();
输入true或者false
boolean用%b代替 string用%s代替 int用%d代替
input.next()就是以字符串的形式返回输入的数据（空格会断开）
input.nextLine()就是以字符串的形式返回一行的数据（可以包括空格）

♦ 三元运算符：
条件 ？ 值1 : 值2 ；

.CompareToIgnoreCase 是忽略大小写的
.compareTo 不忽略大小写

=========================================================

封装类
Character Boolean类属于Object 类的子类
Byte Short Integer Long Float Double 均属于Number 类的子类
封装类属于引用数据类型，具有属性和方法，
：将基本数据类型进行了封装，可以当做对象进行使用
为基本数据类型提供各种转换功能，如将数值转换为字符串，将字符串转换为数值

子类的构造方法之前一定要先调用父类的构造函数

=========================================================
override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。
重写（覆盖）的规则：
1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.
2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符 （public>protected>default>private）。
3、重写的方法的返回值必须和被重写的方法的返回一致；
4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；
5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。
6、静态方法不能被重写为非静态的方法（会编译出错）。

overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。
重载的规则：
1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类 型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；

多态的概念比较复杂，有多种意义的多态，一个有趣但不严谨的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。
一般，我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。
对象方法的多态：重写和重载
对象类型的多态：
向上转型（自动完成）：但是父类对象不能调用子类新增的方法，只能调用子类重写的方法
向下转型（必须明确指出要转的子类类型）：必须先向上转型，在强制向下转型，通过instanceof判断父 类是否 可以转换为子类对象

==================================================
子类继承了抽象类，就必须实现所有的抽象方法，要不子类也必须声明为抽象类
==================================================

类的实例不能被转化为另一个类的实例
抽象类不能用new 实例化
抽象类定义的构造方法在子类实例化的时候也会执行，自动调用
abstract 不能和private static final native synchronized 等同时使用，因为后者都不满足子类重写并实现的要求

native 只是修饰声明的方法

java只支持单重继承，不允许一个类同时继承多个父类，但是通过定义接口，就可部分实现多重继承的功能，

接口不能继承类，即类不能派生接口
允许抽象类实现接口，但不允许继承
接口实现类的行为定义，约定可实现类必须实现的功能interface
=====================================================
接口和抽象类的区别 ：
接口也有属性和方法，也有继承关系，
属性是全局常量默认是private static final
方法是抽象方法，默认是public abstract，不能是非public 最终的 静态的static
定义接口用的是interface
接口没有构造方法，也不能定义构造方法
接口没有内置的this 和super 关键字，、
接口支持多重继承，但是接口之间只有继承没有实现，既没有implements
抽象类只支持单重继承，可以实现多个接口，但不能继承接口，选择性的重写父类的方法和实现接口的方法

两则的选择：
优先 选择接口
既要定义子类的行为，又需要为子类提供公共的功能的时选择使用抽象类

=====================================================

对象数组（引用数据类型）

foreach 输出
for（类 变量名：数组名）{
sysout(变量名.方法)
}

======================================================
内部类inner
| |
| |
| |
成员内部类 局部内部类
| |
实例内部类 静态内部类
=======================================================
实例内部类必须定义在其外部类的对象实例存在的情况下才能创建，其内部不能定义静态成员
内部类提供了更好的封装，不被同一个包里的其他类所见
匿名内部类方便的定义运行时回调和用于仅需要一次使用地类
编写事件驱动程序很方便
内部类不能喝外部类重名

从外部类实例方法访问内部类使用内部类的实例访问
从外部类的静态方法访问内部类需要创建外部类的实
实例内部类（没有static修饰的内部类）不能定义静态成员
=====================================================
静态内部类
不能访问外部类的非静态成员，其对象实例可以独立创建，没有指向外部类的对象实例的引用 若要访问外部类的非静态成员时，需要外部类的实例访问，在外部类中要通过内部类的实例调用实例方法，通过类名.方法形式访问静态方法

=======================================================
局部内部类
没有控制符和static修饰符
局部内部类只能访问所在方法的final 类型的参数与变量
final定义的变量相当于常量，可以延长变量的生命周期，就算方法撤销，其内部类仍可以访问final类型的变量

=======================================================
匿名内部类
匿名内部类只在所定义的代码块内使用一次，
使用父类的构造方法创建实例，若果实现的是接口，那么内部类的构造方法就是object（）；
语法格式:
new 类名或接口名 （参数列表）
非静态代码块
{
赋值语句
}
=======================================================
final 修饰类时，表示不能被继承，不能有子类
修饰方法时，表示该方法不能被子类的方法重写
修饰变量时，表示为常量
abstract 抽象

接口是由全局常量和抽象方法组成
非静态内部类不能含有静态成员

=====================异常处理============================

程序的可扩展性和可读性 可靠性：正确性，健壮性

所有异常都继承Throwable 类
error 和 exception
arithmeticException 算术异常
arrayIndexOutOfBoundsException 数组越界
arrayStoreException 数组存储异常
ClassCastException 对象转换异常
NullPointerException 空指针异常
IllegalArgumentException 传入参数异常

异常处理机制

try catch finally

throws

异常(包括Exception和Error)分为
可查的异常（checked exceptions）
不可查的异常（unchecked exceptions）。
如果能从异常中恢复的就采用检查异常, 如果不能从错误中恢复的, 就应该采用非检查异常.

最简单的判断点有两个：
1.继承自RuntimeException或Error的是非检查型异常，而继承自Exception的则是检查型异常（当然，RuntimeException本身也是Exception的子类）。
2.对非检查型类异常可以不用捕获，而检查型异常则必须用try语句块进行处理或者把异常交给上级方法处理总之就是必须写代码处理它。

==========================================================
throws声明异常
throws 抛出异常的方法声明的异常类型不能比调用处 能处理的异常类型的范围大。否则编译报错 ==========================================================

throw 抛出异常
抛出的是异常类的实例
抛出的为非检查异常时，调用方法可以选择处理
抛出的为检查异常时，需要在方法头部声明方法可能抛出的异常类型，而且调用方法必须选择检查处理
throw 语句后不能紧跟其他语句，因为这些语句不会被执行

system.exit ();则不会执行finally{}

finally 在提交捕获异常前执行

==========================================================
断言
可以检测程序的执行效果
对布尔表达式进行检查
assert 布尔表达式：详细描述信息

==========================================================

java的输入与输出
方向：
输入流，输出流
组成：
===========字节流（抽象类）
inputstream
outputstream
字节流处理的是二进制可执行文件和压缩文件，一般只要是非文本数据都应该用字节流来处理
===========字符流 （抽象类）
writer filewriter
reader filereader

字节流若不执行close 仍可以向文件输出内容，但是字符流若不执行，就无法向文件写入内容
，因为字符流引入了缓冲区机制，内容放在缓冲里，没有close，但可以用flush强制提出数据

文件类 file 类
不属于java流系统
pathSeparator 路径分隔符；
separator 分隔符\\

GBK包含GB2312
utf可以节省空间
decode是将普通字符串按照参数中的编码格式进行解析，然后生成对应的unicode对象
那么encode正好就是相反的功能，是将一个unicode对象转换为参数中编码格式的普通字符
decode("utf-8").encode("gbk")

====================转换流
inputstreamreader
outputstreamwriter

===================内存操作流
ByteArrayOutputStream

ByteArrayOutputStream
默认两个都没有执行close（），因为是个空方法，没有实际操作
一般用来处理临时信息

==================打印流
printStream 是FilterOutputStream 的子类 内置out 和err

使用useDelimiter()将分隔符修改为换行符\n

邮箱验证
String pattern= "^[a-zA-Z0-9_\\.]+@[a-zA-Z0-9-]+[\\.a-zA-Z]+$";

===================================

任意（随机）访问文件类
RandomAccessFile

======================顺序输入流
sequenceInputStream(合并输入流)

=====================压缩流
ZipInputStream

======================对象序列化
是一种轻量级的对象持久化
必须实现Serializable 接口，表明该对象是可序列化的
参与序列化的内容：
属性 类名
没有参与的内容：
方法 static关键字 和transient关键字修饰的属性

==================对象输出流
ObjectOutputStream（序列化）
==================对象输入流
ObjectInputStream（反序列化）

通常喜欢使用集合保存多个对象，然后使用序列化集合中的对象

Externalizable 可以选择需要序列化的内容，但是需要实现readExternal() 和writeEternal()

栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）
堆：存放所有new出来的对象。

=====================================泛型应用
classcastexception 类型转换异常
E ----元素 T===类型
K====键 N====数字
V===值 S U V ==第二 第三 第四个类型

它就是一个类型参数 ，可以指定限定符，只能是extends，不能使super

定义泛型对象
类名<泛型类型> 对象名 = new 类名 <泛型类型> （）；
其中类型为引用数据类型，不能为基本数据类型
不能直接用参数类型构造一个对象 ，可以使用反射机制中的Class.newInstance()方法

java中泛型类不能继承throwable及其子类
java不能使用泛型类型的数组，这样编译时java会做擦拭处理，全部变成object对象类型的数组

泛型只存在于编译期，运行时运行参数会被擦除

=====================通配符
无界通配符 ？ 但注意使用它设置对象时不能通过setter()方法设置被泛型指定的内容,但是可以设置为null
受限泛型
上限<? extends 泛型类型1 & 泛型类型2 & 3 >
下限<? super 泛型类型>
通配符是用来声明一个泛型类型的变量 ，不是用来创建一个泛型类的
即 class first < T extends number>
则规定了实例化时传入的类型参数必须为number的对象或子类对象
而且不能写成
class first <? extends number >

在java的泛型里，对于static 方法而言，是无法访问泛型类的类型参数的

泛型类和非泛型类在继承是的主要区别是：泛型类的子类必须将泛型父类的所需要的类型参数沿着继承链向上传递

======================泛型接口
实现的类的类型参数必须和接口的类型参数一致
（1）在子类后声明泛型的方式实现泛型接口
（2）子类在实现泛型接口时明确给定泛型类型 ===这样在实现子类对象时不用再指定泛型类型了

======================泛型方法
public [ static |final ] <T> 返回值类型 方法名 （ 泛型标示符 参数名）

与泛型类中的泛型方法的区别：额可以被定义成实例方法，也可以被定义为静态方法

泛型方法可以写在泛型类或非普通类中

大多情况下，泛型主要用于处理集合

使用泛型方法
1.对象名|类名.方法名（参数）
2.对象名|类名.<实际泛型类型>方法名（参数）
引入泛型就是使编程变得安全简单，不用等到运行时才发现异常错误

===========================集合

集合的数目是可变的，只能存储引用数据类型，不能存放基本数据类型

java中的集合类主要由两个接口派生即collection 和map
collection 派生的是list 和set map 不是其子接口

list 允许存在相同的元素，有序的
实现类：ArrayList LinkedList

set 不包含重复元素，允许包含null 但 只允许一个set集合中只包含一个null
两种子类 hashset高效无序的 treeset有序存放，但需要comparable进行排序操作
没有get(int index)方法
hashset 不是线程同步的
需重写类的equals和hashcode的方法,来区分集合中是否有重复的元素

======================集合的输出(标准)
Iterator<类型> 迭代名 = 集合.迭代函数
foreach（类型 临时变量：集合）

========================map 接口
保存具有映射关系的数据
key 不允许重复
value 一个key 只能映射一个value

hashmap 类不是同步的，也不保证映射顺序，效率高

treemap 对key进行排序，是有序树映射类，效率低

collections工具类提供的都是静态方法，可以直接通过类名.方法名（）调用
排序，反序，去极值，循环移位，查询，修改

================== 其他集合
vector 向量类
线程安全的 方法之间线程同步 可以使用foreache iterator enumeration 输出
这是与arraylist的区别
只能以foreache Iterator 输出 且线程不安全，但是单线程时效率高

stack栈类

hashtable类
与hashmap的区别，后者是hashtable的轻量级实现（非线程安全的实现）
（1）hashtable在JDK1.0就有了，属于旧的操作类
（2）同步性 hashtable 是线程安全的，也即是同步的，所以效率较低
（3）值，hashtable 不允许null 值和null 键，hashmap 允许存在一个null键和多个null值
====================enum 枚举
可以限制一个类的对象产生范围
类型安全 定义有效地数据类型 可以与程序的其他部分交互 运行效率高

enummap 必须指定一个枚举类 不允许使用null 值作为key 值，但允许null 作为value值

EnumSet不同步的 元素有序

对象需要实现每一个抽象方法
=====================JaVA反射机制==================================

reflect 用在javaBean 中

getFields() GetMethods() 获取类中的public的成员变量和方法，包含继承父类的。
getDeclaredFields() getDeclaredMethods() z只是获取本类中的public的变量和方法

用Class类来加载对象
（1）Class类的构造方法是私有的，所以不能使用new（静态加载）方法实例化，但可以通过提供的静态方法forName（） 动态加载，即使不存在Loader Class类也可以通过编译，只是运行时产生异常，返回的不是加载的类的实例，而是Class类的实例，多用于加载驱动程序
（2）使用类标记
类名.class
public T cast （Object obj）将一个对象强制转换为Class对象所表示的类或接口
CAST 将某种数据类型的表达式显式转换为另一种数据类型
（3）getClass()

使用反射机制生成并操作对象
Class.newInstance(),前提是要保证实例化的类中存在一个无参的构造方法
否则调用有参构造方法实例化对象Constructor

Field类 用于表示类中的成员属性

Method类 用于表示类中的成员方法

getInterface ()获取一个类所实现的全部接口，返回一个class对象数组

获取父类 getSuperclass()
访问成员变量 field

======================java 网络编程
局域网 LAN 城域网 MAN 广域网 WAN
TCP/IP 传输控制协议、因特网互联协议 4层结构 与osi开放式系统参考模型不同（7层）
网络层的ip 传输层的tcp
应用层
传输层 TCP/UDP
网络层：ip协议 ICMP协议（互联网控制报文协议） IGMP(Internet组管理协议)
网络接口层（数据链路层）

TCP它是一种面向连接的可靠的基于字节流的运输层通信协议,得到一个顺序的无差错的数据流，三次握手，必须确保建立连接,四次挥手释放连接
UDP user Datagram protocol用户数据报协议，一种无连接的传输层协议，面向非连接，简单的，不可靠的信息传送服务

ip 网络号+主机号 点分十进制记法 32位
A类：1-126
B类：128-191
C类：192-223
D类：224-239 组播地址
E类：240-255 Internet试验和开发

127.0.0.0-127.255.255.255并不在A类地址内，因为任意以127开头的IP地址都是回送地址，它是一个保留地址，最常见的·127.0.0.1
C类地址中私有地址192.168.X.X是私有地址（192.168.0.0-192.168.255.255）

=====端口
IP地址可以准确的标示网络上的唯一的一个通信实体，但是通过端口可以知道需要网络连接的是计算机上的哪一个服务
端口不是物理存在，是计算机与外界通信的出口 16位的整数，标示不同的进程0-65535（三类）
公认端口： FTP 21 DNS 53
(0-1023) TELNET 23 TFTP 69
SMPT 25 HTTP 80
POP3 110 SNMP 162
注册端口：松散的绑定一些服务
(1024-49151)
动态/私有端口：随机分配
(49152-65535)

========套接字
ip 加端口号 ====Socket
一个TCP的连接由通信双方的socket 确定，实现全双工式的通信。
socket 用于将应用程序与端口连接起来，负责将TCP/TP包发送到指定的IP地址

=======URL（统一资源定位符）
组成：
协议protocol（http.ftp..) 主机名（存放资源服务器的域名系统DNS或ip地址）
端口号 路径（path）

=========================Inetaddress类

域名和ip之间的查找

========================URL URLconnection 类

getref() 获取此URL的锚点（引用）

========================tcp程序设计
serversocket .accept()阻塞方式监听

========================udp程序设计
不可靠的点对点通信，适合对性能要求高但对可靠性要求低的应用，还支持广播和多播通信方式

DatagramPacket 对象作为传输数据的载体，即数据包
DatagramSocket 对象用来接受和发送数据报，服务器需要加一个端口号

=====================多线程

进程最根本的属性就是动态性和并发性 并发不是并行，程序是静态的
进程间的通信（ipc）开销较大，切换开销也大，进程控制表PCB
线程控制表TCP,轻量级进程
进程包括了程序，数据和PCB
由于Runnable 接口对于线程没有任何支持，所以获得实例之后，还必须通过Thread 类的构造方法来实现

比较继承Thread 类和 实现 Runnable 接口（后者好）
(1)可以避免java单继承的局限 ，可以实现多个接口
(2)适合多个相同程序的线程去处理同一资源的情况，数据有效分离，面向对象的设计思想
实现资源共享（如果继承Thread 则可以设置共享资源为static也行）
(3)有利于程序的健壮性，代码可以被多个线程共享，代码与数据是独立的

启动线程start(),进入就绪状态

新建状态===就绪状态====运行状态======阻塞状态====死亡状态
休眠实例 应把sleep() 放在run()方法中，而不是主方法中

线程的插入 join()

isinterrupted() 返回 当前进程中断与否状态
interrupted() 返回 当前进程中断与否状态,并解除中断

后台线程（守护线程）如：jvm垃圾回收线程
setDaemon()设置为守护线程，在所有非后台线程结束后，后台线程也会结束

线程的礼让
yield(),只是交出运行权 ，并不指定线程，让给优先级高的线程 转向就绪状态，不抛出异常
不同于
sleep()：交出运行权，不考虑其他线程优先级 当前线程转向阻塞状态 抛出interruptedExcption
相比yield 有更好的移植性

线程同步和通信
线程安全：解决同步问题的方法
（1）同步代码块
synchronized关键字修饰代码块（Object obj）{ }
如果期间调用了sleep()方法，则线程会放弃CPU运行权，但不会放弃对象的锁 不同于wait()
（2）同步方法
【访问控制符】[ static |final ]synchronized [返回类型] 方法（）{ }
（3）同步锁lock() unlock() ReentrantLock

线程间的沟通
Object 类的方法notify notifyAll wait

========================ant 脚本
有点可以在集成很多种语言时起作用

========================flex3

=====================strus2
OGNL
========================

finalize:和java的垃圾回收机制有关GC
nitify/notifyall() 唤醒等待队列与wait相对（线程里的知识）

变量 instanceof 类名 判断是否是某一个类的实例

equals()和hashcode()方法重写
equals()的形参必须是object类型

System.out.println();在打印引用数据类型时，若不为空，则首先调用引用对象的tostring（）方法获取字符串

=================================
finally final finalize区别
==========================运行时操作类
runtime类本身的构造方法是私有化的，所有应用程序不能创建自己的runtime类实例，但可以通过getruntime()方法获取当前runtime 运行时对象的引用

progress类是一个抽象类

==============定时器
timer timerTask
每一个定时器都有一个后台线程，显示指定该线程为守护线程
timer 是线程安全的，多个线程可以共享单个timer对象而无需进行外部同步

====================系统类
System 提供控制系统状态的静态方法
加载文件和动态链接库native（）
但是访问系统底层硬件设备java无法实现，必须借组c语言
arraycopy（）违背了java的命名规范，第二个单词copy 首字母没有大写
CurrentTimeMillis（）返回的事ms 是一个long类型的整数
gc() 实质就是调用object 的finalize方法
finalize()方法的作用就是释放一个对象占用的内存空间，会被JVM自动调用，没有链式调用，必须手动实现

===================时间类
date()
calendar Calendar为抽象类，不能使用new
需要使用子类GregorianCalendar 或者getInstance()实例化

getTimezone()获取时区
calendar 中的月份要加1，起始位0 获取星期几时要减1，因为是从星期天开始算的

日期格式化DateFormat
也是抽象类 不能用new实例化
使用其静态方法getDateFormat实例化

SimpleDateFormat 自定义日期格式
yy MM D年中的天数
d 月中的天数
E星期中的天数 H 一天中的小时数 h12小时制
S毫秒
s分钟中的秒数
parse(string source)将一个包含日期的字符串转化为一个date

==============================math类
提供的方法都是静态方法。通过类名.方法（）形式调用，无需通过对象（返回都是double型）
--------绝对值
ads()
--------最大（小）值
max() min()
--------取整
ceil(a)返回大于或等于a 的最小整数
floor(a)返回小于或等于 a 的最大整数
rint(a)最接近a 的整数 round(a)四舍五入
--------三角函数
sin() asin() cos() acos() tan() atan()
toDegrees(弧度) 弧度转化为角度
toRadians(角度) 角度转化为弧度
--------幂与开方函数
cbrt(double a) 返回立方根
exp(double a ) 返回欧拉数e的a次幂
expm1(double x) 返回e的x次幂-1
pow(double a ,double b ) 返回a 的b次幂
sqrt(double a ) 求平方根
NaN（它代表“不是一个数字”）的特殊值
-------对数函数
log(a) 即ln(a)
log10(a)
log1p(x)即ln(x+1)
-------随机数
random()范围是0-1

==================格式化类 NumberFormat类
BigDecimal
BigInteger

=================三个修饰符
static
可以修饰属性 （类变量），不可以修饰局部变量（因为随时可能消失）
在对象初始化前静态变量就已经初始化了，类加载时
方法 静态代码块

==============================正则表达式
===========================================================
Pattern 是一个最终类 ，实现Serializable
多个 Matcher可以共享一个Pattern 对象
Pattern compile（string regex ，int flags）将给定的正则表达式编译并创建一个Pattern对象
Matcher mathcer(CharSequece input )创建一个给定名称的matcher对象
String pattern()返回该Pattern对象所编译的正则表达式
String [] split(CharSequece input)将指定的字符串按照Pattern对象包含的正则表达式 为模进行分割
String [] split(CharSequece input， int limit)指定分割的段数

Matcher 是一个最终类，实现 MatcherResult
因为没有提供构造方法，所以需要使用Pattern 对象来创建Matcher对象
Matcher appendReplacment(StringBuffer sb, String replacement)将指定的字符串替换为。。。
StringBuffer appendTail(StringBuffer sb)将最后一次匹配后剩下的字符串添加到指定的sb后
find()
end()
groub() matchers()完全匹配时返回true
replaceAll(String replacement)
reset()重置Macther对象
start()返回当前查获子字符串的开始字符在目标字符串中的位置

==========================数据库
Oracle DB2 SQLserver mysql (瑞典) postgreSQL Sybase
定义：指在计算机存储设备上合理存放相关联，有结构的数据集合
特点：
（1）数据结构化 与文件系统的根本区别
（2）数据冗余度小，共享性高，避免数据的不一致性
（3）具有较高的数据独立性 数据与应用程序的无关性，逻辑和物理
（4）数据库管理系统DBMS
安全性控制 完整性控制 并发控制 数据库故障的发现和恢复
分类：
（1）层次模型 1：N 指针 效率高 限制严格 邻接表 链表法
（2）网状模型 N : N 指针 效率高 复杂难掌握
（3）关系型模型 二维表
（4）面向对象模型 接近人的思维

范式
（1）第一范式 属性原子性
（2）第二范式 行的唯一区分，唯一属性列称为主键 非主属性完全依赖主属性
（3）第三范式 每一列只有一个值 每一行都能区分 每一个表都不包含其他表已经包含的非主属性信息
===============================================================

事务
===============================================================
事务是保证数据库中数据完整性和统一性的重要手段，事务是SQL中的单个的逻辑执行单元，可由一步或多步的数据库操作组成，一个事务内的所有语句作为整体执行，遇到错误时就可以回滚事务，但是提交后的事务无法取消，只能靠日志或者闪回技术
JDBC 的事务范围仅局限于一个数据库连接，不能跨越多个数据库连接
第二在插入操作前，若执行commit（）方法提交事务，则无法再进行回滚操作，即
rollback（）方法无效
nativeSQL(String sql)将sql语句转换为本机SQL语法

事务四大特性 ACID特性。
（1）原子性（atomicity）一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么 都不做
（2）一致性（consistency） 事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与 原子性是密切相关的。
（3）隔离性（isolation） 一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并 发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。（可串行性）
（4）持久性（durability）持续性也称永久性（permanence），指一个事务一旦提交数据，改变就应该是 永久性的。接下来的其他操作或故障不应该对其有任何影响

SQL语言三个部分：
DDL数据定义语言 （Data Definition Language）
创建表，索引 ，触发器create alter drop
DML数据操作语言 ( Data Manipulation Language）
数据更新insert select delete
DCL 数据控制语言 （Data Contrilling Language）
存取允许，存取权限grant revoke 回收权限
TCL事务控制语言(Transaction Control Language)
commit rollback

mysql
mysql -h主机地址 -u用户名 －p用户密码
show databases; 显示数据库列表。
show tables; 显示库中的数据表
describe 表名; 显示数据表的结构
create database 库名; 建库：
use 库名; 使用某个数据库
drop database 库名; 删除库或表
delete from 表名; 将表中记录清空
select * from 表名; 显示表中的记录：
id int(3) auto_increment not null primary key 自动加一，非空 ，主键

mysqldump 备份数据库 (mysqldump命令位于mysql/bin/目录中)

添加属性列
alter table 表名 add 属性名 数据类型 约束条件 after|first 已有属性
修改属性数据类型
alter table 表名 modify 属性 数据类型
修改表名
alter table 旧表名 rename 新表名
删除字段
alter table表名 drop 属性
修改表中字段名
alter table 表名 change 旧属性 新属性 新数据类型

char (29)定长字符串 varchar变长字符串
longtext 最大为4GB mediumtext 最大为16MB

SQL优化
主键长度尽量不要太长 varchar 和char 的使用
无关紧要的字段让自动给一个类型值
对查询频率高的字段建立索引
尽量避免在where语句中使用模糊查询 如like in exists Not <> !> !< 也不适用函数
尽可能 少用DISTINCT，用EXISTS代替
尽可能使用存储过程提高数据处理的速度
oracle执行顺序是自右向左，自下向上

处理操作
Statement 执行静态sql语句
PreparedStatement 继承了Statement ,是子接口，具有可读性和可维护性，还有安全性动态执行 value(?,?,?,?,?,?)
CallableStatement 执行对数据库的存储过程调用

建立连接过程
connection ------statement----execute()------resultset---next()指针移动到最后一行返回false

========================================
调试
shift+d调试
F5进入调用方法
F6单行执行，不进入调用方法，只查看运行结果
F8继续执行

junit
F11

============================================================

Java 图形界面
swing 完善了awt
awt的显示优先级高，总会显示在swing 的组件前面

java的时间处理采用的是委托时间模式 （Delegation Event Model） 由事件监听器处理

适配器
监听器最底层都是以接口的形式提供的，所以存在很多抽象方法，为了避免重复实现这些方法，系统提供了这些方法实现的类，这些类被称为适配器；
所有事件都是EventObject 的子类

程序设计中多采用匿名类的方法设置监听事件 ，比如Android中的设置监听

java笔记