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

基本类型

byte

short

int

long

float

double

char

boolear

数组

基本特点

在堆中是一段连续存储空间

容量不可变

可以通过索引值访问存储元素

可以存储基本数据类型和引用类型

特点

效率

数组是一个简单线性序列，所以使得访问效率非常快

可以存储基本数据类型的能力

数组的实现

int[] arr = new int[size]

int[] arr = {1,2,3,4}

分类

一维数组

多维数组

关键字

异常：Throwable

Error

Error类代表了编译和系统的错误，不允许捕获

Exception

Exception类代表了标准Java库方法所激发的异常

分类

编译时异常

程序出现编译时异常必须进行处理

RuntimeException

Java程序在运行时产生由解析器引发的异常

程序代码逻辑不够严谨

异常的处理

JVM默认处理

输出异常信息，终止程序运行

捕获异常

try...catch...finally

try代码块放的是可能出现异常代码

catch是捕获异常并处理异常

finally块的代码无论异常发不发生都会执行，可以用于资源的释放

抛出异常

throws

作用在方法上，将异常出去该调用者进行处理

throws表示的是一种状态，该方法可能会发生异常

格式：throws 异常类

throw

作用在方法内部，用来抛出一个具体的异常类型

throw表示动作，该语句一定会发生异常

格式：throw new 异常类()

自定义异常

自定义异常需要继承异常的体系

集合

概念

存放对象引用的容器

集合与数组的区别

长度

集合的长度可变

数组长度不可变

存储类型的种类

集合可以存储不同类型的数据

数组只能存储单一类型的数据

存储类型

集合存储的是引用类型

数组可以存储基本数据类型和对象引用

集合

Collection

List

存取有序，元素允许重复，也可以为null

ArrayList

底层结构是数组

特点：查询快，增删慢

线程不安全，效率快

LinkedList

底层结构是链表

特点：查询慢，增删快

线程不安全，效率快

Vector

底层结构是数组

特点：查询快，增删慢

线程安全，效率低

Set

存取无序，元素唯一，可以为null

HashSet

底层结构是哈希表

源码主要是通过实现HashMap来实现

元素存取无序且唯一

主要依赖hashCode和equals方法保证元素的唯一

LinkedHashSet

底层结构是哈希表和链表

继承HashSet

元素存取有序，且唯一

hashCode保证了元素的唯一，链表保证元素的存取有序

TreeSet

底层结构是红黑树

源码：主要是通过TreeMap集合实现

有序：主要是通过自然排序或比较器进行比较排序

唯一：主要通过比较进行判断

Map

反射

控制流程语句

选择结构

if语句

if（条件语句）{执行的代码；}

if（条件语句）{执行的代码；} //当if的条件语句判定为真，就会执行if花括号里的代码，为假就会执行else的代码
else{执行的代码}

switch-case

switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}

三元运算符

variable x = (expression) ? value if true : value if false

循环结构

for

例：for(int i =0; i++; i < 20){
执行的代码；
}

增强for

for(数据类型变量名 :遍历的目标){ //数据类型变量名:声明一个变量用来接收遍历目标遍历后的元素
执行的代码；
}

while或while-do

while(条件语句){
执行的代码；
}

类和对象

封装

含义

把抽象出的数据（属性）和对数据的操作（方法）封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（方法）才能对数据进行操作

优点

提高代码的复用性

降低代码耦合性

类

类的定义

类是一组相关属性和行为的集合，它描述了一类事物的行为和状态，是一个抽象的概念

变量类型

局部变量

声明在方法中或代码块中的变量

全局变量

声明在类中但在方法外的变量

类变量

声明在类中，方法外，用static修饰

对象

是通过类实例化出来的事物，是具体存在的事物

抽象类

概念

从具体事物中抽取或概括共同的方面，本质属性和行为，将个别的非本质方面，属性和行为舍去

abstract修饰符

修饰类

表示该类是抽象类无法被实例化

修饰方法

表示该方法是抽象方法

该类方法可以只有方法的定义而不具体实现

作用

通过继承抽象类来实现多态

抽象类和接口的区别

接口没有构造方法，抽象类有构造方法

接口的方法没有方法体，抽象类的方法可以有方法体

接口不能有静态方法，抽象类可以有

接口中凡是变量必须是public static final，而在抽象类中没有要求

接口

概念

是一系列方法的声明，是一些方法特征的集合

理解

接口是一种特殊的类，是由全局常量和公共的抽象方法组成

作用

解决Java无法多继承

制定标准

修饰符：interface

继承

概念

子类继承父类的特征和行为，使子类对象具有和父类相同的实例域和方法

特征

子类无法继承到父类用private修饰的变量和方法

子类可以用自己的方式来实现从父类中继承的方法

不能多继承，但可以多重继承

缺点

提高了类与类之间的耦合性

多态

概念

