javaSE 思维导图模板_ProcessOn思维导图、流程图

概述与环境搭建

java环境变量的安装

Oracle下载JDK

设置环境变量

JAVA_HOME -----> jdk安装路径

CLASSPATH -----> .;%JAVA_HOME%\lib

Path -----> 编辑 -----> 新建

%JAVA_HOME%\bin

%JAVA_HOME%\jre\bin

java语言的特点

面向对象

开源的

能够跨平台的

简单性

java语言的执行机制

先编译再解释

java语言的命名规范

只允许使用字母下划线数字和 $ 来命名

开头不允许用数字

不能与关键字保留字重名，关键字和保留字是java已经占用的

望文生义，见名知其意

类名：帕斯卡(Pascal)命名法

类名由一个或多个单词组成时每个字母的首字母大写（帕斯卡（Pascal）命名法）

变量名：驼峰(Camel)命名法

函数名由一个或多个单词组成时，第一个单词的首字母小写，其余单词的首字母大写（驼峰（camel）命名法）

包名

包名全小写，只可以使用 ". " 不能以 " . " 进行开头或者结尾

常量名

常量全大写，用_来连接

JAVA语言的书写格式

层级之间必须缩进一个制表位，也就是一个TAB的位置

一行只写一句话，就写到屏幕大小，写不下换下一行写，

JAVA语言的代码注释

单行注释 //

多行注释 /**/

文档注释 /** */

JDK、JRE、JVM的关系

JVM

使用软件在不同操作系统中，模拟相同的环境

JRE

包含JVM和解释器，完整的Java运行环境

JDK

包含JRE+类库+开发工具包(编译器+调试工具)

类的阐述

同一个文件中可以定义多个类

编译后，每个类都会生成独立的.class文件

一个类中，只能有一个主方法，也就是main方法，每个类都可以有自己的主方法

public修饰的类称为公开类，要求类名必须与文件名完全相同，包括大小写

一个源文件中只能由一个公开类

Package（包）

类似于文件夹，用来管理.class（字节码）文件

必须写在源文件的第一行

带包编译 javac -d 源文件名称.java(自动生成目录结构)

带包运行 java 包名.类名（报名+类名又称全限定名）

采用域名倒置结构

JAVA语言基础

变量

变量就是一块内存空间由三要素组成，分别是，数据类型，变量名，值

数据类型就是内存空间的大小

变量名就是内存空间的地址

值就是存储在内存空间里的数据

变量的定义流程

数据类型 + 变量名

java是一种强类型语言，变量的类型必须与数据的类型保持一致，
定义的值的大小不能超过数据类型的大小

变量的定义方式

先声明再赋值

数据类型变量名

变量名 = 值

声明并赋值

数据类型变量名 = 值；

多个同类型变量的声明与赋值

java的数据类型

基本数据类型

小数数据类型

float 4字节 ----------> 值后边加f 1.4E-45 ~ 3.4E+38

double 8字节 4.9E-324 ~ 1.7E+308

布尔数据类型

boolean 2字节只有true false

字符数据类型

char 1字节 ------> ''单引号中写一个字符 Unicode字符集（万国码）

引用数据类型

String

数组

对象

转义字符

\n   换行符

\t    缩进（制表位）

\\    反斜线

\'    单引号

\''   双引号

类型转换

自动类型转换

低 -----> 高字节数低 ------> 字节数高.

强制类型转换

高 -----> 低字节数高 ------> 字节数低

运算符

算数运算符

+   加  求和

-    减  求差

*    乘求积

/    除  求商

%  模  求余

一元运算符（只有一个操作数）

++ 递增变量值+1 i++ 运行完自加 ++i 自加完运行

-- 递减变量值-1 i-- 运行完自减 --i 自减完运行

赋值运算符

=    直接赋值

+=  求和后赋值

-=   求差后赋值

*=   求积后赋值

/=   求商后赋值

%= 求余后赋值

关系运算符

>     大于

<     小于

>=   大于等于

<=   小于等于

==    等于

!=   不等于

操作符

&& 与(并且) 两个操作符，同时为真，结果为真

|| 或(或者) 两个操作符，有一个为真，结果为真

！非(取反) 意为"不是" 真既是假，假既是真

三元运算符

?: 布尔表达式？结果1：结果2

当表达式为真，获得结果1

当表达式为假，获得结果2

选择结构与分支结构

选择结构

if

if - else

else - if

分支结构

switch - case

case后只允许填写
short byte int char boolean 枚举

循环结构

while

先判断再执行
有入口条件先判断再执行适用于循环系数明确的情况

do - while

先执行再判断
没有入口条件，先执行再判断，适用于循环系数不明确的情况

for循环

与while循环差不多
有入口条件，先判断再执行适用于循环系数明确的情况

跳出循环

break 跳出当前循环，剩下的所有循环都不执行了

子主题

