基础部分：
变量：
Byte ：-128 ~ 127
Short char的异同点：
同：都是16位
异：Short ：-2^15--2^15-1
Char ：无符号位 0 ~ 2^16-1 = 65535
Long ：float取值范围比long大
Float ：32位 ：1个符号位，8个指数位，23个尾数位
Double：64 ：1 ，11 ，52
字面量：数值，true，false，null
关键字： goto保留字
运算符：
算术运算符：+ - * / %(取模) ++ --
比较运算符：> < >= == !=
赋值运算符：+= = *= ......
位运算符：& | ~ ! >> <<
逻辑运算符：&&(短路) & || |
三目运算符：? :
逻辑控制语句：
顺序结构
条件分支语句：
If......else.....
Switch(int整型).....case.......(break)
JDK1.7及以后，switch后面可以加String
循环语句
For 知道固定次数 死循环for( ; ; )
跳出循环：
loop : for( ){
For( ){
Break loop;//跳出外层循环
}}
While 当... while(true)
Do...while... 直到....
Java 1995年开始
.java --> ,class(字节码文件) jvm运行字节码文件
IDE 开发工具
环境变量：
JAVA_HOME
PATH
Classpath
Javac编译 java运行
！！ 见名知意
类名：
HellWorld 驼峰命名
方法名：
首字母小写，其他驼峰
变量名：
首字母小写，剩余驼峰
小写 _ 连接 user_id
常量：
全大写 _ 拼接
包名：
域名倒写 ：com.boninle,util(功能模块)
数组：
数组复制，扩容：
System.arraycopy(src , srcPos , dest , destPos , length);
《可以任意截取数组复制到任意位置》
src : 源数组，要复制的数组
srcPos ,：起始位置
dest ：目标数组，要复制到的数组
destPos ：目标数组的起始位置
Length ：要复制的长度
Arrays.copyOf（original，newlength）
//扩容
方法内部：1、新建新长度数组
2、把原数组内容复制到新数组前端
3、返回新数组
Original：原数组
Newlength：新数组长度
Int [ ] arr={1,2,3,4,5,6};
arr = Arrays.copyOf(arr,arr.length+1); //{1,2,3,4,5,6,0}
方法：修饰词 返回类型 方法名（参数列表）{
方法体
}
方法签名：方法名 + 参数列表
代码重复性超过三行，代码功能超过三行，定义方法
修饰符不写时为friendly
N个人围成一个圈，1到3报数，最后剩下的是几号？
解答：
数组定义为 Boolean型，开始都赋值为true，
变量：数组下标index，报数coutNum，剩余人数leftNum
面向对象
面向对象和面向过程：
面向对象：1、做这件事的对象； 2、这件事的结果
面向过程：专注每一步做什么
类：属性（成员变量） 。。的。。
方法（行为）
构造器（描述对象初始化过程的）
This（） super（）两者都只能放在构造器的第一行，所以只存在一个
语句块 { } （描述初始化的共性过程） 在构造器之前被调用
对象：符合类的所有特征的实例个体
New 分配父类空间 默认初始值
调用父类构造器，初始化
分配子类空间 默认初始值
调用子类构造器，初始化
将引用值赋值给变量
栈堆 方法区（存放和类相关的所有）
面向对象的特点：封装、继承、多态
封装：属性私有化，提供公开getXXX（），setXXX（）方法
继承：父类只有一个（单继承），所有类都继承自Object（基类）
向上造型：Father f = new Children（）
向下造型：Child d = （Child）f instanceof
构造器
多态：一种事物，多种形态
重载：方法名相同，参数不同，与返回值类型无关（多态的一种表现形式）
重写：方法签名相同，与返回类型有关
返回类型：父类：int 子类：int
Void void
Farther Child（Father）
Animal 吃，睡 Dog，Pig
关键字：
static 静态的：类（不绑定在对象上）
1、修饰属性：只有一个，所有对象公用
2、调用：类名。属性，类名。方法（）
3、方法：内部只用静态的属性和方法
4、类：只能修饰内部类
5、语句块：类加载的时候自动调用
Final 最终的
1、属性：常量
初始化：可以在声明的同时
每个构造器中
语句块
2、方法：不能被重写
3、类：不能被继承，包装类都是final类 String Integer
Static + final
1、属性：静态常量
初始化：可以在声明同时初始化
静态语句块
类加载：先父类再子类
静态属性、方法、代码块都加载一遍
Abstract 抽象的
1、类：抽象的，可以有抽象方法
有构造器，但是不能new对象
2、方法：没有方法体
abstract class Animal{
abstract void XX（）；
}
Interface 接口（功能） implements（实现接口）
1、没有构造器
2、所有的方法默认添加public abstract
3、所有属性默认添加pubic abstract final
通常包含一些功能，与业务逻辑相关
内部类：
1、成员内部类
Outer outer=new Outer（）；
Inner in = outer.new Inner（）；
2、静态内部类
Inner inB = new Outer.Inner（）；
3、局部内部类
4、匿名内部类
Interface Inner{
Public void m（）；
}
Inner a = new Inner（）{ //匿名内部类，继承抽象类或者实现接口
Public void m（）{
}}；
枚举类：enum
Public enum Season{
Spring，Summer；
//静态常量
}
用法：Season.Spring
静态常量替代枚举
Object类：11个方法
equals
toString
hashcode
getClass 反射
clone 浅克隆（复制引用值）
A a=new A（）；
A b=a；
深克隆（复制一个新对象）
finallize （手动）垃圾回收 GC（隔段时间自动回收）
notify notifyall wait * 3 和线程有关
JavaBean 个体
MVC
Module 模型
View 视图 前段部分 HTML+CSS+JS+JSP
Controller 控制器
书写规范：
1、属性私有化
2、添加get，set方法
3、无参构造器
4、其他构造器
5、toString方法 equals（） hashCode（）
Equals（）：
Public boolean equals(Object o){ //同一个对象
If(this==o){
Return true;}
If(!(o instanceof People)){ //类型不同
Return false;
}
People p=(People) o; //类型相同，比较内容
Return p.name.equals(this.name) && p.age==this.age
&& p.sex==this.sex;
}
hashCode（）：//位置，16进制计算 Set Map
//equals方法判断相等的两个对象，hashCode值也相等
Public int hashCode(){
}
6、可序列化接口，可比较的接口
酒店管理系统：（面向对象思想）
Hotel Room in out search
Room num Guest
Guest
Main{
While（true）{
}
}
JAVA SE部分
SE EE ME
SE：C/S（QQ）：占用内存，每次更新需要下载新客户端，可以调取电脑的底层硬件设施（显卡）
SE01 SE02
API: 帮助文档 Doc
Javadoc命令 生成HTML类型的帮助文档
/**.......*/ 文档注释
// /*.....*/不可以生成帮助文档
API：应用程序编程接口
EE：B/S（浏览器，网页）：不占用内存，不用手动更新，每次更新不需要下载客户端
ME：POS机（很小的客户端）
API：应用程序编程接口 （工具）
String 时间 包装类 集合
IO：输入输出《相对程序》（文件，数据）
线程 Socket（网络端口）
异常 泛型
JDK包：java.lang
Java.util Java.io
Java.math Java.sql
String：字符串
单元测试 JUnit
断点测试 Debug
打桩测试 System.out.println()
常量池特性：仅对字面量有效
字面量编译器会自动存储在常量池中，
并且重复定义时会自动到常量池中获取，
字面量拼接时，编译器会自动编译成整体，
如果是变量拼接，不会自动编译到常量池。
length() 获取字符串长度
字母122 < 127 byte 1个字节
String 统一Unicode编码
所有字符都占2个字节
indexOf（4个） 获取字符所在的第一次出现的位置
找不到字符、字符串，返回-1
重载方法，获取从i开始字符、字符串第一次出现的位置
lastIndexOf() （4个） 获取字符、字符串出现的最后一个位置
反向搜索
substring() （2个）截取字符串
1、两个值 开始位置、结束位置
2、一个值 开始位置，截取到最后
前包含，后不包含
startsWidth() 是否是指定字符串开始
endsWidth()是否是指定字符串结尾
trim() 去掉字符串左右两边“空格”（\t \n \r）
QQ用户名会用到
charAt(index) 获取下标为index对应的字符
判断一段话是否为回文
toUpperCase 全部转换为大写
toLowerCase 全部转换为小写
通常用来忽略大小写对比
equalsIgnoreCase 忽略大小写进行对比
valueOf() 静态方法 String.valueOf()类名调用
n多个重载
作用：将各种类型的数据类型转换成字符串
contains() 是否包含
StringBuffer：（不用）效率低，线程安全
StringBuilder 可变字符串，字符串的内部管理
//追加字符
str.append(",就是为了迎娶白富美");
//替换字符
str.replace(15, 20,"拯救世界");
//删除字符串 0-10（10不包含）
str.delete(0, 10);
//插入字符串
str.insert(0, "活着");
//将字符串反转
str.reverse();
正则表达式 --> 字符串验证
邮箱的正则表达式：
[a-zA-Z0-9_]+@[a-zA-Z0-9_]+(\.[a-zA-Z0-9]+){2,4}
^\w+@\w+(\.[a-zA-Z]+)+$
要求：读懂，会改，3个文档，每天看几个（理解）
matches()是否和正则表达式匹配
split（）字符串切割
replace()字符串替换,作用：屏蔽敏感词汇
包装类：
目的：为了能让基本数据类型进行对象的操作
符合一切皆对象的思想
8个基本数据类型：
byte Byte
short Short
int Integer
long Long
char Charater
boolean Boolean
float Float
double Double
int a=100;
Integer i=200;
i=a;//自动装箱--同下
i=Integer.valueOf(a);
a=i;//自动拆箱--同下
a=i.intValue();
自动装箱： 基本数据类型-->包装类型 valueOf()
超出-128--127范围，相当于new新对象
自动拆箱： 包装类型-->基本数据类型 inValue()
包装类型的默认初始值为null；
八大基本数据类型的包装类只有Integer有常量池，其常量池范围：-128--127 ，字面量会存放在常量池中，在常量池范围内，字面量的运算原理同String
如：Integer i1=33+22； Integer i2=55；
I1==i2 --> true；
Integer i1=127+1； Integer i2=128；
I1==i2 --> false；
只要是new出来的对象，不管多大，都不在常量池里面
int类型的最大值和最小值：
Integer.MAX_VALUE() Integer.MIN_VALUE()
int a=Integer.paseInt(str);将字符串转化为整型
double d=Double.paseDouble(str);
StringUtils 全部是静态方法（工具类）
作业1：
阅读Apache Commons-lang.jar中StringUtils文档
掌握leftPad、rightPad、repeat、abbreviate、join等方法
工具类：
StringUtils Collections Arrays
二进制：
莱布尼茨
一个地址存放一个字节的数据（8个二进制位）
从多字节到少字节，直接截取；
从少的字节扩充多字节，10011000扩充到4个字节时，补符号位
==============================================================
类先加载：
静态的属性
静态的语句块 （谁在前，谁先加载）
静态的方法
类什么时候加载：被使用的时候
1、使用静态属性或静态方法的时候
2、New 对象时
3、使用子类静态成员的时候，父类会被加载
4、在new子类对象时，父类会被加载
5、反射 xx.class
Class.forName(“java.lang.String”);
注意：类只加载一次
==============================================================
Date:
对long做时间维护
1970-1-1以后的毫秒差
getTime（） 毫秒差值
setTime () 设置时间
new Date() 获取当前系统时间
getYear 此类方法均已过时，不建议使用
Calendar: 日历类，抽象类
Calendar 抽象类 对时间进行维护
格里高利日历
getIntance（） 静态方法 默认为当前系统时间
getTime（） 对应的date
setTime（）
获取时间分量：xx.get(Calendar.XXX);
Calendar.YEAR 年
Calendar.MONTH 月份，从0开始
Calendar.DATE 月份中的第几天
Calendar.DAY_OF_MONTH 同DATE
Calendar.DAY_OF_WEEK 一周中第几天 (周日为1)
Calendar.DAY_OF_Year 一年中的第几天
时间格式化：SimpleDateFormat
数组
Int[] a=new int[];
扩容：Arrays.copyOf()
集合：Collection（接口）：存储Object类型
add()，size()，isEmpty()，clear()，remove(),Contains()
toArray（） addAll(),removeAll(),containsAll()
存储对象的引用
遍历：迭代器
用法： Iterator it=c.iterator();
while(it.hasNext()){
Object o=it.next();
if(o.equals("$")){
it.remove();
}
}
方法：hasNext next remove
Foreach
集合转化成数组：toArray(Object[] )重载
泛型：编译时语法 强制类型转换（向下造型）也是编译时语法
List（I） ：有序集合，添加顺序就是读取顺序
允许重复的
1、LinkedList 链表实现，修改效率高（元素增删）
节点
ArrayList 访问效率高
LinkedList 增删效率高
LinkedList 双向链表，不能做到随机访问
getFirst getLast
LinkedList list =new LinkedList();
List.getFirst();
Vector
截取集合 subList 公用同一个空间
数组 --> 集合 Arrays.asList(args[])
转化后的集合，不支持增加、删除操作
实现类 2、ArrayList：数组实现，查询效率高
new ArrayList();
//根据已知集合构造新的集合，将已知的集合全部元素逐个复制到新的集合中
new ArrayList(collection);
重写了toString方法 ,[元素1.toString()，
元素2.toString()，...]
Set（I） ：无序的，不可重复，不常用
位置由它的hashCode经过一系列运算来决定 空间大小
hashCode % 10 --> 8进制
Equals为true的两个元素 hashCode也要相等，反之，也要尽量满足
没有get，没有set，不能用普通for循环
重点：添加、删除过程
HashSet：无序的
SortedSet：有序的
TreeSet
Queue:队列
offer poll peek
Deque:双端队列
offer(First/Last) poll(First/Last) peek(First/Last)
只有一个端口进出 ---> 栈
push pop
Arrays.sort()
Collections 类 集合工具类
sort --> 只对List有效
1、List中的元素要实现Comparable接口（comparaTo）
2、可使用自定义比较器排序，实现Comparator接口（comparae）
对Set排序使用TreeSet
Map（I） 映射 Key键 Value 值
键值对
HashMap:LinkedHashMap 效率高，线程不安全
HashTable:效率低，线程安全
SortedMap:TreeMap
HashMap：（可以用来统计一个字符串，每个字母出现的次数）
添加、修改put(key,value) --> value
删除 remove(key) --> value
查询 get(key) --> value
LinkedHashMap :有序 - 怎么放进去，怎么取出来
初始容量：16
加载因子：0.75
容量达到 16*0.75 自动扩容一倍
哈希码
映射关系 Map.Entry
扩容后，重新计算所有元素的哈希码
HashMap
容量利用率高，查找效率会降低
提升查找效率，容量利用率会降低
LinkedHashMap 有序
不会受到容量影响
TreeMap 排序
插入会compareTo比较
时刻通过compareTo方法保持位置
效率最低
迭代： 3种
map.keySet() 把map中的key部分单独取出，转换成一个set集合
map.values() 获取value值的集合
map.entrySet() 将map中的Entry对象转换成set集合
Java.io.
Input输入流 Output输出流
文件读（Input）、写（Output）
File
创建文件 没文件创建返回true，有文件创建返回false
System.out.println(file.createNewFile());
删除文件 有文件，删除返回true，没文件删除返回false
file.delete(); ---> 文件和空目录
file.mkdics();---> 创建目录
listFiles -->列出目录下面的所有目录、文件 包含隐藏文件
listFiles(fileFilter) 过滤器
RandomAccessFile 基于指针对文件的操作，不属于IO
用于文件复制
指针：指针后移操作不可逆,但是可以通过seek对指针进行移动
getFilePointer
Seek
skipBytes
对源文件进行加密时，写入前要将指针先前移
Write(byte[])
Read(byte[])
文件复制过程。。。。。
文件加密：
需求：原数 计算 密码 --> 新值
新值 计算 密码 --> 原数 （异或）
IO流：InputStream输入流 OutputStream输出流
文件读（read） 写（write）
1、字节流：FileOutputStream 文件输出流
FileInputStream 文件输入流
缓冲字节流：BufferedOutputStream
BufferedInputStream
2、对象流：
ObjectOutputStream
ObjectInputStream
· java.io.NotSerializableException: 你读写的对象类没有序列化
回顾：
File：获得属性
File file=new File(“a.txt”);
getName
length
isDirection
is-file
Exists
File[] listFiles// 目录和文件
目录 mkdir
文件 createNewFile
delete ->文件或者空目录
递归删除
重载File[] listFiles(FileFilter)
FileFilter:boolean accept()
true : 接受
false：过滤掉
RandomAccessFile
seek 移动指针
正常指针不断向后移动（读写），不可逆
getFilePointer 获得当前指针的位置
写write（int） 单字节，只写入低8位
writeInt（int） 4个字节 writeFloat
writeDouble（double） 8个字节 writeLong
writeShort writeChar 2个字节
write（byte[]） 写入字节数组（写入中文，或者一段话）
读 int read() 读单字节
int 就是读取出来的单字节，填入int的低8位
int 如果返回-1，代表文件结束
int readInt（） 读4个字节，
int 就是读取出来的4个字节
最后只剩3个字节，调用readInt
抛出EOFEException，文件意外结束
int read（byte[]）读取多个字节，并且存入byte[]
int 表示读取出来的数据长度
int 如果为-1，代表文件结束
byte[] 就是读取出来的长度，有效数据，0-int个
例：
文件字节数：128+56
byte[] 读2次
第一次，byte数组文字存入128个字节
第二次，byte数组原始状态是上一次读取的数据，覆盖了签名的56个字节数，
剩余字节数依然存在byte数组里
课堂案例： 文件复制 --> 源文件覆盖（加密），另写一个新文件
字节流：FileOutputStream FileInputStream
缓冲字节流：BufferedInputStream BufferedOutputStream
缓冲区：可以实现一次性读取、写入多个字节
FileInputStream fis=new FileInputStream(file/filePath);
BufferedInputStream bis=new BufferedInputStream(fis);
对象流： ObjectInputStream ObjectOutputStream
readObject writeObject
Serializable 接口 可序列化的
serialVersionUID 静态常量 --> 版本号
transient 关键字 标示的属性在序列化时不会把值写入文件
克隆：深克隆：克隆的是对象+引用
源对象和现对象会相互独立
浅克隆：clone 克隆的是引用
源对象和现对象会互相影响
字节、对象、字符
字符流：
OutputStreamWriter 字符集
write写入：字符、字符数组（或一部分）、字符串（或一部分）
InputStreamReader 字符集
Read读取：字符、字符数组（或一部分）、不能直接读取字符串，
但可以使用字符数组构建字符串
课堂练习：
GBK --> 中文一段话
读取文件
同时，按照utf-8字符集写入文件
缓冲字符流：
PrintWriter BufferedReader
对字符流进行的包装
也可以直接对字节流进行包装
也可直接使用，不需要包装
Print println
FileInputStream --> 文件复制，配合缓冲字节流使用
ObjectInputStream --> 读写对象，不仅能写到文件中，还能在客户端之间传
InputStreamReader --> 字节流 - 字符流的转换
BufferedReader --> 读写文件
BufferedInputStream 缓冲字节流
RandomAccessFile 对文件进行随机访问
复习：
API 常用类、接口、方法
使用方法前要先有对象
1、创建对象方式
2、方法的用法、作用
String：1、String str=“hello”
2、String str=new String（“hello”）
3、String str=new String（char[]）;
4、String str=new String(byte[] );
5、String str=StringBuilder sb.toString( );
matches(String redex); split(“”);
indexOf( ); charAt( ); replace( );
StringBuilder :append(); revese();
Date：1、Date date=new Date（）；
2、Date date=new Date(long time);
3、Date date=Calendar c.getTime( );
Calendar:Calendar c=Calendar.getTnstance( );
c.gettime(); c.settime();
c.add();
SimpleDateFormat sdf: .format(Date date);
Date date = sdf.parse(String str);
Collection 接口
接口 Collection c=new 实现类（）；
Collection c=new 实现类（Collection c）；
.add(); .size(); .contains(); .isEmpty(); .clear()
List 接口
List list=new 实现类（）；
List list=new 实现类（List list）；
Set 接口
Set set=new 实现类（）；
Set set=new 实现类（Set set）；
Map 接口
Map map=new实现类（）；
Map map=new 实现类（容量16，加载因子0.75）；
回顾：
File file=new File（）；
creatNewFile（）
makdir（）
delete（）
...获得各种属性
InputStream
FileInputStream 字节流（文件复制）
BufferedInputStream
Reader Writer
InputStreamReader
BufferedReader PrintWriter
ObjectInputStreamReader
Serializable
序列化、反序列化、持久化
数据结构（对象）转换成字节
字节转换成对象
字节存储在文件
RandomAccessFile
Seek getFilePointer skipBytes
Properties
load（） 添加文件
getProperty（key）
=============================================================
项目练习：
在线考试系统：
1、Paper：
String title
题目Question（类） Set
Date date;
2、Question
属性：题干（String body）、选项（List
int scoreItem(每一题的分数);
3、AnswerPaper:
List
4、Student
String name；
String id；
int score；
=============================================================
异常：Exception 所有异常的父类
1、已检查异常：planB 必须要try-catch处理，在代码当中处理
未检查异常（运行时异常）：（eg：空指针异常）
程序出错，需要处理（改）代码，不同try-catch处理 RuntimeException
5中未检查异常：NullPointerException 空指针
ArrayIndexOutOfBounds 数组越界
ClassCastException 当试图将对象强制转换为不是实例的子类时，抛出该异常
NumberFormat...数值转换异常
Eg：String s=“abc”；
Int i=Integer.parseInt(str);
ConcurrentModificationException 线程同步异常
try{正常逻辑}
catch{意外、异常}
finally{一定运行到的语句块}
通常用来释放资源《强制退出system.exit(0)不会运行》
2、API提供的异常有限
所以关于业务逻辑的异常，需要自己定义
通常是已检查异常，直接继承Exception即可
3、处理异常的原则：
A、谁产生，谁处理
B、自己解决不了的，就往上抛
最上层解决--调用者
C、已检查异常，一定要处理
扩展：
1、标注： 注解 Annotation
@Override
注释：给程序员、给使用者，不会出现在class文件，对程序没有影响
注解：给编译器、虚拟机，会影响程序
2、Error Exception
异常可以解决，错误一般是程序员解决不了的