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

第七章继承，多态，抽象类与接口

接口

如果在一个抽象类的所有方法都是抽象的，则可以将这个类用另外一种方式来定义，即接口。接口是由常量和抽象方法组成的特殊类，是对抽象类的进一步抽象。    使用接口可以实现多重继承，一个类可以同时实现多个接口，于是可以将所有需要继承的接口放置implements关键字后使用逗号隔开，实现多个接口语法如下： 修饰符 class 类名 implement 接口1，接口2....{ }

多态

（1）多态的概念

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

（2）多态的类型转换

对象类型的转换在java编程中经常遇到，主要包括向上转型和向下转型操作 1.向上转型 向上转型：将子类对象赋值给父类引用 (自动类型转换) Animal  a=new Dog(); 2.向下转型  向下转型：将父类对象赋值给子类引用 （需要进行强制类型转换） Dog a=(Dog) new Animal();

object类

在Object类中，主要包括clone（），finalize（），equals（），toString()等方法，其中常用的两个方法为equals()和toString()方法。由于所有的类都是object类的子类，所以任何类都可以重写object类中的方法。 （1）getClass（）方法 getClass（）方法是object类定义的方法，它会返回对象执行的Class实例，然后使用该实例调用getName（）方法可以取得类的名称。语法如下： getClass（）.getname（）；  方法的重写 返回参数相同，方法名相同，传入参数相同，方法体不同 （2）tostring（）方法 tostring（）的功能是将一个对象返回为字符串形式，它会返回一个String实例，在实际的应用中通常重写tostring（）方法，为对象提供一个特定的输出的模式，当这个类转换为字符串或与字符串连接时，将自动调用用重写的tostring（）方法。 equals（）方法 在Java语言中，有两种比较对象的方式，分别为“==”运算符与equals（）方法，两者区别在于：“==”比较的是两个对象引用内存地址是否相等，而equals（）方法比较的是两个对象的实际内容，所以equals（）方法判断出了这两个对象实际上是同一个，而“==”运算符无法做出有效判断，如果两个对象类型的不同，那么equals（）方法就会认为两者都不同 。

类的继承：

Java语言每一个类只能继承一个父类。叫做单继承； extends（继承）， 父类的写法； public class 父类类名 (){ } 子类的写法 public  class 子类类名 extends 父类类名； 所有类的构造方法第一行都有一个隐藏的“super();"作用是在执行该构造方法之前调用其父类构造方法 子类重写父类的方法： 返回参数相同方法名相同传入参数相同只有方法体不同

对象类型的转换：

向上转型 clone=克隆； equals=相同； finalize=相等； toSteing= 子类对象赋值给父类引用  Animal a = newDog(); 自动类型转换

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

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

对象名 instanceof 类名 作用： 判断对象是否属于该类或其子类 对象名  instanceof  接口名  判断对象是否属于该接口的实现类

方法的重载

方法名相同 参数不同,返回值 方法名（参数数据类型....参数名称）

final关键字

final变量： final修饰变量----不可改变的量（常量）

final方法： final修饰方法----不可被重写

final类： final修饰类----不能被继承

抽象类