continue 跳出此次循环，剩下的循环依旧执行，直到判断条件为false

方法

方法的定义

实现特定功能的一段代码，可反复使用

方法的使用方式

public 公有的

static 静态的

void 有返回值的没有返回值时用return （void位置放数据类型）

没有void用return

参数

参数类型 + 参数名

递归

自己调用自己
通过return实现实现自己的循环调用

数组

数组的概念

一组连续的内存空间，可以存储多个相同数据的值

是一组内存空间连续，数据类型相同的，长度固定的变量的集合

他的好处就是对批量存储数据中使用变量的一种简化

数组的特点

内存空间连续

数据类型相同

长度固定（不能通过代码动态改变数组）

数组的使用场景

已经知道数组元素

数组的创建方式

声明并赋值（简化版）
数据类型[] 变量名 = {值1,值2，值3,...};

声明并赋值（繁琐版）
数据类型[] 变量名 = new 数据类型[]{值1,值2，值3,...};

先声明、再分配空间
数据类型数组名[];

数组名 = new 数据类型[长度];

声明并分配空间方式
数据类型[] 变量名 = new 数据类型[长度];

数组的默认值

byte       0

short      0

int          0

long       0

double   0.0

float       0.0

char       一个英文空格

boolean  false

String     null

数组的扩容

循环将原数组中的元素直接赋值给新数组

System.arraycopy(原数组,原数组起始位置,新数组,新数组起始位置,长度)
复制可以选择性复制，灵活性高

java.util.Arrays.copyOf(原数组，新长度); //返回带有原值的新数组
复制只能全部复制，灵活性低

堆和栈

栈放基本数据类型

堆放引用数据类型

二维数组

先声明再分配内存空间
数据类型[][] 数组名;

数组名 = new 数据类型[高维长度][低维长度];

声明并分配空间
数据类型[][] 数组名 = new 数据类型[高维长度][低维长度];

声明并赋值(繁琐版)
数据类型[][] 数组名 = new 数据类型[高维长度][]; //不规则数组，自行new低维数组

声明并赋值(简化版)
数据类型[][] 数组名 = {{值1,值2，值3},{值1,值2},{值1,值2,值3,值4},...};

面向对象

变量

类中定义的变量也叫属性也叫成员变量

方法中的变量我们称之为局部变量

类的概念

当把所有的共性统一放在一个文件名下，我们就叫一个类

类中有属性（也叫字段，成员变量，全局变量，实例变量（无static））有方法

构造方法

类中的特殊方法，主要用与创建对象。

特点

名称与类名完全相同。
没有返回值类型。
创建对象时，触发构造方法的调用，不可通过句点手动调用。

调用属性

本类： this

父类：super

面向对象的原则

开闭原则：对修改关系、对扩展开放

接口分离原则：接口中的方法，分类越细越好

高内聚、低耦合原则

三大特性

封装把属性进行私有

概念

概念：尽可能隐藏对象的内部实现细节，控制对象的修改及访问的权限

set() 和 get()

set()

1、赋值
2、过滤脏数据

get()

取值

语法

取值时用this取值

继承

父类

把一个笼统的有相同属性的类叫做父类

修饰符

public

同一项目下都可以访问

private

同一包下，以及不同包的子类下

默认修饰符

同一包下

protected

当前类下

语法

子类 extends 父类

取值时用super来取值

特点

Java为单继承，一个类只能有一个直接父类，但可以多极继承，属性和方法逐级叠加

构造器只创建本类的对象，不可继承

方法的重写与重载

重写(Override)

重写指的是，当父类提供的方法无法满足子类需求时，可在子类中定义和父类相同的方法进行重写

重写原则

方法名称。参数列表，返回值类型必须与父类相同

访问修饰符可与父类相同或是比父类更宽泛

方法重写的原则

子类重写父类方法后，调用时优先执行子类重写后的方法

方法前名和父类都一样，但是访问修饰符不能比父类更严格

重载

指一个类中定义多个同名的方法，但是同名不同参

多态

概念

父类引用指向子类对象，从而产生多种形态

表现形式

父类变量名 = new 子类();

方法调用

返回父类类型具体返回子类对象

装箱和封箱

向上转型(装箱)

父类变量名=new 子类(); --->如果子类重写了父类的方法 new时调用父类会自动调用子类的方法
子类独有成员无法访问

里氏代换原则(LSP)

任何父类类型出现的地方，都可以使用子类对象进行替换

向下转型(拆箱)

运用 instanceof 关键字

在使用instanceof之前我们要先进行 if 判断，判断要进行转换的这个类也就是父类的原始类是什么类

if(要转换的类 instanceof 原始类)

进行强制类型转换原始类变量名 = (原始类)要转换的类

多态的应用方式

父类做类型 new 子类对象父类变量名. 后的是子类

参数做类型传入父类的参数，传递的是子类的参数对象

方法的返回值是父类类型，具体返回的是子类对象

