JavaSE知识点总结思维导图模板_ProcessOn思维导图、流程图

概述与环境搭建

概述：JavaSE，Java platform standard edtion(Java平台标准版)

JavaEE Java platform enterprise edtion(Java平台企业版)

JVM：Java虚拟机（内置垃圾回收机制，自动完成空间管理）

JRE：Java运行环境（包含JVM，和解释器）

JDK：Java开发环境（包含JRE，类库，编译器、调试工具）

语言基础

变量

计算机内存的一块存储空间

组成

数据类型

变量名

值

声明方式

先声名，后赋值

声明并赋值

多个同类型变量同时声明并赋值

数据类型

基本数据类型

整数

byte

1个字节

-2^7~2^7-1

short

2个字节

-2^15~2^15-1

int

4字节

long

8字节

小数

float

double

布尔

boolean

字符

char

引用数据类型

字符串

String

数组

对象

类型转换

自动类型转换

两种类型兼容，目标类型大于原类型

两种类型兼容，目标类型小于原类型

强制类型转换

整数长度完整，数据完整

整数长度不够，数据截断

小数转换整数，数据截断

字符整数互转，数据完整

boolean不可与任何类型转换

类型提升

数字间的常规类型提升

字符串发的特殊类型提升

运算符

算数运算符

+-*、++--

赋值运算符

= += -=*=、=

关系运算符

<><=>===!=

逻辑运算符

&&||!

三元运算符

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

控制台录入

引入工具包：import java.util.Scanner;

声明Scanner input=new Scanner(System.in);

int a=input.nextInt();//控制台输入的值付给a

String str =input.next();

char car=input.next().charAt(0);

选择结构与分支结构

选择结构

基本if选择结构

if else 选择结构

多重if选择结构

嵌套if选择结构

.equals()方法

比较引用类型值是否相等

“是”.equals("是")；

.random(int值)；

获取一个随机数

math.random();:获得一个小数随机数（乘10，强转int,达到获得一个随机数1~9）

3： 0，1，2

分支结构

switch

byte short int char string(jdk7)

case 值不可相同

default: (最后)

追加break；

局部变量

函数内部的变量

从定义行到所在代码快结束

重合范围内不可重名

循环结构

while循环

while(boolean){}

特点：首次有入口条件，先判断后执行，适用于循环次数明确的的条件

do{}while(boolean)

先执行后判断，适用于循环次数不明确

for循环

for（;;）{}

首次有入口条件，先判断，再执行

break

终止，跳出，switch分支语句，以及循环结构

扩展：outer：循环体 break outer; 跳出指定循环

contiune

结束本次进入下一次循环

嵌套循环结构

在一个循环中完整嵌套另一个循环

函数

概念：实现特定功能的一段代码，可以反复使用。

定义语法：public static void 函数名（形式参数）{函数主体 }

函数调用：函数名称（实际参数）；

自己调用自己（递归）

形参与实参：函数定义中是形参，函数调用中为形参赋值为实参。

返回值与返回值类型

返回值类型：基本数据类型，引用数据类型，void

return value;返回值类型应该与函数定义的返回值一致（兼容）

return;void 函数中，直接结束函数。

数组

概述：一组连续的存储空间，存储一组类型相同的数据

数组的创建

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

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

数组的赋值

数据类型[] 数组名=new 数据类型 []{value,value2,value3}

数据类型[] 数组名={value,value,value}不可换行

数组的遍历

普通for循环遍历

增强for循环遍历---for（数据类型变量名：数组名）{System.out.print(变量名)}

增强for循环，专为遍历而存在，解决了数组下标越界异常，//将数组的每个元素赋值给变量

数组的扩充

创建一个新数组，将原来数组上的值，用循环逐一复制过来

System.arraycopy(原数组，原数组起始下标，新数组，新数组的起始村存储下标，需要赋值的个数或长度);

int[] newnum=java.util.Arrays.copyOf(原数组，新长度)；

引入工具包 import java.util.Arrays;

copyOf(原数组，新长度)；//同时完成对新数组的创建

