Java从入门到精通思维导图模板_ProcessOn思维导图、流程图

初识 Java

Java 简介

什么是 Java 语言

Java 是一种通过解释方式来执行的语言，其语法规则和c++类似。同时，Java也是一种跨平台的程序设计语言，用Java语言编写的程序，可以运行在任何平台和设备上。 Java语言程序代码的编译和运行过程

Java 的应用领域

Java 的版本

怎样学好 Java

Java API 文档

Java 语言的特性

简单

面向对象

分布性

可移植性

解释性

安全性

健壮性

多线程

高性能

动态

搭建 Java 环境

JDK 下载

下载 JDK11

在 Windows 10 系统下搭建 JDK 环境

熟悉 Eclipse 开发工具

熟悉 Eclipse

Eclipse 简介

Eclipse 由 IBM 公司投资 4000 万美元开发而成，它基于 Java 语言编写，是目前最流行的 Java 集成开发工具之一。

Eclipse 工作台

工作台

菜单栏

工具栏

主工具栏

视图工具栏

“控制台”视图

使用 Eclipse

创建Java项目

创建Java类文件

使用编译器编写程序代码

运行Java程序

Java 语言基础

Java 主类结构

包声明

一个 Java 应用程序是由若干个类组成的

声明成员变量和局部变量

通常将类的属性称为全局变量，将方法中的属性称为局部变量。

编写主方法

main() 方法是类体中的主方法

导入 API 类库

在 Java 语言中可以通过 import 关键字导入相关的类

基本数据类型

数值型

整数类型

byte，short，int，long

浮点类型

float，double

字符类型

char

布尔类型

Boolean

常量与变量

标识符

是用来标识类名,变量名,方法名,数组名,文件名的有效字符序列

1.任意顺序的字母,下画线,美元符号和数字组成

2.第一个字符不能是数字

3.不能是Java的关键

关键字

声明变量

声明变量就是要告诉编译器（compiler）这个变量的数据类型，这样编译器才知道需要配置多少空间给它，以及它能存放什么样的数据。

声明常量

在程序运行过程中一直不会改变的量被称为常量（constant），通常也被称为“final 变量”。常量在整个程序中只能被赋值一次。

变量的有效范围

成员变量

在类体中所声明的变量被称为成员变量，成员变量在整个类中都有效

局部变量

在类的方法体中声明的变量（方法内部定义，“{”与“}”之间的代码中声明的变量）称为局部变量。局部变量只能在当前代码块中有效。

如图

运算符

赋值运算符

赋值运算符以符号“=”表示，它是一个二元运算符，其功能就是将右方操作所包含的值赋给左方的操作数。

算数运算符

主要有+（加）、-（减）、*（乘）、/（除）、%（求余），它们都是二元运算符。

自增自减运算符

符号在前先算后用（++a（加一）），在后先用后算a++

比较运算符

>(大于)、<(小于)、==(是否相等)、>=(大于等于)、<=(小于等于)、!=(不等于)。

逻辑运算符

&& 与两者都为真结果才为真

|| 或只要有一真结果就为真

! 非非真即假非假即真

位运算符

1.按位与: 两个整形数据a,b对位都是1,结果位才是1,否则为0
2.按位或: 如果两个操作数对应位都是0,则结果才是0,否则为1
3.按位取反: 0变1,1变0
4.按位异或: 相同为0,不同为1
5.位移操作:
左移 <<: 整体左移,空补0,溢出去掉
右移 >>: 整体右移,正补0,负补1
无符号右移 >>>: 整体右移,空补0,溢出去掉

三元运算符

条件式 ? 值1 : 值2
条件真返回值1,条件假返回值2

运算符优先级

优先级由高到低的顺序依次是:
增量和减量运算
算数运算
比较运算
逻辑运算
赋值运算

数据类型转换

隐式类型转换

隐式类型转换((自动)不会丢失数据)

显式类型转换

显式类型转换((强制)有可能会丢失数据)

代码注释与编码规范

代码注释

单行注释：//