参数的表达形式

父类定义一个方法

两个子类继承方法

再单独写一个类A 可继承可不继承

类A里有个方法，去写父类

三大修饰符

abstract(抽象)

概念

概念：似是而非，像又却不是，具备某种对象的特征，但不完整

一般来说父类都需要添加abstract

抽象类可以没有抽象方法，但有抽象方法的类一定是抽象类

语法

public / 默认修饰符 abstract class 类名

public abstract void / 数据类型方法名（）；

作用

可被子类继承，提供共性属性和放法

可声明为引用，更自然的使用多态

禁止实例化

约束子类行为

static

概念

静态属性是整个类共同持有的共享空间（一份），任何对象修改，都会影响其他对象

静态的概念：可以修饰属性和方法

称为静态属性（类方法）、静态方法（类属性）

不必创建对象，可直接通过类名访问

特点

静态方法允许访问静态成员，不允许访问非静态成员

静态方法中不允许使用this或者super关键字

静态方法可以被继承，不能重写，没有多态

类里包含static成员，而且继承了父类，对象的创建过程

1、先父类的静态属性

2、父类的静态代码块

3、子类的静态属性

4、子类的静态代码块

5、父类的实例属性初始化

6、父类的动态代码块

7、父类的构造方法

8、子类的实例属性初始化

9、子类的动态代码块

10、子类的构造方法

第一次new一个对象时，按照1~10的顺序执行

第二次new一个对象，按照5~10的顺序执行

final

概念

最终的不可被继承

作用

修饰属性、局部变量，就称为常量，赋值后，不能动态通过代码改变其值

属性常量：在声明的同时必须赋值，否则报错

局部常量：先声明，再赋值

使用场景

程序里的固定信息，不允许的变量的，例如

提示信息数据库名等

2、final修饰类，最终类，此类不能被继承，没有子类

3、final修饰方法，最终方法不能被子类重写/覆盖

接口

概念

接口就相当于是一种能力和约定，因为在java当中java只支持单继承，不能够多继承，为了满足多继承的方式，推出了接口的概念。

规范

任何类在实现接口的时候，必须要实现接口中所有的抽象方法，否则此类为抽象类

实现接口中的抽象方法时，访问修饰符必须是public

接口的引用

同父类一样，接口也可声明为引用，并指向实现类对象

注意：

仅可调用接口中所声明的方法，不可调用实现类中独有的方法

可强转回实现类本身类型，进行独有方法调用

常见关系

类与类

单继承

extends 父类名称

类与接口

多实现

implements 接口名称2,接口名称1，...

接口与接口

多继承

extends 父接口2，父接口1，...

常量接口

将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统一管理，提高代码可读性

接口的好处

程序的耦合度降低

更自然的使用多态

设计与实现完全分离

更容易搭建程序框架

更容易更换具体实现

常用类

内部类
在类的一个内部再定义一个完整的类

成员内部类

概念：在类的内部定义，与实例变量，实例方法同级别的类

创建对象

外部类  外部类变量名  = new 外部类();

外部类.内部类      内部类变量名  =  外部类变量名.new  内部类()；

给外部类的变量名赋值：  外部类变量名.set属性

给内部类的变量名赋值：   内部类变量名.set属性

静态内部类

静态方法访问  内部静态成员或方法                内部类 . 名称

                        内部非静态成员或方法             内部类  内部类的变量名  =  new  内部类()；

                                                                         内部类的变量名.名称    -------->    赋值

                                                                         内部类的变量名 . 名称

                        外部静态成员或方法                外部类 . 名称

                        外部非静态成员或方法            外部类   外部类的变量名  =  new  外部类()；

                                                                        外部类的变量名.名称    -------->    赋值

                                                                        外部类的变量名 . 名称

非静态方法访问    内部静态成员或方法         内部类 . 名称

                             内部非静态成员或方法      + 名称

                             外部静态成员或方法         外部类 . 类名

                            外部非静态成员或方法        外部类   外部类的变量名  =  new  外部类()；

                                                                        外部类的变量名.名称    -------->    赋值

                                                                        外部类的变量名 . 名称

调用静态内部类的静态方法                            外部类.内部类.静态方法名

调用静态内部类的非静态方法                       外部类.内部类  变量名  =  new   外部类.内部类()；

变量名.set名称    --------->  静态内部类的非静态成员

                                                                      供非静态的方法调用内部非静态成员变量使用

                                                                      变量名 . 内部类的非静态方法

局部内部类

概念

方法里写一个内部类

先输出外部类的方法再输出内部类的方法，顺序结构执行，age和content只能在外部类定义

用法

非静态方法           外部非静态成员或方法                             外部类 . this . 名称

                              外部静态成员或方法                                 外部类 . 名称

                              局部内部类非静态成员或者方法                this . 名称

                              传入的标参  局部非静态成员变量              +名称

                               外部类类名   变量名  = new  外部类类名()；

                               变量名 . 名称

