任课教师：欧阳江林E-MAIL： oujianglin111@163.com

上机地点： 6807

上机要求：每次上机要求写实践报告，每周星期三交作业或实践报告到老师办公室老师办公室： 1414(1 号教学楼 4 楼 )

第一章 Java 语言概述

本章要点

。

开发环境的配置2

Application和 Applet的开发方法3

变量和数据类型4

1 Java语言特点

基本控制结构5

方法的定义6

Java 简介

– Java是 SUN 公司开发的源于 Internet 的一种现代程序设计语言。多年来， SUN 公司对Java 产品不断改进升级，使之紧跟时代步伐，满足了日益复杂的软件开发需求。

– Java 是一种高级的、严格检查数据类型的、面向对象的程序设计语言。 Java 还是一种平台无关的、健壮和安全的的程序设计语言。

Java 发展的历史 Java 的历史可以追溯到 1991 年，源自 Patrick Naughton和 James Gosling 领导的一个 SUN 公司工程师小组的项目。 SUN 公司在 1996 年早期发布了 Java第 1 版。

1.1 Java 语言的特点

– Java 是一种面向对象的程序设计语言

– Java 是健壮的和安全的语言

– Java 是平台无关的语言

跨平台，实现了“一次编写，多处运行”。

– Java 抛弃了复杂的指针、宏定义、结构等，更容易理解和掌握

– Java 不是一个集成开发环境

1.2 Java 程序开发步骤• 1. 编写源程序 程序员通过编辑器编写一个 Java 程序，并以文件的

形式存储在磁盘上，文件的后缀名为 .java。

• 2. 编译生成字节码 通过编译器 (javac.exe) 将编辑好的源文件翻译成字

节码文件 (.class), 并存储在磁盘上。• 3. 运行 Application 由独立的解释器程序运行，需要调用

Java 的解释器 (java.exe)。 Applet 不能独立运行，必须嵌入到 Web 页面中，并由负责解释 HTML 文件的浏览器充当其解释器，来运行 Applet 的字节码程序。但可以用 appletviewer.exe 来运行 .html 文件。

Java 运行机制– 注：有两种类型程序的 .class 文件由类装载器装载 :

• application– ( 通常是存储于本地机器上的程序 )

• applet– （存储在用户通过 WWW 浏览器连接的远程计算机 , 如服务器 ; 它下载到浏览器中，并解释执行，当运行结束后丢弃 )

– 检验和执行• application

– java.exe 工具• applet 运行方式 :

– appletviewer.exe 来打开– 浏览器打开

Java 运行机制• Java 系统运行程序时：

– Java 解释器• ( 通常又叫 JVM ＝ java virtual machine 即 Java

虚拟机 ) ，由这些解释器来解释字节码翻译成本机的二进制代码。

• Java 虚拟机作为 Java 解释器，它能够将字节码转换成计算机当前平台下的机器代码

1.3 J2SDK 的安装与配置 • 登录

– http://java.sun.com

• 下载– 最新的 J2SE 版本– 找到 Download JDK for Windows

• 安装– 双击下载的安装文件（如： jdk-1_5_0_12-

windows-i586-p.exe)

JDK 环境变量的设置 • 配置环境变量

– 目的 : 告诉操作系统 ,所需 java 工具包安装在系统的什么位置上 .Java 运行环境 ( 虚拟机 ) 在什么位置 .

– Win2000,XP 的设置• 选择“我的电脑”－ >右击选择“属性”－ > 在系统特性

中选择“高级”选项卡－ > 打开“环境变量”• 在用户变量和系统变量中找到“ path” 变量• 为 path 变量添加你所安装的 JDK的 bin 文件夹路径• 如： C:\Program Files\Java\jdk1.5.0_12\bin• 注意：添加时各个路径之间用分号格开

• 1.右击“我的电脑”选择“属性” ,打开“系统属性” , 选择“高级”选项卡 .

• 2.单击“环境变量”按钮，打开“环境变量”对话框，在该对话框中可以设置只有当前用户登录时才有效的用户变量 , 也可以设置该系统的所有用户登录时都有效的系统变量

• 3. 在“环境变量”对话框中单击“新建”按钮,在打开的新建系统变量对话框中输入变量名JAVA_HOME, 其环境变量的值设置为 JDK 的安装位置 ,如 C:\JDK1.5。

• 4. 然后在 “环境变量”对话框中再次选择Path 变量 , 将 JDK 开发工具所在的 bin 目录的位置 (C:\JDK1.5\bin)添加到对应的环境变量值后面 ,注意和前面的值用” ;”隔开，单击“确定”按钮，完成 JDK相关环境变量的设置 .

• 5. 在“环境变量”对话框中单击“新建”按钮,在打开的新建系统变量对话框中输入变量名CLASSPATH ， 其 环 境 变 量 的值设 置 为 .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar。