数组的增删改查

数组的参数，返回值

public static 数据类型[] 方法名（数据类型[] 形式参数）；

可变长参数数据类型...形式参数与数据类型[] 形式参数等同

可变长参数只能有一个，并且只能在形参列表的最后

数组的排序

冒泡排序（交换排序）：相邻的两个元素比较大小互换位置。外层：length-1;内层：length-1-i;

选择排序：固定值与其他值依次比较。外层：length-1；内层：length

jdk排序：Java.util.Array.sort(数组名)；//升序

冒泡、选择、插入、希尔、归并、快速、堆、计数、稳定、

二维数组

概念一维数组中的一维数组。数组中的元素还是数组。

语法： int[][] 数组名=new int[行数][列数]；

不规则二维数组int[][] arr =new int[3][];

arr[0]= new int[3];

arr[1]=new int[5];

arr[2]=new int[4];

面向对象

类；

一组相同或者类似的对象中抽取出共性的行为和特征

类的定义 public class 类名{}

对象

具有一定的特征和行为

对象的定义类名对象名=new 类名（）；

实例变量、实例方法

实例变量定义在类的内部，方法的外部。可以不赋值

实例方法的定义 public void 方法名（参数）{可以实现的行为}

方法重载

方法名相同，参数列表不同---与访问修饰符和返回值类型无关

构造的方法

构造方法与类名完全相同，用来创建对象的方法。

public 类名（）{} 没有返回值

可以进行重载增加参数，为实例变量赋值，重写后无参的构造方法将不在起作用

this关键字

this.属性名调用实例属性 /this.方法名（）调用实例方法可以省略隐式存在

this() 调用本类中的其他构造方法

必须在构造方法中，并且只能在首行

三大特征

封装

概念：实例变量和实例方法的访问修饰符设置为 private

仅本类可见，只能通过get\set 方法访问

public int getAge(){return this.age}

public void setAge(int age){this.age=age;}

外界不可以直接访问private修饰的属性，公开的set和get方法是唯一的途径

继承

概念：类与类之间行为和特征的一种赠与和获得

满足 is a 的关系

class 子类 extend 父类{子类的内容}

子类继承父类以后可以使用父类的方法和属性，也可以定义自己的

一个类只能继承一个父类，但是可以多级继承

不能继承父类的构造方法和private修饰的方法

当父类和子类不在一个包时， default修饰的属性

夸包继承只能继承protected，和public 修饰的属性和方法

方法的重写

返回值类型、方法名、参数列表与父类方法相同

访问修饰符比父类方法更广泛

重写后优先执行重写后的方法

@override,重写关键字

super关键字

super关键字，当子类的实例成员与父类的实例成员重名时，super区分

super.属性名/super.方法名（）；调用父类的属性和方法；

super（）；/super（参数）；调用父类的无参有参的构造方法

子类的构造方法中默认提供super（）；调用父类的无参构造方法

多态

概念：父类引用指向子类对象，从而产生多种形态（二者具有直接或间接的继承关系）

父类名对象名=new 子类名（）；

如果子类中重写的父类的方法，则多态对象调用方法时优先调用子类重写后的方法

多态的应用

向上转型（装箱）

父类名对象名=new 子类名（）；

向下转型（拆箱）

父类名对象名=new 子类名（）；

子类名对象名2=（子类名）对象名；

只有转换回子类的对象类型才能访问子类特有的属性

类型转换异常

类型向下转型时，转回类型与向上转型子类名不一致

instanceof关键字

判断一个向上转型的对象是否与一个子类对象相同

if（多态对象名 instanceof 子类）

根据是否相同返回一个布尔类型的值

三个修饰符

abstract（抽象的）

定义方式 public abstract class 类名{实例属性 public abstract void 抽象方法名（）；}

被abstract修饰的类称为抽象类，无法实例化

作用，可以被子类继承，更自然的使用多态

abstract 修饰的类不能new对象，但是可以声明引用

abstract 修饰的方法，只有方法声明，没有方法实现