匿名内部类

1、首先定义一个接口，接口当中写一个方法，因为接口中的方法默认是public abstract 修饰的，所以需要重写该方法，

2、在一个新的类里边，写一个方法，方法里边new 接口 com 变量名 new com(){};

一定要记得大括号结束之后的分号，然后在这个括号里写方法，

3、在主方法里边 new 类然后new后的变量名 . 方法名进行调用

Object类
超类，基类，所有类的父类

getClass方法

public final Class<?>getClass(){}

返回引用中存储的实际对象类型

应用：通常用于判断两个引用中实际存储对象是否一致

hashCode方法

public int hashCode(){}

返回该对象十进制的哈希码值

哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值

哈希码并不唯一，可保证相同对象返回相同的哈希码，尽量保证不同对象返回不同哈希码

toString()方法

public String toString(){}

返回该对象的字符串表示形式

可以根据程序需求覆盖该方法,如，展示对象各个属性值

重写toString方法来实现我们想返回的值，例如数组，返回的是地址，我们就可以用toString来返回值

equals方法

判断obj是否为null

判断两个引用指向的实践对象类型是否一致

强制类型转换

以此比较各个属性值是否相同

finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列

垃圾对象：没有有效引用指向此对象时，为垃圾对象

垃圾回收：由GC销毁垃圾对象，释放数据存储空间

自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象

手动回收机制：使用System.gc(); 通知JVM执行垃圾回收

包装类

Byte
Short
Intrger
Long
Float
Double
Boolean
Character

String

public char charAt(int index)

根据下标获取字符

piblic boolean contains(String 输入的字符)

判断当前字符串是否包含输入的字符

public char[] toCharArray()

将字符串转换成数组

public int indexOf(String 输入的字符)

查找输入的字符首次出现的下标，存在，则返回该下标，不存在则返回-1

public int lengh()

返回字符串的长度

public String trim()

去掉字符串前后的空格

public String toUpperCase()
将小写转换成大写

public String toLowerCase();

将大写转换成小写

public boolean endsWith(String 输入的字符)

判断字符串是否以要输入的字符结尾

public String replace(char oldChar,char newChar)

将字符串替换成新字符串

public String[] split(String 输入的字符)

根据要输入的字符做拆分

public String subString(int beginIndex,int endIndex)

在字符串中截取出一个字符串

StringBuffer
可变字符串在原空间改变字符串值
线程安全，效率低

StringBuilder
可变字符串在原空间改变字符串值
线程不安全，效率高

BigDecimal

精确的小数类型

创建方式

BigDecimal bd = new BigDecimal("1.0");

BigDecimal add(BigDecimal bd)   加

BigDecimal subtract(BigDecimal bd) 减

BigDecimal multiply(BigDecimal bd)  乘

BigDecimal divide(BigDecimal bd)  除

进行除法运算时，如果不能准确的计算出结果时需要指定保留的位数和取舍方式

divide(BigDecimal bd,int scal,RoundingMode mode)

scal：         指定精确到小数点后几位

mode：       指定小数部分的取舍模式，通常采用四舍五入的模式

取值为       BigDecimal.ROUND_HALF_UP

Date

Date表示特定的时间，精确到毫秒

Date类中的大部分方法都已经被Calendar类中的方法所取代

System

static void arraycopy(...) 复制数组
static long currentTimeMillis(); 获取当前系统时间，返回的是毫秒值
static void gc()；建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status) 退出JVM，如果参数是0表示正常退出JVM，非0表示异常退出JVM

集合

概念:对象的容器，定义了对多个对象进行操作的常用方法，可实现对象的功能
位置:java.util.*

Collection<Interface>体系集合
特点:代表一组任意类型的对象、无序、无下标

方法：
boolean add(Object obj) //添加一个对象
boolean addAll(Collection c) //将一个集合中的所有对象添加到此集合中
void clear() //清空此集合中的所有对象
boolean contains(Object o) //检查此集合中是否包含o对象
boolean equals(Object o) //比较此集合是否与指定对象o相等
boolean isEmpty() //判断此集合是否为空
boolean remove(Object o) //在此集合中移除o对象
int size() //返回此集合中的元素个数
Object[] toArray() //将此集合转换成数组

List<Interface>
有序、有下标、元素可以重复

ArrayList<Class>
线程不安全，存储空间连续，数组存储结构，查询快，增删慢

add() //添加元素

add(index,value) //指定索引位置添加元素

addAll(Collection) //从末尾添加集合

addAll(index,value) //从指定位置添加集合

get(index) //获取元素

size() //获取集合中元素个数

remove(index) //根据索引下标删除元素

remove(obj) //根据值删除集合中的元素，从前往后只删除第一个

clear() //删除集合中的所有元素

isEmpty() //判断集合是否为空、空为true、非空为false

