01 Java编程基础

千里之行，始于足下。作为我java SE学习日记的第一句，这八个字笔者会谨记。

学习一门程序语言，就如同熟悉一套积木。只有先熟悉了积木的种类，形状，拼接规则，才能在日后游刃有余的用这套积木搭建出雄伟的城堡。

今天的java编程基础，就是为了熟悉java SE这套积木的基本配置，为日后的工作打下坚实的基础。

1. Java开发环境的配置

工欲善其事，必先利其器。Java开发环境的配置，详细来说包括Java虚拟机的配置，源代码编辑器的配置，Java程序源文件管理和Java程序的编译运行方法四个部分。

1.1 Java虚拟机的配置

下载安装JDK，假设JDK安装在F:\Java目录下。

配置环境变量如下：

JAVA_HOME = F:\Java

PATH = %JAVA_HOME%\bin;%JAVA_HOME%\lib;%JAVA_HOME%\jre\lib;

CLASSPATH = %JAVA_HOME%\lib;%JAVA_HOME%\jre\lib;

这三个环境变量都非常重要:

JAVA_HOME指向的是JDK的安装路径，在这路径下能够找到bin、lib等目录；

PATH指向JDK的bin目录，这样在控制台下面编译、执行程序时就不需要再键入JDK编译、运行的一大串路径了；

CLASSPATH是指向.class文件的目录，JDK编译后产生的.class文件会放在这个目录中，运行所需的.class文件也优先从这个目录中调取。

1.2 源代码编辑器的设置

笔者用的是Vim文本编辑器，优点是可以自定义一些快捷键来执行特定代码编辑动作，效率较高，缺点是缺少类库的补全功能。不过一开始还是好记性不如烂键盘，自己记住并敲出一些长长的类名可以锻炼记忆力嘛!熟练之后再考虑换成eclipse编辑器。

1.3 Java程序源文件管理

Java源文件程序以.java为后缀，编译生成的字节码文件以.class为后缀。这些文件最好都放在同一个文件夹中，该文件夹与CLASSPATH变量指定的一致。

1.4 Java程序的编译运行

源文件写好以后，在控制台下进到CLASSPATH指定的目录下，键入javac XXX.java编译，然后键入java XXX.class运行。

可以用这个简单的Helloworld程序来测试开发环境是否搭建成功：

public class HelloWorld
{
    public static void main(String[] args)
    {
        System.out.println("Hello World^_^");
    }
}

2. 基本类型

基本类型，或者叫做内置类型，是JAVA中不同于类的特殊类型。它们是我们编程中使用最频繁的类型。基本类型共有八种，它们分别都有相对应的包装类。

基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。

2.1 基本类型的大小和范围

名称	二进制位数	包装类	最小值	最大值
byte	8	java.lang.Byte	-128	127
short	16	java.lang.Short	-32768	32767
int	32	java.lang.Integer	-2147483648	2147483647
long	64	java.lang.Long	-9223372036854775808	9223372036854775807
float	32	java.lang.Float	1.4E-45	3.4028235E38
double	64	java.lang.Double	4.9E-324	1.7976931348623157E308
char	16	java.lang.Character	0	65535

2.2 基本类型的转换

这些类型由低级到高级分别为(byte，short，char)--int--long--float--double。

从低级到高级会进行自动类型转换，比如：

byte b;
int i = b;
long l = b;
float f = b;
double d = b;

这样的转换会自动进行。

如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如：

char c = 'c';
int i = c;
System.out.println("output:"+i);
//输出：output:99;

对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换：

short i = 99;
char c = (char) i;
System.out.println("output:"+c);
//输出：output: c;

但根据笔者的经验，byte,short,int三种类型都是整型，因此如果操作整型数据时，最好统一使用int型。

将高级类型变量转换为低级类型变量时，情况会复杂一些，必须使用强制类型转换：

int i = 99;
byte b = (byte) i;
char c = (char) i;
float f = (float) i; 

这种转换可能会导致溢出或精度下降，因此笔者并不推荐这种转换。

2.3 包装类

