JAVA学习笔记（2）

第六章 类和对象

面向对象概述

类与对象时整个面向对象中最基础的组成单元。

类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）；

对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。

类

类的定义

类是用来定义一组对象共同具有的状态和行为的模板。语法格式如下：

class claassName{
      成员变量
      ……
      成员方法
      ……
}

成员变量

成员变量是在类体中定义的变量，即全局变量，成员变量用于定义对象的状态。

成员方法

成员方法是对象行为的描述。每个方法都是由复合语句描述相应的行为。定义成员方法的语法格式如下：
[修饰符] 返回值类型 方法名([形参表]){
      ...//方法体
      return 返回值;
}

权限修饰符

局部变量

如果在成员方法内定义一个变量，那么这个变量被称为局部变量，局部变量只在定义它的方法内有效。

局部变量的有效范围

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

类的构造方法

构造方法的特点如下：
（1）声明构造方法没有返回值类型。
（2）构造方法的名称要与本类的名称相同。

语法：

public 类名([参数列表]){
      //...构造方法体
}

静态变量、常量和方法

由static修饰的变量、常量和方法被称作静态变量、常量和方法。

被声明为static的变量、常量和方法被称为静态成员。语法：

类名.静态类成员

类的主方法

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

public static void main(String[] args){
      //方法体
}

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

对象

对象的创建

语法：
类名 对象名=new 类构造方法();

访问对象的属性和行为

语法：
对象名.属性
对象名.成员方法名()

例如：
String carColor = whiteCar.color;
whiteCar.color = "白色";
whiteCar.run();

对象的引用

语法如下：
类名 对象引用名称

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

继承

• 继承：多个类中存在相同属性（成员变量）和行为（成员方法）时，将这些内容抽取到单独一个类中，那么多个类就无需再定义这些属性和行为了，只要继承那个类即可

• 通过extends关键字可以实现类与类的继承

class 子类名 extends 父类名{}

 单独的类称为父类、基类或超类，子类也叫派生类，父类中的内容是多个子类重复的内容

继承的好处：1、提高了代码的复用性，多个类相同的成员可以放到同一个类中；2、提高了代码的维护性，如果功能的代码需要修改，只需要修改父类这一处即可；3、让类与类之间产生了关系，这是多态的前提（这也是继承的缺点），使得类的耦合性增强

开发的原则：低耦合、高内聚

继承的缺点：1、破坏了封装，子类与父类之间紧密耦合，子类依赖父类的实现，造成子类缺乏独立性；2、支持扩展，但是往往以增强系统结构的复杂度为代价；3、不支持动态继承，在运行时子类无法选择不同的父类；4、子类不能改变父类的接口

继承的特点：1、Java只支持单继承，不支持类的多继承，一个类只能有一个父类，不可以有多个父类；2、Java支持多层继承（继承体系） 

class A{}

class B extends A{}

class C extends B{} 

• 子类只能继承父类中所有非私有的成员方法和成员变量
• 子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法
• 不要为了部分功能而去继承
• 在Java中，所有的继承都是公共继承
• 继承绝对不会删除任何字段或方法
• Object类是Java中所有类的父类，如果某个类没有明确地指出父类，那么Object类就被认为是这个类的父类，这个类就默认访问Object类的无参构造

在子类中访问一个变量的执行顺序：首先在子类的局部范围中找，然后在子类成员范围中找，最后在父类成员范围中找（不能访问到父类的局部范围），如果还是没有就报错

super关键字

• super有两个含义：1、调用父类的方法；2、调用父类的构造器
• 调用父类成员变量

super.成员变量 

• 调用父类的构造方法（使用super调用构造器的语句必须是子类构造器的第一条语句）

 super(参数)

• 调用父类的成员方法

super.成员方法 

• super不是一个对象的引用，不能将值super赋给另一个对象变量，它只是一个指示编译器调用父类方法的特殊关键字
• this代表本类对应的引用，通过其操作本类的成员，super代表父类存储空间的标识

继承中构造方法的关系 