subList(fromIndex,toIndex) //截取集合中的元素，不包含toIndex

Vector<Class>
线程安全，存储空间连续，数组存储结构，增删快，查询慢

add() //添加元素

add(index,value) //指定索引位置添加元素

addAll(Collection) //从末尾添加集合

addAll(index,value) //从指定位置添加集合

get(index) //获取元素

size() //获取集合中元素个数

remove(index) //根据索引下标删除元素

remove(obj) //根据值删除集合中的元素，从前往后只删除第一个

clear() //删除集合中的所有元素

isEmpty() //判断集合是否为空、空为true、非空为false

subList(fromIndex,toIndex) //截取集合中的元素，不包含toIndex

LinkedList<Class>
线程不安全，存储空间不连续，双链表存储结构，增删快，查询慢

在以上方法基础上又额外增加了六种方法：

addFirst(obj) //在第一个位置添加元素

addLast() //在最后一个位置上添加元素

getFirst() //获取集合的第一个元素

getLast() //获取集合的最后一个元素

removeFirst() //删除集合中第一个元素

removeLast() //删除集合中最后一个元素

ArrayList排序

类实现comparable接口并且重写ComparaTo方法

使用匿名内部类方法
Collections.sort(stu,new Comparator<Student>(){

@override
public int compara(Student o1,Student o2){
return o1.getName().comparaTo(o2.getName());
}
});

Set<Interface>
无序、无下标、元素不可重复
全部继承自Collection中的方法
使用foreach循环遍历

HashSet<Class>
存储结构哈希表
基于HashCode实现元素不重复
当存入元素的哈希码相同时，调用==或equals方法进行确认，为true拒绝后者进入

判断值是否相同重写HashCode以及equals

重写HashCode就是把Sting类型的hashcode值相加加上非String类型的变量

重写equals分为四部：
1、判断传进来是否==空，为空false （obj == null）
2、判断两个类型是否不相同，不相同返回false (obj.getClass() != this.getClass())
3、判断传进来的地址是否相同，相同为true (obj == this)
4、强制转换obj转换成比较的数据类型 (Student) stu = (Student) obj
每个值分别去比较，String的用equals非String的用== (this.getName().equals(stu.getN ame()) && this.getAge() == stu.age)
然后else 返回false

LinkedHashSet<Class>
存储结构链表
链表实现的HashSet，可保留元素的插入顺序

方法和HashSet一样同样是值唯一，区别是有序，传入顺序就是输出顺序

SortedSet<Interface>

TreeSet<Class>
存储结构是树，无序且唯一

接口是SortedSet并不是Set
SortedSet<Teacher> sort = new TreeSet<Teacher>();
因为是排序的所以除了基本数据类型和String以外
其余的数据类型必须实现Comparable并重写CompareTo方法

Map<Interface>体系集合
key-value
key唯一，如果重复，会覆盖
value可以重复

key：类似索引，可以任意类型
key键-value值
键的作用：通过键来获取值

HashMap<Class>
存储结构：哈希表
线程不安全，运行效率快
允许用null作为key或value

方法

V put (K key, V value) //将对象存入到集合中关联键值，key重复则覆盖原值

Object get（Object key）//根据键获取对应的值

Set<K> keySet //返回所有key

Collection<V>values() //返回包含所有值的Collection集合

Set<Map.Entry<K,V>>entrySet() //键值匹配的Set集合

remove(Object key) //删除map集合中的元素

遍历Map集合

方式一、获取所有key来获取key中所有的元素

1、Set集合先获取到map集合当中的所有key
Set<String> keys = map.keySet();
2、增强for循环遍历获得所有key
for(String key : keys){
3、根据key获取key对应的value
Teacher t = map.get(key);
System.out.println(t);
}

方式二、直接获取所有的value

运用collection里边的toArray方法

1、通过values()方法获取集合中所有的value
Collection<Teacher> collection = map.values();
2、运用collection方法里边的toArray将其转换成数组
Object[] obj = collection.toArray();
3、运用for循环遍历obj
for(int i=0;i<obj.length;i++){
//将obj里边的每一个元素强制转换成其类型
Teacher t = (Teacher)obj[i];

System.out.println(t);
}

1、通过values()方法获取集合中所有的value
Collection<Teacher> collection = map.values();
2、定义一个Teacher类型的数组 t
将collection中的元素按照new Teacher[0]进行转换
Teacher[] t = collection.toArray(new Teacher[0]);
3、遍历t
for(int i=0;i<t.length;i++){
System.out.println(t[i]);
}

方式三、将Key与Value全部进行获取
但是输出可以选择获取key或者是value

运用Entry<T , V>方法