1.4 Eclipse3.2.2 开发环境的安装 •登录 eclipse官方网站：

www.eclipse.org• 下载 Eclipse3.2.2 for Windows

文件名： eclipse-SDK-3.2.2-win32.zip

• 下载配套的语言包 文件名： NLpack1-eclipse-SDK-3.2.1-win32.zip

• 安装 Eclipse3.2.2 解压文件 eclipse-SDK-3.2.2-win32.zip 到指定

目录，运行目录中的 eclipse.exe 文件即可启动，此时是英文界面。

• 安装多国语言包1. 在 eclipse 目录中新建一个目录，如 newplugins,2. 解压文件 NLpack1-eclipse-SDK-3.2.1-win32.zip到 newplugins 文件夹 .

3. 在 eclipse 安装目录中建立 links 文件夹。4.在 links 文件夹中建立一个文本文件，文件名为：

language.link ，该文件只有一行内容：path=newplugins\\language

5.在 eclipse\configration 文件夹中保留 config.ini 文件，删除该文件夹中的所有其他文件。

6.启动 eclipse.

安装语言包后目录结构如下：

Eclipse启动画面

Eclipse主界面

Eclipse 运行环境配置

• 在 Eclipse主界面中，选择“窗口”→“首选项”，弹出首选项对话框，在该对话框的左侧树形目录中，展开 Java 节点，选择“已安装的JRE” ，再点击该对话框右侧的”添加”按钮，弹出“添加 JRE”对话框，单击 “浏览”，选择 JDK 的安装目录 C:\JDK1.5 ，此时在 JRE系统库中出现了相应的文件， 如下图所示：

Eclipse 运行环境配置

Eclipse 运行环境配置

1.5简单的应用程序 (Application)

打开一个文本编辑器，输入以下代码public class Welcome {

public static void main (String args[ ]){

System.out.println(“Hello world!”);}

}– 注意：大小写，文件保存为 Welcome.java

调试和运行• Javac(java compile)

– 如果没有配置环境变量，必须把文件放到javac所在的目录（ bin中 ), 并在命令提示符进入该目录下，才能调试

– 配置环境变量以后，不管你的文件在哪里，用命令提示符，进入你的文件存放位置，输入命令行

– 进行编译javac Welcome.java

编译命令 编译文件名 ( 全称 )

调试和运行• 编译正确 :

– 则不出现任何提示 , 生成 .class 字节码文件• 编译不正确 :

– 根据错误提示 ,继续修改• 输入命令行运行字节码文件

注意：不要将文件名写成 Welcome.class

java Welcome

运行命令 运行的字节码文件名

运行结果

1.5.2用 Eclipse 开发应用程序

•启动 Eclipse ，在主界面中选择 “文件”→ “新建”→ “项目”， 在对话框中输入项目名： Sample1_1

•右单击项目名，在弹出的右键菜单中选择 “新建”→ “类”，打开一个创建类的向导。输入包名： edu.ch1 ，类名：MyApplication ，打开 eclipse主界面，在编辑区中输入源程序，如下图所示：

源程序代码及运行结果

1.6 简单的 Applet 程序

• Applet就是小应用程序 ,Java Applet就是用 Java 语言编写的这样的一些小应用程序，它们可以直接嵌入到网页 ( 嵌入到 .html 文件中 )或者其他特定的容器中，并能够产生特殊的效果。

• Applet 不是通过 main() 方法来运行的。

例 1.2 Applet 示例

// Applet 程序名： WelcomeApplet.java import java.awt.Graphics; // 引入 Graphics 类 import java.applet.Applet; // 引入 Applet 类 // 声明类 WelcomeApplet继承自父类 Applet public class WelcomeApplet extends Applet { // 在 applet 容器中绘制一个字符串 public void paint( Graphics g ) { // 调用父类中的 paint 方法 super.paint( g ); // 在 x 坐标为 25， y 坐标为 25 位置上绘制一个字符串 g.drawString( "Welcome to Java Programming!", 25,

25 ); }

}

WelcomeApplet.html 文件内容

<html><applet code = "WelcomeApplet.class" width =

"300" height = "45"> </applet> </html>

• 将WelcomeApplet.java 文件编译成字节码文件WelcomeApplet.class ，然后把字节码文件和HTML 文件放在同一目录下。用浏览器打开HTML 文件，可看到运行结果。

在 IE 浏览器中的运行结果

用 JDK 自带的 appletviewer 程序运行 Applet

1.6.3 用 Eclipse 开发 Applet

• 用 Eclipse 开发小应用程序的步骤与开发应用程序相同先新建项目，再新建类。只是在创建类的时候，由于以小应用程序的方式运行，不需要创建 main() 方法。因此不用选择“ public static void main(String[] args)”选项。同时在超类这一栏里，可以输入继承的类名，小应用程序继承的是 Applet 类，因此在超类栏中输入： java.applet.Applet 。如下图所示。在类中输入例 1.2中的代码，在包资源管理器中右单击WelcomeApplet.java 文件，在弹出的右键菜单中选择 “运行方式”→ “ java applet” ，运行结果和 DOS 方式运行结果相同。