所谓包装类，就是可以直接将简单类型的变量表示为一个类，在执行变量类型的相互转换时，我们会大量使用这些包装类。Java共有六个包装类，分别是Boolean、Character、Integer、Long、Float和Double，从字面上我们就可以看出它们分别对应于boolean、char、int、long、float和double。而String和Date本身就是类。所以也就不存在什么包装类的概念了。

简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。即： Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value) 。而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。下面举例总结一下基本类型和包装类的互相转换：

byte b = 169; 
Byte bo = new Byte(b);
b = bo.byteValue();
short t = 169; 
Short to = newShort(t);
t = to.shortValue();
int i = 169; 
Integer io = newInteger(i);
i = io.intValue();
long l = 169;
Long lo = new Long(l);
l = lo.longValue();
float f = 169f; 
Float fo = new Float(f);
f = fo.floatValue(); 
double d = 169f; 
Double dO = new Double(d);
d = dO.doubleValue();

利用包装类，也可以实现不同基本类型变量间的转换，例如，对于一个双精度实型类，int Value()可以得到其对应的整型变量，而double Value()可以得到其对应的双精度实型变量。例如：

float f1 = 100.00f;
Float F1 = new float(f1);
Doubled1 = F1.doubleValue();
double d1 = 100.00;
Double D1 = new Double(d1); 
int i1 = D1.intValue();

2.4 字符串与基本类型的转换

几乎所有从java.lang.Object类派生的类都提供了toString()方法，即将该类转换为字符串。Character,Integer,Float,Double,Boolean,Short等类的toString()方法用于将字符、整数、浮点数、双精度数、逻辑数、短整型等类转换为字符串。例如：

int i1 = 10;
float f1=3.14f;
double d1 = 3.1415926;
Integer I1 = new Integer(i1);
Float F1 = new Float(f1);
Double D1 = new Double(d1);
String si1= I1.toString();
String sf1= F1.toString();
String sd1= D1.toString();

将String类型转换为基本类型，需要 Byte, Short, Integer, Float, Double, Long这些包装类的parse.....类方法，例如：

byte toByte = Integer.parseByte("1");
short toShort = Integer.parseShort("22");
int toInt = Integer.parseInt("1234");
long toLong = Integer.parseLong("123l");
float toFloat = Integer.parseFloat("12.34f");
double toDouble = Integer.parseDouble("12.34");

2.5 进制转换

Integer和Long提供了toBinaryString, toHexString和toOctalString方法，可以方便的将数据转换成二进制、十六进制和八进制字符串。功能更加强大的是其toString(int/long i, int radix)方法，可以将一个十进制数转换成任意进制的字符串形式。 byte, short, float和double等数据类型，可以利用Integer或者是Long的toBinaryString, toHexString, to OctalString和toString方法转换成其他进制的字符串形式。比如下面十进制向二进制的转换：

int i = 2;
String str = Integer.toBinaryString(i);
//输出字符串"10"

3. 运算符

Java有四大类运算符：算术运算、位运算、关系运算和逻辑运算。Java还定义了一些附加的运算符用于处理特殊情况。

3.1 算术运算符

加减运算符（+，-），乘除运算符（*，/），求余运算符（%），自增运算符（++），自减运算符（--）。

有几个需要注意的地方：

自增，自减运算符是单目运算符,可以放在操作元之前,也可以放在操作元之后。++x，--x表示在使用x之前，先使x的值加、减 1 。x++，x--表示在使用x之后,使x的值加、减 1。比如:

int i = 0;
int j = 0;
int a = i++;    //a=0, i=1
int b = ++j;    //b=1, j=1

算术表达式中，Java将按运算符两边的操作元的最高精度保留结果的精度，特别要注意除法结果的类型，例如：

System.println(5/2);       //输出2
System.println(5.0f/2);    //输出2.5

char型数据和整型数据运算结果的精度是int。char型运算结果要强制转换后才能赋值给char型变量。例如：

byte x=7;
char ch=’B’+x;            //不正确
char ch=(char)(’B’+x);    //正确

3.2 关系运算符