1、因为key-value组合是唯一的，所以用Set集合接收
获取所有的键值对对象，数据类型与map相同
运用entrySet()；进行获取键值对key--value
Set<Entry<String,Teacher>> setEntry = map.entrySet();
2、增强for循环进行遍历
for(Entry<String,Teacher> entry : setEntry){
3、运用getKey方法获取key，接收的数据类型与Entry的key相同
String key = entry.getKey();
4、运用getValue方法获取value，接受的数据类型与Entry的value相同
Teacher value = entry.getValue();
5、输出key---value 可以选择一起输出或者是输出key或value
System.out.println(key + value);
System.out.println(key);
System.out.println(value);
}

方式四、直接输出map集合的名字

但是返回的是一个字符串的集合

System.out.println(map);

Hashtable<Class>
线程安全，运行效率慢
不允许null作为key或value
其余用法与HashMap一样

Properties<Class>
Hashtable的子类，要求key和value都是String
通常用于配置文件的读取

SortedMap<Interface>

TreeMap<Class>
可以对key自动排序，key需实现Comparable接口

TreeMap的结合排序是用key来排序

使用TreeMap存数据key必须得实现Comparable接口并重写CompareTo方法

异常

概念

程序在运行过程中出现的特殊情况

异常的分类

Throwable：可抛出的，一切错误或异常的父类，位于java.lang包中

Error：JVM、硬件、执行逻辑错误、不能手动处理。

Exception：程序在运行和配置中产生的问题，可处理

RuntimeException：运行时异常，可处理，可不处理

CheckedException：受查异常，必须处理。

异常的产生

自动抛出异常：当程序在运行时遇到不符合规范的代码或结果时，会产生异常

手动抛出异常：语法：throw new 异常类型("实际参数")；

产生异常结果：相当于遇到return语句，导致程序因异常而终止

异常的传递

异常的传递：按照方法的调用链反向传递，如始终没有处理异常，最终会由JVM进行默认异常处理（打印堆栈跟踪信息）。

受查异常：throws声明异常，修饰在方法参数列表后端。

声明时异常：因可处理可不处理，无需声明异常。

常见异常处理结构

try{ } catch{ }

try{ } catch{ } catch{ }

try{ } catch{ } finally{ }

try{ } catch{ } catch{ } finaly{ }

try{ } finally{ }

注：多重catch，遵循从子(小)到父(大)的顺序，父类异常在最后

自定义异常

概念

需继承Exception或Exception的子类，代表特定问题

经验

异常类型名称望文生义，可在发生特定问题时抛出对应的异常

方法重写

方法名、参数列表、返回值类型必须和父类相同。

子类的访问修饰符符合父类相同或是比父类更宽

线程

进程

概念

程序是静止的，只有真正运行时的程序才能被称为进程

线程

概念

线程，又称轻量级进程(Light Weight Process) 程序中的一个顺序控制流程，同时也是CPU的基本调度单位，进程由多个线程组成，彼此间完成不同的工作，交替执行，称为多线程

进程与线程的区别

进程是操作系统资源分配的基本单位，而线程是CPU的基本调度单位

一个程序运行后至少有一个进程

一个进程可以包含多个线程，但是至少需要有一个线程

进程间不能共享数据段地址，但同进程的线程之间可以

线程的组成

CPU时间片

操作系统（OS）会为每个线程分配执行时间

运行数据

堆空间：存储线程需使用的对象，多个线程可以共享堆中的对象

栈空间：存储线程需使用的局部变量，每个线程都拥有独立的栈

线程的逻辑代码

创建线程

继承Thread类

实现Runnable接口

实现Callable接口

public interface Callable<V>{

public V call() throws Exception;

}

JDK5加入，与Runnable接口相似，实现之后代表一个线程任务

Callable具有泛型返回值、可以声明异常。

--------------> 实现多线程的第三种方式

配合Future接口使用

Future

是一个接口

FutureTask是一个实现类，用来实现runnable的方法

线程的状态

初始状态

就绪状态

运行状态

阻塞状态

终止状态

方法

Thread.sleep // 睡眠
Thread.yield //不争此次，返回就绪态
Thread.join /允许其他线程加入到当前线程中

线程安全问题

临界资源

共享资源(同一对象)，一次仅允许一个线程使用，才可确保其正确性

原子操作

不可分割的多步操作，被称作一个整体，其顺序和步骤不可打乱或缺省

锁

synchronized(临界资源对象){ //对临界资源对象加锁

//代码（原子操作）

}

Lock

void lock() //获取锁，如锁被占用，则等待。

boolean tryLock() //尝试获取锁（成功返回true。失败返回false,不阻塞）。

void unlock() //释放锁

读写锁

概念

一种支持一写多读的同步锁，读写分离，可分别分配读锁、写锁。

支持多次分配读锁，使多个读操作可以并发执行。

互斥规则

写-写：互斥，阻塞。（不一起）

读-写：互斥，读阻塞写、写阻塞读。(不一起)-------> 读多写少 set放写锁 get放读锁

读-读：不互斥、不阻塞（一起）