子类继承抽象类后，必须重写父类中所有的抽象方法，否则子类还是抽象类

static（静态的）

static修饰的类属性和类方法，称为静态~

静态成员是本类所有对象共享的成员

只有一份，其他类不必创建对象，可以通过类名直接访问；本类直接通过方法名访问

特点：

静态方法允许直接访问静态成员

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

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

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

静态代码块和动态代码块

动态代码块 class 类名实例变量{ 动态代码 }构造方法

创建对象时，触发，在实例属性之后，构造方法之前

动态代码块不存在，编译时将代码块重的内容合并到构造方法中

静态代码块 class 类名静态属性 static{静态代码} 静态方法

静态代码块加载类时执行，只触发一次

局部代码块（放在方法内，缩小变量的使用范围，基本不用）

final（最终的）

可修饰，类，属性，方法

final修饰的类不可以被继承

final修饰的方法不可以被覆盖

final修饰的变量只能被赋值一次

实例常量不提供默认值，只能手动赋值

注意：如果要在构造方法中为其赋值，必须要保证所有的构造方法都能正确赋值

局部常量：显示初始化

实例常量：显示初始化、动态代码块、构造方法

静态常量：显示初始化、静态代码块

基本类型常量值不可比变、引用类型常量地址不可变

接口

概念：特殊的抽象类，类中只能定义公开静态常量属性，和公开抽象方法

定义方式：public interface MyInterface {public static final value； public abstract void 方法名（）；}

实现类

“继承”了某个接口的类，称为实现类（重写接口中的抽象方法）

创建实现类

class Impl implement MyInterface{重写接口中的公开抽象方法}

创建实现类对象

MyInterface myInterface=new 实现类名Impl（）；

myInterface.方法名（）；

接口与抽象类的区别

相同点

可以编译成字节码文件

不可以创建对象

可以作为引用类型

具备object类中所定义的方法

不同点

所有属性为公开静态常量，隐式用public static final修饰

所有方法是公开抽象方法，隐式用 public abstract修饰

没有构造方法，没有静态代码块，动态代码块

微观接口（能力）

接口的定义：接口的定义代表类某种能力，方法的定义代表了能力的具体要求

一个实现类实现多个接口（不同于类的单继承）

class 实现类 implement 接口1，接口2，接口3，{重写1，2，3的抽象方法}

接口规范

接口声明引用，创建实现类对象，只能调用接口中所定义的方法，不能调用实现类独有的方法

可强转回实现类自身类型，才可以调用实现类独有的方法

实现类在实现接口时，必须实现接口中所有的抽象方法，否则此类还是抽象类

接口实现多态

通过继承+实现的方式创建是实现子类

只能通过子类名对象名=new 子类名（）；的方式使用接口方法和此类独有方法

接口的关系

类与类：单继承

类与接口：1 implements n

接口与接口：1 extends n

宏观接口（标准）

接口回调：先有接口的使用者，后有接口的实现者

常用类

内部类：类的内部再定义一个完整的类（为外部类提供功能组件）

成员内部类

类的内部与实例变量和实例方法同级

外部类的一个实例部分，创建内部类对象时依赖外部类对象

Outer outer =new Outer();

Outer.Inter=outer.new Inter();

内部类可以直接访问外部类的实例属性和方法，诶不破坏封装（类似get()方法）

成员内部类不能创建静态属性方法（成员内部类可以用任何访问修饰符修饰）

静态内部类

类的内部与静态实例变量和静态实例方法同级

创建内部类对象不依赖外部类对象，可以直接创建

Outer.Inter inter=new Outer.Inter();

静态内部类可以创建，静态属性方法

静态内部类不能直接访问外部类的实例属性和方法，可以直接访问静态属性和方法

局部内部类、

定义外部类的实例方法和静态实例方法中

类的适用范围也和局部变量一样，从定义行到所在代码块结束（当前方法）（不能使用任何访问修饰符）

局部类访问外部类了当前方法中的局部变量，变量必须用final修饰，因为不能保证变量的生命周期与自身相同

匿名内部类

