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

初识java

java语言概述

java是什么？

java是一门优秀的程序设计语言，它具有令人赏心悦目的语法和易于理解的语义

java语言的地位

语言使用广泛程度

java常年占据语言排行榜前三位，是近些年最火的编程语言之一。

java发展简史

Java 语言源于 1991 年 4 月，Sun 公司 James Gosling博士 领导的绿色计划(Green Project) 开始启动，此计划最 初的目标是开发一种能够在各种消费性电子产品(如机顶盒、冰箱、收音机等)上运行的程序架构。这个就是Java的 前身： Oak (得名与Java创始人James Gosling办公室外的一棵橡树)，但由于这些智能化家电的市场需求没有预期 的高，Sun公司放弃了该项计划。随着1995年代互联网的发展，Sun公司看见Oak在互联网上应用的前景，于是改 造了Oak，于1995年5月以Java的名称正式发布，并提出“Write once, Run anywhere" 的口号。

java的语言特性

简单性

Java语言类似C++，因此熟悉C++的程序员很容易掌握java,另外它摒弃了C++中易发生错误的地方，尤其是Java语言不使用指针，并提供了自动的废料收集，使得程序员不必为内存管理而担忧

跨平台性

所谓的跨平台性就是指软件可以不受计算机硬件和操作系统的约束而在任意计算机环境下正常运行。而在Java中它自带的虚拟机可以很好的实现跨平台性，它提供了一个字节码到底层硬件平台及操作系统的屏障，使得Java语言具备跨平台性

面向对象

Java是一种面向对象语言，它可以使得程序的开发更加简单易用。比如具有代码扩展，代码复用等功能

安全

Java的安全性可从两个方面得到保证。一方面，在Java语言里，指针和释放内存等C++功能被删除，避免了非法内存操作。另一方面，当Java用来创建浏览器时，语言功能和浏览器本身提供的功能结合起来，使它更安全。Java语言在机器上执行前，要经过很多次的测试。它经过代码校验，检查代码段的格式，检测指针操作，对象操作是否过分以及试图改变一个对象的类型

多线程

多线程是指允许一个应用程序同时存在两个或两个以上的线程，用于支持事务并发和多任务处理。 Java除了内置的多线程技术之外，还定义了一些类、方法等来建立和管理用户定义的多线程

分布性

Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口，它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI(远程方法激活)机制也是开发分布式应用的重要手段

可移植的

Java系统本身具有很强的可移植性，Java编译器是用Java实现的，Java的运行环境是用ANSI C实现的，另外Java还严格规定了各个基本数据类型的长度

解释的

Java解释器能直接运行目标代码指令，链接程序通常比编译程序所需资源少，所以程序员可以在创建源程序上花上更多的时间

高性能

如果解释器速度不慢，Java可以在运行时直接将目标代码翻译成机器指令，翻译目标代码的速度与C/C++的性能没什么区别

动态性

Java语言的设计目标之一是适应于动态变化的环境，Java程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级

初始java中的main方法

Java的main方法应该是当前主流编 程语言中最“长”的。

源文件

（扩展名为*.java)：源文件带有类的定义。类用来表示程序的一个组件，小程序或许只会有一个 类。类的内容必须包含在花括号里面。

类

类中带有一个或多个方法。方法必须在类的内部声明。

方法

在方法的花括号中编写方法应该执行的语句。

运行java程序

Java是一门半编译型、半解释型语言。先通过javac编译程序把源文件进行编译，编译后生成的.class文件是由字节 码组成的平台无关、面向JVM的文件。最后启动java虚拟机来运行.class文件，此时JVM会将字节码转换成平台能够理解的形式来运行

基本原则

注释

注释是为了让代码更容易被读懂而附加的描述信息. 不参与编译运行, 但是却非常重要. 时刻牢记! 代码写出来是为了给人看的, 更是为了给几个月后的你自己看的

单行注释

// 注释内容（用的最多）

多行注释

/* 注释内容*/（不推荐）

文档注释

/** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可以被javadoc工具解析，生 成一套以网页文件形式体现的程序说明文档

注释规范

内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新

子主篇幅合理: 注释既不应该太精简, 也不应该长篇大论.题

使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论.

积极向上: 注释中不要包含负能量

标识符

在上述程序中，Test称为类名，main称为方法名，也可以将其称为标识符，即：在程序中由用户给类名、方法名或 者变量所取的名字

硬性规则

标识符中可以包含：字母、数字以及 下划线和 $ 符号等等。

类名: 每个单词的首字母大写(大驼峰)

方法名:首字母小写，后面每个单词的首字母大写**(小驼峰)**

变量名:与方法名规则相同

关键字

关键字是由Java语言提前定义好的，有特殊含义的标识符，或者保留字

熟悉eclipse

下载并安装

第一步

点击Browse...编辑

选择需要保存的文件夹位置，也可以右键创建一个新的文件夹并选择

之后后点击Launch，进行下一步

第二步

点击左上小三角形弹出Java Project后点击创建java项目

选择使用执行环境并输入项目名

先点击Next进行下一步后点击Finish完成

第三步

点开左上创建的文件hello,再点开src，选择module-info.java无用文件右键点击Delete删除编辑

再选择src右键选择New后点击Class创建一新的Java类输入项目名称，并勾选public static void main(string[] args),勾选后会自动生成源代码，后点击Finish完成

第四步

开始输入代码：System.out.print("我用Eclipse写的第一个Java程序");

点击运行

最后得出结果

Java语言基础

基本数据类型

整数类型

整数类型简称整形，用来存储整数数值，既没有小数部分的数值。可以是整数，也可以是负数。整形数据根据它所占内存大小的不同，可分为byte、short、int和long4种类型。它们具有不同的取值范围。（使用long型时数据后面要加L）

浮点类型

浮点类型简称浮点型，用来存储含有小数部分的数值 。java语言中浮点类型分为单精度浮点类型（float）和双精度浮点类型（double），它们具有不同的取值范围。

字符类型

转义字符是一种特殊的字符变量，它以反斜杠“\”开头，后跟一个或多个字符。转义字符具有特殊含义，不同于字符原有的意义，故称“转义”。例如：printf函数的格式串用到的“\n”就是一个转义字符，意思是“回车换行

变量与常量

标识符

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

关键字

关键字不可以作为标识符

声明变量

声明变量就要告诉编译器这个变量的数据类型，这样编译器才知道需要配置多少空间给它

声明常量

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

变量的有效范围

在类体中所声明的变量被称为成员变量，成员变量在整个类体中都有效。类的成员变量可以分为两种，即静态变量和实例变量。

局部变量

赋值运算符

赋值运算符以符号“=”表示，它是一个二元运算符（对两个操作数处理），其功能是把右边的操作数所含的值赋给左边的操作数。

算术运算符

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

自增和自减运算符

自增：a++:运算在前，先运算后使用++a：运算在后，先使用后运算（+1）自减：a--：运算在前，先运算后使用--a：运算在后，先使用后运算（-1）

比较运算符

比较运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间的比较。比较运算符的结果是boolean型。当运算符对应的关系成立时，运算结果为true，否则false。

逻辑运算符

逻辑与（&）：两者都为真结果才为真逻辑或（||）：只要有一个为真结果就为真逻辑非（！）：非真即假，非假即真

位运算符

.按位与”运算

”按位与“运算的运算符位”&“，为双目运算符，”按位与“运算的运算法则是:如果两个整形数据a,b对应位都是1，则结果位才是1，否则为0，如果两个操作数的精度不同，则结果的精度和及精度高的操作数相同

按位或”运算

”按位或“运算的运算符为”|“，为双目运算符，”按位或“运算的运算规则是：如果两个操作数对应位都是0，则结果位也是0，否则为1，如果两个操作数的精度不同，则结果的精度与精度高的操作数相同

按位取反”运算

按位取反“运算也称”按位非“运算，运算符为”~",为单目运算符，“按位取反”就是将操作数二进制中的1修改为0，0修改为1

按位异或”运算

“按位异或”运算：两者相同即为0，不同为1，非0即1；“按为异或”运算的运算符为“^”为双目运算符，“按位异或”运算法则是：当两个操作数的二进制表示相同（同时为0或同时为1）时，结果为0，否则为1，若两个操作数的精度不同则结果的精度与精度高的操作数相同

三元运算符

三元运算符使用的格式： 条件式？值1：值2

移位操作

<<左移：整体左移空位补0，溢出去掉

>>右移：整体右正数补0，负数补1，溢出去掉

>>>无符号右移：整体右移，空位补0，溢出去掉

运算符优先级

数据类型转换

隐式类型转换

从低级类型向高级类型的转换，系统将自动执行，程序员无需进行任何操作。这种类型的转换称2为隐式转换。下列基本数据类型会涉及数据转换，不包括逻辑类型和字符类型，这些类型按精度从低到高排列的顺序为： byte < short < int < long < float < double

流程控制

复合语句

java的复合语句是以整个区块为单位的语句，所以又称块语句，复合语句you7开括号“{”开始，“}”结束

条件语句

“if”条件语句

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

if...else语句

if...else”：如果满足某条件，就执行某种处理，否则执行另一种处理语法

if...else if多分支语句

if...else if:如果满足某条件，就进行某种处理，否则如果满足另一条件则执行另一种处理语法

if(条件表达式1){     语句序列1 }else if(条件表达式2){     语句序列2 }...else{     语句序列n }

switch多分支语句

swich语句中表达式的值必须是整型、字符型、字符串类型或枚举类型，常量值1--n的数据类型必须与表达式的值的类型相同

循环语句

while

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

do...while循环语句

do...while：与while循环语句类似，区别是while先判断条件是否成立再执行循环，do...while循环语句则先执行一次循环后，在判断条件是否成立，do...while循环语句至少会循环一次

for循环语句

for循环可以用来重复执行某条语句，直到某个条件得到满足，for循环有两种语句，一种是传统的for语句，一种是foreach语句

数组

数组的概念

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

一维数组

一维数组是一组相同数据类型数据的线性集合

子主题

数组元素的类型[] 数组名

数组的内存分配

要真正的使用数组还要为它分配内存空间，在为数组分配内存空间之必须指明数组的长度

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

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

子主初始化一维数组题

有两种初始化数组的方法

int arr[] = new int[]{1,2,3,4,5,25}   //第一种初始化方法 int arr2[] = {34,23,12,6}             //第二种初始化方法

二维数组

数组的声明

数组元素的类型[][] 数组名； 数元素的类型数组名 [][]

数组的内存分配

第一种是直接为每一维分配空间： 第二种是分别为每一维分配空间

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

int myarr[][] = {{12,0},{45,10}};

填充替换数组元素

填充替换语法

fill(数组名,值)

填充替换部分元素语法

fill(数组名,前索引，后索引，值

对数组进行排序

通过Array类的静态方法sort()可以对数组进行排序

Array.sort(数组名)

复制数组

复制语法：（空位补0，溢出去掉）

copyOf(数组名,复制的长度)

查询数组

查询语法：（先排序再查询）

binarySearch(数组名,值)

查询部分语法

查询部分语法：（先排序在查询，前含后不含）

binarySearch(数组名,前索引,后索引,要搜索的值)

数组排序算法

冒泡排序

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

冒泡排序由双层循环实现，外层循环用于控制层数，一般要循环数组长度减一次才能保证完成排序，内层循环主要用于对比数组中每个相邻的元素大小判断是否交换位置

基本思想

比较相邻的元素，把较小的元素移动到数组前面，把较大的元素放到数组后面，这样较小的元素就像气泡一样从底部上升到顶部

算法示例

冒泡排序由双层循环实现，外层循环用于控制层数，一般要循环数组长度减一次才能保证完成排序，内层循环主要用于对比数组中每个相邻的元素大小判断是否交换位置

直接选择排序

属于一种选择排序，排序速度要比冒泡排序快点，也是常用的排序，初学者应该掌握

基本思想

将指定排序位置元素与其他数组元素对比，如果满足条件就交换元素值，直接排序并不是和冒泡排序一样交换相邻元素，而是把满足条件的元素与指定的排序位置元素交换

算法示例

挑出元素中最小或者最大的一个元素，顺序的放在已排序好的数列的最后，直到全部待排序的数据元素排列完 算法实现

反转排序

以相反的顺序把原有数组的元素重新排序，也是经常用到的一种排序方法

基本思想

将数组最后一个元素和第一个元素交换，倒数第二个元素和第二个元素交换，以此类推，直到把所有元素反转替换

算法示例

反转排序是对数组两边的元素进行替换，所以只需要循环数组长度的半数次，如果数组长度位奇数，例如数组长度为7，那么只会循环3次，中间的数不变

类和对象

对象

对象是事物存在的实体，世间万物皆对象。对象分为两个部分，即静态部分与动态对象部分

静态部分

不能动的部分，称为“属性"

动态部分

对象可执行的动作，称为“行为”

类

类是统一事物的统称，如果将现实世界中的一事物抽象成对象，类就是这类对象的统称。 类是对象的设计图；类是封装对象的属性和行为的载体，具有相同属性和行为的一类实体被称为类。类对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，所以类包括对象的属性和方法

类的构造方法

在类中，出成员方法外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的

构造方法的特点

构造方法没有返回值，构造方法的名称要与本类的名称相同，

构造方法的定义语法格式

（public ：构造方法修饰符；Name：构造方法的名称） public Name(){ .....         //构造方法体 }

在构造方法中可以为成员变量赋值，这样当实例化一个本类对象时，相应的成员变量也将被初始化。如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法

封装

面向对象程序设计

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

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

继承

类与类之间同样具有关系，这种关系被称为关联。两个类之间的关系有很多种，继承是关联中的一种。设计软件时，使用继承思想可以缩短软件开发的周期，复用那些已经定义好的类可以提高系统性能，减少系统在使用过程中出现错误的概率

多态

将父类对象应用与子类的特征就是多态类

成员变量

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

局部变量

如果在成员方法内定义一个变量，那么这个变量被称为局部变量。在实际上，方法中的形参也可以作为一个局部变量

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

在part类中创建静态的exchange（）方法，该方法可以将数组参数arr的前两个元素值互换，通过在方法中定义一个保存临时数据的局部变量tmp,利用tmp交换两个元素的值

静态变量和静态方法

由static修饰的变量和方法被称为静态变量和动态方法。被声明为static的变量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和”.“运算符调用静态成员

使用static关键字要注意的几点

在静态方法中不可使用this关键字

在静态方法中不可以直接调用非静态方法

局部变量不可以使用static关键字声明

主方法必须用static声明

只有内部类可以使用static关键字声明

类名

静态类成员

创建并调用静态属性和静态变量，创建homework类，在类中使用static关键字定义一个属性和一个方法，并在主方法中条用

静态变量与静态方法的作用通常是为了提供共享数据或方法，如数学计算公式等。尽管使用这种方式调用静态成员比较方便，但静态成员同样遵循修饰符的约束

成员方法

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

权限修饰符

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

类的主方法

主方法是类的入口点，它定义了程序从何处开始。主方法提供对程序流向的控制，Java编译器通过主方法来执行程序

主方法的特点

主方法是静态的，所以如要直接在主方法中条用其他方法，则该方法必须也是静态的。 主方法没有返回值

主方法的形参为数组。其中，args[0]~[n]分别代表程序的第一个参数到n个参数，可以使用args.length获取参数的个数

读取主方法的参数组，在项目创建part类，在主方法中编写一下代码，并在Eclipse中设置程序参数

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

类的继承

继承在面向对象开发思想中是一个非常重要的概念，它使整个程序架构具有一定的弹性，在程序中复用已经定义完善的类不仅可以减少软件开发周期，还可以提高软件的可维护性和可扩展性

继承的使用

父类Parent和子类Child都各自有一个无参的构造方法，在main()方法中创建子类中创建子类对象时，Java虚拟机会先执行父类的构造方法，然后再执行子类的构造方法，一个类继承另一个类，用extends关键字，class Child extends Parent { }

java只支持单继承，即一个类只能有一个父类

父类Parent：public class Parent {  public Parent (){    System.out.println("调用Parent类构造方法"); } }

子类Child:class Child extends Parent{  public Child() {   System.out.println("调用Child类构造方法");  } }

Object类

学习使用class关键字定义类时 ，就应用了继承原理 ，因为在Java中，所有的类都直接或间接继承了java.lang.Object类。Object类是比较特殊的类，它是所有类的父类，是Java类层中的最高层类 。当创建一个类时 ，总是在继承 ，除非某个类已经指定要从其他类继承 ，否则它就是从java.lang.Object 类继承而来的 ，可见Java中的每个类都源于 java.lang.Object类 ，如 String  、Integer等类都是继承于添加字群 Object类；除此之外自定义的类也都继承于Object类。\n\n 由于所有类都是Object子类，所以在定义类时，省略了extends Object关键字，在Object类中主要包括clone()、finalize()、equals()、toString()等方法，其中常用的两个方法为equals()和toString()方法。由于所有的类都是Object 类的子类，所以任何类都可以重写Object类中的方法

注意

Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为这些方法被定义为final类型

getClass()方法

getClass()方法是Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用getName()方法可以取得类的名称

语法如下：getClass().getName ();可以将getClass)方法与toString)方法联合使用

toString()方法

toString()方法的功能是将一个对象返回为字符串形式，它会返回一个String实例。在实际的应用中通常重写toString()方法，为对象提供一个特定的输出模式。当这个类转换为字符串或与字符串连接时，将自动调用重写的toString()方法

equals方法

equals方法是比较“=”运算符与equals)方法，说明“=”比较的是两个对象的引用是否相等，而equals方法比较的是两个对象的实际内容

对象类型的转换

向上转型

向上转型可以理解为将子类类型的对象转换为父类类型的对象，即把子类类型的对象直接赋值给父类类型的对象，进而实现按照父类描述子类的效果

向下转型

向下转型可以被理解为将父类类型的对象转换为子类类型的对象。但是，运用向下转型，如果一个较抽象的类的对象转换为一个较具体的类的对象，这样的转型通常会出现错误。例如，可以说某只鸽子是一只鸟，却不能说某只鸟是一只鸽子。因为鸽子是具体的，鸟是抽象的。一只鸟除了可能是鸽子，还有可能是老鹰、麻雀等。因此，向下转型是不安全的

强制类型转换

子类类型子类对象=(子类类型)父类对象；

注意

两个没有继承关系的对象不可以进行向上转型或者向下转型

父类对象可以强制转换为子类对象，但有一个前提条件：这个父类对象要引用这个子类对象

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

当在程序中执行向下转型操作时 ，如果父类对象不是子类对象的实例  ，就会发生ClassCastException异常  ，所以在执行向下转型之前需要养成一个良好的习惯，就是判断父类对象是否为子类对象的实例。这个判断通常使用instanceof操作符来完成。可以使用instanceof操作符判断是否一个类实现了某个接口，也可以用它来判断一个实例对象是否属于一个类

instanceof的语法格式如下：myobject： 某类的对象引用  ExampleClass： 某个类

使用 instanceof操作符的表达式返回值为布尔值。如果返回值为true，说明 myobject 对象为ExampleClass的实例对象；如果返回值为false，说明myobject对象不是ExampleClass的实例对象。

注意

instanceof是Java语言的关键字，在Java语言中的关键字都为小写

方法的重载

构造方法的名称由类名决定，构造方法只有一个名称，但如果希望以不同的方式来实例化对象，就需要使用多个构造方法来完成。由于这些构造方法都需要根据类名进行命名，为了让方法名相同而形参不同的构造方法同时存在，必须用到“方法重载”。虽然方法重载起源于构造方法，但是它也可以应用到其他方法中。方法的重载就是在同一个类中允许同时存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可

final 关键字

final 变量

final关键字可用于变量声明，一旦该变量被设定，就不可以再改变该变量的值。通常，由final定义的变量为常量

final关键字定义的变量必须在声明时对其进行赋值操作。final除了可以修饰基本数据类型的常量，还可以修饰对象引用。由于数组也可以被看作一个对象来引用，所以final可以修饰数组。一旦一个对象引用被修饰为final后，它只能恒定指向一个对象，无法将其改变以指向另一个对象。一个既是static又是final的字段只占据一段不能改变的存储空间

final 方法

定义为fǐnal的方法不能被重写 将方法定义为fǐnal类型可以防止子类修改该类的定义与实现方式，同时定义final的方法的执行效率要高于非final方法。在修饰权限中曾经提到过private修饰符，如果一个父类的某个方法被设置为private修饰符，子类将无法访问该方法，自然无法覆盖该方法，所以一个定义为private的方法隐式被指定为fǐnal类型，这样无需将一个定义为private的方法再定义为final类型

final 类

定义为fǐnal的类不能被继承。如果希望一个类不允许任何类继承，并且不允许其他人对这个类进行任何改动，可以将这个类设置为fǐnal形式

fǐnal类的语法如下：

final class类名()

如果将某个类设置为final形式，则类中的所有方法都被隐式地设置为final形式，但是final类中的成员变量可以被定义为final或非final形式

多态

多态意为一个名字可具有多种语义，在程序设计语言中，多态性是指“一种定义，多种实现”，例如，运算符“+”作用于两个整型量时是求和，而作用于两个字符型量时则是将其连接在一起。利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。类的多态性可以从两方面体现：一是方法的重载，二是类的上下转型

抽象类与接口

instanceof

对象名 instanceof 类名

对象名 instanceof 接门名

判断对象是否属于该类或其子类判断对象是否属于该接口的实现类

抽象方法

修饰符 abstract 返回参数 方法名(传入参数)

抽象类

有抽象方法的类一定是抽象类修饰符abstract class 类名{ }

接口

所有方法都是抽象方法修饰符 interface 接口名! 实现 implements

JAVA语言每个类可以实现多个接口

修饰符 class 类名 implements 接口1，接口2，.........接口n{ }

但这可能会在一个类中产生庞大的代码量，因为继承一个类接口时需要实现接口中所有的方法，一个接口可以继承另一个接口

interface intf1{} interface intf2 extends intf1{} //接口继承接口

包和内部类

类包

在Java中，我们可以使用class关键字来进行定义一个类，在程序被编译后就会产生一个.class文件。类的定义是规定类名不能重复的，如果程序内只定义了少量的类，那自然不用担心这个问题。 但是，随着类的数量增多，那么难免会出现这个问题，如果根据需求需要定义两个名字相同但是程序逻辑不同的类时，那么该如何解决呢，最好的方法就是将这个两个类放置在不同的包下面，类的定义规定，在同一个类包下面不允许出来同名的类，但是在不同类包下面就允许出现这种情况，相当于将两个同名的类放入了不同的盒子内，避免出现这个问题

包和类的关系

类路径

如果一个程序内存在多个同名不同包的max类，那么该如何使用指定包的类呢？ 在使用该类时使用该类的类路径，也成为绝对路径

java.util.Date date=new java.util.Date();  // 选择Java.util包下的Date类 java.sql.Date date2=new java.sql.Date(100) // 选择Java.sql包下的Date类

指定包名(package)

在进行创建包的时候需要注意的是，Java包的命名规则建议使用全小写字母进行命名。 需要了解的是如果一个类没有被定义在一个指定的包内，那么该类就被归纳到默认包(default package)中在某个包下面创建一个类的话，需要在这个类的开头加上表达式 package 包名，该表达式需要放置在程序的第一行，使用package关键字指定包名之后，包名也会成为类名的一部分，在不同包下使用该类的话，需要使用 import 包名.类名 的格式

package test; //指定包名，表示该类在本包内 public class dome{ }

导包

在Java中，如果需要使用到其它包内的类的话，除了使用该类的绝对路径之外，我们还可以使用Java中 import 关键字来指定。例如，如果在其它包内也定义了一个Math，那么假如我们只想使用该Math类的话，那么我们可以使用import关键字进行导包

在进行导包后，我们在使用该包下的Math类后，可以看到，java.lang包下有一个Java给定的Math类，还有一个我们刚刚进行导的包下的Math类

需要注意的是，刚刚我们已经导入了Number_5包下的Math类，如果需要使用java.lang包下的Math类的话，需要使用java.lang.Math类的完整路径的方式使用该类。因为如果在之前导入了Number_5包下的Math类的话，程序中如果使用Math类中的方法，编译器只会去Number_5.Math类内进行寻找该方法，如果没有找到则报错

导入静态方法或静态成员

使用import关键字还可以对静态方法与静态变量进行导包

内部类

内部类顾名思义，就定义在一个类内部的类

成员内部类

定义在一个类成员位置的内部类，称为成员内部类，在成员内部类中可以使用外部类的的任意成员变量与成员方法，即使该外部类成员变量被private所修饰，因为private等权限修饰符是针对外界的调用而进行权限判断的，但是成员内部类定义在该类的内部，那么相对于该类的一部分，就像该类的方法也是可以调用被private修饰的成员变量一般，成员内部类属于外部类的成员之一，内部类是依赖于外部类的存在而存在。除非程序中已经有了一个外部类的对象，否则内部类一般不会单独存在，内部类也可以被权限修饰符进行修饰，如果内部类被private修饰，那么外界无法创建内部类的对象，只能在外部类中创建内部类的对象

该如何获取内部类的对象呢？

两种方法

方法一

对外部类编写get方法，对外提供内部类的对象

如果内部类没有被private修饰，那么可以在外界创建一个内部类的对象

方法二

直接创建内部类对象

成员内部类创建对象格式

外部类.内部类 类名 = 外部类对象.new 内部类构造方法();

匿名内部类

匿名内部类本质是一个隐藏了名字的内部类。匿名类是只有在创建时才会编写类体的一种写法

语法格式

new 继承/实现(){  //重写的方法 };

匿名内部类在一对大括号 { } 的范围内是一个类，整体却是一个new出来的对象

上述匿名内部类处的语法解读

整体来说就是，使用空参构造创建一个实现了Swit接口的匿名内部类的对象，就是说，创建匿名内部类的地方是创建了一个对象。 匿名内部类编译后会产生一个以 “外部类名$序号“ 为名称的 .class文件，序号以1-n排列，分别代表1-n个匿名内部类。那么我们可以找到这个.class文件，并对其进行反编译来查看我的结论是否正确

javap 命令，可以对.class文件进行反编译，将字节码文件进行反编译，会打印出该字节码文件包含的信息

反编译的结果

被圈起来的是虚拟机自行添加的空参构造与重写的接口方法

匿名内部类的对象如果没有赋值给任何引用变量的话，该对象会在使用后被Java虚拟机自动销毁。 匿名类不能写构造方法。 匿名类不能定义静态的成员

父类对象调用子类方法

public class Demo_4{     public static void main(String[] args) {         Swit s=new Swit(){             public void swit(){                 System.out.println("重写了swit方法");             }         };         s.swit(); // 父类对象调用子类重写的方法     } } interface Swit{     public void swit(); }

匿名内部类的那个整体是一个对象，只有大括号内的才是那个具体的匿名内部类

异常处理

在程序设计和运行的过程中，发生错误是不可避免的。尽管Java语言的设计从根本上提供了便于写出整洁、安全的代码的方法，并且程序员也尽量地减少错误的产生，但使程序被迫停止的错误仍然不可避免。为此，Java提供了异常处理机制来帮助程序员检查可能出现的错误，保证了程序的可读性和可维护性。Java中将异常封装到一个类中，出现错误时，就会抛出异常

异常概述

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

程序运行的结果报告发生了算术异常ArithmeticException(根据给出的错误提示可知发生错误是因为在算术表达式“3/0”中，0作为除数出现)，系统不再执行下去，提前结束。这种情况就是所说的异常。  有许多异常的例子，如数组溢出等。由于Java语言是一门面向对象的编程语言，因此，异常在Java语言中也是作为类的实例的形式出现的。当某一方法中发生错误时，这个方法会创建一个对象，并且把它传递给正在运行的系统。这个对象就是异常对象。通过异常处理机制，可以将非正常情况下的处理代码与程序的主逻辑分离，即在编写代码主流程的同时在其他地方处理异常

异常的抛出与捕捉

抛出异常

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

捕捉异常

Java语言的异常捕获结构由try、catch和finally 3部分组成。其中，try语句块存放的是可能发生 异常的Java语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理 结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块

语法如下

try {     //程序代码块 } catch(Exceptiontype1 e) {     //对Exceptiontype1的处理 } catch(Exceptiontype2 e) {     //对Exceptiontype2的处理 } …… finally {     //程序代码块 }

通过异常处理器的语法可知，异常处理器大致分为try-catch 语句块和finally语句块

try-catch 语句块

将可能出现异常的代码用try...catch代码块进行处理，当try代码块中的语句发生异常时，程序就会跳转到catch代码块中执行，执行完catch代码块中的程序代码后，将继续执行catch代码块后的其他代码，而不会执行try代码块中发生异常语句后面的代码。由此可知，Java的异常处理是结构化的，不会因为一个异常影响整个程序的执行

finally 语句块

完整的异常处理语句应该包含finally代码块，通常情况下，无论程序中有无异常发生，finally代码块中的代码都可以正常执行。但是，在以下4种特殊情况下，finally块不会被执行

在finally语句块中发生了异常。

在前面的代码中使用了System.exitO退出程序。

程序所在的线程死亡。

关闭CPU

java常见的异常类

在Java中，提供了一些异常类用来描述经常发生的异常。其中，有的需要程序员进行捕获处理或 声明抛出，有的是由Java虚拟机自动进行捕获处理

自定义异常

使用java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户只需继承Exception类即可自定义异常类。在程序中使用自定义异常类，大体可分为以下几个步骤

创建自定义异常类

在方法中通过throw关键字抛出异常对象

如果在当前抛出异常的方法中处理异常，可以使用try..catch代码块捕获并处理，否则，在方法的声明处通过throws关键字指明要抛给方法调用者的异常，继续进行下一步操作

在出现异常方法的调用者中捕获并处理异常

自定义异常的抛出与捕捉

创建Tran类，在该类中创建一个带有int型参数的方法avg，该方法用来检查参数是否小于0或大于100。如果参数小于0或大于100，则通过throw关键字抛出一个MyException异常对象，并在main)方法中捕捉该异常

在方法中抛出异常

如果某个方法可能会发生异常，但不想在当前方法中处理这个异常，则可以使用throws、throw关键字在方法中抛出异常

使用throws关键字抛出异常

返回值类型名 方法名（参数表）throws 异常类型名 {     方法体 }

使用throw 关键字抛出异常

throw通常用来抛出用户自定义异常，通过throw关键字抛出异常后，如果想在上一级代码中捕获并处理异常，最好在抛出异常的方法声明中使用throws关键字指明要抛出的异常；如果要捕捉throw抛出的异常，则需要使用try...catch代码块

throw 通常用于在程序出现某种逻辑错误时，由开发者主动抛出某种特定类型的异常

使用thorw关键字捕捉自定义异常

使用throw关键字捕捉异常。在项目中创建Captor类，该类中的quotient()方法传递两个 int 型参数，如果其中的一个参数为负数，则会抛出MyException异常，最后在main()方法中捕捉异常

运行时异常

RuntimeException异常是程序运行过程中抛出的异常。Java类库的每个包中都定义了异常类，所有这些类都是Throwable类的子类。Throwable类派生了两个子类，分别是Exception类和Error类。Em类及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重。Excepia类称为非致命性类，可以通过捕捉处理使程序继续执行。Exception 类又根据错误发生的原因分为RuntimeException异常和除RuntimeException之外的异常

java中提供了常见的RuntimeException异常，这些异常可通过try-catch语句捕获

异常的使用原则

Java异常强制用户去考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码处理某个方法可能出现的异常时，可遵循以下几条原则

1、在当前方法声明中使用try-catch语句捕获异常

2、一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类

3、如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常

字符串

Strinig类

单个字符串可以使用char类型保存，多个字符串组成的文本就需要保存在string对象中。string通常被称为字符串，一个string对象最多可以保存（2^32-1）个字节（占用4GB空间大小）的文本内容

声明字符串

str = "你好";         str = new String("你好");//10和11行输出结果一致

String:指定该变量为字符串类型

str:任意有效的标识符，表字符串变量的名称

创建字符串

String(char a[])该方法用一个字符数组ch创建String对象

String(char a[],int offset,int lenght)该方法提取字符数组c中的一部分创建一个字符串对象。参数offest表示开始截取字符串的位置，lenght表示截取字符串的长度

String(char value)该构造方法可分配一个新的String对象，使其表示字符串数组参数中所有的元素连接的结果

除了以上几种使用String类的构造方法来创建字符串变量外，还可以通过将字符串常量的引用赋值给一个字符串变量来创建字符串

连接多个字符串

连接其他类型数据

获取字符串信息

获取字符串长度

使用string类的length（）方法可获取声明的字符串对象的长度：(str为字符串长度)

str.length();

获取字符串的长度

String str = "we are students"; int size = str.length();

字符串查找

String类提供了两种查找字符串的方法，即indexO方法（）与lastIndexOf()方法

1,indexOf(String s):该方法用于返回参数字符串s在指定字符串中第一次出现的索引位置

str.indexOf(substr

str：任意字符串对象     sbustr：要搜索的字符串

2，lastindexOf(String str):该方法用于返回指定字符串最后一次出现的索引位置

str.lastindexOf(substr)

str：任意字符串对象      sbustr：要搜索的字符串

获取指定索引位置的字符

使用charAt()方法可将指定索引处的字符返回

str.charAt(int index)

str：任意字符串       index:整数型，用于指定要返回字符的下标

字符串操作

获取子字符串

通过string类的substring（）方法可对字符串进行截取。substring（）方法被两种不同的重载形式，来满足不同的需求

substring（int beginIndex）【前索引，后索引（前含后不含）】该方法返回是从指定的索引位置开始截取直到该字符串结尾的子串

str.substring(int beginIndex)

substring(int beginIndex,int endIndex)：  该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串

substring(int beginIndex,int endIndex)

beginIndex:开始截取子字符串的索引位置   endIndex:子字符串在整个字符串中的结束位置

去除空格

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

str.trim()

字符串替换

replace（）方法可实现将指定的字符或字符串替换成新的字符或字符串

str.replace(CharSequence target,CharSequence replacement)

target:要替换的字符或字符串  replacement：用于替换原来字符串的内容

判断字符串的开始与结尾

startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束，这两个方法的返回值都是Boolean类型

startsWith()方法   该方法用于判断当前字符串对象的前缀是否为参数指定的字符串结束

str.startsWith(String prefix)

suffix:作为后缀的字符串

判断字符串是否相等

对字符串对象进行比较不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同

即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。使用比较运算符比较两个字符串

因此，要比较两个字符串内容是否相等，应使用equals()方法和equalsignorecase()方法

如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则，返回false

str.equals(String otherstr)

equalsIgnoreCase（）方法

.忽略了大小写的情况比较两个字符串是否相等，返回结果为Boolean类型

str.equalsIgnoreCase（String otherstr）

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

str.compearTo(String otherstr)

说明：compareTo（）方法只有在equals（）方法返回turn时才返回0

字母大小写转换

toLowerCase()方法【转换小写】

str.toLowerCase()

toUpperCase()方法【转换大写】

str.toUpperCase()

字符串分割

split（）方法

str.split()

split(String sign,int limit)方法

str.split(String sign,int limit)

格式化字符串

String类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式

format（String format.Object...args）  该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境

str.format(String format,Object...args)

format（Local l,String format,Object...args）  该方法使用指定的语言环境，格式字符串和参数返回一个格式字符串，格式化后的新字符串使用其指定的语言环境

str.format(Local l,String format,Object...args)

日期和时间字符串格式化

在应用程序设计中，经常需要显示日期和时间。如果想输出满意的日期和时间格式，一般需要写大量的代码、经过各种算法才能实现。format0方法通过给定的特殊转换符作为参数来实现对日期时间的格式化

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

常用的日期格式化转换符

时间格式化

使用format0方法不仅可以完成日期的格式化，也可以实现时间的格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫秒等格式化时间的转换符

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

格式化日期与时间组合的转换符定义了各种日期时间组合的格式，其中最常用的如下

常见类型格式化

使用正则表达式

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“\d”表示数字9中的任何一个，“d”就是元字符。正则表达式中的元字符及其意义如下

在正则表达式中允许使用限定修饰符来限定元字符出现的次数。例如，“A*”代表 A 可在字符串中出现 0次或多次。限定修饰符的用法如表下

字符串生成器

建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的 String 实例，会在内存中创建新的字符串对象。如果重复地对字符串进行修改，将极大地增加系统开销。而JDK 新增了可变的字符序列 StringBuilder类,大大提高了频繁增加字符串的效率

append()方法

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

append(content)

insert(int offset, arg)方法

该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入 int、float、char 和 boolean 等基本数据类型的数据或其他对象

insert(int offset arg)

delete(int start , int end)方法（前删后不删）

移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end-1处的字符。如果不存在这种字符，则一直到序列尾部。如果 stat 等于 end，则不发生任何更改

delete(int start , int end)

常用类库

包装类

Integer 类

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

Double类

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

Boolean 类

Boolean 类的常用方法

Character 类

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

Number 类

前面介绍了 java 中的包装类，对于数值型的包装类，它们有一个共同的父类——Number 类，该类是一个抽象类

数值型包装类共有方法

数字处理

数字格式化

数字格式化操作主要针对的是浮点型数据，包括 double 型和 float 型数据。在 Java 中使用 java.textDecimalFormat 格式化数字。 DecimalFormat 类是 NumberFormat 的一个子类，用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度

DecimalFormat 类中的特殊字符及其说明

Math 类

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

三角函数方法

指数函数方法

取整函数方法

取最大值、最小值、绝对值函数方法

Random 类

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

Random r = new Random(seedValue);

BigInteger 类

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

在 BigInteger 类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作,使用 BigInteger 类。可以实例化一个 BigInteger 对象，并自动调用相应的构造函数。BigInteger 类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字

BigInteger twolnstance = new BigInteger("2");

BigDecimal 类

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

BigDecimal 类中的常用构造方法

BigDecimal 类实现的加、减、乘、除的方法

BigDecimal 类中的 divi() 方法的多钟处理模式

System 类

System 类是 JDK 中提供的系统类，该类是用 final 修饰的，所以不允许被继承

System 类提供的常用方法

控制台输出字符

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

System.out.print("Hello");

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

System.out.print();”  无参数会报错。

可以自动换行的 println() 方法

System.out.println("Hello");

计时

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 类常用方法

SimpleDateFormat 的格式化

常见的时间格式化

Calender 类

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

Calenderright Now = Calendar.getInstance();

集合类

枚举类型与泛型

lambda表达式与流处理

|/O(输入与输出)