• 子类中所有的构造方法默认都会访问父类中的无参构造方法，因为子类会继承父类中的数据，可能还会使用父类的数据，所以子类初始化之前一定要先完成父类数据的初始化（先进行父类的初始化再进行子类的初始化，这叫分层初始化）
• 子类每一个构造方法的第一条语句都是super()，这是系统默认的，写不写都有，但如果父类没有无参构造方法，这时在子类中系统就不会自动调用父类的无参构造了，需手动调用父类的构造方法，不然会报错
   

继承使用场景 

采用假设法：如果有两个类A、B，只要它们符合A是B的一种或者B是A的一种（A is B）或（B is A）这样的关系，就可以考虑使用继承 

 多态

• 多态：一个对象变量可以指示多种实际类型的现象（某一个对象在不同时刻表现出来的多种状态）
• 多态的使用前提：1、要有继承关系；2、要有方法重写；3、要有父类引用指向子类对象

父类名 f = new 子类名(); 

• 多态的好处：1、提高了代码的维护性；2、提高了代码的扩展性

向上转型

 fu f = new zi();

向下转型

zi z = (zi)f; 

多态中的成员访问特点 

• 成员变量：编译看父类，运行看父类
• 成员方法：编译看父类，运行看子类（由于只有成员方法存在方法重写，所以它运行看子类）
• 静态方法：编译看父类，运行看父类（静态和类相关，算不上重写，所以访问的还是父类的）
• 动态绑定（后期绑定）：在运行时能够自动的选择适当的方法，java中的动态绑定是默认行为，动态绑定是多态得以实现的重要因素
• 静态绑定（前期绑定）：在程序执行前已经被绑定，即在编译过程中就已经知道这个方法是哪个类的方法，此时由编译器获取其它连接程序实现。在Java中，final、private、static修饰的方法以及构造函数都是静态绑定的，不需程序运行，不需具体的实例对象就可以知道这个方法的具体内容。
   

 抽象类

•  抽象：所谓抽象就是不是一种具体的事物而是一类事物的总和，如人分男人和女人，那么男人和女人相对于人来说就是具体的，人就是抽象的
• 抽象类：被abstract修饰的类叫抽象类，抽象类没有实体的东西，其无法直接创建对象（不能被实例化），因为调用抽象方法无意义，如果父类为抽象类，那么子类只有重写了父类中的所有方法抽象方法后才可以创建对象，否则该子类还是一个抽象类，因为假如子类没有对抽象类的所有方法重写，那么子类也就会继承了抽象类中的抽象方法，只要有抽象方法的类就一定是抽象类，但抽象类不一定有抽象方法
• 抽象类的思想：强制子类重写抽象方法
• 抽象类的作用：降低接口实现类对接口的实现难度，将接口中不需要使用的方法交给抽象类实现，这样接口实现类只需要对要使用的方法进行重写
• 抽象方法：被abstract修饰的方法叫抽象方法，其没有方法体，且抽象方法必须存在于抽象类中

定义抽象方法：

public abstract class Parent{

          abstract  void testAbstract();

}

• 抽象类不可被实例化
• 抽象类是有构造器的
• 抽象类可以没有抽象方法
• 抽象类的使用场景一般在运用多态时比较适用
• abstract不能与这几个关键字共用：private（私有的方法子类是无法继承的，但是abstract又要求子类需要实现抽象方法，这是矛盾的）、final（类、方法被final修饰后不能被继承和重写，矛盾）、static（通过类名访问抽象方法是没有意义的，因为抽象方法没有方法体）
• 抽象类中的抽象方法是强制要求子类做的事情，非抽象方法是子类继承的事情，提高代码的复用性

 接口

• 接口：接口是Java 语言中的一种引用类型，它是抽象方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法
• 接口用关键字interface修饰

 class 类名 implements 接口名{}

• 接口不能定义构造方法（因为接口的作用主要是为了扩展功能，并不具体存在，没必要初始化）且接口中只有常量（隐式修饰，public static final）
• 接口不能创建对象，只能通过其实现类来使用
• 一个接口可以有多个方法且接口中所有的方法必须是抽象方法，默认修饰符public abstract（隐式修饰），如果需要定义具体方法实现，则此时方法需要使用default修饰
• 接口不是被类继承而是被类实现
• 一个接口能继承另一个接口且接口支持多继承
   
