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

初识java

java简介

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

java语言的特性

1.简单

是一种相对简洁的“面向对象”程序设计语言；省略了C++语言中所有的难以理解、容易混淆的特性，如头文件、指针、结构、单元、运算符重载、虚拟基础类等。

2.面向对象

有“面向对象的系统分析”、“面向对象的系统设计”、“面向对象的程序设计”的完整体系

3.分布性

· 可以访问本地文件系统那样通过URL访问远程对象 · 编写Socket{saa·kiht}通信程序 · 公共网关接口（CGI）脚本 · 应用程序（Apple）、Java服务器页面（Java Server Page,JSP）、Servlet

4.可移植性

同时在Windows、MacOs、UNIX等平台上运行。

5.解释型

相当于C/C++语言来说，Java语言的程序效率低，执行速度。但由于计算机日新月异，运行速度也越来越快，用户是不会感觉慢的

6.安全性

具有较高的安全性

7.健壮性

在编译阶段就会发现问题。具备了许多保证程序稳定、健壮的特性，有效地减少了错误。

8.多线性

交互性、实时性

9.高能性

Java语言源程序编写完成后，先使用Java伪编译器进行编译，将其转换为中间码（也称为字节码）再解释。 提高了一种“准实时”（Just-in-Time，JIT）编译器，当需要更快的速度时； 可以使用JIT编译器将字节码转换成机器码，然后将其缓冲下来，这样子速度就会更快。

1.动态

· 可以简单、直观地查询运行时的信息。 · 可以将新代码加入到一个正在运行的程序中去。

搭建java环境

1.JDK下载

2.在widows 10系统下搭建JDK环境

熟悉Eclipse开发工具

熟悉Eclipse

下载和安装Eclipse工具，以及安装中文语言包就不再进行赘述了。这里只需要注意一下：下载的JDK版本（32位或64位）需要和Eclipse版本（32位或64位）相对应，也就是说，如果下载安装的JDK是32位的，那么Eclipse的版本也应该是32位的。

使用Eclipse

1.创建Java项目

2.创建Java类文件

3.使用编辑器编写程序代码

4.运行Java程序

程序调试

java语言基础

java主类结构

成员变量和局部变量

成员变量

定义在类中，方法外的变量就是成员变量

子主题

局部变量

定义在方法中，或者方法声明上的变量就是局部变量

子主题

基本数据类型

1.基本数据类型 

①数值型

整数类型（byte,short,int,long）

浮点型(float,double)

②字符型

③布尔型

2.引用数据类型

1.类class 2.接口类型 interface 3.数组类型 list 4.枚举类型 5.注解类型 6.字符串型（String，String的衍生类，如StringBuilder等

变量与常量

标识符

用来标识类名，变量名，方法名，数组名，文件名的有效字符序列。 标识符由任意顺序的字母，下画线（_），美元符号（￥），数字组成；并且第一个字符不能是数字。 注意：1.不能是"\"（ \ 表示转义字符） 2.不能有"%"（%表示取余） 3.不能有空格 4.避开关键字（即：代码中彩色的字）

关键字

关键字又称保留字，这些单词不可以作为标识符来使用； 关键字不能作为变量名。

常量

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

变量

定义和赋值：类型+变量名（double+weight）

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

局部变量：在类的方法体中声明的变量；只在当前代码块中有效，也就是只能在“{”  “}”之内使用。

运算符

1.算数运算符

+   (可以是： 常量＋常量 ， 变量+常量） - *  /  %     其中   ：    自增运算符（++） 自减运算符  （ --）  只能变量使用     如： NUM++；         i++ 先用再加； ++i  先加再用。

2.逻辑运算符

&&(与)：两者都为真，结果才是真； ||(或)：只要有一者为真，结果就是真； ！(非)：非真即假，非假即真； false &&...&&...：结果一定是false; true ||...||...：结果一定是true;

3.位运算符

^(异或)：两者相同即为0，不同为1； ~(取反)：0变1，1变为0； <<(左移)：整体左移，空位补0，溢出去掉； >>(右移)：整体右移，正数补0，负数补1，溢出去掉； >>>(无符号右移)：整体右移，空位补0，溢出去掉；

4.赋值运算符

赋值运算符以符号“=”表示；将右边的操作数赋值给左边的操作数(变量) 当一条代码出现两个"="时，从右往左执行。 写代码时需将等号拆开写；

例如： int a,b,c; a = 15; c = b = a+4; b= a+4; c = b;

5.自增自减运算符

++a：符号在前，先运算，后使用； a++：符号在后，先使用，后运算； “++a”和“a++”都相当于a = a + 1；“a--”同理. 例：若a = 3;b = 4; b = ++a；//将a的值+1，然后赋值给b；那么a = 4,b = 4+4，所以b = 8; b = a++；//将a的值赋值给b，a的值再+1；那么a = 4,b = 3;

6.比较运算符

比较运算符有七种，分别是： ==（等于）； ===（全等）； !=（不等于）； >（大于）； <（小于）； >=（大于或等于）； <=（小于或等于）

7.三元运算符

格式： 条件式？值1:值2 运行规则：若格式的值为true，则整个表达式取值1，否则取值2

数据类型转换

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

例：将1转化为0.1，数据可能丢失；将0.1转化为1，则数据一定不会丢失。 精准度由低到高排序： byte < shout < int < long <float < double

（1)多种类型参与运算，小的数据类型会自动转换为大的数据类型         double a=3.14;         int b=3;         double c=a+b;