多行注释：/* */

文档注释：/** */

编码规范

流程控制

复合语句

由“{”开始，“}”结束

条件语句

if 条件语句

if条件语句是一个重要的编程语句,用于告诉程序在某个条件成立的情况下执行某段语句,而在另一钟情况下执行另外的语句.

if...else语句是条件语句中最常用的一种形式,它会针对某种条件有有选择的做出处理.

if...else if：用于处理多种情况,通常表现为"如果满足某种条件,就进行某种处理,否则如果满足另一种条件则执行另一种处理."

switch 多分支语句

switch语句中表达式的值必须是整形,字符型,字符串类型或枚举类型,常量值1~n的数据类型必须与表达式的值的类型相同

循环语句

while 循环语句

while 语句也称条件判断语句,它的循环方式为利用一个条件来控制是否要继续反复执行这个语句.

do...while 循环语句

do...while循环语句与while循环语句类似,do...while循环为先执行一次循环后在判断是否成立.

for 循环语句

for循环语句可以用来重复执行某条语句,直到某个条件得到满足.

循环控制

break 语句

break语句跳出当前循环.

continue 语句

continue不是立即跳出本次循环,而是跳过本次循环,回到循环的条件测试部分,重新开始执行循环.

数组

数组概述

数组是具有相同数据类型的一组数据的集合

一维数组

创建一维数组

1.先声明，再用new关键字进行内存分配，声明有一下两种方式
数组元素类型数组名字[ ];
数组元素类型[ ] 数组名字；
声明一维数组，代码如下：int arr[ ];
为数组分配内存，代码如下：arr = new int[5];
2.声明的同时为数组分配内存：
int month[] = new int[12]

初始化一维数组

int arr[] = new int[]{1,2,3,4,5,25};
int arr2[] = {34,23,12,6}

使用一维数组

public class 例p74 {
public static void main(String[] args) {
  int day[] = new int[] {31,28,31,30,31,30,31,31,30,31,30,31};
  for(int i = 0;i < day.length;i++) {
   System.out.println((i + 1) + "月有" + day[i] + "天");
  }
}
}

二维数组

创建二维数组

1.先声明，再用new关键字进行内存分配
声明：数组元素的类型数组名字[ ][ ];
数组元素的类型[ ][ ] 数组名字；
声明数组
int a[ ][ ];
分配空间：
a = new int[2][4]
声明的同时进行分配：
int a = new int[2][4]

初始化二维数组

type arrayname[][] = {value1,value2...valuen};
代码如下: int myarr[][] = {{12,0},{45,10}};
还可以直接给指定赋值如： a[1][1] = 20;

使用二维数组

public class 例p77 {
public static void main(String[] args) {
  int a[][] = new int[3][4];
  for(int i =0;i < a.length;i++) {
   for(int j = 0;j < a[i].length;j++) {
    System.out.print(a[i][j]);
   }
   System.out.println("");
  }
}
}

数组的基本操作

遍历数组

public class 例p78上 {
public static void main(String[] args) {
  // TODO Auto-generated method stub
  int b[][] = new int[][]{{1},{2,3},{4,5,6}};
  for(int k = 0;k < b.length;k++) {
   for(int c = 0;c < b[k].length;c++) {
    System.out.print(b[k][c]);
   }
   System.out.println();
  }
}
}

填充替换数组元素

子主题

对数组进行排序

import java.util.Arrays;
public class 例p80下 {
public static void main(String[] args) {
  // TODO Auto-generated method stub
  int arr[] = new int[] {23,42,12,8};
  Arrays.sort(arr);
  for(int i = 0;i < arr.length;i++) {
   System.out.println(arr[i]);
  }
}
}

复制数组

1.copyOf方法
语法如下：
copyOf(arr,int newiength)
如果新数组的长度大于数组arr的长度，则用0填充，溢出去掉。

查询数组