没有类名的局部内部类，其他特性与局部类相同

继承式匿名内部类方法{Animal a =new Animal(){实现类};加分号}

接口式匿名内部类方法{Interface a =new interface(){实现类};加分号}

扩展拉姆达表达式

接口中只有一个方法（条件）

接口名对象名=（）->{方法实现}

参数式匿名内部类定义一个接口参数的方法，调用方法时方法{Interface a =new interface(){实现类};加分号}

匿名内部类不能有构造方法暗，一次只能创建一个对象

object类

.getClass() :返回一个类对象Class class=对象名.getClass();

.getName();

.hashCode() :返回该对象的10进制哈希值（int类型）

.toString(); :返回类对象名+@+16进制哈希吗值（可以重写覆盖）

.equas(对象)；：返回一个boolean类型的值（覆盖重写）

包装类

int Iinterage

String类

字符串常量池池；

String s1="abc";

String s2="abc";

相同方式创建对象，相同值，会放到字符串池，两个对象同地址

方法

字符串其实就是字符数组

.charAt(int ) 取字符

.contains（str）匹配串

.toCharArray();转化为字符数组

.indexOf(char,int)通过字符查找首次出现的下标,int 决定从下标int开始查找

String 类

string和stringBuilderde 区别

String 长度不可变

StringBuilder 长度可变

StringBuilder

构造方法

StringBuilder（）

StringBuilder("")

append()方法返回对象自身，所以可以反复使用方法

相互转换

builder转换为string

String s=str.toString()

string转换为builder

StringBulider str=new StringBuilder(s);带参构造方法

可变字符串BigDecimal

Date

Calender

SimpleDateFormat

System

集合

Collection（接口）(无序、无下标、元素可以重复)

List（接口）（有序，有下标，元素可以重复）

ArrayList（基于数组）

有序，有下标，元素可以重复

查询快、增删慢，jdk1.2版本，执行效率高，线程不安全。

Vector（基于数组）

jdk1.0版本执行效率低、线程安全。

LinkedList（基于链表）

增删快，查询慢

双链表

Set（接口）（无序，无下标，元素不可重复）

HashSet

基于hashCode和equals实现元素不重复(仅重写equals方法不能实现去重)

当哈希吗相同时会用那个equals确认，如果为true则拒绝存入

表面无序，实则以哈希值为序

LinkedHashSet

链表实现的 Hashset类，按照链表进行储存，保留了元素的插入顺序

SortedHashSet(接口)

TreeSet

基于排列顺序实现元素不重复

实现了SortedHashSet接口,对元素自动排序

对象类型必须实现Comparable接口，指定排序规则

通过重写compareTo(obj)方法确定是否为相同元素，和排序规则

方法2：通过匿名内部类的方式，实现Comparator接口，并重构compare(s1,s2)

匿名内部类

Map（映射）（接口）

HashMap(线程不安全，效率快，允许插入null)

可以插入重复Key，但value也会被覆盖

被remove的value，再次get时结果会是null

键值视图

键：Set<键泛型> s= 对象名.keySet();

for(String str : 对象名.keySet()){System.out.println(str)}

值：Collection<值泛型> s= 对象名.values();

for(String str : 对象名.value()){System.out.println(str)}

键+值：Set <Map.Entry<泛型,泛型>> entrys=类名.对象名.entrySet();

for(Map.Entry<泛型,泛型> entry : entrys){entry.getKey(); entry.getValue(); }

Hashtable(线程安全，效率慢，不允许插入null)

Properties类

要求key，和value都是string 类型

不安全，继承了一个不该继承的类Hashtable（可以使用put(key,value)方法）

只能使用对象名.setProperties("String")方法和对象名.getProperties("String")方法

子主题

SortedMap(接口)

TreeMap

可以对key自动排序，必须实现comparable接口

匿名类

存储任意键值对（Key-value）

键：无序，无下标，不允许元素重复

值：无序，无下标，允许元素重复

底层实现数组+单向链表

遍历方式

keySet()遍历

entrySet()遍历

异常

概念

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

分类