（2)byte，short,char这三种之间不转换，在运算时会直接转换为int类型         byte x=3;         byte y=4;         int z=x+y;

强制类型转换

从数据类型大的到数据类型小的转换； 格式：目标数据类型 变量名 = (目标数据类型)被转换的数据;         byte x=3;         byte y=4;         byte z=(byte)(x+y); //x和y会自动提升为int类型

代码注释与编码规范

代码注释

（1）单行注释 “//”为单行注释标记，从符号“//”开始直到换行为止的所有内容均作为注释而被编译器忽 略。

（2）多行注释 “/* */”为多行注释标记，符号“/*”与“*/”之间的所有内容均为注释内容。注释中的内容可 以换行。

文档注释

· 每条语句要单独占一行，一条命令要以分号结束。

· 在声明变量时，尽量使每个变量的声明单独占一行，即使是相同的数据类型也要将 其放置在单独的一行上，这样有助于添加注释。对于局部变量应在声明的同时对其进行初始化。

· 在Java代码中，关键字与关键字间如果有多个空格，这些空格均被视作一个。

· 为了方便日后的维护，不要使用技术性很高、难懂、易混淆判断的语句。由于程序的开发与维护不能是同一个人，所以应尽量使用简单的技术完成程序需要的功能。

· 对于关键的方法要多加注释，这样有助于阅读者了解代码结构。

流程控制

复合语句

一条复合语句由一个或多个‘子句’组成。 一个子句则包含一个句头和一个‘句体’。 特定复合语句的子句头都处于相同的缩进层级。 每个子句头以一个作为唯一标识的关键字开始并以一个冒号结束。 子句体是由一个子句控制的一组语句。 子句体可以是在子句头的冒号之后与其同处一行的一条或由分号分隔的多条简单语句，或者也可以是在其之后缩进的一行或多行语句。 只有后一种形式的子句体才能包含嵌套的复合语句；以下形式是不合法的，这主要是因为无法分清某个后续的 else 子句应该属于哪个 if 子句: if test1: if test2: print(x) 还要注意的是在这种情形下分号的绑定比冒号更紧密，因此在以下示例中，所有 print() 调用或者都不执行，或者都执行: if x < y < z: print(x); print(y); print(z)

条件语句

if语句

if语句是用来判定所给定的条件是否满足，根据判定的结果（真或假）决定执行给出的两种操作之一；Verilog HDL语言提供了3种形式的if语句。

第一种：if（表达式）语句 if(a>b)         out1 = int 1;

第二种：if（表达式） if（表达式）                 语句1         else                 语句2 例如： if(a>b)         out1 = int1; else         out1 = int2;

第三种： if(表达式1)         语句1; else        if(表达式2)        语句2; else        if(表达式3)        语句3 ;                         ......                         ......                         ...... else        if(表达式m)        语句m; else                                  语句n;

switch多分支语句

在switch语句中表达式的值必须是整型或者字符型，常量值也必须是整型或者字符型，二者是一一对应的。 switch语句首先计算表达式的值，如果表达式的值和某个case后面的常量值相同则执行该case语句后的若干个语句知道遇到break;语句为止。 如果case语句中没有break;将执行后面的case语句知道遇到break语句为止。 若没有一个常量值与表达式的值相同则执行最后一面的default语句。default语句是可选的，如果没有一个常量值与表达式的值相同，则switch语句不执行任何操作。

switch多分支语句的语法： switch(表达式){    case 常量值：要执行的语句;    break;    case 常量值：要执行的语句;    break;    case 常量值：要执行的语句;    break;    default:    执行语句; }

循环语句 循环四要素：初始化变量，循环条件，循环操作，改变变量的值（防止死循环）

while循环（先判断在执行）

do...while循环： 此条循环语句的作用其实与while语句的作用类似，不过do…while循环不同于while循环的一点在于，dowhile循环是先执行循环体的内容，最后在进行条件表达式判断，这是与while循环不同之处

for循环： for是将 表达式初始化、条件判断、表达式计算，这三种操作集成为一体的一种循环语句。一定程度上简化了代码的变量个数。

语法格式： for(表达式初始化; 条件判断; 表达式计算){  语句序列; }

循环控制

break语句： break语句只能在循环中或者switch语句中使用，它的作用是跳出离它最近的一个循环或switch，或者跳出指定循环。

continue语句： continue语句是对针对break语句的补充，break语句是立即结束最近的一个循环体，而continue语句是结束本次循环。

数组

一维数组； 一维数组实际上是一组相同类型数据的线性集合

一维分配内存： 数组名=new 数组元素的类型【数组长度】 分配内存同时设置初始值 数组名=new 数组元素的类型【】{值1，值2，...，值n}

