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

初时Java

Java简介

Java是一门高级的面向对象的程序设计语言

Java语言的特性

简单

1.语法规则和C++相似

2.Java语言对C++进行了简化和提高

3.Java提供了丰富的库类、API文档一级第三方开发包，另外还有大量基于Java的开源项目

面向对象

Java语言可以凭借URL（统一资源定位符）对象访问网络对象，访问方式与访问本地系统相同

分布性

Java的分布性包括操作分布和数据分布

可移植性

Java程序具有与体系结构无关的特性，Java的库类也实现了针对不同平台的接口

解释型

运行Java程序需要解释器。字节码独立于平台

安全性

Java语言取消了C语言中的指针和内存释放等语法，有效避免了用户对内存的非法操作。而且使用Java可以编写出防病毒和防修改的系统

健壮性

Java语言的设计目标之一，是能编写处多方面、可靠的应用程序。

多线性

Java语言支持多线程机制，能使应用程序在同一时间并行多项任务，而且相应的同步机制可以保证不同线程能够正确第共享数据。使用多线程，可以带来更好的交互能力和实时行为。

高性能

Java编译后的字节码是在解释器中运行的，所以它的速度较多数交互式应用程序提高了很多。另外，字节码可以程序运行时被翻译成特定平台的机器指令，从而进一步提高运行速度。

动态

Java在很多方面比C和C++更能适应发展的环境，可以动态调整库中方法和增加变量，而客户端却不需要任何更改。在Java中进行动态调整是非常简单和直接的。

搭建Java环境

JDK下载

输入网址http://jdk.java.net

在Windows10系统下搭建JDK环境

解压缩

配置环境变量

熟悉Eclipse开发工具

熟悉Eclipse

Eclipse简介

Eclipse所有代码都是开源的，可扩展。

下载Eclipse

搜索框中输入https://www.eclipse.org/downloads,按Enter键访问Eclipse

安装Eclipse的中文语言包

Eclipse的配置与启动

使用Eclipse

创建Java项目

选择“文件”/“新建”/“项目”命令，打开“新建项目”对话框，对该项目的向导，在向导中选择Java项目

弹出“新建项目对话框”/“项目名”文本框中输入“Myproject”，在项目布局栏选中“为源文件和类文件创建单的文件夹”单选按钮

创建Java类文件

Eclipse菜单栏中选择“文件”/“新建”/“类”命令，将打开“新建Java类”向导对话框

使用编辑器编写程序代码

1.打开编译器

2.编写Java代码

运行Java程序

程序调试

断点

可以在编译器显示代码行号的位置窗机添加或删除当前行的断点，或者在当前行号的位置右击

调试器每次遇到程序断点时都会将当前线程挂起，暂停的当前程序的运行

在弹出快捷菜单中选择“切换断点” 实现切换断点的添加与删除

以调试方式运行Java程序

右击文件——快捷菜单中选择“调试方式”/“Java应用程序”命令

程序调试

Java语言基础

Java主类结构

1.包声明

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

2.声明成员变量和局部变量

通常将类的属性称为类的全局变量（成员变量），将方法中的属性成为局部变量

3.编写主方法

main（）方法时类体中的主方法。该方法从“{”开始，至“}”结束。

4.导如API类库

可以通过import关键字导入相关的类

基本数据类型

数据类型

分为整数类型：byte，short，int，long

浮点类型

浮点类型：float，double

字符类型

char型

转义字符\

布尔类型

布尔类型只有true和false两种结果

变量与常量

标识符

1.标识符可以简单地理解为一个名字，是用来标识类名、变量名、方法名、数组名、文件名、的有效字符序列。

2.Java语言规定标识符由任意顺序的字母、下划线（_）、美元符号（$）和数字组成；不能以数字开头；避开关键字。

关键字

又称保留字，被赋予特定意义的一些单词，不可以作为标识符

声明变量

变量的命名必须是合法的标识符。内存空间内的值就是变量值。在声明变量是可以是没有赋值，也可以是直接赋给初值

声明常量

在运行过程中一直不会改变的量成为常量（constant）,称为“final”常量。常量只能被赋值一次

标准语法：final 数据类型常量名称 [=值]   //常量名通常使用大写字母，但是这不是必须的

变量的有效范围

1.成员变量

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

例如： class Demo{          int x = 45;          static int y = 90 }

2.局部变量

在类的方法体中声明的变量（方法内部定义，“{”与“}”之间的代码中声明的变量）成为局部变量

运算符