在读操作远远高于写操作的环境中，可在保障线程安全的情况下，提高运行效率。

生产者与消费者

wait() //等待

notify //唤醒

notifyAll //唤醒所有

多线程

线程池概念

线程容器，可设定线程分配的数量上限。

将预先创建的线程对象存入池中，并重用线程池中的线程对象。

避免频繁的创建和销毁。

线程池原理

线程池用维护者一个队列，队列中保存着处于等待（空闲）状态的线程。不用每次都创建新的线程。

内存溢出

内存满了，没有可用的内存，称为内存溢出

内存泄漏

指的是占用的内存发生了无法回收的情况，称为内存泄漏

语法

ExecutorService es = Executors.newFixedThreadPool(3);

for循环 es.submit(执行的任务----也就是要获取的东西);

线程安全的集合

CopyOnWriteArrayList

线程安全的ArrayList，加强版读写分离。

写有锁，读无锁，读写之间不阻塞，优于读写锁

写入时，先copy一个容器副本、再添加新元素，最后替换引用。

使用方法与ArrayList无异

CopyOnWriteArraySet

·    线程安全的Set, 底层使用CopyOnWriteArraylist实现。
·    唯一不同在于，使用addIf Absent(）添加元素，会遍历数组，
·    如存在元素，则不添加（扔掉副本）。

ConcurrentHashMap

·    初始容量默认为16段 (Segment) ，使用分段锁设计。
·    不对整个Map加锁，而是为每个Segment加锁。
·    当多个对象存入同一个Segment时，才需要互斥。
·    最理想状态为16个对象分别存入16个Segment, 井行数量16。
·    使用方式与HashMap无异。

Queue接口(队列)

常用方法：
  抛出异常：
•    boolean add(E e) ／／顺序添加一个元素（到达上限后，再添加则会抛出异常）
•    E remove(）／成得第一个元素井移除（如果队列没有元素时，则抛异常）
•    E elementO ／月天得第一个元素但不移除（如果队列没有元素时，则抛异常）
返回特殊值：推荐使用
•    boolean offer(E e) ／／顺序添加一个元素（到达上限后，再添加则会返回false)
•    E pollQ ／凡天得第一个元素井移除（如果队列没有元素时，则返回null)
•    E keepQ ／凡天得第一个元素但不移除（如果队列没有元素时，则返回null)

ConcurrentlinkedQueue

· 线程安全、可高效读写的队列，高井发下性能最好的队列。
· 无锁、 CAS比较交换算法，修改的方法包含三个核心参数(V,E,N)

V：要更新的变量、 E:预期值、 N:新值。

只有当V==E时， V=N;否则表示已被更新过，则取消当前操作。

BlockingQueue接口（阻塞队列）

Queue的子接口，阻塞的队列，增加了两个线程状态为无限期等待的方法。

·    方法：
•    void put(E e)／／将指定元素插入此队列中，如果没有可用空间，则等待。
•    E take(）／月天取井移除此队列头部元素，如果没有可用元素，则等待。
·    可用于解决生产生、消费者问题。

阻塞队列

ArrayBlockingQueue:

数组结构实现，有界队列。（手工固定上限）

• LinkedBlockingQueue:
· 链表结构实现，无界队列。（默认上限Integer.MAX_VALUE)

IO框架

什么是流

概念

内存与存储设备之间传输数据的通道

流的分类

输入流：将<存储设备>中的内容读入到<内存>中。

输出流：将<内存>中的内容写入到<存储设备>中。

流的分类

按单位

字节流：以字节为单位，可以读写所有数据

字符流：以字符为单位，只能读写文本数据

按功能

节点流：具有实际传输数据的读写功能

过滤流：在节点流的基础之上增强功能

File类

概念

代表物理盘符中的一个文件或者文件夹

方法

createNewFile()  //创建一个新文件

        mkdir()  //创建一个新目录

        delete()  // 删除文件或空目录

        exists()  //判断File对象所代表的对象是否存在

        getAbsolutePath()  //获取文件的绝对路径

        getName()  //取得名字

        getParent()  //获取文件 / 目录所在的目录

        isDirectory()  //是否是目录（文件夹）

        isFile()  //是否是文件

        length()  //获得文件的长度

        listFiles()  //列出目录中的所有内容

        renameTo()  //修改文件名为

FileFilter接口

当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件才可出现在listFiles()的返回值中。

Properties

属性集合

特点

存储属性名和属性值

        属性名和属性值都是字符串类型

        没有泛型

        和流有关

网络编程

什么是网络

由点和线构成，表示诸多对象间的相互关联

什么是计算机网络

为实现资源共享和信息传递，通过通信线路连接起来的若干主机(Host)

互联网：(Internet)点与点相连

万维网：(www-World Wide Web) 端与端相连

物联网：(loT-Internet of things) 物与物相连

网络编程：让计算机与计算机之间建立连接、进行通信。

网络模型