• 接口与抽象类的区别： 抽象类中定义的是该继承体系的共性功能，而接口中定义的是该继承体系中的扩展功能（特性功能）
•  当引用类型作形式参数或返回值时：
• 类：需要的是该类的对象
• 抽象类：需要的是该抽象类的子类对象（多态）
• 接口：需要的是该接口的实现类对象（多态） 

第八章 内部类 

 内部类

• 内部类：一个类定义在另一个类里面或一个方法里面，这样的类称为内部类，内部类一般包括：成员内部类、局部内部类、匿名内部类、静态内部类
• 内部类和外部类之间没有继承关系

直接访问内部类成员的语法格式：

外部类名.内部类名 对象名 = new 外部类名().new 内部类名(); 

成员内部类 

• 成员内部类是最普通的内部类，位于另一个类的内部
• 成员内部类可以无条件的访问外部类的所有成员变量和成员方法（包括private成员和静态成员）
• 当成员内部类拥有和外部类同名的成员变量或方法时，默认情况下访问的是内部类的成员（就近原则），若要访问外部类的同名成员，语法格式为：

外部类名.this.成员变量

外部类名.this.成员方法 

• 在外部类如果要访问成员内部类的成员就必须先创建一个内部类的对象，再通过指向这个对象的引用来访问
• 内部类是依附于外部类存在的，如果要创建内部类的对象，前提是必须存在一个外部类的对象

 局部内部类

• 局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的作用范围只限于方法内或该作用域内
• 局部内部类可以无条件的访问外部类的所有成员变量和成员方法（包括private成员和静态成员）
• 局部内部类就像是方法里面的一个局部变量一样是不能有public、protected、private以及static修饰的
   

 匿名内部类

•  匿名内部类是没有名字的内部类且它只能使用一次（和匿名对象相似），通常用来简化代码
• 匿名内部类的实质是对象（可将匿名内部类当作对象使用），并不是类，它是一个类或子类或实现接口类的一个对象，是一个继承了该类或实现了该接口的子类匿名对象
• 匿名内部类不能有访问修饰符和static
• 匿名内部类使用条件：必须继承一个父类或实现一个接口
• 匿名内部类是唯一一种没有构造方法的类，因此它的使用范围非常有限，大部分匿名内部类用于接口回调
   

静态内部类 

• 静态内部类是被static修饰的内部类
• 当外部类被加载的时候，静态内部类是不会被加载的
• 当使用静态内部类中的成员时，静态内部类才会被加载且仅仅加载一次，不会有线程安全的问题
• 与静态成员变量不一样的是静态内部类是不能通过外部类对象访问的
• 静态内部类不能使用外部类的非静态成员变量和方法，只能访问外部类的静态成员
   

静态内部类的唯一访问语法格式： 

外部类名.内部类名 对象名 = new 外部类名.内部类名();

第九章 异常处理 

异常概述 

异常是一个在程序执行期间发生的事件，它中断了正在执行的程序的正常指令流。 

捕捉异常 

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

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

Java常见异常

 

自定义异常 

使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。

自定义异常类在程序中使用，大体可分为以下几个步骤。

（1）创建自定义异常类。

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

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

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

在方法中抛出异常 

使用throws关键字抛出异常

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

使用throw关键字抛出异常

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

异常的使用原则

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

• 在当前方法声明中使用try-catch语句捕获异常。
• 一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。
• 如果父类抛出多个异常，那么覆盖方法必须抛出那些异常的一个子集。不能抛出新异常。

第十章 字符串 

string类 

声明字符串

在Java语言中字符串是一个对象，必须包含在一对“”（双引号）之内，它由java.lang.String类定义。字符串是由许多个字符连接而成的。

可以通过如下语法格式来声明字符串变量。
String str = [null] 

创建字符串

•  String(char a[])方法

用一个字符数组a创建String对象

• String(char a[], int offset, int length)

提取字符数组a中的一部分创建一个字符串对象。参数offset表示开始截取字符串的位置，length表示截取字符串的长度。

•  String(char[] value)

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

连接字符串 

连接多个字符串

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

连接其他数据类型

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

获取字符串信息 

获取字符串长度

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

字符串查找

•  indexOf(String s)

该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用字符串的indexOf()方法时，会从当前字符串的开始位置搜索s的位置，如果没有检索到字符串s，该方法返回值是-1。
语法：
str.indexOf(substr)

