JavaSE入门

Day1:======================================================================================

上课时间：
09:15-11:45
13:30-17:45
18:30-21:00

java环境变量：
JAVA_HOME:新建一个jdk路径。
Path:修改，直接运行的程序对应的路径
%JAVA_HOME%\bin;

主方法：
public class 类名称{
public static void main(String[] args){

}
}

Day2:======================================================================================

变量命名规则：
首字符：字母/_/$
其余：字母/_/$/数字
小驼峰规则
不能使用保留字(class,void...)
类命名规则：
大驼峰规则

数据类型：
基本类型：
整型：
byte： 字节型，1字节，-128~127，-2^7~2^7-1
short：短整型，2字节，-32768~32767，-2^15~2^15-1
int： 整 型，4字节，-2148473648~2148473647，-2^31~2^31-1 （经常使用）
long： 长整型，8字节，，-2^63~2^63-1
字面量：3:int
3l或3L:long
字符型：也归于整型
char：2字节，单引号括号，unicode16编码存储的码值
//char c='我';
//char c1='A';
//char c2=65;
浮点型：
float：4字节 精度7-8位
double：8字节 精度15位
字面量：1.2:double
1.2f或1.2F:float
布尔类型：
boolean；1字节，true/false

引用类型：
数组
对象

转义字符：
System.out.println("\n");//换号
System.out.println("\t");//tab
System.out.println("\"");//双引号
System.out.println("\\");//斜杠

类型转换：
把几个数值型排序:
byte,short,char < int < long < float < double

//调用键盘输入交互：
import java.util.Scanner;//引入Scannerd的方法
Scanner input=new Scanner(System.in);//建立一个引用对象
int num1=input.nextInt();//声明一个变量，调用input的方法输入

Day3:======================================================================================

算数云算符：
num++: 先备份 再自增
++num: 先自增 再备份
语句中取的是备份值

关系运算符：
>,>=,<,<=,==,!=
结果是boolean
只能比较两个数的关系

逻辑运算符：
&&: 与，而且，二者都成立，结果为true，否者为false
||: 或，或者，一个成立，结果为true，否者为false
!: 非，取反
&,|,^

位运算符；（了解）
二进制
3<<1, 右移1位，数值等于*2
00000011,3
00000110,6

三目运算符：表达式?成立执行这：不成立执行这;

Day4:======================================================================================

条件结构：
if-else
switch-case

if-else:
若是if或else中的代码只有一行，{}能够省略，但不建议省略

任何状况均可以使用，判断点值，段值均可以

switch(表达式){
case 常量1:
代码;
break;
case 常量2:
代码;
break;
......
default:
代码;
}

if-else vs switch-case:
if-else：任何状况均可以使用，判断点值，段值均可以
switch-case:判断点值，整型，字符串，枚举

对于点值，分支比较多时，建议使用switch-case
switch-case: 表达式只要计算一次，
if-else:每一个条件都要计算一次，分支越多效率比switch-case越低

字符串补充：
输入字符串：input.next();
输入字符：没有直接方法
方式1：能够输入字符串，获得字符串类型
input.next();
String s1 = input.next();
方式2：能够输入字符串，获取第一个字符 ,获得字符类型
input.next().charAt(0)
char c1 = input.next().charAt(0);

字符串判断:equals()
eg:s1.equals("字符串")

//a的b次方
Math.pow(a,b),结果是double类型

//开平方：
Math.sqrt(),结果是double类型

//求随机数
Math.random(),结果是double类型,范围是[0~1)
//产生1~9之间的随机整数 0~8 再+1
System.out.println((int)(Math.random()*9)+1);
//a~b -> 0~b-a -> Math.random()*(b-a+1) -> Math.random()*(b-a+1)+a
//2-8
System.out.println((int)(Math.random()*(8-2+1)+2));

//1-7
System.out.println((int)(Math.random()*7)+1);
System.out.println((int)(Math.random()*7-1+1)+1);

//2-7
System.out.println((int)(Math.random()*6)+2);
System.out.println((int)(Math.random()*7-2+1)+1);

Day5:======================================================================================

循环：
while
do-while
for

while循环语法：
while(条件表达式){
循环体;
每次要作的事情;
}
判断成立执行循环体，最小可能执行次数：0次

Day6:======================================================================================

do while循环语法：
do{
循环体;
每次要作的事情;
}while(条件表达式);
先执行循环体再判断，最小可能执行次数：1次

for循环
for(循环变量初始化;条件表达式;循环变量改变){
循环体;
每次要作的事情;
}

break,continue关键字
break:
1)用在switch中，表示结束switch结构
2)用在循环中，表示结束循环，
通常会结合条件来一块儿使用
continue：
用在循环中，表示提早结束本次循环，进入下一次循环

Day7:======================================================================================