二维数组； 数组元素的类型【】 数组名 数组元素的类型 数组名 【】

二维数组分配内存： 数组名=new 数组元素的类型[行数][列数] 二维数组分配内存同时设置初始值 数组名=new 数组元素的类型【】{{值1，值2，...},{值1，值2，...},{值1，值2，...}}

二维数组元素赋值： 数组名[ 索引 ]= {值1，值2，...}； 数组名[ 行号 ][ 列号 ]= 值 ；

数组的基本操作

替换部分数组元素： 前改后不改 Arrays.fill(数组名，前索引，后索引，值);

复制数组元素： 数组的完全复制，返回一个与arr数组元素相同的数组。 newlength：复制后的新数组的长度，空位补0，溢出去掉 新数组名=Arrays.copyOf（旧数组名，新数组长度）；

复制数组部分元素：前在后不在 新数组名=Arrays。copyOFRange（旧数组名，前索引，后索引）；

数组元素排序 Arrays.sort（数组名）；

数组排序算法

查询数组元素：先排序再查询 索引= Arrays.binarySearch(数组名，值）；  在a数组中查询key的下标位置，并且返回该下标。 数据查询方法，该方法底层实现是通过二分搜索来查找key，所以在使用该方法前，需要让数组有序

指定区间内查询； 左闭右开区间，查找的返回包括前索引，但是不包括后索引。 目标值下标=Arrays.binarySearch(数组名，前索引，后索引，元素)；

冒泡排序； 冒泡算法由双层循环实现，其中外层循环用于控制排序轮数

直接排序； 循环将最大的数放到最后，固定不动，第二次再将最大的数放到最后，固定不动，往后继续。

反转排序； 简称倒排，将数组中的元素倒序一遍；

类和对象

面向对象概述

对象： 在现实生活中，随处可见的一种事物就是对象； 分为静态和动态；静态部分是不能动的部分，称为属性。动态部分即对象可执行的动作，称为行为。

类： 将属性和行为封装起来，构成一个类；类的实质就是封装的对象属性和行为的载体，而对象则是类抽象出来的实例。

封装： 封装是面向对象编程的核心思想；将对象的属性和行为封装起来，其载体是类，类通常对客户隐藏其实实现细节，这就是封装的思想。 面向对象程序设计具有以下特点：封装性，继承性和多态性。

继承： 类与类之间具同样具有关系，这种关系被称为关联；关联主要描述两个类之间的一般二元关系。 当处理一个问题时，可以将一些有用的类保留下来，当遇到同样的问题时拿来复用，可以减少使用过程中出现的错误的概率； 继承主要利用对象之间的共有属性。

多态： 将父类对象应用于子类的特征就是多态；简单地调用父类也就是图形类绘制图的方法即可绘制任何图形，这就是多态最基本的思想； 多态性允许以统一的风格编写程序，以处理种类繁多的已存在的类及相关类；在多态的机制中，比抽象类更方便的方式是将抽象类定义为接口；由抽象方法组成的集合就是接口。

类

成员变量： 在Java中对象属性称为成员变量，成员变量为任意类型。

成员方法： 一个成员方法可以有参数，这个参数可以是对象，也可以是基本数据类型的变量，同时成员方法有返回值和不返回任何值的选择；如果方法需要返回值，可以在方法体中使用return关键字，使用这个关键字后，方法的执行将被终止。 定义成员方法的语法格式如下： 权限修饰符 返回值类型 方法名（参数类型 参数名）{ ... //方法体 return 返回值； }

权限修饰符： Java的权限修饰符主要包括private，public和protected package com.mr; class AnyClass {     public void doString(){         ... //方法体     } }

局部变量：没有初始值,所以必须先初始化才能使用.

局部变量作用有效范围：局部变量在方法创建时生效，在方法结束时被销毁。 技巧：在互不嵌套的作用域中可以同时声名多个名称，类型相同的局部变量；但在相互嵌连的区域中不能重复定义。

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

public void setName(String name) {   //定义一个setName()方法 this.name=name;   //将参数值赋予类中的成员变量 }

this除了可以调用成员变量和成员方法，还可以作为方法的返回值，如： public Book getBook（）{ return this;  //返回Book类的本类对象 }

类的构造方法 在类中，除成员方法外，还存在一种特殊类型的方法，那就是构造方法，构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的，当类实例化一个对象时，类都会自动调用构造方法。 特点如下： 构造方法没有返回值； 构造方法的名称要与本类的名称相同；

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

静态变量和静态方法 在介绍静态变量和静态方法前，首先需要介绍static关键字，因为由static修饰的变量和方法称为静态变量和静态方法。

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

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

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

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

对象

对象的创建： 在前面中讲解过对象，对象可以认为是在一类事物中抽象某一个特例，可以通过这个特例来处理这类事物出现的问题，在java语言中，通过new操作符来创建对象，在讲解构造方法时介绍过，每实例化一个对象就会自动调用一次构造方法，实质上这个过程就是创建对象的过程；

语法如下： Test test = new Test(); Test test = new Test("a");

访问对象的属性和行为： 用户使用new操作符创建一个对象之后，可以使用“对象.类成员”来获取对象的属性和行为，前面已提到过，对象的属性和行为在类中是通过类的成员变量和成员方法的形式来表示的，所以当对象获取类成员时，也相应地获取了对象的属性和行为。

对象的引用： 语法如下： 类名 对象的引用变量  例如；一个People类的引用可以使用以下代码： People tom; 通常一个引用不一定需要有一个对象相关联；引用与对象相关联的语法： People tom = new People();

实际上真正的对象是“new people（）”这段代码，为了方便开发者保存，，调用对象，于是创建了一个people类型，名叫tom的引用变量。既然tom是new people的“代理人”,那么“new people（）”对象能做的事情，tom也能做；例如： new People().getClass 等价于： People tom = new People(); tom.getClass

对象的销毁： 每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收。在其他语言中，需要用户手动回收废弃的对象。Java 拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源。

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

类的继承

继承在人类个体之间说的是物质的继承，那么在Java中类与类之间的继承也类似于此，类在继承关系中分为两种，一种是父类，属于是被继承类，一种是子类，属于是继承类； 如果某一个类继承了另一个类，那么该类就是子类，被继承的类就是父类； Java中一个类继承另一个类，需要使用到关键字extends

使用方法： class Child extends Parent {} //类Child 继承于类 Parent

注意: 在Java中只支持单继承，一个子类只能拥有一个父类，但是一个父类可以拥有多个子类；不允许多继承，但是允许多重继承。 错误代码如下： class C extends A,B {} 允许多重继承： class A{} class B extends A{} class C extends B{ } 子类继承父类之后可以调用父类创建的好的属性和方法；

Java虽然不允许同时继承两个父类，但不代表没有多继承的关系，可以通过类似“祖父>父亲>儿子>孙子”之类的方式实现多代继承 。

Object类

Object类是Java中的顶级父类，在Java中所有类都直接或间接的继承与Object类，它是所有类的父类；主要包括clone（）、finalize（）、equals（）、toString（）等方法； 由于所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法。（注意Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为这些都被定义为final类型。）

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

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

3.equals()方法 在Java语言中，有两种比较对象的方式，分别为“==”运算符与equals()方法。两者的区别在于：“==”比较的是两个对象的引用内存地址是否相等，而equals()方法比较的是两个对象的实际内容。  注意： 在使用equals() 方法比较自行编写的类对象时，那么需要先重写equals方法，因为每个类判相等的规则都是不一样的。而且如果没有重写的话，那么系统会自动调用Object中的equals方法。

对象类型的转换

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

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

注意：在进行向上类型转换后，父类对象依旧无法调用子类独有的属性与方法；只能调用从父类中继承下来的属性与方法。

向下转型 向下类型转换可以理解为将父类类型的对象转换为子类类型的对象。；但是运用向下转型，因为父类大多是较为抽象的类，而子类大多是具体的类， 而将一个较为抽象的类转换为一个较为具体的类，这样的转换通常会出现错误，所以向下转型是不安全的。

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

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

myobject：某类的对象引用。 ExampleClass：某个类。 误区警示：instanceof是Java语言的关键字，Java语言中的关键字都为小写。

方法的重载

方法的重载就是在同一个类中允许存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可； 重载与重写不同但又十分相似；重写是：返回参数相同 方法名相同 传入参数相同 只有方法体不同；重载则是：方法名相同 参数不同 重载和重写的区别在于：重载必须要有继承关系才能使用，而重写只要在同一个类里就能使用

不定长参数

在谈到参数个数可以确定确定两个方法是否具有重载关系时，会想到定义定义不定长参数方法； 语法如下： 返回值  方法名（参数数据类型...参数名称）

final关键字

1.final变量 用final修饰的变量就不可以在改变该变量的值； final修饰变量——不能被改变（常量）

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

例： public class Dad {  public final void turnOnTheTV() {   System.out.println("爸爸打开了电视");  } } class Baby extends Dad{  public final void turnOnTheTV() {   System.out.println("宝宝也要打开电视");  } }     //若用 final修饰则子类不可以重写父类的方法 ，代码将报错

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

多态

同一方法或同一个地方出现不同的形态就叫多态； 利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。 定义如下： public void draw(Square s){  //绘制正方形的方法 } public void draw(Cicular c){  //绘制圆形的方法 }

抽象类与接口

抽象类

一般将父类定义为抽象类，需要使用这个父类进行继承与多态处理；子类要继承父类，在父类里，有抽象方法出现的情况（子类会继承抽象方法）：父类将制定一种规则：子类必须重写两个抽象方法，不然就会报错。  使用abstract 关键字定义的类型为抽象类；抽象方法没有方法体，这个方法本身没有任何意义，除非它被重写；有抽象方法的类一定是抽象类。

语法如下： 修饰符 abstract class 类名{   ... ... } public abstract class Parent{     abstract void testAbstract();  //定义抽象方法 }

将抽象方法写入普通类中会报错；有两种方法改变 : 1.将abstract移除加上方法体 2.将普通类改成抽象类

接口

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

假设接口有三个方法，但是普通类只写了两个情况该怎么解决： 1.将普通类改成抽象类 2.将没写的方法重写 对象名+instanceof+接口名（判断对象是否属于这个接口的实现类）

语法如下： public interface Paintable {     void draw();  //定义接口方法可省略public abstract 关键字 } //修饰符 class 类名 implements 接口1, 接口2....{ }

包和内部类

创建包

1.双击eclipse弹出路径对话框，并复制路径

2.复制路径到文件夹中查找

3.查找后，可以看见在Eclipse里的Java代码，选择一个项目，打开src

4.新建一个项目，在里面创建一个包，右击选择package；返回文件夹就能看新建的包

5.同时创建包并在包里创建一个类

6.创建包，存储域名

7.在创建包存储域名时，把域名一次性打上去

导入包

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

在进行导包后，我们在使用该包下的Math类后，可以看到，java.lang包下有一个Java给定的Math类，还有一个我们刚刚进行导的包下的Math类； 需要注意的是，如果使用import导入某个包下的所有类时，这些类并不包括该包下的子包的类。如果需要使用子包中的类时，需要对子包进行单独引用。

类路径

如果一个程序内存在多个同名不同包的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)

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

导入静态方法或静态成员

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

内部类

内部类就定义在一个类内部的类；

1、成员内部类 定义在一个类成员位置的内部类，称为成员内部类，在成员内部类中可以使用外部类的的任意成员变量与成员方法，即使该外部类成员变量被private所修饰。

class OuteruClass{    //外部类   class InnerClass{     //内部类     }   }

成员内部类不止可以 在外部类使用，在其他类中也可以使用。在其他类中创建内部类的对象语法特殊；

语法如下：  外部类 outer = new 外部类（） 外部类.内部类 inner = outer.new 内部类（）；

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

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

匿名类的特点：现用现写； 匿名内部类在一对大括号 { } 的范围内是一个类，整体却是一个new出来的对象。

使用匿名类时应该遵循以下几点原则： 1、匿名类不能写构造方法。 2、匿名类不能定义静态的成员。 3、如果匿名类创建的对象没有赋值给任何引用变量，会导致该对象用完一次就会被java虚拟机销毁。 说明：匿名内部类编译以后，会产生以“外部类名$序号”为名称的.class文件，序号以1~n排列，分别代表1~n个匿名内部类。

异常处理

异常的抛出和捕捉

抛出异常

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

捕捉异常

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

语法如下： try{     //程序代码块 } catch（Exception1 e）{       //对Exception1的处理   } catch（Exception2 e）{       //对Exception2的处理 } ... finally{     //程序代码块 }

处理操作中的五个关键词： throws: 声明本方法中可能会发生某某异常 throw: 抛出某某异常 try, catch, finally: 捕获并处理某某异常

try、catch语句就是用来捕捉和异常处理的；

finally语句块

无论程序是否出现异常，都会执行finally语句，但是在以下四种情况不会执行finally语句块 1.在finally语句块中出现异常 2.在前面的代码块中使用了System.exit()退出程序 3.程序所在线程死亡 4.关闭cpu

自定义异常类

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

在方法中抛出异常

使用throws关键字抛出异常

throws将代码中可能产生的异常交给别人来处理；throws 应用在明法时，用来指定方法可能抛出的异常，多个异常可使用逗号分隔；语法如下： public void method() throws 异常类型1,异常类型2,...异常类型n{   }

创建方法时，可以使用throws将可能发生的异常抛出，抛出以后该方法就不需要用try-catch来处理，当调用一个含有throws声明异常抛出的方法时，要求必须处理该异常，而处理方式有两种： (1).使用try-catch捕获并解决异常 (2).在当前方法上继续使用throws声明该异常的抛出

//被调用时 try{  method(); }catch(异常类型 e){  e.printStackTrance(); }

使用throw关键字抛出异常

throw关键字通常用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，它后面的语句都不执行。通过throw抛出异常后，如果想在上一级代码中来捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法的声明中指明要抛出的异常；如果要捕捉throw抛出的异常，则必须使用try-catch语句。

异常使用可遵循下面的原则： (1).不要过度使用异常，虽然通过异常可以增强程序的健壮性，但如果使用过多不必要的异常处理，可能会影响程序的执行效率； (2).不要使用过于庞大的 try...catch块；在一个try块中放置大量的代码。这种写法看上去“很简单”但是由于try块中的代码过于庞大，业务过于复杂，会造成try块中出现异常的可能性大大增加，从而导致分析异常原因的难度也大大增加； (3).避免使用catch（Exception)；因为如果所有异常都采用相同的处理方式，将导致无法对同异常分情况处理;另外，这种捕获方式可能将程序中的全部错误，异常捕获到，这时如果出现些“关键”异常，可能会被“悄悄地”忽略掉； (4).不要忽略捕捉到的异常，遇到异常一定要及时处理； (5).如果父类抛出多个异常，则覆盖方法必须抛出相同的异常或其异常的子类，不能抛出来异常。

字符串

String类

声明字符串

在Java语言中，字符串必须包含在一堆双引号（"")之内。 例如："23.23"、"ABCDE"、"你好" 可以通过以下语法格式莱声明字符串变量： String str;

String:指定该变量为字符串类型。 str:任意有效的标识符，表示字符串变量的名称。 声明字符串变量s，代码如下 ：  String s;

创建字符串

在Java语言中，将字符串作为对象来处理，因此可以像创建其他类对象一样来创建字符串对象。创建对象要使用类的构造方法

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

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

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

连接字符串

使用“+”运算符可实现连接多个字符串的功能。“+”运算符可以连接多个String对象并产生一个新的String对象

字符串也可同其他基本数据类型进行连接。如果将字符串同其他数据类型进行连接，会将其他数据类型的数据直接转换成字符串

获取字符串信息

获取字符串长度： 使用String类的length（）方法可获取声明的字符串对象的长度。语法如下： str.length();    //str为字符串对象

获取字符串长度，代码如下： String str ="We are students"; int size = str.length();

字符串查找： String类提供了两种查找字符串的方法，是indexOf()与lastIndexOf方法。

1.indexOf(String s) 该方法用于但会参数字符串s在指定字符串中首次出现的索引位置 语法：str.indexOf(substr)     //str:任意字符串对象    //substr: 要搜索的字符串

查找字符a在字符串str中的索引位置，代码如下; String str ="We are students"; int size = str.indexOf("a")       //变量size的值是3

2.lastIndexOf(String str) 该方法用于但会指定字符串最后一次出现的索引位置 语法：str.lastIndexOf(substr)    //str:任意字符串对象       substr:要搜索的字符串 注意：如果lastIndexOf()方法中的参数是空字符串""(注意没有空格)，则返回的结果与调用length()方法的返回结果相同

获取指定索引位置的字符： 使用charAt()方法可将指定索引处的字符返回

语法：str.charAt(int index)    //str:任意字符串。       index:整型值，用于指定要返回字符的下标。

字符串操作

获取子字符串： 通过String类的substring()方法可对字符串进行截取。substring()方法被两种不同的重载形式，来满足不同的需要。

1.substring(int beginlndex) 该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串， 语法：str.substring(int beginIndex) 其中，beginIndex指定从某一索引处开始截取字符串

截取字符串，代码如下： String str ="Hello World";         //定义字符串str String substr = str.substring(3);      //获取字符串，此时substr值为lo World 注意：在字符串中，空格占用一个索引位置

2.substring(int beginlndex，int endIndex) 该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串 语法：substring(int beginlndex，int endIndex) beginlndex：开始截取子字符串的索引位置 endIndex：子字符在整个字符串中的结束位置

去除空格：  trim()方法返回字符串的副本，忽略前导空格和尾部空格 语法：str.trim()  str为任意字符串对象

字符串替换： replace()方法可实现将指定的字符或字符串替换成新的字符或字符串。 语法;str.replace(CharSequence target,CharSequence replacement)  //target:要替换的字符或字符串     replacement：用于替换原来字符串的内容     replace()方法返回的结果是一个新的字符串，如果字符或字符串oldChar没有出现在该对象表达式中的字符串序列中，则将原字符串返回。

判断字符串的开始与结尾： stsrtsWith()方法与endsWith()方法分别于判断是否以指定的内容开始或结束。这两个方法的返回值都为boolean类型。

1.stsrtsWith()方法 该方法用于判断当前字符串对象的前缀是否为参数指定的字符串 语法：str.stsrtsWith(String prefix)    //prefix是指作为后缀的字符串

2.endsWith()方法 该方法用于判断当前字符串是否为以给定的子字符串结束 语法:str.endWith(String suffix)     //suffix是指作为后缀的字符串

判断字符串是否相等： 对字符串对象进行比较不能简单地使用比较运算符“==”

代码： String tom =new String("I am a student");     String jerry = new String("I am a student");     boolean b = (tom == jerry);

1.equals()方法 如果两个两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则，返回false。 语法：str.equals(String otherstr)    //其中str、otherstr是要比较的两个字符串对象

2.equalslgnoreCase()方法  使用equals()方法对字符串进行比较时是区分大小写的，而使用equalslgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍为boolean类型 语法如下：equalslgnoreCase(String otherstr)  //其中str、otherstr是要比较的两个字符串对象

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

compareToO方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，按字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。 如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。 语法如下：str.compareTo(String otherstr)     //str、otherstr是要比较的两个字符串对象  注意：compareTo()方法只有在equals(Object)方法返回true时才返回0

字母大小写转换： String 类的toLowerCase（)方法可将字符串中的所有大写字母改写为小写字母，而toUpperCase（)方法可将字符串中的所有小写字母改写为大写字母。

1.toLowerCase（)方法 该方法将字符串中的所有大写字母转换为小写 语法：str.toLowerCase（)       //str是要进行转换的字符串

2.toUpperCase（)方法 该方法将字符串中所有小写字母转换为大写 语法：str.toUpperCase（)       //str是要进行转换的字符串

字符串分割： 使用string类中的split()方法可以对字符串进行分割

1.split(String sign) 语法：str.split(String sign) sign ：为分割字符串的分隔符，也可以使用正规表达式

2.split(String sign,int limit) 该方法可根据给定的分割符对字符·串进行拆分，并限定拆分的次数； limit ：主要用来限制的分割次数。 语法：str.split(String sign,int limit)

格式化字符串

1.format(String format, Object... args) 语法如下：str.format(String format,Object...args) format：格式化字符串 args:格式化字符串中由格式说明字符引用的参数

2.format(Local I,String format,Object...args) 该方法使用指定的语言环境、格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用其指定语言环境。 语法：str.format(Local I,String format,Object...args) I: 格式化过程中要应用的语言环境。 format:格式字符串 args：格式字符串中由格式说明符引用的参数。可以为0

日期格式化 例： Date data = new Date();      //创建Date对象date String s = String.formate("%te",date);      //通过format()方法对date进行格式化

时间格式化

常规类型格式化 常规类型格式化可应用于任何参数类型

常用类库

包装类

Integer类

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

Integer类提供了以下4个常量: MAX VALUE:表示 int 类型可取的最大值,即³¹。 2³¹−1。 MIN VALUE:表示 int 类型可取的最小值,即³¹。 −2³¹。 SIZE：用来以二进制补码形式表示int值的位数。 TYPE:表示基本类型int 的Class实例。

Double类

Double类和Float 类是对double、float 基本类型的封装,它们都是Number 类的子类,都是对浮点数进行操作，所以常用方法基本相同； Double 类在对象中包装一个基本类型为double 的值，每个Double类的对象都包含一个double 类型的字段。此外,该类还提供多个方法,可以将double 类型转换为String 类型,将String 类型转换为double类型，也提供了其他一些处理double类型时有用的常量和方法。

Double类主要提供了以下常量： MAX EXPONENT:返回 int 值,表示有限 double 变量可能具有的最大指数。 MIN EXPONENT:返回 int 值,表示标准化 double 变量可能具有的最小指数。 NEGATIVE INFINITY:返回 double 值,表示保存 double 类型的负无穷大值的常量。 POSITIVE INFINITY:返回 double 值,表示保存 double 类型的正无穷大值的常量。

Boolean类

Boolean类将基本类型为boolean的值包装在一个对象中。一个Boolean 类型的对象只包含一个类型为boolean的字段。此外，此类还为boolean类型和String 类型的相互转换提供了许多方法，并提供了处理boolean 类型时非常有用的其他一些常量和方法。

Boolean提供了以下3个常量: TRUE:对应基值true的Boolean 对象。 FALSE:对应基值false的Boolean 对象。 TYPE:基本类型boolean 的Class对象。

Character类

Character类在对象中包装一个基本类型为char的值，该类提供了多种方法，以确定字符的类别(小写字母、数字等)，并可以很方便地将字符从大写转换成小写，反之亦然。Character 类提供了很多方法来完成对字符的操作

Character类提供了大量表示特定字符的常量，例如： CONNECTOR_PUNCTUATION:返回 byte 型值,表示 Unicode 规范中的常规类别“ Pc ”。 UNASSIGNED:返回byte 型值,表示Unicode规范中的常规类别“Cn”。 TITLECASE_LETTER:返回 byte 型值,表示 Unicode 规范中的常规类别“ Lt ”。 说明：Character类提供的常量有很多,详细列表可查看Java API文档。

Number类

Java中的抽象类Number类的子类包括：Byte、Short、Integer、Long、Float、Double。 Number类属于java.lang包。

数字处理

数字格式化

在Java中，没有格式化的数据遵循以下原则： 如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。 如果数据绝对值小于0.001或者大于10000000，是用科学计数法表示。

Math类

Math类提供了众多数学函数方法，这些方法都被定义为static形式 形式调用如下：Math.数学方法 在Math类中，除了函数方法外还存在一些常用数学常量，如PI、E。 形式调用如下： Math.PI Math.E

(1).三角函数方法 Math类中包含的三角函数方法如下： _ public static double sin(double a);返回角的三角正弦。 public static double cos(double a);返回角的三角余弦。 public static double tan(double a);返回角的三角正切。 public static double asin(double a):返回一个值的反正弦。 public static double acos(double a):返回一个值的反余弦。 public static double atan(double a):返回一个值的反正切。 public static double toRadians(double angdeg):将角度转换为弧度。 public static double toDegrees(double angrad):将弧度转换为角度。

(2).指数函数方法 Math类中与指数相关的函数方法如下。 public static double exp(double a):用于获取e的a次方,即取eᵃ。 public static double log(double a):用于取自然对数,即取lna的值。 public static double log10(double a);用于取底数为10的a的对数。 public static double sqrt(double a):用于取a的平方根,其中a 的值不能为负值。 public static double cbrt(double a):用于取a的立方根。 public static double pow(double a, double b):用于取a的b次方。

(3).取整函数方法 在具体的问题中，取整操作使用也很普遍，所以Java 在Math类中添加了数字取整方法。Math类中主要包括以下几种取整方法： public static double ceil(double a):返回大于等于参数的最小整数。 public static double floor(double a):返回小于等于参数的最大整数。 public static double rint(double a):返回与参数最接近的整数,如果存在两个同样接近的整数,则结果取偶数。 public static int round(float a):将参数加上0.5后返回与参数最近的整数。 public static long round(double a):将参数加上0.5 后返回与参数最近的整数,然后强制转换为长整型。

(4). 取最大值、最小值、绝对值函数方法 在程序中最常用的方法就是取最大值、最小值、绝对值等，Math类中包括的操作方法如下： public static double max(double a,double b):取a与b之间的最大值。 public static int min(int a,int b):取a与b之间的最小值，参数为整型。 public static long min(long a,long b):取a与b之间的最小值，参数为长整型。 public static float min(float a,float b):取a与b之间的最小值，参数为单精度浮点型。 public static double min(double a,double b):取a与b之间的最小值，参数为双精度浮点型。 public static int abs(int a)：返回整型参数的绝对值。 public static long abs(long a)：返回长整型参数的绝对值。 public static float abs(float a):返回单精度浮点型参数的绝对值。 public static double abs(double a)：返回双精度浮点型参数的绝对值。

Random类

Random对象创建一个随机数生成器语法如下： Random r = new Random; 设置随机数生成器的种子 语法如下： Random r = new Random(seedValue);

r: Random类对象。 seedValue：随机数生成器的种子。 在Random类中，提供了获取各种数据类型随机数的方法，下国之伙2今孙田计前 public int nextInt):返回一个随机整数。 public int nextInt(int n):返回大于等于0且小于n的随机 public long nextLong()：返回一个随机长整型值。 public boolean nextBoolean):返回一个随机布尔型值。 public float nextFloat()：返回一个随机单精度浮点型值。 public double nextDouble()：返回一个随机双精度浮点型应  public double nextGaussian):返回一个概率密度为高斯少士8台晰明向叶进研