注：str：任意字符串对象。
substr：要搜索的字符串。

• lastIndexOf(String str)

该方法用于返回指定字符串最后一次出现的索引位置。当调用字符串的lastIndexOf()方法时。会从当前字符串的开始位置检索参数字符串str，并将最后一次出现str的索引位置返回。如果没有检索到字符串str，该方法返回-1。

语法：

str. lastIndexOf(substr)

获取指定索引位置的字符

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

语法如下：

str.charAt(int index)

 字符串操作

 获取子字符串

（1）substring(int beginIndex)

该方法返回的是从指定的索引位置开始截取直到该字符串的结尾的子串。

语法：

 str.substring(int beginIndex)

注：beginIndex：指定从某一索引处开始截取字符串。

 （2）substring(int beginIndex , int endIndex)

该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。

语法：

substring(int beginIndex, int endIndex) 

注：beginIndex：开始截取子字符串的索引位置。

endIndex：子字符串在整个字符串中的结束位置。

 去除空格

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

语法：

str.trim() 

字符串替换

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

str.replace(char oldChar,char newChar);

判断字符串的开始与结尾 

•  startsWith()方法

该方法用于判断当前字符串对象的前缀是否是参数指定的字符串。
语法： 

str.startsWith(String prefix)

注：prefix：作为前缀的字符。 

• endsWith()方法

该方法用于判断当前字符串是否是以给定的子字符串结束。
语法： 

str.endsWith(String suffix)

注：suffix：作为后缀的字符串。

判断字符串是否相等

•  equals()方法

如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，则返回true。
语法：
str.equals(String otherstr)
注：str、otherstr：参加比较的两个字符串对象。

•        equalsIgnoreCase()方法

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

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

语法：

str.compareTo(String otherstr) 

 字符串分割

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

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

 格式化字符串

（1）format(String format,Object…args)
该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。
语法：
str.format(String format,Object…args)
注：  format：格式字符串。
  args：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0。 

（2）format(Local local,String format,Object…args)
使用指定的语言环境、格式字符串和参数返回一个格式化字符串。
语法：
str.format(Local local,String format,Object…args)

日期和时间字符串格式化

时间格式化

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

常规类型格式化

 

使用正则表达式

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

字符串生成器

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

 （1）append()方法
该方法用于向字符串生成器中追加内容，通过该方法的多个重载形式，可实现接受任何类型的数据。如int、boolean、char、String、double或者另一个字符串生成器等。
语法如下：
append(content)
注：content：表示要追加到字符串生成器中的内容。可以是任何类型的数据或者其他对象。

（2）intsert(int offset , arg)方法
该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入int、float、char和boolean等基本数据类型或其他对象。
语法如下：
insert(int offset , arg)
 注：offset：字符串生成器的位置。该参数必须大于等于0，且小于等于此序列的长度。
 arg：将插入至字符串生成器的位置。该参数可以是任何的数据类型或其他对象。 

（3）delete(int start , int end)方法
移除此序列的子字符串中的字符。该子字符串从指定的start处开始，一直到索引end - 1处的字符，如果不存在这种字符，则一直到序列尾部。如果start等于end，则不发生任何更改。
语法如下：
delete(int start , int end)
 注：  start：将要删除的字符串的起点位置。
   end：将删除字符串的终点位置。 

第十一章 常用库类 

包装类 

Integer

 1．构造方法

Integer有两种构造函数形式，分别是：