数组；
1,声明数组：肯定元素类型
1)元素类型[] 数组名；
//eg: int [] array;
1)元素类型 数组名[]；
//eg: array [];

2,创造数组对象
数组变量名=new 元素类型[数组长度];
//eg: array=new int[5]

--声明并初始化：
//eg: int[] array = new int[5];

3,使用数组
元素的索引：
范围:0~长度-1
赋值:
数组名[索引]=值；
获取值:
数组名[索引]；
数组长度：
数组名.length，不可改变，建立时肯定了

4,数组声明后没有赋值，元素有默认值：
基本类型：
数值型：默认值是0
Boolean：默认是false
引用类型：默认值是null

5，静态语法
1)元素类型[] 数组名 = {值1,值2,...,值n};
//eg: int[] array = {1,3,5,4,5,7};

2)元素类型[] 数组名 = new 元素类型[]{值1,值2,...,值n}};
//eg: int[] array = new int[]{1,3,5,4,5,7};

注意：长度有实际赋值的元素个数决定

Day8:======================================================================================

方法：包含多行代码
能够反复使用同一个方法

方法的定义：
修饰符 返回值类型 方法名(形参列表){
方法体,写具体的代码
}

修饰符：暂时写public static
返回值类型：若是方法须要返回值，返回值要和返回值类型匹配
若是方法没有返回值，返回值类型写void
经过return 表达式返回结果;
一个方法执行到return就结束了

方法名：和变量名命名同样，使用方法经过方法名
形参列表：用来接收调用者传过来的值,
至关于声明变量，多个变量用逗号隔开，值在调用方法时赋值，不须要担忧初始化问题
若是不须要接收值，就不须要形参，()要有
eg:method1(int num)
method1(int num1,int num2)
method1(int num1,double d)

方法的调用：
在同一个类中，对于public static修饰的方法
经过 方法名(实参);
若是方法有返回值，要接收返回值 变量=方法名(实参);

Day9:======================================================================================

Arrays.sort();
Arrays.toString();
Arrays.binarySearch()

方法的定义：
修饰符 返回值类型 方法名(形参列表){
//方法体
}

修饰符：暂时写public static
返回值类型：
方法返回结果的类型，若是方法没有返回值，返回值类型写void
经过return 表达式; 返回结果
方法执行到return结束

若是方法返回值类型是void,也可使用return;表示结束方法

二维数组：
1)声明二维数组引用变量
元素类型[][] 二维数组变量名;
eg:int[][] array;

2)建立二维数组对象
二维数组变量名 = new 元素类型[二维数组长度][];
eg:array = new int[3][];
二维长度：二维数组变量名.length

每一个元素默认值是：null,没有保存任何一维数组对象的地址

3)给二维数组对象赋值，赋一维数组对象的地址
二维数组变量名[下标]
eg：array[0] = new int[2];
获取一维数组的长度：二维数组变量名[下标].length
eg:array[0].length

4)经过二维数组对象使用每一个一维数组中的每一个元素
二维数组变量名[第几个一维数组的索引][一维数组中第几个元素索引]
eg:array[0][0]

动态语法2：若是每一个一维数组长度相等,差异体如今第2步
1)声明二维数组引用变量
元素类型[][] 二维数组变量名;
eg:int[][] array;

2)建立二维数组对象和一维数组对象
二维数组变量名 = new 元素类型[二维数组长度][一维数组长度];
eg:array = new int[3][2];
二维长度是3，3个一维数组，长度都是2

二维长度：二维数组变量名.length

3)经过二维数组对象使用每一个一维数组中的每一个元素
二维数组变量名[第几个一维数组的索引][一维数组中第几个元素索引]
eg:array[0][0]

静态语法：若是每一个值都已知
能够声明，建立，赋值一步到位
元素类型[][] 二维数组变量名 = {{每一个一维中的值},{每一个一维中的值},...,{每一个一维中的值}};

eg:int[][] array = {{1,2},{3,4,5},{6,7,8,9}};
二维长度3：
一维：2 1,2
一维：3 3,4,5
一维：4 6,7,8,9


Day10:======================================================================================

OOP：Object Orientied Programming

面向对象编程：一周左右，知识点连续度高度，难点，重点
1.基本类，对象，对象使用
2.类的三大特性：（抽象），封装，继承，多态
3.抽象类
4.接口

类语法：
public class 类名{
属性;

方法;
}
对象语法：
1.对象的建立
1)声明一个引用变量,可以保持对应类型的对象地址,使用对象
类名 引用变量名;
2)建立对象
引用变量名 = new 类名();
1)2)能够同时完成

2.对象属性的使用
对象引用变量.属性名
赋值，获取值

3.对象方法的使用

局部变量做用域(生命周期):从声明开始，到声明所在的最小{}结束

对象生命周期：从建立开始，到没有引用指向它
若是没有引用指向对象，对象变成垃圾，JVM后面随时可能释放它的空间