import java.util.Arrays;
public class 例p83 {
public static void main(String[] args) {
  // TODO Auto-generated method stub
  int ia[] = new int[] {1,8,9,4,5};
  Arrays.sort(ia);
  int index = Arrays.binarySearch(ia,4);
  System.out.println("4的索引位置是：" + index);
}
}

类和对象

面向对象概述

对象

通常都会将对象划分为两个部分，即静态部分与动态部分

类

类是同一类事物的统称
类是构造对象时所依赖的的规范，对象就是符合某个类的定义所产生出来的实例
类是封装对象的属性和行为的载体，反过来说，具有相同属性和行为的一类实体被称为类

封装

封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装思想。

继承

多态

其实将对象应用于子类的特征就是多态。

类

成员变量

对象的属性也称为成员变量

成员方法

使用成员方法对应于类对象的行为

权限修饰符

Java中的权限修饰符主要包括private、public和protected,这些修饰符控制着对类和类的成员变量以及成员方法的访问。

局部变量

如果在成员方法内定义一个变量，那么这个变量被称为局部变量。
局部变量是在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误。

this 关键字

this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键字只能在本类中使用。

类的构造方法

构造方法的特点如下：
        构造方法没有返回值。
        构造方法的名称要与本类的名称相同。
构造方法的定义如下：
public Book(){
    ...            //方法体
}
        public: 构造方法修饰符
        Book：构造方法的名称

静态变量和静态方法

由 static 修饰的变量和方法被称为静态变量和静态方法。但静态成员同样遵循着 public、private、和 protected 修饰符的约束。

类的主方法

主方法是类的入口点，它定义了程序从何处开始。主方法提供对程序流向的控制，Java 编译器通过主方法来执行程序。主方法的语法如下：
public static void main(String[] args){
... //主方法
}

对象

对象的创建

在 Java 语言中，通过new操作符来创建对象。准确的说，在 Java 语言中使用 new 操作符调用构造方法创建对象。语法如下：
Test test = new Test();
Test test = new Test("a");

访问对象的属性和行为

package six;
public class Dog {
//成员变量
  String gender;//性别
  String name;//名字
  String color;//颜色
  String call;//叫声
  //构造函数无参
  public Dog (String gender,String name,String color) {
   this.gender = gender;
   this.name = name;
   this.color = color;
  }
  public Dog(String gender,String name,String color,String call) {
   this.gender = gender;
   this.name = name;
   this.color = color;
   this.call = call;
  }
}

对象的引用

对象名的引用
People tom;
通常一个引用不一定需要有一个对象相关联。引用与对象相关联的语法如下：
People tom = new People();

继承、多态、抽象类与接口

类的继承

在 Java 语言中，一个类继承另一个类需要使用关键字 extends，关键字extends的使用方法如下:
class Child extends Parent{}
应为 Java 中只支持单继承，即一个类只能有一个父类，所以类是下面的代码是错误的：
class Chile entends Parent1,Panent2{}

Object 类

在 Object 类中，主要包括 clone() 、finslize()、equals()、toString()等方法。

对象类型的转换

向上转型

向上转型
子类对象赋值给父类引用
Animal a = new Dog();
自动类型转换

向下转型

向下转型
父类对象赋值给子类引用
Dog a = (Dog)new Animal ();
强制类型转换

使用 instanceof 关键字判断对象类型

instanceof
对象名instanceof类名
判断对象是否属于该类或子类

方法的重载

重载
方法名不同参数不同

final 关键字

final 变量

Final修饰变量———不可改变的量（常量）
final double PI = 3.14

final 方法

public final void test(){
...//省略一些程序代码
}

final 类

final 类名{}

多态

假如现在要编写一个绘制图形的方法 draw() ，如果传入正方形对象就绘制正方形，如果传入图形对象就绘制图形，这种场景可以使用重载来实现，定义如下：
public void draw (Square s){ //绘制正方形的方法
}
Public void draw (Circular){ //绘制圆形的方法
}

抽象类与接口

抽象类