1.7 Java 基本语法

1.7.1 Java 的关键字 abstract default if private this

boolean do implements protected throw

break double import public throws

byte else instanceof return transient

case extends int short try

catch Final interface static void

char finally long strictfp volatile

class Float native super while

const For new switch

continue Goto package synchronized assert

数据类型 大小 最小值 最大值byte 8bits –128 127

short 16 bits –32768 32767

int 32 bits –2147483648 2147483647

long 64 bits –9223372036854775808 9223372036854775807

float 32 bits ±1.40239846E-45 ±3.40282347E+8

double 64 bits ±4.94065645841246544E-324

±1.79769313486231570E+308

char 16 bits \u0000 \uFFFF

boolean n/a true 或 false

1.7.2Java 的基本数据类型

1.7.3 变量 • 变量是用来存储数据的。在 Java 中，每一个

使用的变量都需要声明，以便于系统为他分配合理的存储空间。声明一个变量包括两个步骤：指定存储该变量的数据类型，以及给该变量起一个名称。声明变量的格式：

类型 变量名 1[ ，变量名 2 ，……，变量名 n][= 初值 ]；

例： int x; int age;

• 给变量命名应做到“见名知义”。

1.7.4 变量的赋值 • Java 使用赋值操作符“＝”给一个变量赋值例

如

int age; age= 18;

• 变量可以在声明时直接指定它的值。可以用下面这条语句来替代上面的两行语句。

int x = 18;

数据类型转换• 变量从一种数据类型转换到另一种数据类型，称为类型转换。凡是把占用比特数较少的数据转换成占用比特数较多的数据，可以由编译系统自动完成，这种转换称为隐式转换。如果要把占用比特数多的数据转换成占用比特数少的数据，可以采用强制类型转换。强制类型转换的格式是：

( 数据类型 ) 变量名；例如：int a=20,b=7;

float x=(float)a/b;

1.7.5 整型类型 • 有 4种可以用来表示整型数的数据类型：

– Byte– Short– Int– long。

• 例 1-3 整型数示例。 public class IntegerDemo {public static void main(String [] args){int a = 18; //声明并初始化变量short x,y=10,z=20; //同时声明多个变量x = (short)( y + z ); //这里为什么要强制转换 ?System.out.println("x 的值是 :"+x);

long b = 12345678987654321L; /* 常量数值 后为何要加‘ L’ 字符 ? */

System.out.println("b 的值是 :"+b);

b = a; //隐式类型转换byte c;

c = (byte)a; //强制类型转换System.out.println("c 的值是 :"+c);

}

}

1.7.6 浮点数类型 • 保存浮点数的数据类型有两种：

– Float 32位– Double 64位 默认情况下 Java以 double 方式处理浮点数，如果要指定某个浮点数的存储方式是 float而不是double ，需要在书写具体数值时追加一个类型标志符 F ，如 123.321F。

例 1-4 浮点数示例。public class FloatDemo {public static void main(String [] args){double pi = 3.14159;float f = 2.7F;// 注意这里指定以 float 类型存

储System.out.println("pi = " + pi);System.out.println("f = " + f);int n = 15, d = 4;f = n/d; //f 里面存储的值是什么？

System.out.println("f 的值是： " + f);

int radius = 10;

double area = pi * radius * radius;

//area里面存储的值是什么？System.out.println("area = " + area);

}

}

程序运行结果：pi = 3.14159

f = 2.7

f 的值是： 3.0

area = 314.159

1.7.7 布尔类型 • 布尔类型（ Boolean），用来表示布尔值。布尔变量

的取值只可以是 true 或者是 false。• 例 1-5 布尔类型使用示例。 public class BooleanDemo {public static void main(String[] args) {boolean t = true;System.out.println("t 的值是 " + t);int x = 2;boolean y = (x > 2);System.out.println("y 的值是 " + y);

x=x+1;

y=(x>2);

System.out.println("在 x加 1 以后， y 是 "+y);

// y = x; // 不能编译 !

}

}程序运行结果：t 的值是 true

y 的值是 false

在 x加 1 以后， y是 true

说明：在 Java 中，布尔数据类型不是一个整型值，不能将一个整数数赋值给布尔变量。

转义字符 含义

\t tab键

\b backspace退格键

\n newline换行

\r carriage return回车

\’ single quote单引号

\” double quote 双引号

\\ backslash反斜杠

1.7.8 字符数据类型

表 1-3 常用转义字符

在 Java 中，字符数据类型是用 16 位来表示的，可以表示 Unicode 字符集，这个字符集可以处理国际通用的字符。