属性：若是不赋值，有默认值

Day11:======================================================================================

OOP三大特性之一（封装，继承，多态）

封装:

把信息封装造成一个总体
1）把属性，方法放到类中
2）信息的隐藏
属性的隐藏(经过private修饰)
方法实现细节的隐藏(调用者无需关注方法的实现细节，知道做用，能执行便可)

包：package
一个工程下的类：默认直接放到src下

建立包，
包名：一般以公司的域名倒置做为前缀，加具体功能等，以.隔开一级一级的
eg:com.hwua.view:界面类
com.hwua.dao:数据库访问类,对数据库增删改查的

定义的类：要加上所在包声明
package 包名;
必须在有效代码的第一行
导包：eg:工程下/bin/com/hwua/homework

构造方法：
在建立对象时调用，完成对象的初始化
定义语法：
1）没有返回值类型
2）方法名和类名同名

this关键字
引用，表明当前对象的引用，

* 封装的标准版本：
* 属性私有化，方法公开化，
* 提供get,set方法，建议都提供，暂时也能够按照需求提供
* 形参和属性同名的区分：this
* 构造方法根据需求来写

属性赋值：总结
若是属性可见，能够直接赋值
若是属性不可见，能够经过set方法赋值
还能够在建立对象时，直接初始化，利用构造方法

类中给属性赋值：3个地方
1)属性申明时：
private String name = "小白";
2)代码块：
{
name = "小黄";
}
3)构造方法：
public Cat(String name){
this.name = name;
}

方法重载(overload):
同类中方法名相同，形参不一样

Day12:======================================================================================

static关键字
修饰属性(静态属性)，方法(静态方法)，代码块(静态代码块)
当类被加载时候存在，都属于这个类的

静态属性：只有一份，被你们共享的,
使用：类名.静态属性名
静态方法
使用：类名.静态方法(实参)

类内部，静态的不能够直接使用非静态的

静态代码块：
static{}，在类加载时，执行，只会执行一次

设计模式：单例模式，利用static完成：
public class Test {
private static Test test=new Test();
private Test() {
}
public static Test getTest() {
return test;
}
}
public class Test {
private static Test test=null;
private Test() {
}
public static Test getTest() {
if(test==null){
test=new Test();
}
return test;
}
}

Day13:======================================================================================


继承:
public class B extends A{
//增长新的属性，方法
//对继承来的方法作修改--方法的重写
}

方法重写(override):
子类方法不能使用比被重写方法更严格的访问权限。
父类中的私有方法不能被重写

super:
表明的是父类对象的引用（当子类和父类有一样的方法，默认调用子类方法）


final:
1)写在变量前，变量变成了常量，不可修改
2)写在方法前，方法不能被子类重写
3)写在类前，此类不能被继承

代码调试(debug)：跟踪代码
对于语法错误：修改语法便可
对于数组下标越界等异常：根据提示找到位置，重点看运行异常信息
对于逻辑上的问题：能够经过debug方式来跟踪代码，找到问题

控制按钮：
step into:F5, 执行一行，若是这一行有方法调用，继续调整到方法中一行一行控制走
step over:F6
执行一行，若是这一行有方法调用，快速执行完，不须要一行一行控制
step return:F7，快速执行到return
F8:快速执行到下一个断点

类名 引用变量名 = new 构造方法();
Person
| |
Student Teacher

Student stu = new Student();//√
父类引用能够指向子类对象，只能调用父类中存在的方法
1)编译阶段：根据引用变量的类型来肯定是否存在这个方法
2)运行阶段：根据对象的类型来肯定调用哪一个方法
总结：编译看引用，运行看对象

Day14:======================================================================================

向上转型: Person stu = new Student()
向下转型: Person stu = new Student()
不安全，经过instanceof来预判一下：
子类类型引用 = (子类类型)父类引用;

instanceof:
引用 instanceof 类名：返回布尔值
true：引用所指向的对象是这个类或它的后代
false:引用所指向的对象不是这个类或它的后代
做用:在运行时，判断对象是不是某一类型

object经常使用的方法重写：
toString()；打印输出时能够省略不写
equals()：返回boolean；
重写时，一般有必要同时重写 hashCode 方法
eclipse 系统自动生成

int hashCode()
返回该对象的哈希码值。

Class<?> getClass()
返回此 Object 的运行时类。

String方法：
.charAt(int index):查找对应索引的字符
.indexOf():查找字符所在的索引
.lastIndexOf():从最后开始查找字符所在的索引
.compareTo(String array):对比数组的大小，一个一个字符的的数字比较
.concat(String array):在后面拼接数组
.contains():查找是否有这样的字符
.endsWith():判断是否以这个字符结尾，返回boolean
.startsWith():判断是否以这个字符结尾，返回boolean
.equals()：比较两个字符的值是否同样
.replace(,):新字符替换就字符
.split(""):经过字符把拆分红多个字符串的数组
.toUpperCase():转大写
.toLowCase():转小写
.trim():取掉收尾空格部分