Throwable可抛出的

Error
硬件、jvm、执行逻辑的错误，不能处理

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

RuntimeException
运行时异常、可处理、可不处理

NullPointerException空指针异常

ArrayIndexOutOfBoundsException数组下标越界异常

Class CastException 类型转换异常

NumberFormatException数字格式化异常

ArithmeticExecption 算数异常

CheckedException
检查时异常，必许处理

产生

自动抛出异常：当程序运行时遇到不规范的代码和结果时

手动抛出： throw new 异常类型（"实际参数"）

相当于遇到 System.exit(0)，导致程序因异常而终止

传递

按照方法调用链反向传递

处理

try{
可能会出现异常的代码
}catch{
//捕获异常
//处理异常
}finally{
//无论异常是否发生都会执行的代码
}

处理异常的三种方式

自定义处理（）

e.printStackTrace()

e,Message();

声明，抛出异常

throws ：声明异常

throw : 抛出异常

自定义异常

异常类 extends Exception(或子类){
重写父类的构造方法
}

多线程

基本多线程

概念

运行的程序被称为进程
线程是轻量级的进程

cpu的基本执行调度单位

JVM就是一个进程，main方法是主线程，通过代码创建多个线程与主线程并行运行

组成

时间片：OS 为每个线程分配的执行时间

运行数据：

堆空间：存储线程所需要使用的对象

存储线程使用的局部变量，每个线程有各自独立的栈

线程的逻辑代码

创建线程

方法一： extends Thread

方法二： implements Runable

Runnable接口

线程状态

初始

就绪

运行

等待

阻塞

终止

线程安全

同步代码块

同步方法

线程通信

wait()；等待

notify(); 唤醒

生产者消费者问题

子主题

高级多线程

线程池

Executor（顶级接口）
execute(Runnable)方法

ExecuterService(线程池接口)
submit(Runnable)
submit(Callable)

Executors(实现类)

创建线程池
ExecutorService es=Executors.newFixeThreadPool(线程数量)//指定数量线程池

newCachedThreadPool()//动态数量的线程池

newSingleThreadExecutor() //单线程池

ExecutorService es = Executors.newScheduledThreadPool(4);// 延时线程池**

Callable接口

相当于带有返回值的Runnable接口

Future<T> submit(Callable);

Future接口

异步计算结果

用于接收submit(Callable)的返回值

.get()方法获得future的值//原理future进入无限期等待异步计算结果的完成

Lock接口

比synchronized更加高级，显式定义，结构更加灵活

重入锁ReentrantLock：Lock的实现类，与synchornized用相同的排斥锁功能

lock();开启锁

unlock();释放锁（处理异常时，写在finally中）

ReentrantReadWriteLock:读写锁

//创建读写锁对象
ReentrantReadWriteLock rw=new ReentrantReadWriteLock();

//创建读锁对象
ReadLock readlock= rw.readLock();

//创建写锁对象
WriteLock writelock= rw.writeLock();

线程安全的集合

Collections类方法将一个集合转换成线程安全的集合

CopyOnWriteArrayList

CopyOnWriteArraySet

ConcurrentHashMap

初始容量默认为16段

通过分段锁确保线程安全

1.8之后采用CAS算法（乐观锁） ----悲观锁：synchornized
（compare安定swap 比较交换算法）

ThreadLocal

在JDBC中存储连接对象

Queue（接口）

ConcurrentLinkedQueue底层使用CAS算法，线程安全

BlockingQueue(接口)

ArrayBlockingqueue

LinkedBlockingQueue

IO框架

文件类

File file=new File("文件路径")(路径必须存在)

file.creatNewFile();//创建文件

文件夹操作

File dir=new File("多级文件夹")

dir.mkdirs();//创建多级文件夹

流的概念：内存与存储设备之间传输数据的通道

流的分类

输入流：从存储设备向内存传输

输出流：从内存向存储设备传输

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

InputStream

FileInputStream
字节节点输入流(文件字节输入流)

一次读一个字节

一次读一组字节

OutputStream