一个字符可以被作为无符号的整数值来处理，因此可以进行一些算术操作，如比较两个字符值的大小等

在描述一个字符时，我们需要给该字符加上一对单引号。例如，’ A’ ，这样系统就以字符方式识别 A （注意：如果用双引号，则系统将识别为字符串 String ，而不是单个字符）。有些字符是不可打印的，可以用转义符（ \）来表示。表 1-3列举了常用的转义字符。

如果需要以 Unicode值的方式指定某个特定的字符可以使用转义符 \u 加上 Unicode 字符值。（注：该字符值以 16进制方式来表示）。例如’ \uF9A4’。

例 1-6 char 数据类型的使用示例。

public class CharDemo {public static void main(String[] args) {char a = 'A';char b = (char) (a + 1);System.out.println(a + b);System.out.println("a + b is " + a + b);int x = 75;char y = (char) x;char omega = '\u03A9';System.out.println("y is " + y + " omega is " + omega);

}}

程序运行结果：131

a + b is AB

y is K and omega is Ω

1.7.9 字符串 • 字符串就是一系列的字符。 Java用 String 类来抽象描

述了所有 string 对象的特征。注意， Java 中的字符串不是基本数据类型，它以类的形式存在。该类封装了操作 string 的一些常用方法，这使得用户在使用字符串对象时只要调用相应的方法就能轻松实现对字符串的操作。

• 在 Java 中，每一个基本类型和一个字符串连接时都将自动转换成一个字符串对象。而该对象的内容就是该变量里面保存的数据。这样做简化了对基本数据类型的显示和输出。事实上， Java 中的任何对象（不仅仅是内建类型）都可以转换成一个字符串对象，因为 Java 中的每个对象都有一个 toString() 方法，而 toString() 方法在输出时会被自动调用 .

例 1-7 字符串的演示示例 public class StringDemo{public static void main(String [] args){String first = “zheng”, last = “zhe”;String name = first + “ “ + last;System.out.println(“Name = “ + name);double pi = 3.14159;String s = “Hello, “ + first;System.out.println(s + pi + 7); System.out.println(pi + 7 + s);

}}

• 运行结果如下：Name = zheng zhe

Hello, zheng3.141597

10.14159Hello, zheng

1.7.10 常量 如果一个变量的值不能改变，这就要使用常

量了，如 Pi＝ 3.14 是一个常量，它不能变成4.32。需要声明某个变量是一个常量时，使用final 关键字来限定。

final double pi = 3.14159;pi = -5.0; // 编译时出错 !final int x //空常量值x = 12; //只能初始化一次x = 100 // 编译时出错！注意：试图修改一个常量的值会造成编译错误。同时，常量只能被初始化一次

1.8 Java操作符表 1-4 常用 Java 运算符及其优先级

优先级 描 述 运算符1 单目运算 ++ -- !

2 算术乘除运算 * / %

3 算术加减运算 + -

4 移位运算 << >> >>>

5 大小关系运算 > >= < <=

6 相等关系运算 == !=

7 按位与，非简洁与 &

8 按位异或 ^

9 按位或，非简洁或 |

10 简洁与 &&

11 简洁或 ||

12 三目条件运算 ? :

13 复合赋值运算符 *= /= %= += –= <<= >>= >>> = &= ^= |=

例 1-8 操作符的使用示例 public class ArithmeticDemo{public static void main(String [] args){System.out.println(5 + 4 * 6 / 3 – 2);System.out.println((5 + 4) * 6 / (3 – 2));int x = 5, y, z;y = x++;System.out.println(“x = “ + x + “ y = “ + y);x = 5;z = ++x;System.out.println(“x = “ + x + “ z = “ + z);int m = 15%4;System.out.println(“m = “ + m);

m = 29;

System.out.println(“m << 2 = “ + (m >> 2));

double d = 5.0;

d *= 4.0;

System.out.println(“d = “ + d);

System.out.println(“Ternary: “

+ (x==5 ? “yes” : “no”));

}

}

示例输出11

54

x = 6 y = 5

x = 6 z = 6

m = 3

m << 2 = 7

d = 20.0

Ternary: no

1.8.1 自增自减运算符 • 自增（ ++ ）和自减（ -- ）操作符都是单目运算符，即只有一个操作数的运算符。自增运算使单个变量的值增１，自减运算使单个变量的值减１。自增、自减运算符都有两种用法：

• ① 前置运算──运算符放在变量之前。• 格式：＋＋变量；－－变量。• 前置运算先使变量的值增（或减）１，然后再以变化

后的值参与其它运算，即先增减、后运算。• ② 后置运算──运算符放在变量之后。• 格式：变量＋＋、变量－－• 后置运算时，变量先参与其它运算，然后再使变量的值增（或减）１，即先运算、后增减。