BigInteger类

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

注意:参数2的双引号不能省略，因为参数是以字符串的形式存在的。 一旦创建了对象实例，就可以调用Biglnteger 类中的一些方法进行运算操作，包括基本的数学。算和位运算以及一些取相反数、取绝对值等操作。 下面列举了Biglnteger类中常用的几种运算方法： public BigInteger add(BigInteger val)：做加法运算。 public BigInteger subtract(BigInteger val)：做减法运算。 public BigInteger multiply(BigInteger val)：做乘法运算。 public BigInteger divide(BigInteger val)：做除法运算。 public BigInteger remainder(BigInteger val)：做取余操作。 public BigIntegerl] divideAndRemainder(BigInteger val):用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。 public BigInteger pow(int exponent):进行取参数的exponent次方操作。 public BigInteger negate()：取相反数。

BigDecimal类

在BigDecimal类，常用的两个构造方法如下：

BigDecimal类实现的加减乘除的方法如下：

System类

控制台输出字符

(1).不会自动换行的print()方法 printO方法的语法如下： System.out.print("Hello!"); 此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello”文字末尾，不会自动换行。

(2). 可以自动换行的 println()方法 printlnO方法在print后面加上了“1n”后缀(就是line的简写)，语法如下： System.out.println(”书籍是人类进步的阶梯！”)； 此方法输出“书籍是人类进步的阶梯！”后会自动换行。光标停留在下一行的开头。