抽象方法
修饰符 abstract 返回参数方法名（传入参数）。
抽象类有抽象方法的类一定是抽象类
修饰符 abstract class 类目{
}
使用 abatract 关键字定义的类称为抽象类，而使用这个关键字定义的方法为抽象方法。抽象方法没有方法体。定义抽象的语法如下：
public abstract class Parent{
abstract void testAbstract(); //定义抽象方法
}
反过来讲，如果声明一个抽象方法，就必须将承载这个抽象方法的类定义为抽象类。

接口

接口所有方法都是抽象方法
修饰符 interface接口名{
}
实现 implements
Java语言每一个类可以实现多个接口
修饰符class类名implements接口1，接口2，…{
}

包和内部类

Java 类包

类名冲突

在程序中定义一个Login类，因业务需要，还要定义一个名称为Login的类，但是这两个类所实现的功能完全不同，于是问题就产生了——编译器不会允许同名的类文件。解决这类问题的办法是将这两个类放置在不同的类包中。

完整的类路径

例如：
java.util.Date date = new java.util.Date();
java.sql.Date date2 = new java.sql.Date(1000);
在Java中采用类包机制非常重要，类包不仅可以解决类名冲突问题，还可以在开发庞大的应用程序时，帮助开发人员管理庞大的应用程序组件，方便软件复用。

创建包

1.在src节点上右击，选择New/Package。
2.弹出New Java Package对话框，在name文本框中输入新建包名，然后点击Finish。
3.语法如下：
package 包名

导入包

1.使用 import 关键字导入包
在程序中使用 import 关键字导入 com.mr.Math 类，在程序中使用 Math 类是就会自动选择 com.mr.Math 类。import 关键字的语法如下：

import com.mr.*; //导入 com.mr 包中的所有类
import com.mr.Math //导入 com.mr 包中的 Math 类
在所有 import 关键字时，可以指定类的完整描述，如果为了使用包中更多的类，可以在使用 import 关键字指定时在包指定后加上 * ，这表示可以在程序中使用该包的所有类。

2.使用 import 导入静态成员
import 关键字除导入包外，还可以导入静态成员，语法：

import static 静态成员

内部类

成员内部类

在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。成员内部类的语法如下：

class OuterClass{                        //外部类
    class InnerClass{                    //内部类

    }
}

匿名内部类

匿名类是只在创建对象时才会编写类体的一种写法。匿名类的特点是“现写现用”，其语法如下：

new 父类/父接口(){
子类实现的内容
}；

异常处理

异常概述

在程序中，异常可能有程序员没有预料到的各种情况产生，也可能有超出了程序员可控范围的环境因素产生，如果用户的环数据、试图打开一个根本不存在的文件等。在Java中，这种在程序运行时可能出现的一些错误称为异常。

异常的抛出与捕捉

抛出异常

异常抛出后，如果不做任何处理，程序就会被终止。例如，将一个字符串转换为整形，可以通过Integer类的parseInt（）方法来实现。但如果该字符串不是数字形式，parselnt（）方法就会抛出异常，程序将在出现异常的位置终止，不在执行下面的语句

捕捉异常

Java语言的异常捕捉结构由try、catch 和 finally3部分组成。

Java 中常见的异常类

自定义异常

1.创建自定义异常类。
2.在方法中通过throw关键字抛出异常对象。
3.如果在当前抛出异常的方法中处理异常，可以使用try - catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者异常，继续进行下一步操作.
4.在出现异常的方法的调用者中捕捉并处理异常。

在方法中抛出异常

使用 throws 关键字抛出异常

throws关键字通常被应用在声明方法时，用来指定方法可能抛出的异常。多个异常可使用逗号分隔。

使用 throw 关键字抛出异常

throw关键字通常用于方法体，并且抛出一个异常对象。程序在执行到throw语句时立即终止，他后面的语句都不执行。

字符串

String 类

声明字符串

字符串必须包含在一对双引号（“”）之内。例如：
"23.23"、"ABCDE"、"你好"
String str;
String: 指定该变量为字符串变量类型；
str：任意有效的标识符，表示字符串变量的名称。
声明字符串变量s，代码如下：
String s;