赋值运算符

以符号“=”表示 例如：  int a = 100;

算数运算符

主要有+（加）、-（减）、*（乘）、/（除）、%（求余）

自增和自减运算符

符号在前先运算再使用，符号在后先使用再运算 例如： ++a（--a)    //表示在使用变量a之前，先使a的值加（减）1 a++(a--)//表示在使用变量a之后，再使a的值加（减）1

比较运算符

使用不同的比较运算符判断两个整数的关系

逻辑运算符

&：两者都为真，结果才是真。 |：只要有一者为真，结果就是真。 ！：非真即假，非假即真。

位运算符

1.“按位与”运算 &：两者都为1，结果才是1。

2.“按位或”运算 |：只要有一者为1，结果就为1。

3.“按位取反”运算 1变0，0变1。

4.“按位异或”运算 两者相同即为0，不同为1。

5.位移运算符 <<：左移。整体往左移，空位补0，溢出去掉。 >>：右移。整体右移，正数补0，负数补1，溢出去掉。 >>>：无符号右移。整体右移，空位补0；溢出去掉。

三元运算符

格式：  A（条件句） ？  B  :   C 若条件式的值是正确的，则表达式取值B，否则取值C.

运算符优先级

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

数据类型转换

隐式类型转换

使用隐式转换提升数值的精度

显示（强制）类型转换

有可能会丢失数据

代码注释与编码规范

流程控制

复合语句

ava语言的复合语句是以整个块区为单位的语句，所以又称块语句。复合语句由开括号“{”开始，闭括号"}"结束。

条件语句

if条件语句

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

语法： if（布尔表达式）{     语句序列 }

if...else 语句

if...else语句是条件语句中最常用的一种形式，它会针对某种条件有选择地做出处理。通常表现为“如果满足某种条件，就进行某种处理，否则就进行另一种处理”。

语法： if（条件表达式）         语句序列1 }else{         语句序列2 }

if...else if 多分支语句

if……else if多分支语句用于针对某一事件的多种情况进行处理。通常表现为“如果满足某种条件，就进行某种处理，否则如果满足另一种条件则执行另一种处理”

语法： if（条件表达式1）{  语句序列1 }else if（条件表达式2）{  语句序列2 } …… else if（条件表达式n）{  语句序列n }

switch多分支语句

在编程中，一个常见的问题就是检测一个变量是否符合某个条件，如果不符合，再用另一个值来检测，以此类推。在Java中，可以用Switch语句将动作组织起来，以一个较简单明了的方式来实现“多选一”的选择。

语法： switch（表达式）{ case 常量值1：      语句块1      【break】 …… case 常量值n：      语句块n      【break】 default：      语句块n+1      【break】 }

循环语句

while循环语句

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

语法： while（条件表达式）{ 语句序列 }

do...whlie循环语句

do……while循环语句与while循环语句类似，它们之间的区别是while语句为先判断条件是否成立，再执行循环体，而do……while循环语句则先执行一次循环后，再判断条件成立。也就是说，do……while循环语句“{}”中的程序段至少要被执行一次。

语法： do{ 语句序列 }while（条件表达式）

for循环语句

for语句