Day15:======================================================================================

抽象类：
abstract:抽象的
修饰方法：抽象方法，只有方法的声明，没有实现
有些方法，只是为了被继承重写，自身的实现没有意义，能够声明为抽象方法

修饰类：
包含抽象方法的类被必须声明为抽象类
抽象类能够没有抽象方法
和普通类的不一样：
抽象类不能被实例化
普通类继承抽象类，必须实现抽象方法(方法的重写)
做用：用来被继承，交给子类去实现，多态

静态方法是否能够是抽象的？
--不能够，静态方法不存在重写
私有方法是否能够是抽象的？
--不能够，私有方法只在当前类内部可见，没法在子类中重写


接口：interface
java继承：单继承，只能继承一个父类
接口弥补了单继承

接口和类并列：
接口组成：
jdk1.7及之前版本：接口中只能包含静态常量，抽象方法
类能够实现接口，类只能继承一个父类，同时实现多个接口

语法：
定义一个接口：
public interface 接口名{
静态常量;
抽象方法;
}
类能够实现接口：
public class 类名 implements 接口名{
对接口中的方法作实现
}

接口的引用能够指向实现类对象
编译看引用，运行看对象

接口中语法细节强调：
静态常量能够缩写：类型 变量名=值;
eg：public static final int NUM = 3;
-- int NUM = 3;//等价

方法也能够缩写：
eg：public abstract void swim();
-- void swim();

接口中的静态常量，方法都是公开的

Day16:======================================================================================

异常分类：
1）按照继承关系
Throwable
| |
Error Exception
| |
RuntimeException 其余子类

RuntimeException:
运行时异常，基本为代码逻辑问题
好比：ArrayIndexOutOfBoundsException:下标问题致使的，修改代码
NullPointerException:引用为空
ClassCastException:利用instanceof先判断一下

Exception其余子类：外界因素致使的问题
必须经过异常机制来处理，不然编译没法经过

2)按照是否必须经过异常机制来处理分类
必须经过异常机制来处理(受查异常)：不然编译没法经过
Exception类以及除了RuntimeExcepteion的其余子类
不须要经过异常机制来处理(非受查异常):
Error,RuntimeException

异常的处理：
经过异常机制来解决问题对应的处理手段
方式1：捕获异常 try,catch,finally
方式2：继续抛出异常 throws,throw

语法1：try-catch
try{
监视可能会出现异常的代码
}catch(异常类 变量名){
捕获到异常后的处理代码
}
-----------------------------------
Date类: 包java.util.Date;
Date date = new Date();

SimpleDateFormat类: 包java.text.SimpleDateFormat;
建立SimpleDateFormat时，要指定时间对应的格式模式字符串

Date date = new Date();
SimpleDateFormat dates = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
dates.format(date);

Day17:======================================================================================

语法2：try-catch-catch
try{
监听的代码
}catch(异常类型 变量名){
异常的处理
}catch(异常类型 变量名){
异常的处理
}...

匹配的时候从前到后，若是一个能处理，后面catch就再也不执行
注意：可能出现父子类型， 先子后父

语法3：try-catch-finally

try{
监听的代码
}catch(异常类型 变量名){
异常的处理
}finally{
必定会执行的代码;
作一些收尾工做
}

finally:必定会执行的代码,包括前面有return
System.exit(0):特殊，直接退出程序，不会再执行finally
语法4：
try{
监视代码;
}finally{
即便出了任何异常问题，也会执行到的代码
}

异常处理方式2：向上抛出
对于受查异常，若是当前方法不处理，要继续向上抛出，必须在方法上添加抛出声明
语法：throws 异常类名
public void test() throws IOException{

throw new Exception其余子类();

}

表示这个方法可能会出现IO异常，本身不处理，抛给调用者
继承父类，起一个合理的类名，把父类的各类形式的构造方法都添加一份便可

接口--jdk1.8新特性

接口中也能够包含实现的方法，须要加default关键字(总接口已添加，就能直接条用了)
也能够包含静态方法

自动装箱与拆箱
基本类型：变量直接存储值
引用类型：变量存储的对象的地址(引用)

java中，每一个基本类型都有一个对应的类(包装类)
byte short char int long float double boolean
Byte Short Character Integer Long Float Double Boolean

jdk1.5新特性：

自动装箱与拆箱
自动装箱：可以自动把基本类型转换成对应的包装类类型
Integer integer3 = 3;
//等价于：Integer integer3 = new Integer(3);

自动拆箱：可以自动把包装类类转换成对应的基本类型
int num3 = integer3;
//等价于：int num3 = integer3.intValue();

