java基础知识思维导图思维导图模板_ProcessOn思维导图、流程图

io

并发和并行

进程和线程

概述

继承Thread类的方式实现

实现Runnable接口的方式进行实现

利用Callable和Furture接口方式实现

实现方式

多线程

Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言Java之父：詹姆斯·高斯林（James Gosling）2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可：[https://www.oracle.com](https://www.oracle.com/)

语言背景

JavaSE(Java Platform Standard Edition)：开发普通桌面和商务应用程序，是另外两类的基础

JavaEE(Java Platform Enterprise Edition)：是为开发企业环境下的应用程序提供的一套解决方案，包含Servlet、Jsp等，主要针对Web应用程序开发

JavaME(Java Platform Micro Edition)：是为开发电子消费产品和嵌入式设备提供的解决方案

版本

简单

面向对象

分布式

。。。

特性

Java程序并非是直接运行的，Java编译器将Java源程序编译成与平台无关的字节码文件(class文件)，然后由Java虚拟机（JVM）对字节码文件解释执行。所以在不同的操作系统下，只需安装不同的Java虚拟机即可实现java程序的跨平台。即 **先编译在解释**

java跨平台原理

编写代码

.java属于源文件，无法被JVM所识别执行，这一步的目的使用jdk中的翻译工具，将其翻译成jvm可以直接识别的

编译代码

将生成的.class运行在JVM虚拟机中

y运行代码

Java程序开发运行流程

* JVM（Java Virtual Machine），Java虚拟机

* JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）

* JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具

总结：我们只需安装JDK即可，它包含了java的运行环境和虚拟机。

JDK，JRE，JVM

java简介

//

单行注释

/* */

多行注释

/** * */

文档注释

注释

关键字是指被java语言赋予了特殊含义的单词。

关键字的特点：关键字的字母全部小写。常用的代码编辑器对关键字都有高亮显示，比如现在我们能看到的public、class、static等。

关键字

常量：在程序运行过程中，其值不可以发生改变的量。

字符串常量用双引号括起来的多个字符（可以包含0个、一个或多个），例如\"a\"、\"abc\"、\"中国\"等整数常量整数，例如：-10、0、88等小数常量小数，例如：-5.5、1.0、88.88等字符常量用单引号括起来的一个字符，例如：'a'、'5'、'B'、'中'等布尔常量布尔值，表示真假，只有两个值true和false 空常量一个特殊的值，空值，值为null

除空常量外，其他常量均可使用输出语句直接输出。public class Demo { public static void main(String[] args) { System.out.println(10); // 输出一个整数 System.out.println(5.5); // 输出一个小数 System.out.println('a'); // 输出一个字符 System.out.println(true); // 输出boolean值true System.out.println(\"欢迎\"); // 输出字符串 }}

分类

常量

变量：在程序运行过程中，其值可以发生改变的量。从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。

定义

**数据类型**：为空间中存储的数据加入类型限制。整数？小数？ **变量名**：自己要为空间起的名字，没有难度 **数据值**：空间中要存储的数值，没有难度

数据类型变量名 = 初始化值; // 声明变量并赋值int age = 18;System.out.println(age);

格式数据类型变量名 = 数据值；

1. 在同一对花括号中，变量名不能重复。2. 变量在使用之前，必须初始化（赋值）。3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。4. 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。

注意事项

int x= 1;

实例变量

成员变量

局部变量

范围

static int y = 2

有效范围可以跨类，甚至可以在整个应用程序

直接以类名.静态变量访问

特点

静态变量

变量

注意：不能以0开头，0除外

十进制

八进制 0123 == 十进制 83

以0开头

八进制

十六进制0x25 == 十进制 37

以0X或0x开头

十六进制

表示形式

byte

short

int

long

类型

整数

float

double

浮点

char

字符

boolean

布尔

基本数据类型

数组

对象

引用数据类型

数据类型

可以理解为名字，用来标记类名，变量名，数组名这些

标识符

即{ }

方法体

什么叫运算符或者表达式

=

赋值运算符

+ - * / %

算数运算符

比较运算符

a++

a--

自增自减运算符

逻辑运算符

位运算符

？：

三元运算符

运算符

隐式转换

强制转换

类型转换

顺序

int num = 1; if(num == 1){ }else if(num == 2){ }else{ }

if

switch (choose){ case \"1\": // 开启学生1管理系统 //StudentController studentController = new StudentController(); OtherStudentController studentController = new OtherStudentController(); studentController.start(); break; case \"2\": // 开启老师管理系统 TeacherController teacherController = new TeacherController(); teacherController.start(); break; case \"3\": System.out.println(\"3\"); System.exit(0); //break; default: System.out.println(\"输入有误，请重新输入\"); }

switch

条件语句

while

do。。。while

fori 增强for

for

循环语句

break

continue

循环控制

流程控制

语言基础

进制的介绍与书写格式

子主题

任意进制到十进制的转换

十进制到任意进制转换

进制

同一种类型数据的集合。其实数组就是一个容器。

概念

静态初始化

int[] arr = new int[3];

动态初始化

初始化

二维数组

ArrayIndexOutOfBoundsException

索引越界异常

NullPointerException

空指针异常

常见异常

for增强

Collection<String> c = new ArrayList<>(); c.add(\"a\"); c.add(\"b\"); c.add(\"c\

Iterator（迭代器）

数组遍历

**面向过程：**是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的

**面向对象：**是一种以对象为中心的编程思想，通过指挥对象实现具体的功能

思想

对现实时间中某一种具体事物的抽象描述（特征和行为）

* 对象：是能够看得到摸的着的真实存在的实体

**类是对象的抽象（模板），而对象是类的具体实例**

关系

类和对象

属性

方法

组成

类

对现实世界中某一种类型的多种事物的抽象描述

- 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类- 抽象类不能实例化- 抽象类可以有构造方法- 抽象类的子类要么重写抽象类中的所有抽象方法要么是抽象类

抽象类(abstract)

权限修饰符

* 方法名与类名相同，大小写也要一致* 没有返回值类型，连void都没有* 没有具体的返回值（不能由retrun带回结果数据）

格式

* 创建对象的时候调用，每创建一次对象，就会执行一次构造方法* 不能手动调用构造方法

执行

用于给对象的数据（属性）进行初始化

作用

如果没有定义构造方法，系统将给出一个默认的无参数构造方法如果定义了构造方法，系统将不再提供默认的构造方法

构造方法

区分局部变量和成员变量的重名问题

调用重载构造方法

特指对象本身

this

用于完成特定的功能

封装

super

继承

同一个对象，在不同时刻表现出来的不同形态

什么是多态

- 要有继承或实现关系- 要有方法的重写- 要有父类引用指向子类对象

多态的前提

编译看父类，运行看父类

编译看父类，运行看子类

成员方法

访问特点

提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

好处

不能使用子类的特有成员

弊端

向上转型

向下转型

转型

：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

instanceof

多态

面向对象三大特征

方法重写（又称方法覆盖）

方法重载：如果同一个类中包含了两个及两个以上方法名相同，方法参数的个数、顺序或者类型不同的方法，则称为方法的重载。简单的说就是：方法重载就是方法名称重复，加载参数不同。

1. 同一个类中，方法名称一致2. 方法参数的个数、类型或者顺序不一致；3. 与返回值、访问修饰符无关。

判断

重载

是我们判断是否使用静态关键字的条件

+ 被类的所有对象共享

对象需要类被加载后，才能创建

+ 在类加载时被执行，只执行一次，优先于对象存在

也可以通过对象名调用

+ 可以通过类名调用

+ 静态方法只能访问静态的成员+ 非静态方法可以访问静态的成员，也可以访问非静态的成员+ 静态方法中是没有this关键字

static关键字

final代表最终的意思，可以修饰成员方法，成员变量，类

final修饰类、方法、变量的效果

final

+ 位置: 方法中定义

+ 作用: 限定变量的生命周期，及早释放，提高内存利用率

局部代码块

+ 位置: 类中方法外定义

+ 特点: 每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行

+ 作用: 将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性

构造代码块

+ 特点: 需要通过static关键字修饰，随着类的加载而加载，并且只执行一次

+ 作用: 在类加载的时候做一些数据初始化的操作

静态代码块

代码块 {}

1. 用来定义规范

2. 用来做功能的拓展

两个意义

- 接口不能实例化我们可以创建接口的实现类对象使用- 接口的子类要么重写接口中的所有抽象方法要么子类也是抽象类

public class 类名 implements 接口名 {}

类实现接口用implements表示

public static final int NUM = 10;

只能是常量默认修饰符：public static final

没有，因为接口主要是扩展功能的，而没有具体存在

public abstract void show();

只能是抽象方法默认修饰符：public abstract

接口的成员特点

继承关系，只能单继承，但是可以多层继承

类与类的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

类与接口的关系

继承关系，可以单继承，也可以多继承

接口与接口的关系

类和接口的关系

public static final

public abstract

抽象方法

- 默认方法(Java 8)

- 静态方法(Java 8)

- 私有方法(Java 9)

接口组成更新概述

public default void show3() { }

public default 返回值类型方法名(参数列表) { }

解决接口升级的问题

- 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字- public可以省略，default不能省略- 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

默认方法(default)

public static void show() {}

public static 返回值类型方法名(参数列表) { }

- 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用- public可以省略，static不能省略

静态方法(static)

接口(interface)

class Outer { public class Inner { }}

在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

- 内部类可以直接访问外部类的成员，包括私有- 外部类要访问内部类的成员，必须创建对象

内部类的访问特点

内部类概念

class Outer { private int num = 10; private class Inner { public void show() { System.out.println(num); } } public void method() { Inner i = new Inner(); i.show(); }}public class InnerDemo { public static void main(String[] args) { //Outer.Inner oi = new Outer().new Inner(); //oi.show(); Outer o = new Outer(); o.method(); }}

成员内部类

class Outer { private int num = 10; public void method() { int num2 = 20; class Inner { public void show() { System.out.println(num); System.out.println(num2); } } Inner i = new Inner(); i.show(); }}public class OuterDemo { public static void main(String[] args) { Outer o = new Outer(); o.method(); }}

局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用

局部内部类

存在一个类或者接口，这里的类可以是具体类也可以是抽象类

前提

new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }Inter i = new Inter(){ @Override public void method(){ }}

interface Inter{ void method();}class Test{ public static void main(String[] args){ new Inter(){ @Override public void method(){ System.out.println(\"我是匿名内部类\"); } }.method(); // 直接调用方法 }}

调用方式

匿名内部类

class Outer { static class Inner { public void show(){ System.out.println(\"inner..show\"); } public static void method(){ System.out.println(\"inner..method\"); } }}public class Test3Innerclass { /* 静态成员内部类演示 */ public static void main(String[] args) { // 外部类名.内部类名对象名 = new 外部类名.内部类名(); Outer.Inner oi = new Outer.Inner(); oi.show(); Outer.Inner.method(); }}

静态内部类

内部类

- 有一个接口

- 接口中有且仅有一个抽象方法

- 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类

- Lambda表达式：只能是接口

所需类型不同

- 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类

- 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

span style=\

- 匿名内部类：编译之后，产生一个单独的.class字节码文件

- Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

实现原理不同

Lambda表达式和匿名内部类的区别

Lambda表达式

String

Stringbuilder

字符串

Math

exit

currentTimeMillis

System

返回地址值，建议所有子类重写

Object类的toString方法

比较对象是否相等，默认比较地址，重写比较内容

Object类的equals方法

Object

toString（对象）

toString（对象，默认字符串）

isNull

nonNull

Objects

add

subtract

multiply

常规

精确运算

divide

BigDecimal

toString

sort

binarySearch

Arrays

基本类型-》包装类转换成对象，以便更好操作数据

1，在使用包装类型的时候，如果做操作，最好先判断是否为null

2，推荐只要是对象，在使用前必须进行不为null的判断

注意

Byte

Short

自动装箱和自动拆箱

parseInt

类型装换 String 《=》 Int

Integer

Long

Float

Double

Character

Boolean

基本类型包装类

public Date()分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒

public Date(long date)分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

System.currentTimeMillis

=>

public long getTime()获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值

public void setTime(long time)设置时间，给的是毫秒值

Date类

格式化（从Date到String）将日期格式化成日期/时间字符串

解析（从String到Date）从给定的字符串开始解析文本以生成对象计算时间可用

//SimpleDateFormat sdf = new SimpleDateFormat(\"yyyy年MM月dd日 HH:mm:ss\"); // 2021年07月19日 14:37:26

常用格式

SimpleDateFormat

时间日期类

LocalDate 表示日期（年月日）

LocalTime 表示时间（时分秒）

public static LocalDateTime now()获取当前系统时间

获取时间对象

public int getYear()获取年

public int getMonthValue()获取月份（1-12）

public int getDayOfMonth()获取月份中的第几天（1-31）

public int getDayOfYear()获取一年中的第几天（1-366）

public DayOfWeek getDayOfWeek()获取星期

public int getMinute()获取分钟

public int getHour()获取小时

获取时间中的每个值

public LocalDate toLocalDate () 转换成为一个LocalDate对象

public LocalTime toLocalTime () 转换成为一个LocalTime对象

转换方法

public String format (指定格式)把一个LocalDateTime格式化成为一个字符串

public static DateTimeFormatter ofPattern(String pattern)使用指定的日期模板获取一个日期格式化器DateTimeFormatter对象

格式化与解析

public LocalDateTime plusYears (long years)添加或者减去年

public LocalDateTime plusMonths(long months)添加或者减去月

public LocalDateTime plusDays(long days)添加或者减去日

public LocalDateTime plusHours(long hours)添加或者减去时

public LocalDateTime plusMinutes(long minutes)添加或者减去分

public LocalDateTime plusSeconds(long seconds)添加或者减去秒

public LocalDateTime plusWeeks(long weeks)添加或者减去周

plus系列

前缀不一样，效果和plus相反

minus系列

前缀不一样，写法同上

with系列

增减时间

LocalDateTime 表示时间+ 日期（年月日时分秒）

public int getYears()获得这段时间的年数

public int getMonths()获得此期间的总月数

public int getDays()获得此期间的天数

public long toTotalMonths()获取此期间的总月数

Period 获取年月日

public long toSeconds()获得此时间间隔的秒

public int toMillis()获得此时间间隔的毫秒

public int toNanos()获得此时间间隔的纳秒

Duration 获取时分秒

时间间隔对象

JDK8时间日期类

常用api类

异常体系

public String getMessage()返回此 throwable 的详细消息字符串

public String toString()返回此可抛出的简短描述

public void printStackTrace()把异常的错误信息输出在控制台

Throwable成员方法

public static void main(String[] args) throws ParseException{

throw new NullPointerException(); //当参数为null的时候

throw throws

抛出

try。。catch

捕获

异常处理方式

public class AgeOutOfBoundsException extends RuntimeException { public AgeOutOfBoundsException() { } public AgeOutOfBoundsException(String message) { super(message); }}

1. 定义异常类2. 写继承关系3. 提供空参构造4. 提供带参构造

try { int age = Integer.parseInt(ageStr); s.setAge(age); break; } catch (NumberFormatException e) { System.out.println(\"请输入一个整数\"); continue; } catch (AgeOutOfBoundsException e) { System.out.println(e.toString()); System.out.println(\"请输入一个符合范围的年龄\"); continue; }