关系运算符用来比较两个值的关系.关系运算符的运算结果是boolean 型，当运算符对应的关系成立时，运算结果是true，否则是false。它们的含义与数学运算大体相同，比如“>”大于、“<”小于、“>=”大于等于、“<=”小于等于、“==”等于、“!=”不等于。注意算术运算符的优先级高于关系运算符。另一个要特别注意的地方是如果被比较的”值“不一定只是基本类型变量。”值“表示任何可以用数字表示的实体，实际上包含基本类型和对象两类实体。如果被比较实体中不只含有基本类型变量，还含有包装类，甚至其它对象，情况就会变得复杂。会涉及到包装类的装拆包操作，和对象的equals方法与==的区别，可能会产生一些反直觉的结果。这类错觉可能导致非常隐蔽的错误。比如：

int i = 0;
int j = 0;
// == 运算符陷阱
Integer I = new Integer(i);
Integer J = new Integer(j);
System.out.println(i == j);     //true
System.out.println(I == j);     //true
System.out.println(I == J);     //false
//不等运算符陷阱
System.out.println(i != j);     //false
System.out.println(i != J);     //false
System.out.println(I != J);     //true
System.out.println(i >= j);     //true
System.out.println(i >= J);     //true
System.out.println(I >= J);     //true

对于==运算符，两边至少有一边是基本类型变量时，则包装类会自动拆包，比较基本类型变量的值。而如果两边都是包装类对象时，则不会自动拆包，==比较的是两个包装类对象的引用的值。这两个包装类对象占据内存不同位置，所以比较结果是false，不相等。若想比较它们包装的基本类型变量的值，需要手动拆包后再比较。

对于>=和!=运算符，规则有所不同。其两边的实体中凡是有包装类对象，都会被自动拆包成对应的基本类型变量，所以最后三行的比较是相等的。

3.3 逻辑运算符

在Java语言中有三种逻辑运算符，它们是NOT（非，以符号“!”表示）、AND（与，以符号“&&”表示、）OR（或，以符号“||”表示）。这里它们的真值表不再赘述。短路现象需要注意，对于&&符，只要左边的是false就会立刻返回false，对于||符，只要左边的是true就会立刻返回true。 

3.4 位运算符

所有的数据、信息在计算机中都是以二进制形式存在的。我们可以对整数的二进制位进行相关的操作。这就是位运算符，它主要包括：位的“与”(&)、位的“或”(|)、位的“非”(~)、位的“异或”(^)。真值表不再赘述。

3.5 移位运算符

移位运算符的面向对象也是二进制的“位”。可以单独用移位运算符来处理int型数据。它主要包括：

左移位运算符，用符号“<<”表示。它是将运算符左边的对象向左移运动运算符右边指定的位数（在低位补0）。

“有符号”右移运算符，用符号“>>”表示。它是将运算符左边的运算对象向右移动运算符右侧指定的位数。它使用了“符号扩展”机制，也就是说，如果值为正，在高位补0，若为负，则在高位补1。

“无符号”右移运算符，用符号“>>>”表示。它同“有符号”右移运算符的移动规则是一样的，惟一的区别就是：“无符号”右移运算符，它采用了“零扩展”，也就是说，无论值为正负，都在高位补0。

3.6 赋值运算符

赋值就是向某个有名字的内存空间放入值的过程。赋值运算符是”=“。这里要注意赋值运算符可以和其它运算符（算术运算符、移位运算符）等组成简写的综合运算符：

综合运算符	完整表达式	等价综合运算符表达式
+=	a = a + b	a += b
-=	a = a - b	a -= b
*=	a = a * b	a *=b
/=	a=a / b	a /= b
%=	a = a % b	a %= b
>>=	a = a >> b	a >>= b
>>>=	a = a >>> b	a >>>= b

3.7 三目运算符

三目运算符比较罕见，因为它有三个运算对象，但它也确实属于运算符的一种，因为它最终也是产生一个值。它也可以转化为条件判断语句，只不过这种处理方式更简洁、明了。不过要注意三目运算符在运算时要求冒号两边的表达式返回值为同一类型，可能会包含自动的强制类型转换。在三目运算符表达式包含char类型变量时，这个规则可能会导致意想不到的问题：

int i = 0;
System.out.println(false ? i : 'c');     //返回99
System.out.println(false ? 100 : 'c');   //返回c
System.out.println(true ? 100 : 'c');    //返回d