创建字符串

1. String(char a[])
2. String(char a[],int offset,int length)
3. String(char[] value)

连接字符串

连接多个字符串

使用 “+” 运算符可实现连接多个字符串的功能。

连接其他数据类型

package tenbao;
public class Link {
public static void main(String[] args) {
  // TODO Auto-generated method stub
  int booktime = 4;
  float practice = 2.5f;
  //将字符串与整数类型、浮点类型相连、并将结果输出
  System.out.println("我每天花费" + booktime + "小时看书：" + practice + "小时上机练习");
}
}

获取字符串信息

获取字符串长度

使用String类的length（）方法可获取声明字符串对象的长度。
获取字符串长度，代码：
String str = "We are student";
int size = str.length();

字符串查找

1.indexOf（String s）
该方法用于返回参数字符串 s 在指定字符串中首次出现的位置。如果没有检索到字符串 s ，该方法返回 -1

查找字符 a 在字符串 str 中的索引位置，代码：

String str = "We are student";
int size = str.indexOf('a');

获取指定索引位置的字符

使用 charAt（int index）方法可指定索引处的字符返回。语句如下：

str.charAt(int index)

字符串操作

获取子字符串

1. substring(int beginIndex)
该方法返回的是从指定的索引位置开始截取直到该字符串结尾的字串。语法如下：

str.substring(int beginIndex)
2. substring(int beginIndex,int endIndex)
该方法返回的是从字符串某一索引位置开始到某一位置结尾的字串。语法如下：

str.substring(int beginIndex，int engIndex)

去除空格

trim() 方法返回字符串的副本，忽略前导空格和尾部空格。语法如下：

str.trim()

字符串替换

replace()方法可实现将指定的字符或字符串替换成新的字符或字符串。语法如下：

str.replace(CharSequence target,CharSequence replacment)

判断字符串的开始与结尾

1.startsWith() 方法
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：

startsWith(String prefix)
2.endsWith() 方法
该方法用于判断当前字符串是否以给予的字符串结尾。语法如下：

str.endsWith(String suffix)

判断字符串是否相等

如果两个字符串具有相同的字符和长度，则使用equals（）方法进行比较时，返回true。否则返回false。使用equals（）是区分大小写的，而使用equalslgnoreCase（）忽略了这种情况返回类型为boolean类型

按字典顺序比较两个字符串

比较 compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode 值，按字典顺序将 String对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此 String对象位于参数字符串之前，则比较结果为一个负整数;如果按字典顺序此 String对象位于参数字符串之后，则比较结果为一个正整数;如果这两个字符串相等，则结果为 0

字母大小写转换

1.toLowerCare()方法
该方法将字符串中的所有大写字母转化为小写。字符串长度不变。语法：

str.toLowerCase()
2.toUpperCase()方法
该方法将字符串中的所有小写转化为大写。

str.toUpperCase()

字符串分割

1.split(String sign)
该方法可根据给定的分割符对字符串进行拆分。语法如下：

str.split(String sign)
2.split(String sign,int limit)
该方法可根据给定的分割符对字符串进行拆分,并限定拆分次数。语法如下：

str.split(String sign,int limit)

格式化字符串

日期和时间字符串格式化

日期格式化

1.日期格式化
先来看一个例子。返回一个月中的天数，代码如下：

Date date = new Date();
String s = String.format("%te",date);

时间格式化

子主题

格式化常见的日期时间组合

子主题

常规格式化

使用正则表达式

子主题

字符串生成器

1.append()方法

该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如int、boolean、char、String、double或者另一个字符串生成器等。语法如下：

append(content)
其中，content 表示要追加到字符串生成器中的内容，可以是任何类型的数据或其他对象。

2.insert（int offset，arg）

向字符串生成器中指定的位置添加字符，代码如下：

StringBuilder bf = new StringBuilder("hello");
bf.insert(5,"world");
System.out.println(bf.toString());
3.delete(int start,int end)方法