语法： for(表达式1；表达式2；表达式3）{        语句序列 }

foreach语句

语句： for(元素类型 x : 遍历对象 obj ){         引用了x 的Java语句； }

循环控制

break语句

用在switch条件语句和循环语句中，它的作用是终止某个case并跳出switch结构。

continue语句

用在循环语句中，它的作用是终止本次循环，执行下一次循环

数组

数组概括

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

一维数组

创建一维数组

是同类数组的线性集合，在程序中需要处理一组数据，或者传递一组数据时，可用这种类型的数组 使用一维数组的例子

1.先声明，再用new关键字进行内存分配

声明的俩种方式： 数组元素类型  数组名字[ ] ; 数组元素类型[ ]  数组名字；

数组分配内存空间的语法格式： 数组名字  =new  数组元素的类型[数组元素的个数];

2.声明的同时为数组分配内存

语法： 数组元素的类型  数组名  =  new  数组元素的类型[数组元素的个数]

初始化一维数组

数组的初始化有以下两种方式： int arr = new int[1,2,3,4,5,25];//第一种初始化方式 int arr[] = {34,23,12,6};//第二种初始化方式

使用一维数组

二维数组

创建二维数组

1.先声明，再使用new 关键字进行内存分配

语法： 数组元素的类型 数组名字 [] []; 数组元素的类型[] [] 数组名字；

2.声明的同时为数组分配内存

第二种创建方式第一种实现的功能相同，只不过声明与赋值合并到同一行代码中

初始化二维数组

语法： type arrayneme[][] = {value1,value2,value3…valuen};

使用二维数组

数组的基本操作

遍历数组

遍历数组就是获取数组中的每一个元素。通常遍历数组都是使用for循环来实现。遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。

填充替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。

1.fill(int[]a,int value)

该方法可将指定的int值分配给int型数组的每个元素。 语法如下： fill(int[]a,int value)

2.fill(int[]a,int fromIndex,int toIndex,int value)（前改索引后不改索引）

该方法将指定的int值分配给int型数组指定范围中的每个元素。 语法如下： fill(int[]a,int fromIndex,int toIndex,int value)

子主题

对数组进行排序

通过Arrays类的静态方法sort()可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。 语法如下： Arrays,sort(object)

复制数组

Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中

1.copyOf()方法 该方法提供了多种重裁形式，用于满足不同类型数组的复制。 语法如下： copyOf(arr,int newlength)

2.copyOfRange()方法（前在后不在） 该方法同样提供了多种重裁形式， 语法如下： copyOfRange(arr,int formIndex,int toIndex)

查询数组

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象，该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重裁形式，用于满足各种类型数组的查找需要。

1.binarySearch(Object[]a,Object key)(先排序，后查询） 语法如下： binarySearch(Object[]a,Object key)

2.binarySearch(Object[]a,int fromIndex,int toIndex,Object key) 该方法在指定的范围内检查某一元素。语法如下： binarySearch(Object[]a,int fromIndex,int toIndex,Object key)

数组排序算法

冒泡排序

冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将较小的数往前放、较大的数往后放，类似水中气泡往上升的动作，所以称为冒泡排序。

1.基本思想 冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面（也就是交换两个元素位置），这样较小的元素就像气泡一样从底部上升到顶部。

2.算法实现

直接选择排序

1.基本思想 直接选择排序属于的基本思想是将排序位置元素与其他数组元素分别对比，如果满足条件就交换元素值。

2.算法示例

反转排序

1.基本思想 反转排序的基本思想比较简单，也很好理解，其实现思路就是把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换。

2.算法示例

类和对象

面向对象

对象

在现实生活中，随处可见的一种事物就是对象。通常都会将对象划分为两个部分，级静态部分和动态部分。静态部分就是不能动的部分，这个部分被称为“属性”，动态部分即对象可执行的动作，被部分被称为“行人”。

类

不能将一个事物描述成一类事物，类就是同一类事物的统称，

封装

面向对象程序设计具有一下特点：封装性、继承性和多态性。

继承

面向对象程序设计具有一下特点：封装性、继承性和多态性。

多态

其实将父类对象用于子类的特征就是多态。在多态的机制中，比抽象类更方便的方式是将抽象类定义为接口。由抽象方法组成的集合就是接 口。

类

成员变量

在lava 中，对象的属性也称为成员变量，成员变量可以是任意类型，整个类中均是成员变量作用范围。

成员方法

在Java语言中，使用成员方法对应于类对象的行为。 定义成员方法的语法格式如下： 权限修饰符  返回值类型 方法名（参数类型 参数名）{ …                                                                             //方法体     return 返回值 }

权限修饰符

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

局部变量

局部变量是在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误

局部变量的有效范围

可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止

在相互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量

this关键字

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

类的构造方法

构造方法的特点如下： 1.构造方法没有返回值 2.构造方法的名称要与本类的名称相同

构造方法的定义语法格式如下： public Book(){ ...      //构造方法体 }

静态变量和静态方法

调用静态成员，语法如下： 类名.静态类成员

如果在执行类时，希望先执行类的初始化动作，可以使用static定义一个静态区域，这块区域放 为静态代码块。当类文件被执行时，会首先执行static块中的程序，并且只会执行一次。

静态代码块的语法如下： public class example{     static{         ...  //可以在这里写初始化的代码     } }

最后总结以下使用static关键字要注意的几点： 在静态方法中不可以使用this关键字。 在静态方法中不可以直接调用非静态方法。 局部变量不可以使用static关键字声明。 主方法必须用static声明。 只有内部类可以使用static关键字声明。

类的主方法

主方法的语法如下： public static void main(String[] args){     ...   //方法体 }

在主方法的定义中可以看到其具有以下特性： 主方法是静态的，所以如要直接在主方法中调用其他方法，则该方法必须也是静态的。 主方法没有返回值。 主方法的形参为数且。其中，args[0]~args[n]分別代表程序的第一个参数到第n个参数，可以使用arga.length获取参数的个数。

对象

对象的创建

使用new操作符调用构造方法创建对象，语法如下： Test test =new Test(); Test test =new Test("a");

访问对象的属性和行为

用户使用new操作符创建一个对象后，可以使用“对象.类成员“来获取对象的属性和行为。当对象获取类成员时，也相应地获取了对象的属性和行为。

对象的引用

语法： 类名  对象的引用变量

引用与对象相关联的语法如下： People  tom  =  new  People();

对象的销毁

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收 何种对象会被Java虚拟机视为“垃圾”。

对象引用超过其作用范围，这个对象将被视为垃圾。

将对象赋值为null

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

类的继承

一个类继承另一个类需要使用关键字extends，关键字extends的使用方法如下： class Child extends Parent{}

Java只支持单继承，即一个类只能有一个类，所以类似下面的代码是错误的的：  class Child extends Parent1，Parent2{} 子类在继承父类之后，创建子类对象的同时也会调用父类的构造方法

Object类

在Object类中，主要包括clone()、finalize()、equals()、toString()等方法，其中equals()、toString()最常用。由于所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法。 注意：Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为这些方法被定义为final类型。

1.getClass()方法 此方法时Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用getName（）方法可以取得类的名称。语法如下： getClass().getname();  可以将getClass()方法与toString()方法联合使用。

2.toString()方法 toString()方法的功能时将一个对象返回为字符串形式，它会返回一个String实例。

3.equals()方法 在Java语言中，有两种比较对象的方式，分别为“==”运算符与equals()方法。两者的区别在于：“==”比较的是两个对象的引用内存地址是否相等，而equals()方法比较的是两个对象的实际内容。

对象类型的转换

要注意的是，只有具备继承关系得类与类之间才能进行对象类型转换，非继承关系之间不能进行类型转换。 对象之间的类型转换在Java编程中还是很常见的。类型转换分为向上转型与向下转型。

1.向上转型 而向上转型就是将子类对象赋值给父类对象。可以理解为将子类类型的对象转换为父类类型的对象，即把子类类型对象直接赋值给父类类型的对象。 格式为： 父类 对象名 = (父类) 子类对象;

2.向下转型  向下类型转换可以理解为将父类类型的对象转换为子类类型的对象。

需要借助强制类型转换 语法如下： 子类类型  子类对象  =（子类类型）父类对象；

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

instsnceof的语法格式如下： myobject instanceof ExampleClass

误区警示：instanceof是Java语言的关键字，Java语言中的关键字都为小写

方法的重载

重载与重写不同但又十分相似 重写是：返回参数相同 方法名相同 传入参数相同 只有方法体不同 重载则是：方法名相同 参数不同 重载和重写的区别在于：重写必须要有继承关系才能使用，而重写只要在同一个类里就能使用

不定长方法的语法如下： 返回值 方法名（参数数据类型。。。参数名称）

final关键字

final变量

用final修饰的变量就不可以在改变该变量的值 final修饰变量——不可改变的量（常量）

final方法

final修饰方法——不能被重写

final类

final修饰类——不能被继承 如果不希望一个类被任何类继承，只需要在类的前面加上final就行

多态

利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。 假如现在要编写一个绘制图形的方法draw（），如果传入正方形对象将绘制正方形，如果传入圆形对象就绘制圆形，这种场景可以使用重载来实现

定义如下： public void draw(Square s){ //绘制正方形的方法 } public void draw(Circular c){ //绘制圆形方法 }

抽象类与接口

抽象类

抽象方选没有方法体，这个方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继系。实际上抽象类除了被继承没有任何意义。

定义抽象类的语法如下： public abstract class Parent{     abstract void testAbstract();   //定义抽象方法 }

接口

接口所有方法都是抽象方法 修饰符inter face 接口名{} 实现implements java语言每个类可以实现多个接口 修饰符 class 类名 implements 接口1，接口2，接口3，.....{}

接口使用 interface 关键字进行定义，其语法如下:  public interface Paintable{     void draw();     //定义接口方法可省略public abstract关键字 }

实现多个接口的语法： class 类名 implements 接口1，接口2，接口3...

一个接口可以继承另一个接口，语法如下： interface intf1{} interface intf2 extends intf1{}   //接口继承接口

包和内部类

异常处理

字符串

常用类库