三目表达式在计算时会将较低精度的操作数转换成较高精度的操作数的类型。按照之前基本类型一章中提过的精度顺序，char类型字符’c‘与int类型整数i在一起时被转换成int类型，返回字符’c‘的ASCII码值99。而第二个例子中左边的100被看做char类型字符的ASCII码，该表达式按照char类型返回字符’c‘。如果第二个例子中的false换成true，则返回ASCII码为100的字符d。

3.8 运算符优先级

在实际的开发中，可能在一个运算符中出现多个运算符，那么计算时，就按照优先级级别的高低进行计算，级别高的运算符先运算，级别低的运算符后计算，具体运算符的优先级见下表：

优先级	运算符	结合性
1	() []	从左到右
2	! +(正) -(负) ~ ++ --	从右向左
3	* / %	从左向右
4	+(加) -(减)	从左向右
5	<< >> >>>	从左向右
6	< <= > >= instanceof	从左向右
7	== !=	从左向右
8	&(按位与)	从左向右
9	^	从左向右
10	|	从左向右
11	&&	从左向右
12	||	从左向右
13	?:	从右向左
14	= += -= *= /= %= &= |= ^= ~= <<= >>=>>>=	从右向左

4. 数组

数组是有序数据的集合，数组中的每个元素具有相同的数组名和下标来唯一地确定数组中的元素。这是一种很常用的数据结构。数组中的元素在内存中的排列位置和元素索引值大小有一一对应关系。如果一个索引值仅指向一个元素，则是一维数组。如果指向一个数组，则是多维数组。每个数组都是一个对象，数组的声明和创建是两个分开的过程。下面以比较常用的一维数组为例总结一些规则。

4.1 数组初始化

数组的初始化可以细分为定义，分配空间和赋值三个步骤。这三个步骤可以在一条语句中进行，也可以在多条语句中进行。这将会导致出现三种不同的初始化方式：

动态初始化：数组定义与为数组分配空间和赋值的操作分开进行，例如：

int a[];
a = new int[3];
a[0] = 0;
a[1] = 1;
a[2] = 2;
Date days[];
days = new Date[3];  
days[0] = new Date(2008,4,5);
days[1] = new Date(2008,2,31);
days[2] = new Date(2008,4,4);

静态初始化：在定义数组的同时就为数组元素分配空间并赋值，例如：

int a[] = {0,1,2};
Date days[] = {new Date(19,42,42),new Date(1,23,54),new Date(5,3,2)}; 

默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化：

int a [] = new int [5] ;   //int数组的元素会被隐式地赋初值为0

4.2 数组的方法

一个数组是Java中一个特殊的对象。数组本身有一些重要的属性和方法，同时Arrays工具类提供的类方法也可以操纵数组。笔者查阅API，结合毕老师的视频，总结了一些常用的数组方法。

数组的复制：

//public static void System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)    
//src是源数组，srcPos是源数组开始复制的元素的索引，dest是目标数组，destPos是目标数组开始接收复制元素的位置的索引，length为要复制的元素个数
String[] A = {"H","e","l","l","o"};       
String[] B = new String[3];               
System.arraycopy(A, 0, B, 1, B.length - 1); 
//B的元素为null,"H","e"

数组的填充：

//public static void fill(Object[] a, int fromIndex, int toIndex,Object val)
//向对象数组a从fromIndex到toIndex范围内的元素填充对象val
String[] A = new String[5];
Arrays.fill(A, "Hello");                      
for(int i = 0; i < A.length; i ++)
System.out.print(A[i] + " ");
//运行结果Hello，Hello，Hello，Hello，Hello

判断数组内容相等：

String[] A = {"1","2","3"}; 
String[] B = {"一","二","三"};                 
String[] C = {"1","2","3"};                    
System.out.println(Arrays.equals(A, B));
System.out.println(Arrays.equals(A, C));
//输出false，true 

将数组转换成列表：

public static <T> List<T> asList(T... a)
//返回列表
String[] A = {"H","e","l","l","o"};  
System.out.println(Arrays.asList(A));
//输出[H,e,l,l,o]

数组排序：

//按照String类的compareTo()方法排序
String[] A = {"A","B","c","D","e","f","G","H"};
Arrays.sort(A); 
System.out.println(Arrays.asList(A));    
//运行结果为：[A, B, D, G, H, c, e, f]