• Integer(int number

该函数以一个int型变量作为参数来获取Integer对象。

•  Integer(String str)

该函数以一个String型变量作为参数来获取Integer对象。

2．常用方法

Integer类的常用方法如图所示

 3．常量
Integer类提供了4个常量分别是：

•         MAX_VALUE：表示int类型可取的最大值。即231－1。
•         MIN_VALUE：表示int类型可取的最小值。即－231。
•         SIZE：用来以二进制补码形式表示int值的比特位数。
•         TYPE：表示基本类型int的Class实例。

Double 

1．构造方法
Double类提供了两种构造方法可获得Double类对象。

•       Double(double value)

基于double参数创建Double类对象。

•         Double(String str) 

2．常用方法

Double类的常用方法如图所示。

 

 3．常量
Double类提供了一些有用的常量表示，例如：

•         MAX_EXPONENT：返回int值，表示有限double变量可能具有的最大指数。
•         MIN_EXPONENT：返回int值，表示标准化double变量可能具有的最小指数。
•         NEGATIVE_INFINITY：返回double值，表示保存double类型的负无穷大值的常量。
•         POSITIVE_INFINITY：返回double值，表示保存double类型的正无穷大值的常量。

Boolean

 1．构造函数

•   Boolean(boolean value)

该函数创建一个表示value参数的Boolean对象。

•    Boolean(String str)

该函数以String变量作为参数创建Boolean对象。如果String参数不为null且在忽略大小写时等于“true”，则分配一个表示true值的Boolean对象；否则获得一个false值的Boolean对象。

 2．常用方法
Boolean类的常用方法如图所示。

 3．常量
Boolean提供了3个常量，分别是：

•         TRUE：对应基值true的Boolean对象。
•         FALSE：对应基值false的Boolean对象。
•         TYPE：基本类型boolean的Class对象。

Character

 Character类在对象中包装一个基本类型char的值。一个Character类型的对象包含类型为char的单个字段。

1．构造方法
Character类的构造方法是：
语法：
Character(char value) 

2．常用方法

 3．常量

Character类提供了大量表示特定字符的常量。例如：

•        CONNECTOR_PUNCTUATION：返回byte型值，表示Unicode规范中的常规类别“Pc”。
•        UNASSIGNED：返回byte型值，表示Unicode规范中的常规类别“Cn”。
•        UNASSIGNED：返回byte型值，表示Unicode规范中的常规类别“Cn”。
•        TITLECASE_LETTER：返回byte型值，表示Unicode规范中的常规类别“Lt”。

Number

 抽象类Number是BigDecimal、BigInteger、Byte、Double、Float、Integer、Long和Short类的超类。Number的子类必须提供将表示的数值转换为byte、double、float、int、long和short的方法。

数组处理 

数字格式化 

在Java中可以使用DecimalFormat类进行格式化操作。

当格式化数字时，在DecimalFormat类中使用一些特殊字符构成一个格式化模板，使数字按照一定特殊字符规则进行匹配 

Math类 

Math类包含了所有用于数学运算的函数方法，这些方法都是静态的，所以每个方法只要使用“Math.数学方法”就可以调用。
语法：
Math.数学方法 

Random类

可以通过实例化一个Random对象创建一个随机数生成器。
语法：
Random r=new Random();

注：r：Random对象。

在Random类中提供获取各种数据类型随机数的方法，下面列举几个常用的方法。
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()：返回一个概率密度为高斯分布的双精度值 

BigInteger 

BigInteger支持任意精度的整数，也就是说在运算中BigInteger类型可以准确的表示任何大小的整数值而不会丢失任何信息。
当使用BigInteger类时，可以实例化一个BigInteger对象，并自动调用相应构造函数。BigInteger类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。
语法如下：
public BigInteger(String val)
注：val：十进制字符串。 

BigDecimal 

一般的float型和Double型数据只可以用来做科学计算或工程计算，由于在商业计算中，要求数字精度比较高，所以要用到java.math.BigDecimal类。BigDecimal类支持任何精度的定点数，可以用它来精确计算货币值。
在BigDecimal类中常用的两个构造方法如下：

• public BigDecimal(double val)：实例化时将双精度型转换为BigDecimal类型
• public BigDecimal(String val) ：实例化时将字符串形式转换为BigDecimal类型 

下面列举了BigDecimal类中实现加减乘除的方法。

• public BigDecimal add(BigDecimal augend)：做加法操作
• public BigDecimal subtract(BigDecimal subtrahend)：做减法操作
• public BigDecimal multiply(BigDecimal multiplicand)：做乘法操作
• public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode) //做除法操作 

第十二章 集合类 

集合类概述 

Java中的集合对象就像是一个容器，用来存放Java类的对象。java.util包中提供了一些集合类。这些集合类又被称为容器。提到容器不难会想到数组，集合类与数组不同之处是，数组的长度是固定的，集合类的长度是可变的，数组用来存放基本类型的数据；集合类用来存放对象的引用。
常用的集合有List集合、Set集合、Map集合。List与Set实现了Collection接口。各接口还提供了不同的实现类。上述集合类的继承关系如图所示。 