OSI（Open System Interconnection）开放式系统互联

Tcp / Ip模型

一组用于实现网路互连的通信协议，将协议分成四个层次

TCP / UDP

TCP协议
Transmission Control Protocol传输控制协议

是一种面向连接的、可靠的、基于字节流的传输层通信协议。数据大小无限制。建立连接的过程需要三次握手，断开连接的过程需要四次挥手。

UDP协议
User Datagram Protocol用户数据报协议

是一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务，每个包的大小64KB。

开发步骤

建立通信连接(会话) ：

创建ServerSocket, 指定端口号

调用accept等待客户端接入

客户端请求服务器：

创建Socket, 指定服务器 IP + 端口号

使用输出流, 发送请求数据给服务器

使用输入流, 接收响应数据到客户端 (等待)

服务器响应客户端：

使用输入流, 接收请求数据到服务器 (等待)

使用输出流, 发送响应数据给客户端

反射

类的对象

基于某个类new出来的对象，也称为实例对象

类对象

类加载的产物，封装了一个类的所有信息(类名、父类、接口、属性、方法、构造方法)

获取类对象

通过类的对象，获取类对象
Student s = new Studnet();
Class c = s.getClass();

通过类名获取类对象
Class c = 类名.class;

通过静态方法获取类对象
Class c = Class.forName("包名.类名");

常用方法

获取类对象

获取对象的类名及包名

获取该类的父类的类名及包名

获取hashCode值

获取包名

获取类所实现的接口

获取类的方法及相关属性

通过无参构造方法创建类的对象

通过有参构造方法创建类的对象

获取类对象的public修饰的方法

获取当前类中的所有方法

调用该类普通的无参方法

调用该类普通的有参方法

调用私有属性修饰的无参方法

调用私有属性修饰的有参方法

调用无参static方法

调用有参static方法

获取包括父类在内的所有publc属性

给类中的属性赋值并调用

获取本类中所有的属性

给私有属性赋值并调用

设计模式

概念

一套被反复使用，多数人知晓的，经过分类编目的、代码设计经验的总结
可以简单理解为特定问题的固定解决方法

工厂设计模式

开发中有一个非常重要的原则"开闭原则"，对扩展开放、对修改关闭
工厂模式主要负责对象创建的问题
可通过反射进行工厂模式的设计，完成动态的对象创建

单例模式

饿汉式

懒汉式

枚举

枚举是一种引用类型，枚举是一个规定了取值范围的数据类型

枚举变量不能使用其他的数据，只能使用枚举中常量赋值，提高程序安全性

定义枚举使用enum关键字

注解

注解(Annotation)是代码里的特殊标记，程序可以读取注解，一般用于替代配置文件

开发人员可以通过注解告诉类如何运行
再JAVA技术里注解的典型应用是：可以通过反射技术去得到类里面的注解，以决定怎么去运行类

常见注解：@Override @Deprecated

定义注解使用 @Interface关键字，注解中只能包含属性

元注解

用来描述注解的注解

@Retention：用于指定注解可以保留的域

@Target：指定注解用于修饰类的哪个成员，告诉注解运行在哪里

java8新特性

Lambda表达式

概念

特殊的匿名内部类，语法更简洁

基本语法

<函数式接口> <变量名> = （参数1, 参数2...） -> {

//方法体

}
Lambda引入了新的操作符：->(箭头操作符), ->将表达式分成两部分

左侧：(参数1, 参数2...)表达参数列表

右侧：{}内部是方法体

函数式接口

如果一个接口只有一个抽象方法，则该接口称之为函数式接口，函数式接口可以使用Lambda 表达式，Lambda表达式会被匹配到这个抽象方法上

常见函数式接口

Consumer

Supplier

Function

Predicate

方法引用

概念

方法引用是Lambda表达式的一种简写形式。如果Lambda表达式方法体中只是掉用一个特定的已经存在的方法，则可以使用方法引用

常见形式

对象::实例方法

        类::静态方法

        类::实例方法

        类::new

Stream

概念

流(Stream)与集合类似，但集合中保存的是数据，而Stream中保存对集合或数组数据的操作

特点

Stream自己不会存储元素

Stresam不会改变源对象。相反，他们会返回一个持有结果的新Stram

Stream操作是延迟执行的，会等到需要结果的时候才执行

使用步骤

创建：

        创建一个流。

        中间操作：

        在一个或多个步骤中，将初始Stream转化到另一个Stream的中间操作

        终止操作：

        使用一个终止操作来产生一个结果。该操作会强制之前的延迟操作立即执行，在此之后，该         Stream就不能使用了

新时间API

之前时间API存在的问题：线程安全问题，设计混乱。

本地化日期时间 API：

        LocalDate

        LocalTime

        LocalDateTime

Instant：时间戳

Zoneld：时区

Date、Instant、LocalDateTime的转换

DateTimeFormatter：格式化类