数组元素的二分查找：

//必须在排完序的数组上使用
//public static int binarySearch(<T>[] a, <T> key)
String[] a = {"a","d","e","w","f"};     
Arrays.sort(a); 
System.out.println(Arrays.asList(a));  
int index1 = Arrays.binarySearch(a, "f");                           
System.out.println("要查找的值存在的时候：" + index1);                          
int index2 = Arrays.binarySearch(a, "n");                          
index2 = index2 - 1;                         
System.out.print("当不存在的时候输出该值最可能存在的位置：" + index2);

逆向输出数组（用到Collections类的排序接口）

String[] a = {"a","b","c"};                     
Arrays.sort(a,Collections.reverseOrder());                         
System.out.println(Arrays.asList(a));
//输出：[c,b,a] 

数组的长度：

String[] a = {"a","b"};
System.out.println(a.length);
//输出2

5. 控制结构

Java程序中的控制结构主要有顺序结构，选择结构和循环结构，另外还有配合使用的跳转语句。

5.1 顺序结构

一般的多行表达式语句都是按书写顺序执行的，这就是顺序结构，比如：

int k, i=3, j=4;                      
k=i+j;                      //k=7
System.out.println(″k=″+k); //输出k=7

5.2 选择结构

按照一定条件在运行时决定表达式执行顺序的，是选择结构，有多种实现方法，比如：

if语句，这是最简单的单分支结构。条件表达式的值为true，就执行s1语句，否则就忽略s1语句。s1语句可以是复合语句：

if (条件表达式)
   s1语句;

if...else二分支语句，if语句通常与else语句配套使用，形成二分支结构。当条件表达式的值为true，就执行s1语句，忽略else和s2语句；条件表达式的值为false，程序忽略s1语句，执行else后面的s2语句。s1和s2都可以是复合语句：

if (条件表达式)
     s1语句;
else
     s2语句;

if....else多分支语句，是if与else关键字嵌套生成的语句，用于复杂的情况。在这里依次计算条件表达式，如果某个条件表达式的值为true，就执行它后面的语句，其余部分被忽略；所有表达式的值都为false，就执行最后一个else后的s3语句。s1、s2和s3都可以是复合语句。

if (条件表达式1)
      s1语句;
else if (条件表达式2)
      s2语句;
else
      s3语句;

switch语句：虽然嵌套的条件语句可实现多个分支处理，但嵌套太多时容易出错和混乱，这时可以使用开关语句switch处理。实际上开关语句switch也是一种if…else结构，不过它使你在编程时很容易写出判断条件，特别是有很多条件选项的时候：

switch (表达式) {
case 常量1:
     语句1;
     break;
case 常量2:
     语句2;
     break;
case.........
default:
     语句n;
}

其中switch、case、default是关键字，default子句可以省略。开关语句先计算表达式，然后将表达式值与各个常量比较，如果表达式值与某个常量相等，就执行该常量后面的语句；如果都不相等，就执行default下面的语句。如果无default子句，就什么都不执行，直接跳出开关语句。

使用开关语句时，注意以下几点：
case后面的常量必须是整数或字符型，而且不能有相同的值；

通常在每一个case中都应使用break语句提供一个出口，使流程跳出开关语句。否则，在第一个满足条件case后面的所有语句都会被执行，会出现错误。

5.3 循环结构

循环可使程序根据一定的条件重复执行某一部分程序代码，直到满足终止循环条件为止。Java中提供的循环语句有： 确定次数循环（for）、条件循环（while）、先执行后判定循环（do）。下面举例说明：

for循环语句：

如果希望程序的一部分内容按固定的次数重复执行，通常可以使用for循环。for循环采用一个计数器控制循环次数，每循环一次计数器就计数，直到完成给定的循环次数为止。结构如下：

for (表达式1; 表达式2; 表达式3)
    循环体

其中表达式1可以给出计数器的初值，是一个赋值语句；表达式2指出循环结束条件，是一个逻辑表达式；表达式3指出计数器每次的增量，是一个赋值语句。