例 1-9 自增自减运算符示例 public class IncreaseDemo {

public static void main(String[] args) {

int x=6, y;

System.out.println("x="+x); //输出 x 的初值

y = ++x; //前置运算 System.out.println("y=++x:

x="+x+",y="+y);

y = x--; // 后置运算 System.out.println("y=x--:

x="+x+",y="+y);

}

}

运行结果如下：x=6

y=++x: x=7,y=7

y=x--: x=6,y=7

• 前置运算时， x 先增 1 ，再赋值给 y ，所以 x和 y 的值都是 7。后置运算时，先将 x 的值 7赋值给 y,x 的值再减 1 ，所以 x 的值为 6， y的值为 7。

1.8.2 复合赋值操作符

• Java 提供了复合赋值操作符以简化赋值语句的书写。对一个变量的操作和结果的赋值用一条语句实现。复合赋值操作符有：*=； /=；%=； +=； -=；例如： y*=a+b; 等效于 y=y*(a+b); y/=a+b; 等效于 y=y/(a+b); y%=x; 等效于 y=y%x; y+=x; 等效于 y=y+x; y-=x; 等效于 y=y-x;

1.8.3 移位操作符 • 在 Java 中有三种移位操作：一个左移位 (<<)

和两个右移位 (>>和 >>>)。移位操作是通过对一个和整型数相对应的二进制数值的移动来实现的。

• 将一个整型数向左移位 (<<)将使二进制的最低位补上一个 0

• 向右移动操作符将二进制数据向右移动。“ >>” 是带符号右移，而“ >>>” 是不带符号右移。不带符号右移在数值向右移动的时候，无论符号位是什么，总是以 0来填补。

例 1-10 移位操作符示例 public class ShiftDemo{

public static void main(String [] args){

byte b = 11; System.out.println(b << 1); //左移 1位 System.out.println(b >> 1); //带符号右移 1

位 System.out.println(b >>> 1);// 不带符号右移1位 byte c = -10;

System.out.println(c << 3); //左移 3位System.out.println(c >> 1); // 带符号右移 1位

System.out.println(c >>> 1);

}

}

运行结果如下：22

5

5

-80

-5

2147483643

1.8.4 关系运算符 • Java 中的关系运算符有 6个，用于大小关系比较的运算符有 4个： < 、 <=、 >、 >=。用于相等关系的运算符有 2个： ==、 !=。大小关系运算符的优先级别高于相等关系运算符。关系运算是比较两个表达式大小关系的运算，关系运算的结果都是布尔型的量，即 true(真)或 false(假 )。例如：

int a=4,b=6;boolean y,c=true;y=a>b!=c;

1.8.5 布尔运算符

表 1-5 布尔运算符 运算符 运算 例 运算规则

& 非简洁与 x&y x、 y都真时结果才为真

| 非简洁或 x|y x、 y都假时结果才为假

! 取反 !x x真时为假，假时为真

^ 异或 x^y x、 y同真假时结果为假

&& 简洁与 x&&y x、 y都真是结果才为真

|| 简洁或 x||y x、 y都假时结果才为假

• 布尔运算符用来连接两个或两个以上布尔型变量或表达式。布尔运算的操作数和运算结果都是布尔型的量

• 对于简洁与运算（ &&），如果第一个操作数被判定为“假”，系统不再判定或求解第二个操作数。因为对于与运算，只要有一个操作数为假（ false），其结果即为假（ false）。而对于非简洁与运算 (&)，无论第一个操作数是真还是假，都会求解第二个操作数，然后根据两个操作数的值计算最终的结果。同理，对于简洁或运算（ ||），如果第一个操作数被判定为“真”，系统不再判定或求解第二个操作数。因为对于或运算，只要有一个操作数为真（ true），其结果即为真（ true）。而对于非简洁或运算（ |），无论第一个操作数是真还是假，都会求解第二个操作数。

例 1-11 布尔运算符“非简洁与”和“简洁与”的区别