注意：实参给形参赋值，也同样，自动装箱与拆箱
返回值接收，也同样，自动装箱与拆箱

对于-128~127，常量池中包含了这些对象，一个值对应的对象只有一份
Integer i1 = 1;
Integer i2 = 1;
System.out.println(i1==i2); //true
Integer i3 = 128;
Integer i4 = 128;
System.out.println(i3==i4); //false

泛型：
编写类通常不会涉及到泛型编程，应用的类内部可能使用了泛型

public class MyData<E>{
private E num;

public void setNum(E num){
this.num = num;
}
}

建立对象时，指定泛型类型，只能是引用类型
类名<实际类型> 引用变量 = new 构造方法<实际类型>(实参);
类名<实际类型> 引用变量 = new 构造方法<>(实参);
eg:
MyData<Integer> md1 = new MyData<>();
MyData<Double> md2 = new MyData<Double>();
MyData<String> md3 = new MyData<String>();
MyData md4 = new MyData();//Object

Day18:======================================================================================

泛型默承认以设定为任何引用类型
若是要限定泛型的类型只能是某个类型，
T extends 类名：设定上限,只能是这个类或者这个类的后代
public class MyData<T extends Number>{

}
T:Number(√),Integer(√)，Double(√),String(×)

? 能够表明任何引用类型，?能够设定上限，下限
? extends 类名 ：上限
? super 类名 ：下限

集合：
数组
一系列类：存储多个值，多多个值进行操做。

体系：
1.Collection体系：存储一个一个的值
Collection
| | |
List(重点) Set ...
| | | |
ArrayList LinkedList HashSet TreeSet

Collection:接口，表示一组对象
List：接口，有序的 collection（也称为序列）。
ArrayList: List 接口的大小可变数组的实现（重点）
LinkedList: List 接口的连接列表实现

2.Map:存储一对一对(键值对)的值

Map
| |
HashMap TreeMap

Map:将键映射到值的对象。一个映射不能包含重复的键；每一个键最多只能映射到一个值。
HashMap:基于哈希表的 Map 接口的实现。
TreeMap:基于红黑树（Red-Black tree）的 NavigableMap 实现


ArrayList:
底层结构：数组
替代数组，比数组更强大

ArrayList<元素类型> 对象名 = newArrayList<元素类型>();

经常使用方法：
boolean add(E e)
将指定的元素添加到此列表的尾部。
void add(int index, E element)
将指定的元素插入此列表中的指定位置。

元素在列表中的下标可能变化的
int size()
返回此列表中的元素数。
E get(int index)
返回此列表中指定位置上的元素。
E set(int index, E element)
用指定的元素替代此列表中指定位置上的元素。
E remove(int index)
移除此列表中指定位置上的元素。
boolean isEmpty()
若是此列表中没有元素，则返回 true
元素的个数是0表示空
void clear()
移除此列表中的全部元素。

其余方法：
boolean contains(Object o)
若是此列表中包含指定的元素，则返回 true。
int indexOf(Object o)
返回此列表中首次出现的指定元素的索引，或若是此列表不包含元素，则返回 -1。
int lastIndexOf(Object o)
返回此列表中最后一次出现的指定元素的索引，或若是此列表不包含索引，则返回 -1。
Object[] toArray()
按适当顺序（从第一个到最后一个元素）返回包含此列表中全部元素的数组。
protected void removeRange(int fromIndex, int toIndex)
移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的全部元素。

ArrayList遍历(List):
1.利用下标，循环
for(int i=0; i<list.size(); i++){
System.out.println(list.get(i));
}

2.利用迭代器，看起来难，实际是固定的套路

Iterator<对象类型> it=对象列表.iterator()
while(it.hasNext()){
元素类型 引用变量 = it.next();

if(引用变量){
it.remove();//删除元素
}

}

3.for-each：
对于数组：底层用的for循环
对于Collection:底层用的迭代器，因此不能在foreach中对集合增删改
for(int num:array){
System.out.println(num);
}

List排序：升序/降序
类：Collections:
Collection的工具类

1.元素类实现Comparable接口，泛型指定为元素的类型
public class 对象类型 implements Comparable<对象类型>

2.实现compareTo方法
public int compareTo(Student o){
//根据比较的需求，
经过返回正整数，0，负整数表示当前对象大于，等于，小于o
eg:
if(this.age < o.age) {
return -1;
}else if(this.age == o.age) {
return 0;
}else {
return 1;
}
}

3.对某个元素的List进行排序
Collections.sort(对象list);
排序取决于你的compareTo算法

Day19:======================================================================================

Arrays:数组的工具类
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}

ArrayList<String> list = new ArrayList<String>(
Arrays.asList("hello","haha","hi","hello","hello","hi"));

List排序：

