第2章 Java基础语法
Java基础语法包括基本数据类型和引用数据类型、Java的运算符和表达式、流程控制以及常量变量和注释等。为了更好地掌握这些语法，本章将运用实例来讲解它们的功能。
实例4 变量和常量
程序中需要大量的数据来代表程序的状态，其中有些数据在程序的运行过程中值会发生改变，有些数据在程序运行过程中值不能发生改变，这些数据在程序中分别叫做变量和常量。变量代表程序的状态。程序通过改变变量的值来改变整个程序的状态，或者说是实现程序的功能逻辑。变量包括实例变量、类变量等。常量在程序运行过程中有两个作用：一是代表常数，便于程序的修改；二是增强程序的可读性。本实例介绍如何运用实例变量、类变量和常量。
技术要点
运用变量与常量的技术要点如下：
• 变量语法格式：
数据类型 变量名称；
数据类型和变量名称之间使用空格进行间隔，空格的个数不限，但是至少需要一个。语句使用“；”作为结束。也可以在声明变量的同时，设定该变量的值，语法为：
数据类型 变量名称=值；
• 常量的语法格式只需要在变量的语法格式前面添加关键字final即可。在Java编码规范中，要求常量名必须大写。格式为：
final数据类型 常量名称=值；
实现步骤
（1）新建一个类名为TextConstant.java。
（2）代码如下所示：
package com.zf.s2; //创建一个包
class Sub { //内部类
final String subName = "HelloWorld"; //声明常量并赋值
final double fPi = 3.14; //声明常量并赋值
}
public class TextConstant { //操作常量和变量的类
int number =0;
public void run(Object obj){ //传入对象参数的方法
System.out.println("是对象Object:"+obj);
}
public void run(Sub sub){ //传入类对象参数的方法
System.out.println("是类Sub:"+sub);
}
private void showObject(){ //显示实例化对象的信息
Sub sub=new Sub(); //实例化对象
System.out.println("Sub.subName= "+sub.subName); //获得对象的属性
System.out.println("Sub.fPi= "+sub.fPi);
}
public static void main(String[] args) { //Java程序主入口处
TextConstant constant = new TextConstant(); //类对象
constant.number = 5; //常量赋值
System.out.println("t.i " + constant.number);
constant.showObject(); //调用方法
constant.run(null); //调用方法
}
}
（3）运行结果如下所示：
t.i 5 Sub.subName= HelloWorld Sub.fPi= 3.14 是类Sub:null
源程序解读
（1）showObject()方法中实例化一个对象，可称为实例变量，显示对象中的常量信息。其中Sub类中的常量声明为final，则变量值不可修改。如果方法声明为final，则方法不可重写；如果类声明为final，则类不可继承，没有子类。
（2）类中的两个run()方法是多态的一种方式：重载。在Java中，同一个类中的两个或两个以上的方法可以有同一个名字，只要它们的参数不同即可，在这种情况下，该方法就被称为重载(overloaded)。在main()方法中调用run()方法并传入null作为参数。null作为关键字，用来标识一个不确定的对象。可以将null赋给引用类型变量，但不可以将null赋给基本类型变量。在调用run()方法中，先考虑类对象，如果参数不是类对象才考虑Object对象。
实例5 基本数据类型转换
Java有8种基本数据类型。包括整数int（4个字节）、short（2个字节）、long（8个字节）、byte（一个字节)；浮点数float（4个字节）、double（8个字节)；字符类型char（2个字节)；布尔类型boolean。这些类型之间可以相互转换，本实例将讲解基本类型的转换，以及转换要注意的几个规则。
技术要点
本实例运用两种转换基本类型的方法：自动提升和强制转换。技术要点如下：
• 类型的自动提升发生的条件是两种类型是兼容的，或者目标类型的范围比原类型的范围大。
• 如果要转换数据的类型，需要进行强制类型转换。强制类型转换的方法是在数据前放一对包括新的类型名的括号，如语句“int i=(int)55555L;”表示将long型的55555L转换成int型，然后赋值给变量i。
实现步骤
（1）新建一个类名为BasicTypeChange.java。
（2）代码如下所示：
package com.zf.s2; //创建一个包
public class BasicTypeChange { //修饰基本数据类型转换的类
private void typeAutoUpgrade() { //基本类型的自动提升
byte b = 44;
char c = 'b';
short s = 1024;
int i = 40000;
long l = 12463l;
float f = 35.67f;
double d = 3.1234d;
//result声明为其他类型会出错，除非进行类型转换
double result = (f * b) + +(l * f) + (i / c) - (d * s);
System.out.print(" 结果 :" + result+" = ");
System.out.println((f * b) + " + " + (l * f) + " + " + (i / c) + " - "
+ (d * s)); //输入经过运算获得的结果
}
private void autoChange() { //基本类型的自动转换
char c = 'a';
byte b = 44;
short s0 = b;
int i0 = s0;
int i1 = c;
long l = i0;
float f = l;
double d = f;
float fl = 1.7f;
double dou = fl;
System.out.println("fl = " + fl + "; dou = " + dou);
//一个数从一种类型转换成另外一种类型，再转换回来时，值还是一样的
fl = (float)dou;
System.out.println("fl = " + fl + "; dou = " + dou);
}
private void forceChange() { //强制类型转换
double d = 123.456d;
float f = (float) d; //将double类型强制转换成float
long l = (long) d; //将double类型强制转换成long
int i = (int) d; //将double类型强制转换成int
short s = (short) d; //将double类型强制转换成short
byte b = (byte) d; //将double类型强制转换成byte
System.out.print("d = " + d + "; f = " + f + "; l = " + l);
System.out.println("; i = " + i + "; s = " + s + "; b = " + b);
d = 567.89d;
//下面的转换首先进行截断操作，将d的值变为567，因为567比byte的范围256还大，
//于是进行取模操作，567对256取模后的值为55
b = (byte) d;
System.out.println("d = " + d + "; b = " + b);
}
public static void main(String[] args) { //Java程序主入口方法
BasicTypeChange change = new BasicTypeChange(); //实例化对象
change.typeAutoUpgrade(); //调用基本类型的自动提升方法
change.autoChange(); //调用基本类型的自动转换方法
change.forceChange(); //调用强制类型转换方法
}
}
（3）运行结果如下所示：
结果:443334.29465 = 1569.48 + 444555.2 + 408 - 3198.3616 fl = 1.7; dou = 1.7000000476837158 fl = 1.7; dou = 1.7000000476837158 d = 123.456; f = 123.456; l = 123; i = 123; s = 123; b = 123
源程序解读
（1）typeAutoUpgrade方法演示了基本数据类型的数据在进行运算时，其类型会自动进行提升，并对自动提升规则进行了说明。
（2）autoChange方法演示了基本数据类型的自动转换，以及自动转换发生的条件。当某些float类型的数据自动转换成double类型时，会出现前后不相等的情况，这是由该数不能够用有限的二进制位精确表示造成的。
（3）forceChange方法演示了何时进行强制类型转换，以及如何进行强制类型转换。在强制类型转换过程中会损失一定的精度。
实例6 操作多种运算符
Java运算符包括算术运算符（+、-、*、/）、比较运算符（==、<、>、<=、>=）、赋值运算符（=、+=、-=、*=、/=）、布尔运算符（&&、||、!、&、|、^）和位运算符（>>、>>>、<<）以及其他运算符（?:、++、--）。
技术要点
本实例讲述使用运算符的规则和注意事项。技术要点如下：
• 算术运算符应用。涉及数字精度问题，数字精度就是不同类型的数据之间进行运算，为了使结果更加精确，则由系统自动转化为精度更高的数据类型。
• 比较运算符应用。关系运算符的结果是布尔型数据。
• 赋值运算符应用。赋值就是将数值赋给变量，最简单的运算符为“=”。
• 位运算符应用。位运算符主要针对二进制。主要包括左移、右移、带符号的右移位运算符。
• 三元运算符表现形式：布尔表达式？值0：值1。
实现步骤
（1）创建一个类名为TextOperator.java。
（2）代码如下所示：
package com.zf.s2; //创建一个包
public class TextOperator { //操作运算符应用的类
int a=6,b=5;
byte c=23,d=24;
boolean e=true,f=false;
private void calculateOperator(){ //算术运算符应用
int divideA=a/b; //根据基本类型自动转换规则，除数与被除数都是整数，
//得到的结果也是整数。a/b结果是1，而不是1.2
float divideB=a/b;
float divideC=a/(b*2.0f); //对于声明为float类型的数字，数字后加f
double divideD=a/(b*2.0d); //对于声明为double类型的数字，数字后加d
System.out.println("(divideA=a/b),divideA="+divideA);
System.out.println("(divideB=a/b),divideB="+divideB);
System.out.println("(divideC=a/(b*2.0f)),divideC="+divideC);
System.out.println("(divideD=a/(b*2.0d)),divideD="+divideD);
}
private void compareOperator(){ //比较运算符应用
System.out.println("(a==b) = "+ (a==b));
System.out.println("(a>b) = "+ (a>b));
System.out.println("(a<b) = "+ (a<b));
System.out.println("(a!=b) = "+ (a!=b));
System.out.println("(a>=b) = "+ (a>=b));
System.out.println("(a<=b) = "+ (a<=b));
System.out.println("(a=b) = "+ (a=b));
}
private void evaluateOperator(){ //赋值运算符应用
//+=运算符是先将运算符左边的操作符的值加上右边的操作数的值，
//将结果再赋给运算符左边的操作符
a +=1; //等价于a=a+1;
System.out.println("a+=1的值为:"+a);
a -=1; //等价于a=a-1;
System.out.println("a-=1的值为:"+a);
a /=2; //等价于a=a/2;
System.out.println("a/=2的值为:"+a);
a *=2;// 等价于a=a*2;
System.out.println("a*=2的值为:"+a);
a &=2; //等价于a=a&1;
System.out.println("a &=2的值为:"+a);
a |=2; //等价于a=a|2;
System.out.println("a |=2的值为:"+a);
a ^=2; //等价于a=a^2;
System.out.println("a ^=2的值为:"+a);
}
private void bitOperator(){ //位运算符应用
int bitA=a & b; //按位与,两个运算数都为1时，结果为1，其余结果为0
int bitB=a | b; //按位或,两个运算数都为0时，结果为0，其余结果为1
int bitC=a ^ b; //按位异或,两个运算数相同时结果为0，不同时结果为1
int bitD=~a; //按位非,0变成1，1变成0
int a=6; //重新赋值
int bitE = a >> 1; //右移，左边空出位以0填充
int bitF = a >>> 1; //右移，左边空出位以0填充
int bitG = a << 1; //左移，右边空出位以0填充
System.out.println("(bitA=a & b), bitA="+bitA);
System.out.println("(bitB=a | b), bitB="+bitB);
System.out.println("(bitC=a ^ b), bitC="+bitC);
System.out.println("(bitD=~a), bitD="+bitD);
System.out.println("(bitE = a >> 1), bitE="+bitE);
System.out.println("(bitF = a >>> 1), bitF="+bitF);
System.out.println("(bitG = a << 1), bitG="+bitG);
}
private void booleanOperator(){ //布尔运算符应用
boolean booA=e && f; //与，当所有操作数都为true时，结果返回true,
//否则为false
boolean booB=e || f; //或，当一方操作数为true时，就返回true,
boolean booC=e && (a==b); //所有操作数都为false时，返回false
boolean booD=e || ((a==b)==f);
System.out.println("(booA=e && f),booA="+booA);
System.out.println("(booB=e || f),booB="+booB);
System.out.println("(booC=e && (a==b)),booC="+booC);
System.out.println("(booD=e || ((a==b)==f)),booD="+booD);
//注意&&是短路与，意思是:当对操作数的表达式进行从左到右运算时，
//若遇到有操作数的值为false，则结束运算，将结果置为false
if(e && (a=b)==10)
System.out.println("a="+a);
if(f || (a=b)==10)
System.out.println("a="+a);
//||运算符:对操作数进行或运算，当所有操作数都为false时，结果为false，
//否则结果为true
if(f || (b==a-1))
System.out.println("a="+a);
if(e || ((b--)==++b))
System.out.println("b="+b);
//对操作数的值进行取反运算，操作数为true，取反为false
if(!f)
System.out.println("布尔变量f为false,取反后值为"+!f);
else
System.out.println("布尔变量f为true,取反后值为"+!f);
//|运算符，和||一样，对操作数进行或操作，但它不是短路的
if(e | (a=b)==10)
System.out.println("a="+a);
if(f |(a=b)==10)
System.out.println("a="+a);
//&运算符，和&&一样，对操作数做与操作，不同的是它不是短路的，
//它会运算完所有的操作数表达式
if(e & (a=b)==10){
System.out.println("a="+a);
}
if(f &(a=b)==10)
System.out.println("a="+a);
//^运算符，对操作数做异或操作，相同为false，不同为true
if(e ^ (b==a-1))
System.out.println("布尔变量e值与(b==a-1)的值不同！");
else{
System.out.println("布尔变量e值与(b==a-1)的值相同！");
}
}
private void otherOperator(){ //其他运算符应用
int oA=(a>=b) ? 1:0; //可以用三元运算符替代简单的if语句
//格式x=a?b:c
System.out.println("(oA=(a>=b) ? 1:0),oA的值为"+oA);
if(b++ ==a) //b++表示先进行运算，再将b的值加1
System.out.println("表达式(b++==a)的值为true!");
else
System.out.println("表达式(b++==a)的值为false!");
if(++b ==a) //++b表示先将b的值加1，再进行运算
System.out.println("表达式(++b==a)的值为true!");
else
System.out.println("表达式(++b==a)的值为false!");
a--; //a--表示先进行运算，再将a的值减1
--a; //--a表示先将a的值减1，再进行运算
System.out.println("a的值为:"+a);
}
public static void main(String[] args) { //Java程序的主入口处
TextOperator operator=new TextOperator(); //实例化一个对象
System.out.println("1.算术运算符应用方法:");
operator.calculateOperator(); //调用算术运算符应用方法
System.out.println("2.比较运算符应用方法:");
operator.compareOperator(); //调用比较运算符应用方法
System.out.println("3.赋值运算符应用方法:");
operator.evaluateOperator(); //调用赋值运算符应用方法
System.out.println("4.位运算符应用方法:");
operator.bitOperator(); //调用位运算符应用方法
System.out.println("5.布尔运算符应用方法:");
operator.booleanOperator(); //调用布尔运算符应用方法
System.out.println("6.其他运算符应用方法:");
operator.otherOperator(); //调用其他运算符应用方法
}
}
（3）运行结果如下所示：
1.算术运算符应用方法: (divideA=a/b),divideA=1 (divideB=a/b),divideB=1.0 (divideC=a/(b*2.0f)),divideC=0.6 (divideD=a/(b*2.0d)),divideD=0.6 2.比较运算符应用方法: (a==b) = false (a>b) = true (a<b) = false (a!=b) = true (a>=b) = true (a<=b) = false (a=b) = 5 3.赋值运算符应用方法: a+=1的值为:6 a-=1的值为:5 a/=2的值为:2 a*=2的值为:4 a &=2的值为:0 a |=2的值为:2 a ^=2的值为:0 4.位运算符应用方法: (bitA=a & b), bitA=0 (bitB=a | b), bitB=5 (bitC=a ^ b), bitC=5 (bitD=~a), bitD=-1 (bitE = a >> 1), bitE=3 (bitF = a >>> 1), bitF=3 (bitG = a << 1), bitG=12 5.布尔运算符应用方法: (booA=e && f),booA=false (booB=e || f),booB=true (booC=e && (a==b)),booC=false (booD=e || ((a==b)==f)),booD=true b=5 布尔变量f为false,取反后值为true a=5 布尔变量e值与(b==a-1)的值不同！ 6.其他运算符应用方法: (oA=(a>=b) ? 1:0),oA的值为1 表达式(b++==a)的值为true! 表达式(++b==a)的值为false! a的值为:3
源程序解读
（1）在calculateOperator()方法中，对于除法运算，当除数和被除数都是整型时，若除不尽结果取整数部分。当除数和被除数不全是整型时，结果要声明为浮点型，否则要进行强制转换。
（2）在compareOperator()方法中，比较两个数是否相等用双等号，而不是等号。等号代表对变量进行赋值。
（3）evaluateOperator ()方法是讲解赋值运算符的运用。
（4）在bitOperator()方法中，“>>”是将数字按二进制位右移，左边空出位以0填充；“<<”是将数字按二进制位左移，右边空出位以0填充；“>>”与“>>>”对于正数操作没有什么区别，对于负数差别就大了。
（5）在booleanOperator()方法中，当“&&”左边的表达式值为false时，右边的表达式就不用计算了，整个表达式的值为false；当“&&”左边的表达式值为true时，就要计算右边的表达式，右边表达式的结果关系到整个表达式的结果。而“&”运算符不同，无论它左边连接的表达式的值是什么，都会计算右边的表达式的值，整个表达式最后得到的结果与“&&”得到的一样。“||”与“|”的区别和“&&”与“&”的区别一样。
（6）在otherOperator()方法中，a++与++a的区别：a++是先进行运算，再将a的值加1，++a是先将a的值加1，再进行运算。
实例7 不同数制间的转换
在使用计算机时，显示在计算机中的数值、图像等信息都是以二进制的形式存储和识别的，计算机底层硬件只能识别0、1，这种只有0、1两个数字符号的组合称为二进制。实际开发中使用最多的是十进制，但也会遇见八进制以及十六进制。为了读取数据方便，下面讲解不同数制间的转换。
技术要点
本实例根据数制表现形式的不同进行讲解。技术要点如下：
• 二进制有两个数字：0、1，运算时逢2进1，如100。
• 八进制有0～7八个数字，运算时逢8进1。八进制的数据有一个0的前缀，如012。
• 十六进制有16个数字，包括0～9和A、B、C、D、E、F，运算时逢16进1。十六进制的数据有一个0X的前缀，如0X1。
• 十进制有0～9十个数字，运算时逢10进1，如24。
实现步骤
（1）创建一个类名为TextNumberConversion.java。
（2）代码如下所示：
package com.zf.s2; //创建一个包
import java.util.Scanner;
public class TextNumberConversion { //操作数制转换的类
public static int NumberToTen(int beforeConversion, String number) {
//其他进制转成十进制
double result = 0; //声明转换后的数值
String subString;
//根据字符串的长度循环获得单个元素
for (int i = 0; i < number.length(); i++) {
subString = number.substring(i, i + 1); //将字符串按循环截取
if (beforeConversion == 16) { //判断是否是十六进制
subString = sixteenCharToNumber(subString); //将字母转换成数字
}
result += Integer.parseInt(subString) //返回转换的结果
* Math.pow(beforeConversion, number.length() - i - 1);
}
return (int) result;
}
public static String TenToNumber(int afterConversion,String number) {
//十进制转成其他进制
int current = Integer.parseInt(number); //将字符转换成整数
String opResult = "";
//判断转换后的数制是否是十六进制
if(afterConversion==16){
//判断传入的数是否大于16，大于则逢16进1
while(current>=afterConversion){
opResult+=sixteenNumberToChar(current%afterConversion);
//将数字转换成字母
current/=afterConversion;
}
if(current!=0)opResult+=sixteenNumberToChar(current); //最终余数
}else{
//判断传入的值是否大于转换后的数制
while(current>=afterConversion){
opResult+=current%afterConversion;
current/=afterConversion;
}
if(current!=0)opResult+=current; //最终余数
}
String riResult = ""; //倒序二进制字符串
//根据二进制的转换方式进行循环输出
for(int i=opResult.length()-1;i>=0;i--){
riResult = riResult + opResult.substring(i,i+1);
}
return riResult;
}
public static String sixteenCharToNumber(String s){ //十六进制字母对应数字
String num="";
if(s.equals("A") || s.equals("a"))
num="10";
else if(s.equals("B") || s.equals("b"))
num="11";
else if(s.equals("C") || s.equals("c"))
num="12";
else if(s.equals("D") || s.equals("d"))
num="13";
else if(s.equals("E") || s.equals("E"))
num="14";
else if(s.equals("F") || s.equals("f"))
num="15";
else
num=s;
return num;
}
public static String sixteenNumberToChar(int num){ //十六进制数字对应字母
String c="";
if(num==10) c="A";
else if(num==11) c="B";
else if(num==12) c="C";
else if(num==13) c="D";
else if(num==14) c="E";
else if(num==15) c="F";
else c=String.valueOf(num);
return c;
}
public static void main(String []args){ //Java程序的主入口处
String number; //要转换的数
int beforeConversion,afterConversion; //转换前的数制，转换后的数制
String result=""; //经过数制转换后的结果
String stop="";
Scanner read=new Scanner(System.in); //得到用户输入的值
do{
System.out.println("请输入三个参数（整数）:
待转换的数据 转换前的数制 转换后的数制");
number=read.next();
beforeConversion=read.nextInt();
afterConversion=read.nextInt();
stop="Q";
}while(stop!="Q"); //跳出循环
try {
if(beforeConversion!=10){ //判断转换前的数制是否是十进制
String temp=String.valueOf(
NumberToTen(beforeConversion,number)); //转换成十进制的数
result=String.valueOf(
TenToNumber(afterConversion, temp)); //十进制转换成其他进制
}else{
result=String.valueOf(
TenToNumber(afterConversion, number)); //十进制转换成其他进制
}
System.out.println(beforeConversion+"进制的数:"+number+",转换成"
+afterConversion+"进制的数为:"+result);
} catch (Exception e) {
System.out.print("转换失败，请输入合法数据！");
//所有程序（方法，类等）停止，系统停止运行
System.exit(-1); }
}
}
（3）运行结果如下所示：
请输入三个参数（整数）:待转换的数据 转换前的数制 转换后的数制 12 10 8 十进制的数:12,转换成八进制的数为:14
源程序解读
（1）NumberToTen()方法根据传入的数制转换成十进制，用循环遍历字符串获得字符串中的单个字符，然后对每个字符进行判断。传入的如果是十六进制的数，则调用sixteenCharToNumber()方法将字符转换成数字。并运用Math.pow()返回底数的指定次幂的功能对数据进行计算。Math.pow(x,y)相当于计算xy。
（2）TenToNumber()方法首先将要转换的字符转为整型，并根据转换后的数制获得相应的结果。十进制转换为二进制时，需要将十进制的数依次除2取余，获得的余数需要进行倒序整理。
（3）由于十六进制的数据中含有字母和数字，在进行数制转换时需要进行相应的字母数字转换。
（4）在程序主方法main()中，笔者运用运行程序获取用户输入的方式获得数据，具有很好的灵活性和可操作性。
实例8 多种方式实现阶乘的算法
本节将用四种算法实现计算阶乘，包括运用递归算法、运用简单的循环相乘的算法、数组添加的算法、利用BigInteger类实现。
技术要点
本实例主要根据处理阶乘的算法不同进行讲解。技术要点如下：
• 递归主要就是处理好入口和出口，入口是最初始的外部对函数调用，出口是对于继续递归也就是继续调用自身的限制条件，内容是对整个过程中单个步骤的一般化的抽象。简单地说就是在一个函数内部调用自身。
• 利用BigInteger类，可以计算更大的阶乘。
实现步骤
（1）创建一个类名为TextFactorial.java。
（2）代码如下所示：
package com.zf.s2; //创建一个包
import java.math.BigInteger; //导入类
import java.util.ArrayList;
import java.util.List;
public class TextFactorial { //操作计算阶乘的类
public static int simpleCircle(int num){ //简单的循环计算的阶乘
int sum=1;
if(num<0){ //判断传入数是否为负数
throw new IllegalArgumentException("必须为正整数!"); //抛出不合理参数异常
}
for(int i=1;i<=num;i++){ //循环num
sum *= i; //每循环一次进行乘法运算
}
return sum; //返回阶乘的值
}
public static int recursion(int num){ //利用递归计算阶乘
int sum=1;
if(num < 0)
throw new IllegalArgumentException("必须为正整数!");//抛出不合理参数异常
if(num==1){
return 1; //根据条件,跳出循环
}else{
sum=num * recursion(num-1); //运用递归计算
return sum;
}
}
public static long addArray(int num){ //数组添加计算阶乘
long[]arr=new long[21]; //创建数组
arr[0]=1;
int last=0;
if(num>=arr.length){
throw new IllegalArgumentException("传入的值太大");//抛出传入的数太大异常
}
if(num < 0)
throw new IllegalArgumentException("必须为正整数!");//抛出不合理参数异常
//建立满足小于传入数的while循环
while(last<num){
arr[last+1]=arr[last]*(last+1); //进行运算
//last先进行运算，再将last的值加1
last++;
}
return arr[num];
}
public static synchronized BigInteger bigNumber(int num){
//利用BigInteger类计算阶乘
ArrayList list = new ArrayList(); //创建集合数组
list.add(BigInteger.valueOf(1)); //往数组里添加一个数值
for (int i = list.size(); i <= num; i++) {
BigInteger lastfact = (BigInteger) list.get(i - 1);//获得第一个元素
BigInteger nextfact = lastfact.multiply(BigInteger.valueOf(i));
//获得下一个数组
list.add(nextfact);
}
return (BigInteger) list.get(num); //返回数组中下标为num的值
}
public static void main(String []args){ //Java程序的主入口处
int num=5;
int num1=23;
System.out.println("简单的循环计算"+num+"的阶乘为" //调用simpleCircle
+simpleCircle(num));
System.out.println("利用递归计算"+num+"的阶乘为" //调用recursion
+recursion(num));
System.out.println("数组添加计算"+num+"的阶乘为" //调用addArray
+addArray(num));
System.out.println("利用BigInteger类计算"+num1+"的阶乘为"
+bigNumber(num1)); //调用bigNumber
}
}
（3）运行结果如下所示：
简单的循环计算5的阶乘为120 利用递归计算5的阶乘为120 数组添加计算5的阶乘为120 利用BigInteger类计算23的阶乘为25852016738884976640000
源程序解读
（1）本实例程序创建两个ArrayList类实例，第一个ArrayList类实例使用默认无参数的构造函数创建，通过调用Add方法初始化数据；第二个ArrayList类实例使用一个指定元素的数组创建，在创建的同时初始化数据。这两种方法所创建ArrayList类的初始容量是不同的。
（2）本实例程序所创建的第一个ArrayList类实例，所有的元素都是string数据类型，在遍历该集合的元素时，可以指定遍历对象的数据类型为string，第二个ArrayList类实例的元素不止一种数据类型，此时应指定遍历对象的数据类型为object。
（3）为说明两种初始化方式的区别，本实例程序未压缩ArrayList类实例的容量，在实际编程中可以使用TrimToSize方法压缩ArrayList类实例的容量。