FileOutputStream
字节节点输出流

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

Reader

FileReader
字符节点输入流（文件字符输入流）

Writer

FileWriter
字符节点输出流（文件字符输出流）

节点流：具有直接传输数据的读写功能

过滤流（装饰类）：在节点流的基础上增强功能

InputStream

BufferedInputStream（）没啥意义
字节过滤输入流

ObjectInputStream
对象过滤输入流

读取文件中存入的Java数据

OutputStream

BufferedOutputStream（字节节点流对象）
字节过滤输出流

.flush();//刷新缓冲池

.close();//关闭缓冲池，级联刷新

ObjectOutputStream（字节节点流对象）
对象过滤输出流（序列化）

输出Java中的数据类型（将数据写入文件，并非文本）

将一个Object类型写入文件，该类必须实现可序列化接口（Serializable）

字节打印流

PrintSteam(.print(97)

Reader

BufferedReader（字符节点流对象）
字符节点过滤输入流

转换流

将文件字节流转换为文件字符流

Writer

BufferedWriter
字符节点过滤输出流

打印流

PrintWriter (.print(97))

序列化：从内存中将一个对象写入文件中（反之叫做反序列化）

对象必须实现Serializable接口

必须保证类的所有属性都可以序列化

transient修饰的属性为临时属性，不能序列化

静态属性不能序列化

读到文件末尾会抛出EOF异常，不是-1

网络编程

反射

反射技术

反射：通过反射机制获取类对象，并使用类对象的方法，获得类的个方法和属性等

类对象：封装了一个类的全部信息（属性，方法，构造方法等）

获取类对象

通过类的对象： s.getClass();

通过类名：类名.class；

通过静态方法获取： Class.forName("包名.类名")

获取类对象的方法

构造方法

类对象.constructors();--全部构造方法

Construct<?> con=类对象.constructor();---获取无参构造方法

类对象.constructor(参数类型.class,参数类型.class);---获取带参构造方法

实例方法

类对象.getMethods();-----全部方法

Method method=类对象.getMethod("方法名");------无参方法

类对象.getMethod("方法名"，参数类型.class);------带参方法

获取私有方法

类对象.getDeclareMethod("方法名")

使用前 method.setAccessible(true)；

使用实例方法（非私有，非静态）

method.invoke(对象)-----无参方法

method.invoke(对象，实参)-----带参方法

获得一个对象

（拆箱，向下转型）构造方法对象.newInstance();

（Student）类对象.newInstance（）；
（Student）类对象.newInstance（实参，实参）；

获取属性

类对象.getFields();---全部属性

Field field=类对象.getField();----公开属性

类对象.getDeclareField()----私有属性

为属性赋值

field.set(对象，实参)；---公开

field.setAccessible(true);--可修改的
field.set(对象，实参)-----私有属性
会破会类的封装行----解决方法（内省技术）

内省

内省：采用反射机制实现对属性进行操作的一种机制。
PropertyDescriptor：属性描述符，代表一个属性
BeanInfo：实体类信息 ,包含类的信息
Introspector：工具类

PropertyDescriptor pd1=new PropertyDescriptor("属性名",类对象);----属性描述器

Method method=pd1.getWriteMethod();----获得设置方法（实则调用set方法）

method.invoke(对象，实参)-----赋值操作

工厂设计模式（负责创建对象）

开闭原则：扩展开放，修改关闭

通过反射进行工厂模式的设计

单例设计模式

饿汉式：类加载时创建，天生线程安全

懒汉式：使用时创建，线程不安全，加同步

枚举

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

enum关键字---创建枚举
public enum Gender{
male,female,男，女；
}

本质

终止类，继承了Enum抽象类

枚举中的常量时当前类型的静态常量

注解Annotation

一般代替配置文件

常见注解@Override，@Deprecated

定义注解使用@interface关键字---注解中只能包含属性。

jdk8新特性

lambda表达式

实质：特殊的匿名内部类，语法更简洁
允许把一个函数作为方法的参数。

子主题

函数式接口

方法引用

Stream流

新时间API