1.Comparable
经过元素类实现Comparable接口，提供比较算法
调用Collections.sort(list); 按照提供的比较算法进行排序

2.Comparator
是否能够把比较算法抽离出来，脱离元素类，其余类提供比较算法
任意类实现Comparator接口

排序步骤：
一、定义一个类实现Comparator接口，泛型指定为要比较的对象类型
二、实现compare方法，提供两个对象的比较算法
三、调用Collections.sort(list,Comparator实现类对象);

比较Comparable和Comparator:
Comparable：修改元素类，提供比较算法，而且只能提供一种比较算法
Comparator：增长新的类，提供比较算法，每一个类能够提供一种比较算法，能够有多个类

面向对象设计一个原则：对修改关闭，对扩展开放


1)匿名内部类：
没有类名，只能用一次

new 父类/接口(){
//类体;
}

new Comparator<Student>(){
public int compare(Student o1,Student o2){
return o1.getAge()-o2.getAge();
}
};

表示建立了一个实现Comparator接口的类对象，这个类没有名字，类体是{}这一部分。

2)内部类：
在类的内部定义的类

3)局部内部类: 类比局部变量
在方法或代码块中定义

4)静态内部类：类比静态属性
直接在类的内部定义，加上static关键字

public class Singleton {
private Singleton() {}

public static Singleton getInstance() {
//当第一次获取实例时，才加载静态内部类SingletonHolder
//才建立对象，赋值在类加载时完成，类加载只有一次， 只会建立一次
return SingletonHolder.instance;
}
//利用静态内部类来实现
private static class SingletonHolder{
private static final Singleton instance = new Singleton();
}
}

String类补充：字符串
实现了Comparable
int compareTo(String anotherString)
按“字典顺序”比较两个字符串。
按照码值比较

LinkedList:
List 接口的连接列表实现
底层结构：链表
特色：由一个一个节点组成,每一个节点空间不连续，能够方便扩大，缩小，改变引用的指向便可

用的层面：和ArrayList基本同样，方法有增长

void addFirst(E e)
将指定元素插入此列表的开头。
void addLast(E e)
将指定元素添加到此列表的结尾。
E getFirst()
返回此列表的第一个元素。
E getLast()
返回此列表的最后一个元素。

Map:键值对（key-value)
键：不能重复
值：能够重复

Map:<K,V> K:对应键的类型， V:对应值的类型
经常使用方法：
int size()
返回此映射中的键-值映射关系数。
V put(K key, V value)
将指定的值与此映射中的指定键关联（可选操做）。
做用1：若是键不存在，添加键值对
做用2：若是键存在，则替换值
V get(Object key)
返回指定键所映射的值；若是此映射不包含该键的映射关系，则返回 null。
boolean containsKey(Object key)
若是此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value)
若是此映射将一个或多个键映射到指定值，则返回 true。
remove
clear

Day20:======================================================================================

Map遍历：
不能直接遍历

方式1：keySet(),返回此映射中包含的键的 Set 视图(Collection体系)。 特色：元素不重复的

方式2：entrySet()，返回全部键值对(Entry)对应的Set视图。效率更高
K getKey()
返回与此项对应的键。
V getValue()
返回与此项对应的值。

ctrl+1，快速补全对应的方法

HashMap：
根据键的哈希码(hashCode())计算出在数组的位置：
若是这个位置没有任何元素，则做为链表的第一个元素
若是这个位置已经有元素了，和每一个元素做比较,equals()肯定键是不是重复的，
若是比较下来都不重复，则添加键值对，若是有重复的，则修改对应的值

键不重复的，标准：hashCode(),equals()
遍历顺序和添加顺序不一致的：无序的(没法经过下标位置控制的)

TreeMap
基于红黑树（Red-Black tree）的 NavigableMap 实现

Set:一个不包含重复元素的 collection

集合总结：
List(重点)：列表，精确控制位置 Collection一个分支
ArrayList(整个的重点)
底层结构：数组
经常使用方法
遍历方式:下标，迭代器，foreach
排序：Comparable,Comparator Collections.sort()
LinkedList
底层结构：链表
使用和ArrayList同样
Map(存储键值对)
重点掌握经常使用方法
要求掌握一种遍历方法 keySet(),entrySet()
了解HashMap(用的比较多，底层链表的数组，基于哈希表的实现),TreeMap
Set(用的不多) Collection一个分支
经常使用方法了解，和位置无关
遍历方式：迭代器，foreach
基于HashMap和TreeMap来了解HashSet和TreeSet


File类：文件或文件夹对应的类
File file = new File("文件/文件夹路径")