抽象方法： 修饰符 abstract 返回参数 方法名（传入参数）;列：public abstract void methodName() 抽象类： 使用abtract而使用这个关键字定义的方法称为抽象方法。抽象方性没有方法体，这个方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继承 实际上抽象类除了被维承没有任何意义.定义抽象类的语法如下: public abstract class Parent{                                                           //定义抽象方法 abstract void testAbstract(); } 有抽象方法的类一定是抽象类 修饰符 abstract class 类名{ }

第八章包和内部类

java类包

类名冲突

Java中每个接口或类都来自不同的类包，无论是Java API中的类与接口还是自定义的类与接口，都需要隶属于某一个类包，这个类包包含了一些类和接口。

完整的类路径

一个完整的类名需 要包名与类名的组合，每个类都隶属于一个类包， 只要保证同一类 包中的类不同名，就可以有效地避免同名类冲突的情况。

创建包

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

导入包

(一)使用import关键字导入包 使用Java中的import关键字指定。例如，如果在程序中使用import关键字导入com.mr.Math类，在程序中使用Math类时就会自动选择com.mr.Math类。 import关键字语法 import com.mr.*;//导入com.mr包中的所有类 import com.mr Math//导入com.mr包中的Math类 在使用import关键字时，可以指定类的完整描述，如果为了使用包中更多的类，可以在使用import关键字指定时在包指定后加上*，这表示可以在程序中使用该包中的所有类。 （二）使用import导入静态成员 import static//静态成员

内部类

成员内部类

（一）成员内部类简介 在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。 语法： class OuterClass{             //外部类         class innerClass{      //内部类 }         } 知识点： 在成员内部类可以随意使用外部类的成员方法及成员变量，尽管这些类成员被修饰为private。 成员内部类不止可以在外部类中使用，在其他类中也可以使用。在其他类中创建内部类对象的语法非常特殊，语法如下： 外部类 outer=new 外部类（）; 外部类.内部类 inner=outer.new   内部类（）; （二）使用this关键字获取内部类与外部类的引用 如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用this关键字。

匿名内部类

匿名类是只在创建对象时才会编写类体的一种写法。匿名类的特点是“现写现用”，其语法如下： new 父类/父类接口（）{         子类实现的内容 }

第九章异常处理

异常概述

知识点： 程序运行的结果报告发生了算术异常AithmetiExeption (根据给出的错误提示可知，发生错误是因为在算术表达式“3/0”中，0作为除数出现)，系统不再执行下去，提前结束。这种情况就是所说的异常。有许多异常的例子，如数组溢出等。Java语言是一门面向对象的编程语言，因此异常在Java语言中也是作为类的实例的形式出现的。当某一方法中发生错误时， 这个方法会创建一个对象， 并且把它传递给正在运行的系统。这个对象就是异常对象。通过异常处理机制，可以将非正常情况下的处理代码与程序的主逻辑分离，即在编写代码主流程的同时在其他地方处理异常。 在Java中，异常是指在程序运行期间可能出现的错误或异常状况。这些异常可以由Java程序自行捕获和处理，从而可以帮助程序员开发更健壮和可靠的应用程序。 Java中的异常分为两类： 1.Checked Exception和Unchecked Exception。Checked 2.Exception是在编译期就可以检查出来的异常，需要明确地进行处理。 Unchecked Exception是在运行期间才会出现的异常，属于程序员的错误或代码问题。

异常的抛出与捕捉

抛出异常

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

捕捉异常：异常捕获结构由try，catch和finally 3部分组成

Java语言的异常捕获结构由try， catch 和finally 3部分组成。其中，try 语句块存放的是可能发生异常的Java语句；catch 语句块在try语句块之后，用来激发被捕获的异常: finally 语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally 语句块。 语法 try{ //程序代码块 } catch（Exceptiontype1 e）{ //对Exceptiontype1的处理 catch（Exceptiontype e）{ //对Exceptiontype2的处理 } ... finally{ //程序代码块 } (1)try-catch语句块public class Baulk {//创建类Baulk    public static void main(String[] args) {//主方法   // TODO Auto-generated method stub  try {   int result = 3/0;//定义int型变量并赋值   System.out.println("程序结束");   System.out.println(result);//将变量输出  }catch(ArithmeticException e) {   System.out.println("出现算数异常");    }  }   } //捕捉算数异常知识点：JAVA的异常处理是结构化的，不会因为一个异常影响整个程序的执行 注意： 有时为 了编程简单会忽略catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会导致最终运行结果与期望的不一致，而错误发生的原因很难查找因此要养成良好的编程习惯，最好在catch语句块中写入处理异常的代码。 （2）finaly语句块 知识点： 完整的异常处理语句一定要包含finally语句，无论程序中有无异常发生，并且无论之前的try-catch语句块是否顺利执行完毕，都会执行finally。 四种特殊情况下，finally块不会被执行 1.在finally语句块中发生了异常。 2.在前面的代码中使用了System.exit()退出程序。 3.程序所在的线程死亡。 4.关闭CPU。 代码：public class Baulk {//创建类Baulk    public static void main(String[] args) {//主方法   // TODO Auto-generated method stub  try {   int result = 3/1;//定义int型变量并赋值   System.out.println(result);//将变量输出  }catch(ArithmeticException e) {   System.out.println("出现算数异常");  }finally {   System.out.println("程序结束");  }  }   } //捕捉算数异常

Java常见的异常类

自定义异常

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

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

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

自定义异常 知识点： 使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户只需维示Exception类即可自定义异常类。在程序中使用自定义异常类，大体可分为以下几个步骤: (1)创建自定义异常类。 (2)在方法中通过throw关键字抛出异常对象。 (3)如果在当前抛出异常的方法中处理异常，可以使用tny-catch语句块捕获并处理，否则在方注 的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。 (4)在出现异常的方法的调用者中捕获并处理异常。

在方法中抛出异常

throws关键字

throw语句用于手动抛出一个异常。抛出异常后，程序会尝试查找匹配的catch块进行处理

throw关键字

在方法定义中使用throws语句，可以指定一种或多种异常类型，表示该方法可能抛出这些异常。

运行时异常

RuntimeException异常的种类

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

第十章字符串

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

声明字符串

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

创建字符串

1. String(char a[]) 2. String(char a[],int offset,int length) 3. String(char[] value)代码： package tenbao; public class Test {  public static void main(String[] args) {   //字符串变量的声明   String s;      //字符串变量初始化 //  s = "你好";   s = new String("你好");   System.out.println(s);      //字符串变量初始化  传入字符类型数组   char[] ch = {'g','o','o','d'};   String st = new String(ch);   System.out.println(ch);      //字符串变量的初始化 传入字符串类型数组，初始索引号，个数   char[] chr = {'s','t','u','d','e','n','t'};   String str = new String(chr,2,4);   System.out.println(str);      //字符串相连接   System.out.println(s + st);      //字符串与其他相连接   System.out.println(1.6 + str + 3);  } }

字符串生成器

StringBuilder类

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

格式化字符串;String 类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式。 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进行格式化 常用的日期格式化转换符如上表：2.时间格式化  格式化时间的转换符如下表：

.格式化常见的日期时间组合 格式化日期与时间组合的转换符定义了各种日期时间组合的格式，其中最常见的如上表：

常规类型格式化

常规类型格式化可应用于任何参数类型，如下表：

子主题

使用正则表达式

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。 正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。 如下表：

注意：在正则表达式中，“.”代表任何一个字符，因此在正则表达式中如果想使用普通意义的点字符“.”，必须使用转移字符“\". 在正则表达式中，可以使用方括号括起若干个字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。 方括号元字符还可以为其他格式，如： 1. [^456]:代表4、5、6之外的任何字符 2. [a-r]:代表a~r中的任何一个字母 3. [a-zA-Z]:可表示任意一个英文字母 4. [a-e[g-z]]:代表a~e或g~z中的任何一个字母（并运算） 5. [a-o&&[def]]:代表字母d、e、f（交运算） 6. [a-d&&[^bc]]:代表字母 a、d(差运算） 在正则表达式中允许使用限定修饰符来限定元字符出现的次数。

连接字符串

连接多个字符串

使用 “+” 运算符可实现连接多个字符串的功能。 代码：package Join; public class join {  public static void main(String[] args) {   // TODO Auto-generated method stub   String s1 = new String("春色绿千里");   String s2 = new String("马蹄香万家");   String s = s1 + "\n" + s2;   System.out.println(s);  } }

连接其他数据类型

代码：package Link; 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'); .lostindexOf(String str) 2.lostindexOf(String str)该方法用于返回参数字符串 s 在指定字符串中最后一次出现的位置。如果没有检索到字符串 s ，该方法返回 -1 说明： 如果 lostindexOf（）方法中的参数是空字符串 "" (注意没有空格)，则返回的结果与调用 length() 方法的返回值相同。 代码： package Text; public class Test {  public static void main(String[] args) {   String str = "We are student";   int size = str.lastIndexOf("");   System.out.println("空字符串在字符串 str 中的索引位置是：" + size);   System.out.println("字符串 str 的长度为" + str.length());  }

获取指定索引位置的字符 使用 charAt（int index）方法可指定索引处的字符返回。语句如下： str.charAt(int index) 例题10.4： 代码： package Ref; public class Ref {  public static void main(String[] args) {   // TODO Auto-generated method stub   String str = "hello world";   char mychar = str.charAt(6);   System.out.println("字符串 str 中索引位置是 6 的字符为：" + mychar);  } }

字符串操作

获取子字符串

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

去除空格

trim() 方法返回字符串的副本，忽略前导空格和尾部空格。语法如下： str.trim()  例题10.6:   public class Blak {  public static void main(String[] args) {   // TODO Auto-generated method stub   String str = "  java  class   ";   System.out.println("字符串原来的长度：" + str.length());   //将 str 去掉前导和尾部的空格后的长度输出   System.out.println("字符串现在的长度：" + str.trim().length());  } }

字符串替换

replace()方法可实现将指定的字符或字符串替换成新的字符或字符串。语法如下：  str.replace(CharSequence target,CharSequence replacment) 例题10.7： public class NewStr {  public static void main(String[] args) {   // TODO Auto-generated method stub   String str = "address";   String newstr = str.replace("a","A");   System.out.println(newstr);  } }

判断字符串的开始与结尾

1.startsWith() 方法 该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下： startsWith(String prefix)  2.endsWith() 方法 该方法用于判断当前字符串是否以给予的字符串结尾。语法如下：public class StartOrEnd {  public static void main(String[] args) {   //判断字符串开头   String num1 = "22045612";   boolean b1 = num1.startsWith("22");   System.out.println(b1);      //判断字符串结尾   String num2 = "21304578";   boolean b2 = num2.endsWith("78");   System.out.println(b2);  } }

判断字符串是否相等

对字符串对象进行比较不能简单地使用比较运算符“==” 代码： String tom =new String("I am a student");  String jerry = new String("I am a student");  boolean b = (tom == jerry); 布尔类型变量b的值位false,因为字符串是对象，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是要进行转换的字符串

字符串分割

1.split(String sign) 该方法可根据给定的分割符对字符串进行拆分 语法：str.split(String sign)   //sign为分割字符串的分割符，也可以使用正则表达式 2.split(String sign，int limit) 该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数 语法：str.split(String sign，int limit) sign:分割字符串的分割符，也可以使用正则表达式 limit:限制的分割次数

第十一章常用库类

包装类包装类及其对应的基本数据类型

Integer类

Integer类在对象中包装了一个基本数据类型int的值，该类的对象包含一个int类型的字段。 常用方法如上表：

Double类

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

Boolean类

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

Character类

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

Number类

数值包装类的共有方法

数字处理

数字格式化

在Java中，没有格式化的数据遵循以上原则： 1.如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。 2.如果数据绝对值小于0.001或者大于10000000，是用科学计数法表示。DecimalFormat中的特殊字符及其所代表的含义如下：

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):将弧度转换为角度。

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台晰明向叶进研

Biglnteger类

在Biglnteger类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作。 使用BigInteger类，可以实例化一个BigInteger对象，并自动调用相应的构造函数。BigInteger类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。 例如，将2转换为BigInteger类型，可以使用以下语句进行初始化操作： Biglnteger twolnstance =new Biglnteger("2"); 注意:参数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()：取相反数。 public Biglnteger shiftLeft(int n)：将数字左移n位，如果n为负数，做右移操作。public BigInteger shiftRight(int n)：将数字右移n位，如果n为负数，做左移操作。public BigInteger and(BigInteger val)：做与操作。 public BigInteger or(BigInteger val)：做或操作。 public int compareTo(BigInteger val):做数字比较操作。 public boolean equals(Object x)：当参数x是BigInteger类型的数字并且数值与对象实例的数值相等时，返回true。 public BigInteger min(BigInteger val)：返回较小的数值。 public BigInteger max(Biglnteger val)：返回较大的数值。

BigDecinal类

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

子主题

时间日期处理

Data类

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

日期时间格式化类

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();

Calender类

Calendar 提供了一个类方法 getnstance()，以获得此类型的一个通用的对象。Calendar类的grtnstance()方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化，其使用方法如下： Calendar rightNow =Calendar.getlnstance(); 说明：由于Calendar类是一个抽象类，不能用new创建实例对象，因此除了使用getInstance0方法创建其对象，如果需要创建其对象，必须使用其子类，如GregorianCalendar类。

Runtime类

执行本地命令

本地命令指的是操作系统的命令。例如，在Linux系统下就表示shell命令，在Windows系统下就表示cmd命令。 Rutime类提供exec()方法让Java代码可以执行系统的命令，exec)方法有很多重载的形式，例如： Process exec(String command) Process exec(String， cmdarray) command：要执行的系统命令，字符串类型。 cmdarray：要执行的命令和相应的命令参数，字符串数组类型。 其实这两个重载方式很类似，如执行“javac hellojava”这行命令，使用第一种重载方式的代码如下：Runtime.getRuntime().exec("javac hello.java"); 使用第二种重载方式的代码如下： String command，=("javac","hello.java"]; Runtime.getRuntime().exec(command); exec)方法会返回一个 Process对象。Process类是Java中进程类，该类是抽象类，不能使用new关键字创建实例。Process类的常用方法如表11.22所示，开发可以使用getlnputStream)方法获取进程返回的信息。

查看内存

代码：package a;   public class MemoryDemo {    public static void main(String[] args) {   // TODO Auto-generated method stub   Runtime r = Runtime.getRuntime();   Integer ints[] =new Integer[10000];   long before = r.freeMemory();   System.out.println("赋值前空闲内存字结束："+before);   for (int i = 0,length = ints.length;i< length;i++) {    ints[i]=i;   }   long after = r.freeMemory();   System.out.println("赋值后空闲内存字节数："+after);   System.out.println("数组用掉的内存字节数："+(before-after));  }   }注意：freeMemory()方法得到的剩余内存量是近似值。

System类System类是JDK中提供的系统类，该类是用final修饰的，所以不允许被继承。Svstem类提供 服多系线层面的操作方法，并且这些方法全部都是静态的。System类提供的较常用方法如上：

输出

1.不会自动换行的print()方法 printO方法的语法如下： System.out.print("Hello!"); 此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello”文字末尾，不会自动换行。 2. 可以自动换行的 println()方法 printlnO方法在print后面加上了“1n”后缀(就是line的简写)，语法如下： System.out.println(”书籍是人类进步的阶梯！”)； 此方法输出“书籍是人类进步的阶梯！”后会自动换行。光标停留在下一行的开头。 print()方法与println()方法输出的对比效果如上：综上所述，Java输出换行的方法有以下两种： System.out.print("\n"); //利用换行符\n 实现奂行 System.out.println(); //空参数即可实现换行 误区警示： 使用这两个输出方法时还要注意以下两点： (1)“System.out.println("n")；”会打印两个空行。 (2)“System.out.print);”无参数会报错。 原文出处链接及本声明。 原文链接：https://blog.csdn.net/zhengkaioo/article/details/130754107

计时

代码：public class SystemTimeDemo {    public static void main(String[] args) {   // TODO Auto-generated method stub  long start = System.currentTimeMillis();  String str =null;  for(int i=0;i<10000;i++) {   str+=i;   }  long end = System.currentTimeMillis();  System.out.println("循环用时："+(end-start)+"毫秒");  }   }

Scanner类

输入

Scanner类首先要引入该类，语法如下： import java.util.Scanner;     //引入Scanner类 上表所示的常用的方法，通过这些方法可以获取控制台中输入的不同类型的值使用Scanner类扫描控制台的代码如下： Scanner sc = new Scanner(System.in);

第一章初识JAVA

1.1java简介

1.1.1什么是Java语言：Java是一门面向对象编程语言，不仅吸收了C语言的各种优点，还摒弃了C里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。

1.1.2Java的应用领域：Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 [1] 。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 [2] 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等 [3]

1.1.3Java的版本：Java主要分为两个版本：Java SE和java EE。

1.1.4怎样学好Java：明确自己的学习目标和大的方向，选择并锁定一门语言，然后按照自己的方向努力学习，认真研究。

1.1.5Java语言的特性：API的全称是Application programming Interface,即应用程序编程接口，主要包括类的继承结构，成员变量，成员方法，构造结构，静态成员的描述信息和详细说明等内容。

1.2java语言的特性

1.简单，2.面向对象，3.分布性，4.可移植性，5.解释型，6.安全性，7.健壮性，8.多线程，9.高性能，10.动态

1.3搭建java环境

1.3.1JDK下载

1.3.2在windows10系统下搭建JDK环境

第二章熟悉Eclipse开发工具

2.1熟悉Eclipse

2.1.1Eclipse简介

Eclipse由IBM公司投资4000万美元开发而成，它基于Java语言编写，是目前最流行的Java集成开发工具之一。Eclipse 所有代码都是开源的，可扩展，其后续开发由Eclipse联盟负责。 Eclipse为编程人员提供了-流的Java程序开发环境，它的平台体系结构是在插件概念的基础上构建的，插件是Eclipse平台最具特色的特征之一， 也是其区别于其他开发工具的

2.1.2下载Eclipse

2.1.3安装Eclipse的中文语言包

2.1.4Eclipse的配置与启动

2.1.5Eclipse

2.1.6透视图与视图

2.1.7菜单栏

2.1.8工作栏

2.1.9“包资源管理器”视图

2.1.10“控制台”视图

2.2使用Eclipse

2.2.1创建Java项目

2.2.2创建Java类文件

2.2.3使用编辑器编写程序代码

2.2.4运行Java程序

2.3程序调试

1.断点

2.以调试方式运行Java程序

3.程序调试

第三章JAVA语言基础

3.1Java主类结构

标识符：用来标识类名，变量名，方法名，数组名，文件名的有效字符序列。 组成：任意顺序的字母，下画线，美元符号和数字组成，第一个字符不能是数字，要避开关键字。  关键词; 是Java语言中已经被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用。

3.2基本数据类型

3.2.1整数类型

整数类型简称整型，用来存储整数数值，即没有小数部分的数值。可以是正数，也可以是负数。收型数据根据它所占内存大小的不同，可分为byte、 short、 int 和long 4种类型。它们具有不同的取值范围。

3.2.2浮点类型

3.2.3字符类型

字符类型(char) 用于存储单个字符，占用16位(两个字节)的内存空间。在定义字符型变量要以单引号表示，如's表示 一个字符。 但是"s"则表示一个字符串，虽然只有一个字符，但由于使用引号，它仍然表示字符串，而不是字符。

3.2.4布尔类型

子布尔类型又称逻辑类型，简称布尔型，通过关键字bolan来定义布尔类到数类型进行转换。布尔类型 和false 两个值，分别代表布尔逻辑中的“真”和“假”。布尔值不能与整数类型变量，布尔类型只有me通常被用在流程控制中，作为判断条件。定义布尔类型变量，

3.3变量与常量

3.3.1标识符和关键字

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

关键词; 是Java语言中已经被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用。主题

什么是变量

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

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

什么是常量

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

3.3.4变量的有效范围

由于变量被定义出来后只是暂存在内存中，等到程序执行到某一个点，该变量会被释放掉，也就是说变量有它的生命周期。因此，变量的有效范围是指程序代码能够访问该变量的区域，若超出该区域，则在编译时会出现错误。在程序中，一般会根据变量的“有效范围”将变量分为“成员变量”和“局部变量”。

3.4运算符

赋值运算符

将右方操作数所含的值赋给左方的操作数。

算术运算符

算术运算符主要有+，-，*，/，%。

自增和自减运算符

符号在后，先使用，在运算。 符号在前，先运算，在使用。

比较运算符

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

逻辑运算符

&&，&两者都为真结果还是真 列：true&&false==false    true&&true==true false&&false==false ||只有一种为真，结果就是真。 列：true||true==true，true||false==true false||false==false !:非真即假，非假即真。 列：！true==false，！false==true

位运算符

按位与运算：&两者都为1，结果才是1。 按位或运算：||只有一者为1，结果才是1. 换位取反：0变1，1变0. 按位异或运算：两者相同，即为0，不同为1. 移位操作：<<:整体往左移，空位补0，溢出去掉。 >>:整体右移，正数补0，负数补1，溢出去掉。 >>>:整体右移，空位补0，溢出去掉。

三元运算符

条件式？值1：值2                         条件为真选值1                           条件为假选值2                         列题：int a=6；                             int b=a>3? 6:7;

运算符的优先级

增量和减量运算

算数运算

比较运算

逻辑运算

赋值运算

3.5数据类型转换

隐式转换

也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。 要实现自动类型转换，必须同时满足两个条件，●第一是两种数据类型彼此兼容， 第二是目标类型的取值范围大于源类型的取值范围。byte b = 3;+ int x= b; /1 程序把byte类型的变量b转换成了int类型，无须特殊声明

显示转换

➢强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。 ➢当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。 ➢强制类型转换的格式如下所示: 目标类型变量= (目标类型) 值+

第四章流程控制

复合语句

与C语言及其他请言相同，Java 语言的复合语句是以整个块区为单位的语句，所以又称块语句、复合语句由开括号“1”开始，闭括号“}”结束。 在前面的学习中我们已经接触到了这种复合语句。例如，在定义一个 类或方法时，类体就是以“，与“)”作为开始与结束的标记，方法体同样也是以“1”与“)”作为标记。复合语句中的每个语句愿是从上到下被执行。复合语句以整个块为单位，能够用在任何一个单 独语句可以使用的地方，并且本合语句中还可以嵌 套复合语句。

条件语句

if条件语句

①①if条件语句、 if语句是指如果满足某种条件，就进行某种处理，其语法格式如下 所示: if (条件语句){ ψ 代码块 }4 _上述语法格式中，判断条件是一个布尔值，当值为true时，才会执 行{}中的语句。

switch条件语句

Java中的switch语句是一种用于根据一个表达式的值选择不同代码分支的流程控制语句。它通常用于取代一系列的if-else语句，以使代码更加简洁和易于阅读。 代码： 输入条件，进行判断， pablic class Example10 public static void main(Stringl) arga) { long week =6; switch (week) { case 1: System.out.println("星期一 "); break; case 2: System. out.println("星期二"); break; case 3: System. out.printin("星期三"); break; case 4: Ѕуѕtеm. оut . рrіntln ("星期四"); break; case 5: System. out.println("星期五"); break; case 6: System. out.println("星期六"); break; case 7: System. out.println("星期日"); break; default: System. out.println("输入错误"); break;

if....else条件语句

if...eIse语句 ➢f..else语句是指如果满足某种条件，就进行某种处理，否则就进行 另一种处理，其语法格式如下所示: if (判断条件) {v执行语句1 }else{ 执行语句2 }

if..elsei f..else语句

if..else if ..else语句用于对多个条件进行判断，进行多种不同的处理，其语法格式如下所示: if (判断条件1) { 执行语句1 } else if (判断条件2) {执行语句2) { 执行语句2 } ........ else if (判断条件n) {执行语句n）{         执行语句n } else { 执行语句n+1 }

循环语句

while循环语句

语句1 while(条件) {语句2} 语句3 1->条件真->2->...条件真->2->条件假->3          java中的while循环是一种重复执行代码块的语句，只要指定的条件为true，就会一直执行循环体中的语句。当条件变为false时，程序将跳出循环，并继续执行程序的下一条语句。

do......while循环语句

do{执行语句...} while（循环语句）；       是一种先执行循环体中的语句，然后再判断循环条件是否成立的循环结构。 do-while循环先执行一次循环体中的语句，然后再进行循环条件的判断。如果循环条件成立，就继续执行循环体中的语句，并继续进行循环条件的判断；如果循环条件不成立，则退出循环。需要注意的是，无论循环条件是否成立，do-while循环至少会执行一次循环体中的语句。         与while循环相比，do-while循环的一个重要区别是循环条件的判断时机不同。在while循环中，循环条件是在循环体执行前判断的，因此如果循环条件一开始就不成立，while循环中的循环体不会执行；而在do-while循环中，循环条件是在循环体执行后判断的，因此即使循环条件一开始就不成立，do-while循环中的循环体也会执行一次。

for循环语句

ava的for循环语句是一种常用的循环结构，通常用于遍历集合或数组等数据结构。 跳转循环语句

循环控制

break语句

在Java中，break语句是一种用于循环控制的关键字，通常用于在循环中提前终止循环的执行，即跳出循环体。当break语句被执行时，程序会立即跳出循环，继续执行后续的代码。 break语句通常与条件语句一起使用，例如在for循环或while循环中，如果满足某个条件就需要提前结束循环，可以使用break语句来实现。

continue语句

Java中的continue语句用于在循环结构中提前结束当前循环的迭代，然后开始下一次迭代。具体来说，当continue语句被执行时，程序将跳过当前循环迭代中剩余的语句，然后进入下一次迭代，即从循环体的开始处重新执行。 continue语句通常用于需要跳过某些特定条件下的循环迭代的情况，

第五章数组

数组概述

数组是具有相同数据类型的一组数据的集合。 例如，球类的集合一足球、 篮球、羽毛球等:电器集合一电视机. 洗衣机。电风扇等，在程序设计中， 可以将这些集合称为数组。 数组中的每个元素具有相同的数据类型。在Java中同样将数组看作一个对象，虽然基本数据类型不是对象，但由基本数据类型组成的数组却是对象。在程序设计中引入数组可以更有效地管理和处理数据。可根据数组的维数将数组分为-维数组、二维数.....

一维数组

一维数组的声明: 1.数组元素的类型[ ]数组名 2.数组元素的类型 数组名[ ] 一维数组分配内存; 数组名=new 数组元素的类型[数组长度] 一维分配内存同时设置初始值 数组名=new 数组元素的类型[]{值1，值2，...，值n} 一维数组元素赋值 数组名[索引]=值; 一组具有相同数据类型的连续内存空间，它们按照一定的顺序排列在内存中。数组中的每个元素都可以通过其下标来访问，下标从0开始，依次递增。一旦定义和初始化完成后，数组的长度就不能。

二维数组

二维数组的声明: 1.数组元素的类型[ ][ ]数组名 2.数组元素的类型 数组名[ ][ ] 二维数组分配内存; 数组名=new 数组元素的类型[行数][列数] 二维分配内存同时设置初始值 数组名=new 数组元素的类型[][]{{值1，值2，...}，{值1，值2，...}，...，{值1，值2，...}}; 二维数组元素赋值 数组名[行号]={值1，值2，...}; 数组名[行号][列号]=值; 维数组中的每一行可以拥有不同的元素个数，但是在同一行中的元素个数必须相同。在定义和初始化二维数组时，只需要指定行数和列数即可，Java会根据指定的行数和列数来为二维数组分配内存空间。

数组的基本操作

替换数组： Arrays.fill(数组名，值)

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

复制数组元素：空位补0，溢出去掉 新数组名=Aeeays.copyof(旧数组名，新数组长度)；

复制数组部分元素：前在后不在 新数组名=Aeeays.copyof(旧数组名，前索引，后索引)；

查询数组：先排序后查询 索引=Aeeays.copyof(旧数组名，值)；

foreach遍历循环;

子主题

数组排序算法

子数组排序算法 冒泡排序：排序数组元素的过程总是将较小的数往前放，较大的数往后放 冒泡算法：由双层循环实现，其中外层循环由于控制排序轮数，一般为要排序数组长度减1次，因为最后一次循环只剩下一个数组元素。内层循环主要用于对比数组中每个邻近元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。

反转排序 把所有数值的顺序反转

直接选择排序 选择其中最大一个往后放一直循环

第六章类和对象

面向对象概述

面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。当然，一个应用程序会包含多个对象，通过多个对象的相互配合来实现应用程序的功能，这样当应用程序功能发生变动时，只需要修改个别的对象就可以了，从而使代码更容易得到维护。 面向对象的特点主要可以概括为封装性、继承性和多态性

类

this关键字

his关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类，this关键字只能在本类中使用。 public void setName（String name）{ this.name=name; }

super 关键字

当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，为了解决这个问题，在Java中专门提供了一个super关键字用于访问父类的成员。例如访问父类的成员变量、成员方法和构造方法。接下来分两种情况来学习一下super关键字的具体用法。

final  关键字

final关键字可用于修饰类、变量和方法，它有“无法改变”或者“最终的含义，因此被final修饰的类、变量和方法将具有以下特性: 1.final修饰的类不能被继承。 2.final修饰的方法不能被子类重写。 3.final修饰的变量(成员变量和局部变量)是常量，只能赋值一次

封装性

封装是面向对象编程的核心思想，将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装思想。采用封装思想保证了类的内部数据结构的完整性，使用类的用户不能轻易地操作类的数据结构，只能执行类允许公开的数据，这样子避免了外部操作和内部数据影响，提高了程序的可维护性。

继承性

继承性主要描述的是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。继承不仅增强了代码的复用性、提高开发效率，还为程序的维护补充提供了便利。

多态性

多态性指是在程序中允许出现重名的现象，它指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同类中具有不同的语义。

类的构造方法

构造方法的定义

在一个类中定义的方法如果同时满足以下三个条件，该方法称为构造方法，具 体如下: 1、方法名与类名相同 2、在方法名的前面没有返回值类型的声明 3、在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束。

构造方法的重载

与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法只要每个构造方法的参数类型或参数个数不同即可。在创建对象时，可以通过调用不同的构造方法来为不同的属性进行赋值。

静态成员

静态变量

在一个Java类中，可以使用static关键字来修饰成员变量，该变量被称作静态变量。静态变量被所有实例共享，可以使用“类名.变量名”的形式来访问。 注意: static关键字只能用于修饰成员变量，不能用于修饰局部变量否则编译会报错。

静态方法

要实现这样的效果，只需要在类中定义的方法前加上static关键字即可，通常称这种方法为静态方法。同静态变量一样，静态方法可以使用“类名.方法名”的方式来访问，也可以通过类的实例对象来访问。 注意:在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。

类的主方法

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

对象

创建和使用

应用程序想完成具体的功能，仅有类是远远不够的，还需要根据类创建实例对象。在java程序中可以使用new关键字来创建对象，具体格式如下： 类名 对象名称 =new 类名（）; 例如，创建person类的实例对象代码如下： person p=new person（）；

销毁

每个对象都有生命周期，当对象的生命周期结束时，就会销毁

类的封装

在设计一个类时，应该对成员变量的访问作出一些限定，不允许外界随意访问，这就鸳要实现类的封装。  所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在类中被访问，如果外界想要访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的get（）方法和设置属性值的set（）方法。 权限修饰符   java中的权限修饰符主要包括private、public和protected,这些修饰符控制着对类和类的成员变量以及成员方法的访问。