有一些需要特别注意的地方：计数器可在for语句之前定义，也可在循环括号中定义。计数器增量为1时常写成增量运算的形式，以加快运算速度。根据需要，增量可以大于或小于1。增量计算也可以放在循环体中进行，即把表达式3移到循环体内的适当位置，原位置为空。使用循环语句时常常会遇到死循环的情况，也就是无限制地循环下去。所以在使用for循环时，要注意初值、终值和增量的搭配。终值大于初值时，增量应为正值，终值小于初值时，增量应为负值。编程时必须密切关注计数器的改变，这是实现正常循环避免陷入死循环的关键。

while循环语句：

while循环不像for循环那么复杂，while循环只需要一个条件判断语句，便可以进行循环操作。结构如下：

while (条件表达式)
      循环体

其中while是关键字。每次循环之前都要计算条件表达式，其值为true时，就执行一次循环体中的语句，然后再计算条件表达式，决定是否再次执行循环体中的语句；如果条件表达式的值为false时，就跳出循环体，执行循环体下面的语句。必须警惕的是while循环中的条件表达式是逻辑表达式，所以循环体中一定要有改变条件表达式值的语句，使条件表达式的值有机会变为false，否则会陷入死循环。

do......while循环语句：
do…while循环与while循环相反，是先执行循环体中的语句，再计算while后面的条件表达式，若条件表达式值为false则跳出循环；否则继续下一轮循环。有些情况下，不管条件表达式的值是为true还是false，都希望把指定的语句至少执行一次，那么就应使用do…while循环。结构如下：

do {
循环体
} while (条件表达式);

其中do、while是关键字。程序首先执行do下面的循环体，然后计算while后面条件表达式的值，如果其值为true，则重复执行循环体；否则，就结束循环。与while循环相同，do循环在循环体中也一定要有改变条件表达式值为false的语句，否则会陷入死循环。do…while循环控制并不是很常用，但有时却非常重要，使用时特别注意不要忘记了while语句结尾处的分号“;”。

5.4 跳转语句

跳转语句可以无条件改变程序的执行顺序。Java支持3种跳转语句： break、continue和return。
break语句：

break语句提供了一种方便的跳出循环的方法。使用break语句可以立即终止循环，跳出循环体，即使循环没有结束也如此。break语句只能跳出当前循环（一层），比如：

while(表达式1)
{
       表达式2;
       if(表达式3)
       break;
}

如果表达式3成立，break语句会立刻让程序跳出while循环。

带标号的break语句：

标号是标记程序位置的标识符。break语句只能跳转到循环语句下面的第一条语句上，而带标号的break语句可直接跳转到标号处。正常的break只退出一重循环，如果要退出多重循环，可以使用带标号的break语句。比如：

loop:
while(表达式1)
{
       while(表达式2)
       {
            if(表达式3)
            break loop;
       }
}

表达式3成立时，循环会直接跳到loop标识符处，相当于直接跳出了两层循环。

continue语句：

continue语句只能用在循环结构中，它跳过循环体中尚未执行的语句，重新开始下一轮循环，从循环体第一个语句开始执行。比如：

while(表达式1)
{
       表达式2;
       if(表达式3)
       continue;
       表达式4;
}

执行到if语句时，如果表达式3为真，则continue语句会将程序直接跳回到表达式1处开始下一次循环，从而忽略了表达式4。带标号的continue语句与带标号的break语句相似。

return语句：

return语句用于方法的返回上，当程序执行到return语句时，终止当前方法的执行，返回到调用这个方法的语句。return语句通常位于一个方法体的最后一行，有带参数和不带参数两种形式，带参数形式的return语句退出该方法并返回一个值。当方法用void声明时，说明不需要返回值（即返回类型为空），应使用不带参数return语句。不带参数的return语句也可以省略，当程序执行到这个方法的最后一条语句时，遇到方法的结束标志}就自动返回到调用这个方法的程序中。结构如下：

return 表达式;

当程序执行到这个语句时，首先计算“表达式”的值，然后将表达式的值返回到调用该方法的语句。返回值的数据类型必须与方法声明中的返回值类型一致，可以使用强制类型转换来使类型一致。

6. 总结

Java语言与C语言有许多相似的地方，尤其是在不涉及面向对象的基础部分。以上的总结还有许多不全面不细致的地方，毕竟理论是服务于实践的，多多练习才会熟能生巧。