Collection接口 

Collection接口是层次结构中的根接口。构成Collection的单位，被称之为元素。Collection接口通常不能直接被使用，但该接口提供了添加、删除元素管理数据的方法 

List集合 

List接口
List接口继承了Collection接口，因此，包含Collection中的所有方法。又因为List是列表类型，所以List接口还提供了一些适合于自身的常用方法，如表所示。 

ArrayList类

ArrayList类实现了可变的数组，允许所有元素，包括NULL。可以根据索引位置对集合进行快速的随机访问。缺点是向指定的索引位置插入对象或删除对象的速度较慢。原因是向指定索引位置插入对象时，会将指定索引位置及之后的所有对象相应的向后移动一位；如图所示。

Set集合 

Set接口
Set集合由Set接口和Set接口的实现类组成。Set接口继承了Collection接口，因此，包含Collection接口的所有方法。Set接口中常用方法如表所示。 

 Map集合

Map接口
Map接口提供了将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。Map接口中同样提供了集合的常用方法如clear()、isEmpty()、size()等，除此之外还包括如表所示的常用方法。 

 

第十三章 枚举类型与泛型 

使用枚举类型设置常数

使用枚举类型定义常数的语法结构。
语法：
public enum Constants{
   Constants_A,
   Constants_B,
   Constants_C
}
其中，enum：定义枚举类型关键字。
当需要在程序中使用该常量时，可以使用Constants.Constants_A来表示。

深入了解枚举类型

举类型中的重要方法

使用枚举类型的优势

• 类型安全。
• 紧凑有效的数据定义。
• 可以和程序其他部分完美交互。
• 运行效率高。
• 易读且更改容易。

枚举类实质上以类的方式存在，它的使用方便安全，但需要注意以下几点：

• 不能有public的构造函数，从而保证没有办法创建enum实例。
• 所有的枚举值都是public、static、final类型的。
• 获取枚举成员，使用values()方法。
• ordinal()方法得到枚举成员的位置索

 泛型

定义泛型类

在JDK1.5版本以后，提出了泛型机制，它的语法如下：
类名<T>
其中，T代表一个类型的名称。 

 泛型的常规用法

1．定义泛型类时声明多个类型
在定义泛型类时，可以声明多个类型，语法格式如下：
语法：
MutiOverClass<T1,T2>
MutiOverClass：泛型类名称。

•  T1：可能被定义的类型。
•  T2：可能被定义的类型。 

 2．定义泛型类时声明数组类型

 3．集合类声明容器的元素
可以使用K和V两个字符代表容器中的键值与与键值相对应的具体值。

泛型的高级用法 

1．限制泛型可用类型
默认可以使用任何类型来实例化一个泛型类对象，但是Java中也提供了泛型类实例的类型的限制，它的语法格式如下。
class 类名称<T extends anyClass>
注：anyClass：某个接口或类。
2．使用类型通配符
在泛型机制中，提供类型通配符，类型通配符主要的作用是在创建一个泛型类对象时限制这个泛型类的类型实现或继承某个接口或类的子类，要声明这样一个对象可以使用“？”通配符来表示，同时依然使用extends关键字来对泛型做限制，使用泛型类型通配符的语法格式如下。
泛型类名称<? extends List> a=null;
其中，<? extends List>表示类型未知，当需要使用该泛型对象时，可以单独实例化。

3．继承泛型类与实现泛型接口
定义为泛型的类和接口也可以被继承与实现

泛型总结

在没有出现泛型时，Java也提供了对Object的引用“任意化”操作，此种操作的缺点如下：

• 对象需要显示的强制转换类型，对于转换中存在的错误，编译期间不可知。
• 需要开发者预知对象的类型，否则可能产生运行时错误。
• 加大程序的维护成本，给程序扩展与维护带来一定的困难。 

 泛型的使用方法总结：

• 泛型的类型参数只能是类类型，不可以是简单类型。例如A<int>这种泛型定义就是错误的。
• 泛型的类型个数可以是多个，中间用逗号分隔。
• 可以使用extends关键字限制泛型的类型。
• 可以使用supper关键字限制泛型的类型。
• 可以使用通配符限制泛型的类型。