public class AndDemo {public static void main(String[] args) {

int n1=1,n2=2,n3=3,n4=4; boolean x=true,y=true; boolean z=(x=n1>n2)&&(y=n3>n4); System.out.println("&&:

x="+x+",y="+y+",z="+z); x=true;y=true; z=(x=n1>n2)&(y=n3>n4); System.out.println("&:

x="+x+",y="+y+",z="+z);}

}

• 运行结果如下：&&: x=false,y=true,z=false&: x=false,y=false,z=false• 对于简洁与运算，由于 x=false ，则可以得出

z=false ，不再求解 y 的值，所以 y=true 。但对于非简洁与运算，则要把 x 和 y 的值都求解出来，再求解 z的值，所以 y=false。

1.8.6 三目运算符 • 三目运算符在使用时需要三个操作数，它是一个 if /else 控制结构的简写方式。格式如下：

(表达式 1) ?（表达式 2 ） :（表达式 3）• 执行顺序：先求解表达式 1 ，如果为真，则表达式 2的值就作为整个表达式的值；如果表达式 1 的值为假，则表达式 3 的值就是整个表达式的值。

• 例如： max=(a>b) ? a : b;• 如果 a>b ，则max=a；否则max=b 。执

行结果是把 a和 b中的较大者赋值给max。

1.9 Java 注释语句 • 在上面的例子当中，已经使用了一些注释语句，这些语句只是起到注释作用，方便程序员和其它读者阅读程序代码。 Java 的注释有三种方式：1. 使用双斜杠来注释一行文字。例如： //……2. 使用 /*和 */来注释多行文字。例如： /*……*/3. 使用 /**和 */来注释若干行，并写入 javadoc 文档

。通常这种注释的多行写法如下：/** * * */

• 这是 Java 的一种特殊注释方式，它可以利用 javadoc工具来生成 HTML 文档来包含注释信息。关于 javadoc工具的使用可以参考其它相关资料。

1.10 结构化程序设计 • Java 语言是面向对象的语言，但在局部的语句块内部，仍需要借助于结构化程序设计的基本流程结构来组织语句。结构化程序设计的基本原则是：任何程序都可以且只能由三种基本流程结构构成，即顺序结构、分支结构和循环结构。

1.10.1 if条件语句 • if 语句的一般格式： if(表达式 ) {语句组 A;} [else { 语句组 B;} ]• if 语句的执行过程：（ 1）缺省 else子句时例如： if(a>b) System.out.println(“max=“+a);

1.10.1 if条件语句（ 2 ）指定 else子句时例如： if(a>b) System.out.println(“max=“+a);

else System.out.println(“max=“+b);

if 语句的嵌套 一般形式： if (表达式 1 ) if (表达式 2 ) {语句组 A;} else { 语句组 B;} else if (表达式 3) {语句组 C;} else { 语句 D;}

例 1-12 ：输入学生的分数 score（ 0～100），如果 90≤ score≤100 ，输出“优秀”，如果 80≤ score<90 ，输出“良好”，如果 70≤ score<80 ，输出“中等”，如果 60≤ score<70 ，输出“及格”，如果 0≤ score<60 ，输出“不及格”，如果输入分数超出范围，输出“输入错误”。试编写 Java应用程序。

public class Score{

public static void main(String[] args) throws java.io.IOException{

String str=""; //声明字符串 char c=' '; //声明字符型变量 int score; //声明整型变量

System.out.println("请输入分数 :\n");

while(c!='\n') // 如果按回车键，则退出循环 {

c=(char)System.in.read(); //从键盘输入一个字符赋值给 c

str=str+c; // 将字符添加到 str 的末尾 str=str.trim();//除去字符串开始和尾部空格 }

score=Integer.parseInt(str); // 将字符串转换为整型数

if(score>=90 & score<=100) System.out.println("优秀 "); else if(score>=80 & score<90) System.out.println("良好 ");

else if(score>=70 & score<80) System.out.println(" 中等 ");

else if(score>=60 & score<70) System.out.println("及格 ");

else if(score>=0 & score<60) System.out.println(" 不及格 ");

else System.out.println("输入错误！ ");}

}

运行结果如下：请输入分数 :

78

中等

1.10.2 switch 语句 witch 语句格式：switch （表达式）{

case 常量 1: 语句组 1; break; //分支 1

case 常量 2: 语句组 2; break; //分支 2

…… case 常量 n: 语句组 n; break; //分支 n

[default: 语句组 n+1; ] //分支 n+1

}

switch、 case、 default 为关键字， break 语句是switch 语句的出口。

例 1-13 ：将例 1-12用 switch 语句实现

public class Sample1_13 {public static void main(String[] args) throws

java.io.IOException{ String str=""; //声明字符串

char c=' '; //声明字符型变量 int score; //声明整型变量

System.out.println("请输入分数 (0-100):"); while(c!='\n') // 如果按回车键，则退出循环 { c=(char)System.in.read(); //从键盘输入一个字符赋值给 c

str=str+c; // 将字符添加到 str 的末尾 str=str.trim();//除去字符串开始和尾部空格 }

score=Integer.parseInt(str); // 将字符串转换为整型数 switch(score/10){ case 10: case 9: System.out.println("优秀 ");break; case 8: System.out.println("良好 ");break; case 7: System.out.println(" 中等 ");break; case 6: System.out.println("及格 ");break; case 5: case 4: case 3: case 2: case 1: case 0: System.out.println(" 不及格 ");break; default : System.out.println("输入错误 "); }

}}

运行结果如下：请输入分数 :

87

良好

1.10.3 while循环 while循环语句的基本结构如下：while(表达式 ) { 循环体 } 表达式返回的值为布尔型。

例 1-14：求 1+2+3+4+5+……+100。 public class Sum {

public static void main(String[] args) {

int n=100,sum=0,i=1; // 变量定义及初始化while(i<=n)

{ //循环体sum=sum+i; // 求和i++; //循环变量更新

}

System.out.println("sum="+sum); //输出运算结果 }

}

运行结果如下： sum=5050

1.10.4 do-while循环 • 语法结构如下： do

{

循环体}while(表达式 );

例 1-19 嵌套 for循环示例(Sample1_19)

char current ='A'; //声明并初始化变量 currentfor(int row = 1; row <= 3; row++) //外

循环{ for(int column = 1; column <= 10;

column++) //内嵌循环 { System.out.print(current + " "); current++; //当前字符值自增 1

if(current>‘Z’) break; // 当前字符值大于 Z 时，退出循环

}System.out.println(); //换行}

1.11 方法

• 方法类似于 C 语言中的函数，其主要作用就是对类中定义的数据进行操作。 方法用来描述类的动态属性。简言之，方法就是定义在类中的函数。

1.11.1 方法签名• 方法签名也称为方法声明。例如 main() 方法

的签名就是：public static void main(String [ ] args)

• 访问控制符的值可以是：private,public,protected,和 default

• 可选控制符的值可以是： static,final,abstract,native和 synchronized • 方法的返回值可以是基本数据类型，也可以是

对象的引用。• 方法名必须符合标识符的规定。• 参数列表

1.11.2 编写方法体 • 一个完整的方法是由方法签名和方法体共同组

成的，方法体以一对大括号表示。在方法体内，放置具体的实现该方法的代码。如果该方法有返回值，则必须在方法中书写 return 语句，返回某个值。如

public String getName() // 方法签名{

return name; // 方法体}

1.11.3 方法调用 • 方法调用即使用该方法。在同一个类中调用方

法，可直接使用如下的格式来调用方法：方法名（实际参数）调用其他类中的方法必须指定类名或对象名：类名（对象名） . 方法名（实际参数）

方法

• 方法– 如果你学过 C或 C++ 语言的话 , 方法类似于函数 ,他的主要作用就是对类中定义的数据进行操作

• 和 C 语言函数的区别– 类是 Java 程序的基本单位 ,所有的数据和对

数据操作的方法都封装在类当中，成为他的一个重要组成部分。

什么是方法• 什么是方法

– 方法是在类中定义，用来实现对象操作的过程或者函数。方法是类的成员，并有自己的可访问性。 Java 程序中，方法的声明和方法的实现是分开的。

– 方法与普通函数和过程不同，方法只应用于特定类及其祖先类的对象。另外，每一个方法都有一个隐含的参数，称为 this ，它引用作为方法调用主体的对象。调用一个方法的语法格式是：对象名 . 方法名 ( 实际参数 );

– 实例字段和实例方法是属于某一具体实例对象的字段和方法，必须先创建这个实例对象，然后才能使用这些字段和方法。对于同一个类创建的不同的实例对象，其字段可以有不同的取值，以反映该对象的不同状态。

– 除此之外，还有一种通过类就可以直接访问的静态字段和静态方法，这种静态的字段和方法用 static 关键字标识，不需要创建实例就可以通过类直接访问。

方法– 访问控制符（ Access specifier） :

• 参见向类添加属性这节– 可选控制符

• 他们可以是 static,final,abstract,native和 synchronized 。• 要注意的是可选控制符不必全部出现，也不是只能出现一个，

它根据你的需要来定，这也就是可选的含义

– 返回值（ return value）• 通常情况下，方法都必须有返回值，如果没有返回值，那么就用 void表示，否则，你就需要指定返回值的数据类型

尽管你会发现先写可选控制符，再写访问控制符，如static public void main(String[] args).

系统仍能正常工作。但我们约定的规范写法是先写访

问控制符，再写可选控制符

方法– 方法名（ method name）

• 方法名可以是任何合法标志符• 方法名通常是一个动名词（表示某种操作行为）

– 参数列表（ Parameter list）• 在方法名之后的一对圆括号中包含的就是参数列表。利用

它用户在调用该方法时就可以传递给该方法想要处理的数据。

• 这些用户传递进来的数据，将产生一份拷贝，并存放在参数变量里。（ Java 的参数传递都是传值形式）

• 每一个参数的定义和变量的定义类似，即一个数据类型，加上一个标志符，多个参数之间用逗号隔开。

方法

• 方法体的编写– 同函数的编写– 包含在一对大括号内– 在函数体内定义的任何变量都是局部变量，在使用前必须初始化。

多个参数之间用逗号隔开。但是要注意的是，声明参

数时必须每个参数都要显式指定他的数据类型。也就

是说，你不能像定义变量一样简单地写成 fun(int

a,b)而必须写成 fun(int a ,int b)选控制符

方法调用

• 方法调用– 当完成一个方法的编写之后，这个方法就可

以使用了。– 通过 .(dot) 来调用某个方法。（参见访问对

象属性和方法）– 注意：每个方法都含有一个默认的引用 this

，

1. public class Test {2. public static String name=" 张三 ";

3. public static void main(String[]args)4. {5. this.getName();

6. }

7. public static String getName()8. {9. return name;10. }11.}

1. public class Test {2. public static String name=" 张三 ";

3. public static void main(String[]args)4. {5. getName();

6. }

7. public static String getName()8. {9. return name;10. }11.}

为什么这里没有使用引用变量就可以直接访问另一个方法？方法调用

方法的调用栈（ call stack）

– 也许你至今还有这样的疑问，为什么我们的程序需要从 main 方法开始，在 main 方法处理的过程中会根据程序员的语句安排依次执行，并最终完成整个程序的运行？

– 控制流改变了方法的执行• 一个方法在执行的过程中调用了另一个方法，这

时候就会发生控制流的改变 • 上例的第 5 行， main 方法进入 getName() 方法

中执行，执行完 getName() 方法再返回给 main，继续执行

方法调用栈

• 系统是如何实现的呢 – 系统中存在一个专门用来维护方法调用的栈

，我们称之为调用栈（ call stack） • 当前在执行的方法是处于栈顶位置的方法。如果该方法完成了它的执行操作，那么它将从栈中删除，控制流就返回到栈中下一个方法的中去了。如果在执行该方法的过程中，调用了一个新方法，新方法就会被添加到栈中，成为栈顶元素

main

开始执行 main 方法main

getName

中断 main 方法调用 getName 方法

main

完成 getName 重新调用 main 方法

方法调用栈

– 一个方法被调用执行，它就会添加到调用栈中成为栈顶元素，并开始执行，直到它完成。有三种会导致方法执行的完成

• 方法执行时被 return返回了，此时方法的执行就完成了，它向调用者返回一个基本类型数值或是一个引用

• 当方法没有返回值，则在执行完方法体的最后一条语句时，该方法就执行完成，并从调用栈中删除，进而获取新的栈顶方法来处理

• 方法抛出一个异常，该异常将告知调用者，该方法也执行完毕，

递归方法 (Recursion)

• 递归方法– 方法调用自己public class Test {

public static String name=" 张三 ";public static void main(String[]args){

getName();}public static String getName(){ getName(); return name;}

}

在 getName 方法中调用自己

递归方法 (Recursion)

main

开始执行 main 方法

main

getNamegetName

中断 getName 调用 getName新副本

getName

main

getNamegetName

中断 getName 调用 getName新副本

中断 main 方法调用 getName 方法

main

getName

为什么还要递归– 新的 getName副本在执行的过程中，又生成新的副本

，并开始调用。想象一下，这个过程反复进行，不断循环，最终的将会耗尽你的调用栈，使程序无法正常返回

• 既然递归调用会造成严重的后果，我们是不是应该限制它的使用？ – 事实上，情况并不如此，知道上述的原理以后，只要我们保证方法在递归调用自己的时候，每个方法总能在合适的时候正常返回，也就是退出调用栈，那么程序就能正常运行完成。而且递归调用在很多情况下会把一个复杂的问题的处理变得简单和直观。

public long factorial( long number ) { // 基本情况 if ( number <= 1 ) return 1; // 递归步骤 else return number * factorial( number - 1 );} // end method factorial

递归应用示例

• 当我们要求 factorial(3) 时，系统是如何进行求解的呢？

递归应用示例

factorial(3)

执行 factorial(3) 方法

factorial(3)

factorial(2)

factorial(1)

中断 f(2) 调用 f(1)新副本中断 f(3) 方法调用副本 f(2) 方法

factorial(3

factorial(2)

factorial(3)

根据 f(2) 的求解， f(3)可以计算结果

factorial(3)

factorial(2)

factorial(1)

f(1) 是基本情况，返回 根据 f(1) 的返回值， f(2)得到求解

factorial(3)

factorial(2)

递归示例——汉诺塔问题

方法• 方法重载 Method overloading

– 许多方法具有相同的名称（方法名相同）– 系统如何区分这些名称相同的方法？

• 根据参数的不同来决定调用哪个方法– 参数的个数– 参数的类型

• 方法重载使用原则– 把不同类型数据的类似操作可取相同名

Java API Packages

• API 文档– 查看 JavaAPI提供的类的简介– 提供类的说明– 类的继承关系– 类的属性– 类的方法

– 下载： J2SE 5.0 Documentation – 在线 API 文档：– http://java.sun.com/j2se/1.5.0/docs/api/index.html

如何学好 Java

• 养成良好的编程习惯– 代码风格– 编程方法– 使用类库– 添加注释– 定义变量– KIS原则（ keep it simple）– 阅读文档

如何学好 Java

– 生成文档– 熟练查错