计时

Scanner类

canner类首先要引入该类，语法如下： import java.util.Scanner;     //引入Scanner类

日期时间类

1.Date类

使用Date类的第2种构造方法创建一个Date类的对象，代码如下： long timeMillis = System.currentTimeMillis();    //当前系统时间所经历的毫秒数 Date date =new Date(timeMillis);

2.日期时间格式化

DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化。DateFormat类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种： SHORT：完全为数字，如12.13.52或3：30pm。 MEDIUM：较长，如Jan 12,1952。 LONG:更长，如January 12,1952或3：30：32pm。 FULL：完全指定，如Tuesday、April 12、1952AD或3：30:42pm PST。

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

3.Calendar类

Calendar 提供了一个类方法 getnstance()，以获得此类型的一个通用的对象。Calendar类的grtnstance()方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化，其使用方法如下： Calendar rightNow =Calendar.getlnstance();

说明：由于Calendar类是一个抽象类，不能用new创建实例对象，因此除了使用getInstance0方法创建其对象，如果需要创建其对象，必须使用其子类，如GregorianCalendar类。

Runtime类

1.执行本地命令

本地命令指的是操作系统的命令。例如，在Linux系统下就表示shell命令，在Windows系统下就表示cmd命令。 Rutime类提供exec()方法让Java代码可以执行系统的命令，exec)方法有很多重载的形式，例如： Process exec(String command) Process exec(String， cmdarray)

command：要执行的系统命令，字符串类型。 cmdarray：要执行的命令和相应的命令参数，字符串数组类型。

2.查看内存