多态是同一行为具有多种不同表现形式的能力

多态就是同一个接口因实例不同而表现出不同功能

多态性是对象多种表现形式的体现

多态三个必要条件

继承

重写

父类引用指向子类对象

作用

增强代码的健壮性

降低耦合性

方法的重写与重载

重写

子类用自己方式实现从父类中继承的方法

特点：子类重写的方法与父类的方法具有相同的返回值类型，方法名相同，参数类型相同，参数个数相同

方法被重写后可以通过super关键字来调用父类中被子类重写的方法

子类重写方法的权限必须大于父类被重写的方法

子类重写父类方法时，子类必须抛出相同或父类异常的子类异常

如果父类方法没有抛出异常，重写的方法不能抛出异常，只能捕获并处理

重载

方法重载是类用统一的方式来处理不同的数据类型

方法重载的特点：

在同一类中

方法名相同

参数类表不同

返回值类型可以不同

常用API

Math类

包含基本的数学运算方法

Character类

子主题对单个字符进行操作

StringBuffer 和 StringBuilder 类

用于操作字符串

时间日期类

Date类：用于封装时间

SimpleDateFormat 格式化日期

泛型

概念

在程序编译时提供一个类型安全监测机制，该机制允许程序员在程序编译时监测非法类型

泛型本质就是参数化类型

作用范围

类

方法

泛型在方法上充当参数列表时，该方法可以接收不同的参数类型

方法中的返回值也可以是泛型

注意：泛型参数得到是引用类型，不是原始类型

例子

// 泛型方法 printArray
public static < E > void printArray( E[] inputArray )
{
// 输出数组元素
for ( E element : inputArray ){
System.out.printf( "%s ", element );
}
System.out.println();
}

多线程

进程和线程

进程

进程就是一个正在运行的程序

是系统进行资源调用和分配的独立单元

每个进程都有自己的内存地址和内存资源

多进程的意义：可以在同一时间段并发处理多个进程

多进程的作用：提高CPU的使用率

线程

一个进程里可以包含多个线程

线程是程序的执行单元，也叫执行路径，是程序使用CPU的基本单元

单线程只有一条执行路径

多线程是有多条执行路径

多线程的意义是提高应用程序使用率

程序的执行其实就是抢夺CPU的执行权

多线程程序：

继承Thread类，并重写Thread类中run方法。

线程调度

Java虚拟机按照特定机制为多个线程分配CPU执行权

分类

分时调度

多个线程轮流使用CPU执行权

抢占式调度

多个线程抢夺CPU执行权，优先级越高，抢到的几率越大

获取线程优先级和设置线程优先级

int getPriority()：获取线程优先级

void setPriority(int newPriority)：设置线程优先级

参数

MIN_PRIORITY：最小优先级

NORM_PRIORITY：默认优先级

MAX_PRIORITY：最高优先级

线程休眠

让线程在一定时间内进入休眠状态，但不会释放锁和CPU的执行权与抢夺权

public static void sleep(long millis)：参数millis是线程休眠的毫秒值

线程加入

等待该线程死亡，其它线程在该线程未消亡时，无法权夺CPU的执行权

public final void join()

线程礼让

暂定该线程执行，并让其它线程执行

public static void yield()

线程守护

当只有守护线程时，Java虚拟机就会退出

public final void setDaemon(boolean on)：标记线程为守护线程

public final boolean isDaemon()：判断线程是否是守护线程

线程终止

public final void stop()：终止线程（已过时）

public void interrupt()：清除线程的状态

线程的生命周期

线程的状态

创建

线程对象被创建

就绪

具有抢夺CPU执行权的资格，没有CPU执行权

运行

拥有CPU执行权

阻塞

没有执行权和执行资格

消亡

线程对象成为垃圾，等待被清理

线程的实现方式

继承Thread类，并重写run方法

实现Runnable接口，重写run方法

可以多个线程共享同一资源

避免单继承带来的局限性

线程安全问题

IO流

IO流的作用

用于处理设备之间的数据传输

File类

文件和目录路径名的抽象表现形式

构造方法

File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例

File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例

File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例

File(URI uri) ：通过将给定的 file: URI转换为抽象路径名来创建新的 File实例

常用方法

boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件

static File createTempFile(String prefix, String suffix) :在默认临时文件目录中创建一个空文件，使用给定的前缀和后缀生成其名称

FilenameFilter

一个过滤接口

实例

String[] fileNames = file.list(new FilenameFilter() {
@Override
public boolean accept(File arg0, String arg1) {
if (arg0.getName().endsWith(".txt")) {
return true;
}
return false;
}
});

递归

方法中调用方法本身的现象

注意事项

使用递归必须设置出口

递归的次数不能太多，会发生内存溢出

构造方法不能递归使用

实例