经常使用方法：
boolean exists()
测试此抽象路径名表示的文件或目录是否存在。
String getAbsolutePath()
返回此抽象路径名的绝对路径名字符串
String getName()
返回由此抽象路径名表示的文件或目录的名称。
boolean isDirectory()
测试此抽象路径名表示的文件是不是一个目录。
boolean isFile()
测试此抽象路径名表示的文件是不是一个标准文件。
boolean isHidden()
测试此抽象路径名指定的文件是不是一个隐藏文件。
long length()
返回由此抽象路径名表示的文件的长度。 以字节为单位
String getParent()
返回此抽象路径名父目录的路径名字符串；若是此路径名没有指定父目录，则返回 null。
File getParentFile()
返回此抽象路径名父目录的抽象路径名；若是此路径名没有指定父目录，则返回 null。
String[] list()
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录
File[] listFiles()
返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
获取全部的孩子

boolean createNewFile()
当且仅当不存在具备此抽象路径名指定名称的文件时，不可分地建立一个新的空文件。
若是所在文件夹不存在，则会抛IOException
boolean mkdir()
建立此抽象路径名指定的目录。
boolean mkdirs() 推荐
建立此抽象路径名指定的目录，包括全部必需但不存在的父目录。
boolean delete()
删除此抽象路径名表示的文件或目录
若是此路径名表示一个目录，则该目录必须为空才能删除。

Day21:======================================================================================

IO流：
I:input,O:ouput 输入输出，要完成输入输出，经过流对象

IO流分类：
按照方向：输入流，输出流
输入，读：外部数据源到程序
输出，写：程序到外部数据目的地
按照单位分：字节流，字符流
字节流：数据以字节为单位
字符流：数据以字符为单位
按照功能分：节点流(基本功能流)，包装流(给其余流添加功能)

体系：四个抽象类，各类流继承这四个抽象类
InputStream：输入字节流
OutputStream：输出字节流
Reader：输入字符流
Writer：输出字符流

文件的读写
FileInputStream
FileOuputStream
FileReader
FileWriter

缓冲流：包装流，给其余流提供缓冲区，提升读写效率
自带缓冲区
BufferedInputStream
BufferedOutputStream
BufferedReader:重点
BufferedWriter：后面还有一个对BufferedWriter封装的流PrintWriter


BufferedReader:
String readLine() :读取一个文本行

BufferedWriter
void write(String str)

void newLine() 新增方法
写入一个行分隔符。
利用这两个方法能够一次写一行

Day22:======================================================================================

转换流：包装流，把字节转换成字符
InputStreamReader
InputStreamReader 是字节流通向字符流的桥梁
构造方法：
InputStreamReader(InputStream in)
建立一个使用默认字符集的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName)
建立使用指定字符集的 InputStreamReader。
charsetName: //eg:GBK/UTF-8

OutputStreamWriter

打印流：
PrintWriter：包装流，字符流，输出流
对BufferedWriter作了再封装
构造方法：
PrintWriter(String fileName)
建立具备指定文件名称且不带自动行刷新的新 PrintWriter。
PrintWriter(String fileName, String csn)
建立具备指定文件名称和字符集且不带自动行刷新的新 PrintWriter。
PrintWriter(OutputStream out)
根据现有的 OutputStream 建立不带自动行刷新的新 PrintWriter。
PrintWriter(OutputStream out, boolean autoFlush)
经过现有的 OutputStream 建立新的 PrintWriter。
autoFlush:true,每次输出后都会强制刷新缓存
false,不会强制刷新缓存
网络编程中要用到
PrintWriter(Writer out)
建立不带自动行刷新的新 PrintWriter。
PrintWriter(Writer out, boolean autoFlush)
建立新 PrintWriter。
方法：
void println(String x)
打印 String，而后终止该行。
写一行

流总结：
节点流：提供基本功能
文件读写拷贝：重点
FileInputStream/FileOutputStream/FileReader/FileWriter
包装流：给其余流增长功能
缓冲流
BufferedInputStream/BufferedOutputStream/BufferedReader/BufferedWriter
自带缓冲区，读写效率高
重点：读一行 BufferedReader:readLine()

转换流：字节转换成字符
InputStreamReader/OutputStreamWriter

打印流：
PrintWirter：对BufferedWriter封装
重点：写一行：PrintWriter:println();

对象流：
ObjectInputStream/ObjectOutputStream
重点：序列化，反序列化，Serializable接口


多线程实现方式：
1.利用继承
1)定义一个类继承Thread
2)重写run()方法，线程启动执行的方法
3)建立子类对象
4)调用线程对象start()方法，启动线程， 此时真正开辟线程，并在新的线程中执行线程对象的run()方法
2.利用实现
1)定义一个类实现Runnable，用来提供算法
2)实现run()方法，提供算法
3)建立实现类对象
4)建立线程对象，传入第三步对象
5)调用线程对象的start()方法，启动线程，会执行到传入对象的run()方法

Thread类：

