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

( ) [ ] .

！ +(正） -(负） ~(按位取反) ++ --

* / %

+(加） -(减)

<<(左移) >>(右移) >>>(无符号右移)

<(小于) <=(小于等于) >(大于) >=(大于等于) instanceof(是否属于某个类)

== !=

& ^ | && || ? :

= += -= *= /= %= &= |= ^= <<= >>= >>>=

运算符优先级(大到小)

运算符运用

执行语句内 : 若有 break 或 continue ：13; ① break ：不执行 break 之后的语句并结束循环直接跳出循环13; ② continue ：跳过本次循环直接到下次循环判断

① while( ){...} 先判断再循环13;② do...while 至少循环一次，先循环再判断

① while ( 判断表达式 ){13; 执行语句； 13; } 13;② do{ 13; 执行语句；13; }while ( 判断表达式);

特殊使用方法： ① ( ; ; ) 无限循环 == while(true){ 执行语句 }13; ② (单次表达式 ; 条件表达式 ; ) { 执行语句 }13; 末尾循环体在{} 内来定义，如：二分查找的书写13; ③ 执行语句内放 break 或 continue ：13; break ：不执行 break 之后的语句并结束循环直接跳出循环13; continue ：跳过本次循环直接到下次循环判断

foreach：①增强for循环，仅限于部分集合和数组使用；数组底层还是 for 循环，集合底层是 iterator 迭代器；13; ②自己写的类想用 foreach 需要实现Iterable接口；

for ：循环中有下标概念；集合遍历要求下标更改元素使用或使用下标来进行操作时使用

① for 循环：for(单次表达式 ; 条件表达式 ; 末尾循环体){13; 执行语句;13; } 13;13;② foreach : for( 数据类型变量名 : 遍历的目标) {13; 执行语句;13; }

循环结构

判断表达式：结果只能是 true / false

执行语句：表达式成立即执行的语句，若语句中有 break; 会终止执行 break 后面的语句

①13; if(判断表达式){13; 执行语句13; }13; ②13; if (判断表达式){13; 执行语句113; }else {13; 执行语句213; }13; ③13; if(判断表达式1){13; 执行语句113; }else if(判断表达式2){13; 执行语句213; }else{13; 执行语句313; }

表达式类型：char byte int short 枚举 String13; (JDK1.5之后能放枚举 1.7之后能放String)

①case 常量表达式：语句；break；-->不会发生贯穿现象 13;②case 常量表达式：语句；-->会发生贯穿现象

①default 可作为最后 case 都无法进入时进入且执行的语句；13;②default 省略不写时：默认带一个 default : break;

switch (表达式)13;{13; case 常量表达式1：语句113; case 常量表达式2：语句213; ┇13; case 常量表达式n：语句n13; default: 语句n+113;}

判断结构

①break 结束循环或结束后续代码

②continue 跳过在此代码之后的代码，直接进入下一次循环判断

③default 用于 switch 判断；表明在所有case之后都不满足情况下运行的代码语句

③return 在返回值是void的方法中代表结束该方法，在返回值为 T 方法中代表返回 T 类型的值并结束该方法

break continue default return

关键字

循环结构和判断语句

基本数据类型：byte short int long float double boolean

引用数据类型：String、Integer、Double 等

自己写的类类型： Employee 等

数组可以声明的类型

分支主题

写法： ① 类型[ ] 数组名 = {值1，值2，值3，值4};②类型[ ] 数组名 = new 类型[【长度】];

一维数组、二维数组声明

反转

遍历输出

二分查找：

顺序查找 :

查找：二分（有序）、顺序查找

冒泡排序

顺序排序

排序：冒泡、顺序

自己写的部分方法

数组

只能有一个 public 修饰的类

final 修饰的类叫最终类：无法被继承且无法被重写13;如：String 类

修饰符仅能是：缺省或 final 或 public 且可一块使用

声明：【修饰符】class 类名{13; 【成员】13; }

声明方式：类内，方法外；13; 在类加载阶段时赋默认值或赋予的值13;特点：有初始化默认值

视图1 ：单一修饰符的使用

可以被权限修饰符 private 、缺省、 protected 、public

静态修饰符：static 无法重写，可以被继承，用类名.静态方法调用

最终修饰符：final 无法重写，可以被继承，用对象名.最终方法调用

视图2 ：多修饰符的使用

特点：可权限修饰符和其他修饰符共同使用

可用的修饰符：

本类内：其他成员直接调用任何修饰符修饰的成员变量

权限修饰符允许范围内其他类内调用时：13; ① 静态属性：类名 . 静态属性13; ② 非静态属性 : 对象 . 属性

静态方法和非静态方法

抽象方法：子类重写父类的方法，当子类对象调用；

最终方法：对象名.最终方法调用

调用方式：

成员变量 / 属性 / 实例变量

类型：① 非静态方法13; ② 静态方法 static 修饰的方法13; ③ 最终方法 final 修饰的方法13; ④ 抽象方法 abstract 修饰的方法13; ⑤ 本地方法 native 修饰的方法，底层在 C 内，不在 java 层面

权限修饰符：public \\ 缺省 \\ protected \\ private

其他修饰符 : ① static（静态方法）13; ② final（最终方法）13; ③ abstract（抽象方法）13; ④ native （本地方法）13;（可有可没有，看具体程序要求）

返回值类型： ①基本数据类型：byte short int long float double char boolean13; ②空类型：void13; ③引用数据类型：String 数组类类型 13;

形参列表：调用方法时传入的值类型，可以是任意类型；13;（可有可没有，看具体程序要求）

return ：①空类型 void ：在其中使用结束本方法，后续代码不执行13; ②其他类型：返回该类型的返回值并结束本方法；后续代码不执行

声明方式：权限修饰符【其他修饰符】返回值类型方法名 (【形参列表】) {13; 执行语句；13; 【return ：(返回值) ;】13; }

视图1 ：同类内调用其他方法和属性

非静态方法

视图2 ：同类内静态方法调用同类的方法和属性

静态方法

本类内：非静态方法：可以直接互相调用(包括本类内的静态方法) / 属性( 静态属性）13; 静态方法：调用静态属性或静态方法时：直接调用即可； 13; 调用非静态属性或方法时：对象 . 非静态属性 / 对象 . 非静态方法13; 抽象方法：需要被继承，让子类来实现抽象方法；13; 本地方法；13;

视图1 ：非本类内调用其他类的方法

其他类内调用非本类的方法在权限修饰符允许范围内：13; ① 静态方法：类名.静态方法13; ② 非静态方法：对象 . 方法13; ③ 抽象方法：

无法在子类的静态方法中使用，静态方法属于类，super和this 属于对象；

this()

super()

关键字引用

成员方法

public : 任意包的类都可以 new 对象时调用

private ：又称：私有构造器，在枚举 enum 未引入之前来声明常量对象，外部类无法调用构造器，也就无法造对象，导致只能使用类内造好的对象；

缺省、 protected

权限修饰符 :

构造方法名：必须和类名保持一致

形参列表：外部造对象时传入的参数，可以在执行语句进行操作赋值等

执行语句：正常使用

声明方式：权限修饰符构造方法名(【形参列表】) {13; 执行语句;13; }

构造器首行默认有： super()；如果声明出来调用时，可以改成 this()；也必须在首行

可以省略不写，类内自带一个无参构造器；若是声明了一个有参构造器，那么自带的无参构造就会消失，一般会同时声明有参构造和无参构造

在父子类中：造对象时：先调用父类的构造器，再调用自己的构造器；

特点：

在 new 对象时调用，造一个对象会调用一次

调用：

构造器

声明： static { 执行语句 }13; 类加载阶段调用，执行代码块内部语句；13; 优先级高于其他成员13; 优先级高于非静态的属性和非静态代码块。13; 与静态属性优先级一样，谁在上面谁先执行

使用：类加载阶段时加载，造对象时调用，仅调用一次

静态代码块

声明：{ 执行语句 }13; 类加载阶段调用，执行代码块内部语句。13; 优先级高于其他成员；13; 与非静态属性优先级一样，谁再上面谁先执行

使用：类加载阶段加载，造对象时调用，造一次对象调用一次

非静态代码块

视图2 ：代码块的调用结果

视图1 ：代码块

代码块

其他修饰符：public 、缺省、protected 、private 、abstract 、final

类的成员：声明所有成员包括非静态成员和静态成员都可以

静态内部类可以继承父类以及父接口

声明：【权限权限修饰符】class 外部类名 {13; 【其他修饰符】static class 内部类名{13; 【类的成员(静态和非静态的成员都有)】13; }13; }

①静态内部类：直接使用外部类的静态成员13;②非静态成员：外部类名对象名 = new 外部类名( )；13; 对象名 . 成员；

内部类调用外部类成员：13;（包括私有化成员）

①内部类静态成员：内部类名 . 内部类成员13;②内部类非静态成员：内部类名对象名 = new 内部类名( )；13; 对象名 . 内部类成员

外部类调用静态内部类成员：13;(包括私有的成员)

外部类的外面调用内部类成员：外部类名 . 内部类名对象名 = new 外部类名 . 内部类名( );13; 对象名 . 内部类非静态成员13;（内部类权限修饰符允许范围之内且只能调用非私有化成员）

静态内部类

其他修饰符： public 、 protected 、缺省、 private 、 final 、 abstract

内部类的成员：仅限于声明非静态成员

可以继承父类的接口和抽象类

声明：【权限修饰符】class 外部类名 {13; 【其他修饰符】 class 内部类名 {13; 【成员（仅限于非静态成员）】13; }13; }

①非静态内部类：直接使用外部类的非静态成员；13;②外部类静态成员：外部类名对象名 = new 外面类名( );13; 对象名 . 外部类静态成员

内部类的调用外部类成员：13;(包括私有的成员)

内部类名对象名 = new 内部类名( )；13;对象名 . 内部类成员

外部类调用内部类成员13;（内部类仅有非私有化成员）

①外部类名对象名1 = new 外部类名( );13;对象名1 . 内部类名对象名2 = 对象名1.new 内部类名( );13;对象名2 . 内部类成员

②外部类声明一个方法，方法内创造内部类对象；13; 外部类的外面通过造外部类对象时，调用外部类的方法13; 接收返回的内部类对象13; 内部类对象名 . 内部类成员

外部类的外面调用内部类成员

非静态内部类

成员内部类13;（外部类内，外部类的方法外）

内部类修饰符：final 、abstract

声明方式：【外部类权限修饰符】 class 外部类名 { 13; 【方法权限修饰符】【方法其他修饰符】返回值类型方法名（【形参列表】）{ 13; 【方法的其他代码】13; 【其他修饰符】class 内部类名{13; 【非静态成员】13; }13; }13; }

①当方法修饰符是由 static 修饰时：可以使用外部类的所有的成员13;②当方法修饰符不是 static 修饰时：只能使用外部类的非静态成员13;13; （包括私有的成员）

局部内部类使用外部类成员

外部类仅能在使用局部内部类的方法内且在声明局部内部类后使用局部内部类的成员；13;（外部类非声明局部内部类的方法或外部类的外面都无法使用局部内部类的所有成员）

外部类使用局部内部类成员

局部内部类

声明方式：

匿名内部类

局部内部类13;（外部类的方法内）

内部类

成员：成员变量、成员方法、构造器、代码块、内部类

意义：使得代码更加安全；提高复用性，降低耦合度

形式：利用权限修饰符和其他修饰符来修饰属性

封装的内容：属性，方法...

视图1：封装属性

封装

意义：提高代码复用性，降低耦合度，继承父类的非静态方法和属性的同时，还可以扩展自己独有的方法或重写父类的方法

形式：class A {13; }13;13; class B extends A {//B类继承A类13; }

特点：① 子类继承父类所有的方法和属性；13; ② 子类可以直接调用父类的非私有化属性，和所有的方法13; ③ 子类可以重写父类的非静态方法；13; ④ 外部类可以通过子类对象调用父类的属性和方法

继承

意义：提高代码复用性；实现代码的动态绑定，使得代码更加灵活

试图1：形式①的实例

形式①：子类对象继承父类时，子类重写父类的方法：在外部类中，父类变量引用子类对象；使得运行时是子类，编译时是父类；实现动态绑定，在运行程序之前无法知道运行结果 --->又称为虚方法

形式②：向上转型（强制转换，有一定的风险）

常用于抽象类中，子类必须重写父类的所有方法；

多态

特征：封装、继承、多态、（抽象性）

public ：都可以调用，权限最大，不安全；常用于方法

protected：① 限于本包以及非本包的子类直接调用

缺省：① 所有成员都可以修饰 13; ② 仅限于本包内直接使用；

private ：① 除代码块以外所有成员都可以修饰：常用于属性和类内的独特方法13; ② 仅限于本类内直接访问，其他地方需要造对象来访问

权限修饰符：

static : 后续有详细说明

final：修饰类、属性、方法；13; 修饰：属性方法：可以被继承无法被重写13; 修饰类：无法被继承，称为最终类；

native：修饰的方法底层不在java内，在C语言中，无法看到源码；

其他修饰符：

常见修饰符

声明：在方法的( )声明内

数据类型可以是任意类型

书写格式：数据类型... 变量名

形式：public void method(数据类型... a){13; 方法体;13; }

特点：① JDK1.5引入：可以传入0~n 个参数（传入的是值），用来代替数组类型（传入的是一个数组）13; ② 需要放到形参列表最后面，否则无法区分传入参数的分配问题13; ③ 有下标的概念，可以通过for循环遍历；

可变参数

形式：用于方法的形参传递

传递机制：① 基本数据类型传递的是值；方法内更改值或任何操作与实参无关；13; ② 引用数据类型传递的地址值；方法内更改值，实参也会改变；13; 直到引用数据类型指向新对象后；

参数的传递

在类中：① 方法名一致，形参列表不同；与其他的无关（返回值类型，方法体，形参列表名等）13; ② 在一个类中可以有多个重写的方法13; ③ 重写注意：当形参列表是一个数组时和可变参数概念一样；都是放入多个参数（只不过可变参数更灵活）

视图1：重载部分书写

方法的重载

方法A内调用方法A，称为递归调用；

视图1：递归调用演示

递归调用

特点：只有一个对象；构造器私有化

视图1：enum类创造单例

视图2：class类创造单例

视图3：class类创造单例

饿汉式

视图4：饱汉式单例

视图5：饱汉式单例

饱汉式

单例模式

面向对象成员补充

使用：可以用在所有的成员上；

Static 静态

修饰类的修饰符除了： static 、final 两个不能和 abstract 结合，其余都可以修饰

abstract 修饰的方法叫抽象方法需要子类重写13; 没有方法体

声明：【修饰符】abstract class 类名 { 13; 【abstract 返回值类型方法名() ;】13; 【成员】13; }

特点：① 抽象类可以声明所有的成员13; ② abstract修饰的类外部无法直接new抽象类的对象13; ③ 子类继承抽象类必须重写全部的抽象方法，除非子类也是抽象类13; ④ 抽象对象名造子类对象时：体现多态性；13; 子类自己造子类对象时：把继承来重写的抽象方法当成自己的方法13; ⑤ 当类是抽象类且没有抽象方法时：不想外部来造自己的对象，而是造子类对象来调用自己的成员13; 里面的成员、方法都是静态的，外部不需要new对象来调用，直接类名.成员来调用即可

abstract 抽象类

声明：【修饰符】interface 类名{13; 【成员】13; }

视图：③的实例

视图：④继承其他接口

⑤：当实现类继承了一个类同时实现了一个接口时，且类和接口方法名一致时，调用方法就会冲突，需要重写方法（谁都不听，全部重写）或选择其中一个方法作为调用本类方法的方法（听父类：super().方法）;(听接口：接口名.方法)

特点：① 突破单继承，实现多接口模式；13; ② 接口无法直接创建对象，需要子类实现接口并重写所有的抽象方法13; ③ 接口成员：抽象方法(abstract)，静态方法(static)，默认方法(default)，私有方法(private)13; ④ 接口可以有继承其他的类和其他的接口(extends)；13; ⑤ 接口的冲突：当接口的方法和实现类的方法或实现类父类方法冲突