File[] files = file.listFiles();
for (File f : files) {
if (f.isDirectory()) {
showFile(f);
}else {
System.out.println(f.getAbsolutePath());
}

IO按种类分类

流向

输入流

将硬盘数据读取的控制台（读取数据）

输出流

将数据从控制台写的硬盘中（写数据）

数据类型

字节流

字节输入流：InputStream

字节输出流：OutputStream

字符流

字符输入流：Writer

字节输出流：Reader

装饰设计模式

缓冲流

BufferedInputStream

BufferedOutputStream

转换流

InputStreamReader

将读取的字节根据编码表转换成字符

OutputStreamWriter

将写入的字符根据编码表转换成字节

产生的条件

多线程环境

多个线程共享同一资源

多条语句在同一时间段操作共享数据

解决方法

解决思路

将同一时间段操作共享数据的多条代码封装成一个整体，在同一时间段只允许一个线程进入

解决方式1：同步代码块

synchronize（对象）{ 需要同步的代码 }

这个对象是锁对象，多个线程只能共用一个锁对象

同步代码块的锁可以是任意对象

解决方式2：同步方法

synchronize 返回值类型方法名（）{需要同步的代码}

锁是该对象本身

如果是static修饰，那么锁就是类的字节码对象

synchronize

可以保证在同一时刻只有一个线程执行某个方法或者某个代码块

前提

多个线程同时使用一个锁

Lock锁

Condition newCondition()：返回一个新的Condition绑定到Lock实例上

void lock() ：获取锁

void unlock() : 释放锁

死锁问题

两个或两个以上的线程在抢夺资源的过程中，发生相互等待的情况

线程间通信

多个不同线程同时共享同一个资源

线程组

用于管理线程对象的，线程组可以存放线程对象和线程组对象

每个线程对象都属于某个线程组，如果没有设定，那么就会归属于默认线程组main线程组

创建

public ThreadGroup(String name)

public ThreadGroup(ThreadGroup parent,String name)

设置线程的线程组

Thread Thread = newThread(线程对象，线程名称，线程组对象)

线程池

网络编程

编写运行在计算机上程序，通过网络把计算机连接起来

网络参考模型

IOS模型

TCP/IP模型

网络编程三要素

IP地址

在网络中计算机的唯一标识

组成：网络号段+主机号段

doc命令

ipconfig：查看本机IP地址

ping + ip地址：测试本机与通信计算机连接是否正常

InetAddress类：Java提供用来封装和操作IP地址的类

端口

计算机中正在运行程序的标识

有效端口号是0~65535，而0~1024是系统保留端口

通信协议

TCP(传输数据协议)

保证了两个程序之间安全通信，通常用于互联网通信，被称为TCP/IP

需要建立连接，形成数据传输通道

通过三次握手完成连接的建立

因为需要建立连接，所以传输效率有所降低

UDP(用户数据报协议)

无连接协议，提供了应用程序发送数据的数据包

将数据源和目的地封装到数据包

每个数据包限制在64k内

无需建立连接，传输数据快，但是不安全

socket网络套接字

ip地址+端口号的组合，构成了能唯一识别的标识符套接字

原理机制

通信两端都有socket

网络通信就是socket通信

数据在两个socket之间通过IO传输

UDP协议

发送数据包

创建socket对象：DatagramSocket ds = new DatagramSocket();

将数据打包：DatagramPacket dp = new DatagramPacket(buf,length,InetAddress,port)

发送数据包：ds.send(dp);

资源释放：ds.close();

接收数据包

创建socket对象：DatagramSocket ds = new DatagramSocket(port);

创建容器：DatagramPacket dp = new DatagramPacket(buf,length);

接收数据包：ds.receiver(dp);

解析数据包：

获取计算机的ip地址：public InetAddress getAddress()

获取数据缓冲区：public byte[] getData()

获取缓冲区长度：public int getLength()

获取端口号：public int getPort()

释放资源：ds.close();

TCP协议

客户端发送数据

创建客户端socket对象

Socket s = new Socket(ipString,port);

对象创建成功就说明完成连接

获取输出流，写数据

获取输出流：OutputStream os = s.getOutputStream()

写数据：os.write("hello wrold".getBytes());

释放资源

os.close();

服务器端接收数据

创建服务器端Socket对象

ServerSocket ss = new ServerSocket(int port)：创建指定端口的Socket对象

建立连接

public Socket accept()：侦听要连接到此套接字并接受它。，该方法将阻塞直到建立连接。

Socket s = ss.accept();

获取输入流，并读取数据

InputStream is = s.getInputStream();

释放资源

s.close();

设计模式

单例模式

保证类在内存只有一个对象

如何保证类在内存中只有一个对象？

构造方法私有化

在类的成员变量中提供实例对象

提供方法可以访问到实例对象

饿汉式

类加载到内存就会创建对象

懒汉式

只有在需要时才会创建对象

懒加载

线程安全问题