线程的生命周期：
新建：建立线程对象
就绪：调用start方法，真正开辟线程，在启动以前，设置各类参数
多个线程，等着CPU调度
运行：CPU调度某一个线程，处于运行状态，分配一个时间片
就绪状态和运行状态相互切换
阻塞：线程由于一些缘由，暂时没法继续，等到某些条件符合了再继续，回到就绪 阻塞：IO阻塞，sleep方法阻塞，wait方法阻塞，join方法等
死亡：可能代码执行结束，线程结束，死亡
可能出现意外状态，致使线程结束

Thread方法介绍：
void setPriority(int newPriority)
更改线程的优先级。
int getPriority()
返回线程的优先级。
1~10：值越大优先级越高，默认优先级是5
static int MAX_PRIORITY：10
线程能够具备的最高优先级。
static int MIN_PRIORITY :1
线程能够具备的最低优先级。
static int NORM_PRIORITY:5
分配给线程的默认优先级。
static void sleep(long millis) 重点掌握
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操做受到系统计时器和调度程序精度和准确性的影响。

void join() 了解
等待该线程终止。
static void yield()
暂停当前正在执行的线程对象，并执行其余线程。
CPU调度某个线程时，调用yield方法，会致使线程提早结束本次调度，等待下一次调度，CPU从新调度，但可能调度的仍是它
void stop()
已过期。
不建议使用，简单粗暴
void interrupt()
中断线程。中断处于阻塞状态的线程，会产生异常
不建议使用

线程同步实现(one by one 执行)：
经过synchronized关键字

Day23:======================================================================================

synchronized：利用对象内置锁，自动还锁
1）synchronized加在方法上

2）synchronized加载代码块上
synchronized(对象引用){
同步代码;
}

ArrayList vs Vector:
ArrayList:没有作线程同步，多线程不安全的
Vector:作了线程同步，多线程安全的

同步步骤：
1）属性私有化
2）操做这个属性的方法经过synchronized来修饰

Thread.wait()
Thread.notify()

Day24:======================================================================================

Lock类
synchronized是java的关键字，来实现的，synchronized锁机制，自动释放锁
Lock类机制实现的，Lock锁必须手动释放锁

Lock接口：
void lock()
获取锁。
void unlock()
释放锁。
Condition newCondition()
返回绑定到此 Lock 实例的新 Condition 实例。

Condition接口：
void await()
形成当前线程在接到信号或被中断以前一直处于等待状态。
void signal()
唤醒一个等待线程。

同步代码写法：
Lock l = ...;

lock.lock();
try{
同步代码;
}finally{
lock.unlock();
}

ReentrantLock:可重入锁，和synchronized实现同样的功能

Lock实现线程线程通讯
利用Condition对象
在经过Lock上锁后，能够经过newCondition()方法建立Condition对象，能够根据须要建立
须要阻塞当前线程时：经过condition对象的await()阻塞，
线程被阻塞了，锁还回去
要唤醒这个阻塞的线程：经过对应的condition对象的signal()唤醒
随机唤醒一个阻塞的线程，等到再次获取到锁会继续执行

相比wait(),notify(),更加灵活，能够有多个Condition对象，在不一样条件下的阻塞唤醒更加清楚控制


ServerSocket:此类实现服务器套接字
构造方法：
ServerSocket(int port)
建立绑定到特定端口的服务器套接字。
方法：
Socket accept()
侦听并接受到此套接字的链接。

Socket:
构造方法：
Socket(String host, int port)
建立一个流套接字并将其链接到指定主机上的指定端口号。
方法：
InputStream getInputStream()
返回此套接字的输入流。
OutputStream getOutputStream()
返回此套接字的输出流。

咱们传输为了方便，传写字符串，以行为单位：
读一行：BufferedReader-->InputStreamReader-->socket.getInputStream()
写一行：PrintWriter-->socket.getOutputStream()
先写到缓冲区，缓冲区满了才一次性写出去，
若是写给另外一端，马上收到，写的时候要flush()
能够在建立new PrintWriter(socket.getOutoutStream,true)
自动刷新缓存

服务器端程序流程：
1.建立服务器套接字对象，ServerSocket(int port)，指定端口号
多个进程不能使用同一个端口号
2.写一个死循环，保证服务器一直运行

1）每次等待客户端的链接请求，Socket accept()，
若是没有客户端链接，阻塞，直到有客户端链接，链接成功则返回Socket对象
反回的Socket对象：用来专门与对应的客户端交互
2）利用返回的Socket对象与客户端交互，io操做
多是耗时的
能够把2)放到一个独立的线程中，使用完了，Socket要关闭

利用多线程来完成2-2）,提升效率，快速同时与多个客户端链接


客户端程序流程：
1.须要与服务器端创建链接时，建立一个Socket套接字对象，
Socket(String host, int port)
若是对象建立成功，则表示链接成功

2.利用Socket套接字对象，与服务器端交互，io操做