删除指定位置的子字符串，代码如下：

StringBuilder bf = new StringBuider("StringBuider");
bf.delete(5,10);
System.out.println(bf.toString);
前删后不删

常见类库

包装类

Integer 类

Integer 类在对象中包装了一个基本数据类型 int 的值，该类的对象包含了一个 int 类型的字节。

Double 类

Double 类在对象中包装一个基本数据类型为 double 的值，每个 Double 类的对象都包含一个 double 类型的字段。此外，该类还提供了多个方法，可以将 double 类型转换为 String 类型，将 String 类型转化为 double 类型。

Boolean 类

Boolean 类的常用方法

Character 类

该提供了多种方法，以确定字符的类别（小写字母、数字等），并可以很方便地将字符从大写转化为小写，反之亦然。Character 类的常用方法：

Number 类

数值型包装类共有方法：

方法功能介绍
byteValue() 以 byte 形式返回指定的数值
intValue() 以 int 形式返回指定的数值
floatValue() 以 float 形式返回指定的数值
shortValue() 以 short 形式返回指定的数值
longValue() 以 long 形式返回指定的数值
doubleValue() 以 double 形式返回指定的数值

数字处理

数字格式化

数字格式化操作主要针对的是浮点型数据，包括 double 型和 float 型数据。在 Java 中使用 java.textDecimalFormat 格式化数字。

DecimalFormat 类是 NumberFormat 的一个子类，用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度。

Math 类

Math 类提供了众多数学函数方法。主要包括三角函数方法，指数函数方法，取整函数方法，取最大值、最小值，以及平均值函数方法。这些方法都被定义为 static 形式，所以在程序中应用比较简便。

Random 类

Random 类是 JDK 中的随机数生成器类，可以通过实例化一个 Random 对象创建一个随机数生成器，语法如下：

Random r = new Random();
也可以设置随机数生成器的种子。语法如下：

Random r = new Random(seedValue);

BigInteger 类

BigInteger 类的数字范围教 Integer 类的数字范围大的多。

在 BigInteger 类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作。

使用 BigInteger 类。可以实例化一个 BigInteger 对象，并自动调用相应的构造函数。BigInteger 类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。

例如，将 2 转换为BigInteger 类型，可以使用以下语句进行初始化操作：

BigInteger twolnstance = new BigInteger("2");

BigDecimal 类

BigDecimal 类和 BigInteger 类都能实现大数字的运算，不同的是 BigDecimal 类加入了小数的概念。

System 类

控制台输出字符

1. 不会自动换行的 print() 方法

System.out.print("Hello");
2.可以自动换行的 println() 方法

System.out.println("Hello");
使用这俩个输出方法时还要注意一下两点：

（1）“System.out.println("\n");” 会打印两个空行。

（2） “System.out.print();” 无参数会报错。

计时

System.currentTimeMillis() 方法可以获取自1970年1月1日零点至今的毫秒数。

Scanner 类

使用Scanner 类首先要引入该类，其语法如下：
import.java.util.Scanner;
使用 Scanner 类扫描控制台的代码如下：
Scanner sc = new Scanner(System.in);

日期时间类

Date 类

Date 类用于表示日期时间，使用该类表示时间需要使用其构造方法创建对象。

日期时间格式化

DateForemat 类时日期时间格式化子类的抽象类，可以按照指定的格式对日期时间进行格式化。

另外，使用DateFormat类还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期，Sy首先需要创建DateFormat类的一个对象，由于它是抽象类，因此可以使用其静态方法getDateInstance()进行创建，语法如下：

DateFormat df = DateFormat.getDateInstance();

Calendar 类

Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY OF MONTH HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段(如获得下星期的日期)提供了一些方法。另外，该类还为实现包范围外的具体日历系统提供了其他字段和方法，这些字段和方法被定义为 protected。
Calendar 提供了一个类方法 getInstance()，以以获得此类型的一个通用的对象。Calendar类的 getInstance()方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化，其使用方法如下:

Calenderright Now = Calendar.getInstance();