2.1 Java语法基础 2.2 Java 流程控制 2.3 数组 2.4 字符串

2.1.1 标识符和关键字 2.1.2 数据类型与常量、变量 2.1.3 运算符和表达式 2.1 Java语法基础 2.1.1 标识符和关键字 2.1.2 数据类型与常量、变量 2.1.3 运算符和表达式

2.1.1 标识符和关键字 Java语言采用Unicode字符集，前256个字符与ASCII相同。 2.1.1 标识符和关键字 Java语言采用Unicode字符集，前256个字符与ASCII相同。 采用16位编码，即单个英文字母与一个汉字所占字节数一样，都是2个字节。

1 标识符 标识符用来表示类名、变量名、数组名、方法名 Java 的标识符由字母、数字、_和$组成，长度不限，但实际命名不宜过长。 标识符的第一个字符必须为字母、 “_”或 “$”，数字不能作为标识符的开头字符。标识符区分大小写。 合法的标识符： name, s_no, $2, boy_number 不合法的标识符： 2y， a*b， w/

1 标识符 为了提高程序的可读性，标识符最好“见名知义”，而且规范大小写的使用方式： 变量名、对象名、方法名、包名等标识符全部采用小写字母；如果标识符由多个单词构成，则首字母小写，其后单词的首字母大写，其余字母小写。如getAge。 类名首字母大写。 常量名全部字母大写。 不能与关键字同名。

2 关键字 关键字是由Java语言定义的、具有特殊含义的字符序列。用户只能按照系统规定的方式使用，不能自行定义。 关键字一律用小写字母表示。

提醒：关键字不能做标识符 常用的要记忆 数据类型 程序控制结构 第1章例题 类的定义 所涉及过的 abstract boolean byte break char case continue catch class double default do else extends float for final finally int if import implements interface long length new package private protected public return short static switch super this try throw throws thread void while 数据类型 三个特殊值：false true null 程序控制结构 第1章例题 类的定义 所涉及过的 常用的要记忆 assert const enum goto instanceof native synchronized strictfp transient volatile

2.1.2 数据类型与常量、变量 Java的数据类型分为2大类：基本数据类型和引用数据类型。 基本数据类型是由一种简单数据组成的数据类型，其数据是不可分解的。例如，整数类型int的数据有34，17等。 基本数据类型的变量中保存数据值，而引用数据类型的变量保存地址。Java的引用数据类型包括数组（array）、类（class）和接口(interface) 。

Java的数据类型分类 数据类型 字节型（byte） 标准型（int） 整数型 短整型（short） 加L或l 长整型（long） 加F或f 基本数据类型 单精度（float） 浮点数型 数据类型 双精度（double） 字符型（char） 布尔型（boolean） 类（class） 接口（interface） 复合数据类型 数组（Array）

1 Java基本数据类型 整数类型 整数类型数据值有负整数、零和正整数。整数类型又细分为4种子类型。不同整数类型的差别在于占用的内存空间和数据取值范围的不同。 数据类型 所占字节 取值范围 long（长整型） 8 -9223372036854775808～9223372036854775807 int（整型） 4 -2147483648～2147483647 short（短整型） 2 -32768～32767 byte（位） 1 -128～127

1 Java基本数据类型 整数类型 一个整数的缺省类型为int。要表示一个整数为long型，在其后加后缀L或l，如345L。 十进制数。用0~9之间的数字表示的数，其首位不能为0。 八进制数。用0~7之间的数字表示的数，以0为前缀。 十六进制数。用0~9之间的数字或a~f，A~F之间的字母表示的数，以0x或0X为前缀。

1 Java基本数据类型 浮点数类型 浮点数类型有2种表示形式： float（单精度浮点数）和double（双精度浮点数）。 标准记数法：由整数部分、小数点和小数部分组成，如12.37 科学记数法：由尾数、E或e及阶码组成，也称为指数形式，如2.5E4表示2.5×104

1 Java基本数据类型 浮点数类型 取值范围及所占用的内存大小 浮点数类型 所占字节 取值范围 float（单精度浮点数） 4 -3.4E38～3.4E38 double（双精度浮点数） 8 -1.7E308～1.7E308 一个浮点数缺省类型为double。要表示一个浮点数为float型，在其后加后缀F或f，如34.5f。

1 Java基本数据类型 字符类型 字符类型（char）表示为Unicode编码，1个字符占16位。如：‘A’ 字符类型数据表示方法： 用单引号括起来的单个字符。 用Unicode码表示，前缀是“\u”。 Unicide字符集中的控制字符需要通过转义字符表示。 转义字符 功能 Unicode码 \b 退格 \u0008 \t 水平制表 \u0009 \n 换行 \u000a \f 换页 \u000c \r 回车 \u000d

1 Java基本数据类型 由多个字符组成的字符序列称为字符串，字符串用双引号括起来。 如 "green"就是一个字符串。

1 Java基本数据类型 布尔类型 布尔类型（boolean）只有true（真）和false（假）2个值。布尔类型值占1个字节。

Java基本数据类型表 数据类型 所占 字节 表示范围 long(长整形) 8 -9223372036854775808~ 9223372036854775807 int(整型) 4 -2147483648~ 2147483647 short(短整型) 2 -32768~32767 byte(位) 1 -128~127 char(字符) 0~256 boolean(布尔) true 或 false float(单精度) -3.4E38~ 3.4E38 double(双精度) -1.7E308~ 1.7E308

2 常量 常量是指在程序运行过程中其值始终保持不变的量。 直接常量：27 ‘a’ true 34.9 符号常量 常量

符号常量 如：final float PI=3.14159; final char SEX='M'; final int MAX=100; 可以用标识符表示常量，称为符号常量。 符号常量必须先声明，后使用。声明方式如下： final [修饰符] 类型标识符 常量名=（直接）常量； 修饰符是表示该常量使用范围的权限修饰符：public，private，protected或缺省。 如：final float PI=3.14159; final char SEX='M'; final int MAX=100;

3 变量 变量是指在程序运行过程中其值可以改变的量。变量必须先定义后使用。其格式为： [修饰符] 类型标识符 变量名[=常量]；

3 变量 以下是合法的变量声明： float x=25.4, y; char c; boolean flag1=true, flag2; 3 变量 以下是合法的变量声明： float x=25.4, y; char c; boolean flag1=true, flag2; int l, m; 其中，变量x和flag1被赋予初始值，其它变量没有初始化。

例：使用整数型变量，分析运行结果。 程序运行结果如下： a=13 b=20 c=37 x=30 y=123456 public class Integers { public static void main(String args[]) int a=015; //八进制数 int b=20; //十进制数 int c=0x25; //十六进制数 short x=30; long y=123456L; System.out.println("a="+a)； //输出a的值 System.out.println（"b="+b）; System.out.println("c="+c); System.out.println("x="+x); System.out.println("y="+y); } 程序运行结果如下： a=13 b=20 c=37 x=30 y=123456

程序运行结果如下： a=35.45 b=3.56E18 例：使用单精度和双精度类型变量 public class Floats { public static void main(String args[]) float a=35.45f; double b=3.56e18; System.out.println("a="+a); System.out.println("b="+b); } 程序运行结果如下： a=35.45 b=3.56E18

例：使用字符类型变量 public class Characters { public static void main(String args[]) char ch1=’a’; char ch2=’B’ System.out.println("ch1="+ch1)； System.out.println("ch2="+ch2)； } 程序运行结果如下： ch1=a ch4=B

例：使用字符串类型数据 public class Samp2_5 { public static void main(String args[]) String str1="abc"; String str2="\n"; String str3= "123"; System.out.println("str1="+str1+str2+"str3="+str3); } 程序运行结果如下： str1=abc str3=123

例：使用逻辑类型变量 public class Logic { 程序运行结果如下： 逻辑状态1=true 逻辑状态2=false public static void main(String args[]) boolean instance1=true; boolean instance2=false; System.out.println("逻辑状态1="+instance1+ " "+"逻辑状态2=" +instance2); } 程序运行结果如下： 逻辑状态1=true 逻辑状态2=false

2.1.3 运算符和表达式 1. 运算符 根据操作数的个数，可以将运算符分为单目、双目和多目运算符。 2.1.3 运算符和表达式 1. 运算符 对数据进行加工和处理称为运算，表示各种运算的符号称为运算符，参与运算的数据称为操作数。 根据操作数的个数，可以将运算符分为单目、双目和多目运算符。 运算符分为：算术运算符、关系运算符、逻辑运算符、位运算符。

(1) 算术运算符 算术运算符完成数学上的加、减、乘、除四则运算。算术运算符包括双目运算符和单目运算符。 双目算术运算符包括+（加）、-（减）、*（乘）、/（除）和%（取余）。

(1) 算术运算符 例如： 23+5 //结果是28 6*5 //结果是30 27/3 //结果是9 45/4 //结果是11 23+5 //结果是28 6*5 //结果是30 27/3 //结果是9 45/4 //结果是11 9%3 //结果是0 9%4 //结果是1

(1) 算术运算符 单目算术运算符包括++（自增）、--（自减）、-（负号）。 “++”和“--”只能用于整数类型的变量，而不能用于常量或表达式。“++”和“--”既可以出现在变量的左边，也可以出现在变量的右边。 例如： int j=5; j++； //先运算，再自增 ++j; //先自增，再计算 --j; //先自减，再运算 j--; //先运算，在自减

(2) 关系运算符 关系运算是2个操作数之间的比较运算。关系运算符有：>、<、>=、<=、= =和!=。 “= =”和“!=”还可用于布尔类型及字符串类型操作数。 字符类型操作数的比较依据是其Unicode值，字符串从左向右依此对每个字符比较。 关系运算的运算结果是布尔类型值。如果关系成立，结果的值为true；否则，结果的值为false。

(2) 关系运算符 > >= < <= = = != 运算符 用例 功能 a > b 如果a > b成立，结果为true；否则，结果为false >= a>= b 如果a ≥ b成立，结果为true；否则，结果为false < a < b 如果a < b成立，结果为true；否则，结果为false <= a <= b 如果a≤b成立，结果为true；否则，结果为false = = a = = b 如果a = b成立，结果为true；否则，结果为false != a != b 如果a ≠ b成立，结果为true；否则，结果为false

(2) 关系运算符 例如： 23.5>10.4 //结果是true 45!=45 //结果是false true!=false //结果是true ’T’<’a’ //结果是true ’u’<’9’ //结果是false

(3) 逻辑运算符 逻辑运算是对布尔类型操作数进行的与、或、非、异或等运算，运算结果仍然是布尔类型值。 逻辑运算符有：&（与）、|（或）、!（非）、^（异或）、&&（条件与）、||（条件或）。 特别注意： && 与 || 可能会忽略第二个表达式的运算 短路与 短路或

逻辑运算真值表 a b !a a&b，a&&b a|b, a||b a^b false true

(3) 逻辑运算符 例如： ! true //结果是false true & false //结果是false 逻辑运算用于判断组合条件是否满足，例如 ( age>20) && (age<30) //判断age的值是否在20~30之间 ( ch= =’b’) || (ch= =’B’) //判断ch的值是否为字母’b’ 或’B’

(4) 位运算符 位运算是对整数类型的操作数按二进制的位进行运算，所运算结果仍然是整数类型值。 位运算真值表 位运算符： ~（位反）、&（位与） |（位或）、^（位异或） <<（左移位）、>>（右移位） >>>（无符号右移位）。 位运算真值表 a b ~a a&b a|b a^b 1

(4) 位运算符 运算符 用例 功能 ~ ~a 将a逐位取反 & a&b a、b逐位进行与操作 | a|b a、b逐位进行或操作 ^ a^b << a<<b a向左移动b位,空位补0 >> 有符号右移 a>>b a向右移动b位,空位补符号位,正数补0,负数补1。 >>> 无符号右移 a>>>b a向右移动b位,移动后的空位均用0填充

(4) 位运算符 例如：a=15，b=2；计算~a和a^b的值。 （1）将整数转换为二进制表示。 ~ 0000 0000 0000 1111 =1111 1111 1111 0000 (-16的补码) （3）对a，b按位进行异或操作 0000 0000 0000 1111 ^ 0000 0000 0000 0010 0000 0000 0000 1101 所得结果：~a=-16，a^b=13。 13

(4) 位运算符 public class BitOperation{ public static void main(String args[]){ int a=15; int b=2; int x=a&b; int y=a|b; int z=a^b; System.out.println(a+"&"+b+"="+x); System.out.println(a+"|"+b+"="+y); System.out.println(a+"^"+b+"="+z); System.out.println("~"+a+"="+(~a)); System.out.println(a+"<<"+b+"="+(a<<b)); System.out.println(a+">>"+b+"="+(a>>b)); System.out.println(a+">>>"+b+"="+(a>>>b)); }}

(5) 赋值运算符 赋值运算用于给变量赋值，形式如下： 变量名=表达式； (5) 赋值运算符 赋值运算用于给变量赋值，形式如下： 变量名=表达式； 赋值运算的次序是从右向左的，即先计算表达式的值，再将表达式的值赋予变量。 例如： int i=3, j; //i的初始值是3 j=i+2; //结果，j的值是5 i=2*j; //结果，i的值是10 j=j+4; //结果，j的值是9

复合赋值运算符 赋值运算符还可以与算术运算符、逻辑运算符和位运算符组合成复合赋值运算符，使用方法见表。 运算符 用例 等价于 += x += y x=x+y &= x &= y x=x&y -= x-= y x=x-y |= x |= y x=x|y *= x*= y x=x*y ^= x ^= y x=x^y /= x /= y x=x/y <<= x <<= y x=x<<y %= x %= y x=x%y >>= x >>= y x=x>>y >>>= x >>>= y x=x>>>y   例如：i*=10; 等价于 i=i*10;

(6) 条件运算符 条件运算格式如下： 表达式1 ？表达式2 ：表达式3 ？：称为条件运算符，是三目运算符。 例如： int min , x=4, y=20; min=(x<y)? x : y; //结果使min取x和y中的较小值， 即min的值是4

括号运算符 圆括号运算符“（）”用于改变表达式中运算符的运算次序。先进行括号内的运算，再进行括号外的运算；在有多层括号的情况下，优先进行最内层括号内的运算，再依次从内向外逐层运算。

2 . 表达式 用运算符将操作数连接起来的，符合语法规则的运算式。 例如： int i=5, j=10, k; k=(24+3*i)*j;

<< >> >>> (1) 运算符的优先级 运算符 描述 优先级 结合性 . [ ] ( ) 域，数组，括号 1 从左至右 ++ -- - ! ~ 一元运算符 2 从右至左 * / % 乘，除，取余 3 + - 加，减 4 << >> >>> 位运算 5 < <= > >= 逻辑运算 6 == != 7 & 按位与 8 ^ 按位异或 9 | 按位或 10 && 逻辑与 11

(1) 运算符的优先级 ——续前表 运算符 描述 优先级 结合性 || 逻辑或 12 从左至右 ? : 条件运算 13 = *= /= %= ? : 条件运算 13 = *= /= %= += －= <<= >>= >>>= &= ^= |= 赋值运算 14

表达式的数据类型由运算结果的数据类型决定。 例如： int i=3, j=21, k; boolean f; k=(i+3)*4; //(i+3)*4是算术表达式 f=(i*2)>j; //(i*2)>j是布尔表达式

例 单目运算符实例 i++=15 ++i=17 --i=16 i--=16 i=15 public class Operator { public static void main(String args[]) int i=15, j1, j2, j2, j4; j1=i++; //在操作数的右面 System.out.println("i++="+j1); j2=++i; //在操作数的左面 System.out.println("++i="+j2); j3=--i; System.out.println("--i="+j3); j4=i--; System.out.println(“i--="+j4); System.out.println("i="+i); } 程序运行结果如下： i++=15 ++i=17 --i=16 i--=16 i=15

(2) 数据类型的转换 当将一种数据类型的值赋给另一种数据类型的变量时，出现了数据类型的转换。 在整数类型和浮点数类型中，可以将数据类型按照精度从“高”到“低”排列如下级别： double 高级别 float long int short byte 低级别

(2) 数据类型转换规则 当将低级别的值赋给高级别的变量时，系统自动完成数据类型的转换。 float x=200; //将int类型值200转换成float类型值 // 200.0， 结果x获得的值是200.0 当将高级别的值赋给低级别的变量时，必须进行强制类型转换。 int i; i=(int) 26L; //将long类型值26转换成int类型值26， //结果i获得int类型值26 进行强制类型转换时，可能会造成数据精度丢失。

Java举例——整数相除 例：整数相除 public class Divide { public static void main(String args[]) int i=15, j=4, k; float f1, f2; k=i/j; f1=i/j; f2=(float)i/j; System.out.println("k="+k); System.out.println("f1="+f1); System.out.println("f2="+f2); } Java举例——整数相除 运行结果如下： k=3 f1=3.0 f2=3.75

2.2 Java 流程控制 2.2.1 语句及程序结构 2.2.2 顺序结构 2.2.3 选择结构 2.2.4 循环结构 2.2.1 语句及程序结构 2.2.2 顺序结构 2.2.3 选择结构 2.2.4 循环结构 2.2.5 跳转语句

如：total=math+phys+chem； 2.2.1 语句及程序结构 语句用来向计算机系统发出操作指令。程序由一系列语句组成。 Java中语句以分号（；）作为结束标记。 如：total=math+phys+chem； 复合语句 用 “{ }”将多条语句括起来，在语法上作为一条语句使用。 如：{z=x+y; t=z/10;}

2.2.1 语句及程序结构 加载已定义好的类和包 属性 方法1 主类类体 方法2 import java.applet.*; 2.2.1 语句及程序结构 import java.applet.*; import java.awt.*; import java.awt.event.*; public class AppletInOut extends Applet implements ActionListener { Label prompt; TextField input,output; public void init() prompt= new Label("请输入您的名字"); input=new TextField(6); output=new TextField(20); add(prompt); add(input); add(output); input.addActionListener(this); } public void actionPerformed(ActionEvent e) output.setText(input.getText()+",欢迎你！"); 加载已定义好的类和包 属性 主类类头 方法1 主类类体 方法2

结构化程序的三种结构： 顺序结构（Sequence Structure） 选择结构（Selection Structure） 循环结构（Iteration Structure）

(1) 顺序结构 顺序结构中，语句的执行顺序是按照程序语句书写的顺序，从上到下依次执行。 流程图画法

(2) 选择结构 选择结构：程序的执行流程根据判断条件，选择其中一个分支执行。

(3) 循环结构 循环结构是指如果满足一定条件，则反复执行一段程序，直到条件不再满足为止。

2.2.2 顺序结构 顺序结构是最简单的一种程序结构，没有固定的语句格式，程序的执行按照语句的书写次序顺序进行。

public static void main(String args[]) double g, mSun, mEarth, f; 例：计算太阳和地球之间的万有引力 public class Force { public static void main(String args[]) double g, mSun, mEarth, f; g=6.66667E-8； mSun = 1.987E33； mEarth = 5.975E27； f = g* mSun* mEarth /(1.495E13*1.495E13); System.out.println("The force is "+f); } 程序运行结果如下： The force is 3.5413E27 F=G*M1*m2/r*r G=6.67E-11,万有引力常数 m=地球质量,M=太阳质量,r=日地距离

摄氏温度c和华氏温度f之间的关系为：c=5(F-32)/9 例: 华氏温度转换为摄氏温度 摄氏温度c和华氏温度f之间的关系为：c=5(F-32)/9 public class Conversion { public static void main(String args[]) float f, c; f=70.0f; c=5*(f-32)/9; System.out.println("Fahrenheit="+f); System.out.println("Centigrade="+c); } 程序运行结果如下： Fahrenheit=70.0 Centigrade=21.11111

public static void main(String args[]) 例: 求解方程ax+b=0的根x public class Root { public static void main(String args[]) float a, b, x; a=Float.parseFloat (args[0]); b=Float.parseFloat (args[1]); x=-b/a; System.out.println("a="+a); System.out.println("b="+b); System.out.println("x="+x); }

带参数的程序运行方式： 1、命令行方式： java Root 2.0 6.0 运行程序，2.0和6.0分别作为第1和第2个参数传递给args[0]和args[1]。 2、TextPad环境下：

2.2.3 选择结构 Java语句提供了两条基本的分支选择语句if和switch。if语句应用在“二选一”的条件下，而switch语句应用在“多选一”的条件下。它们都是对条件表达式进行判断，针对不同的结果，决定转向要执行的Java语句。

选择结构和条件判断 在现实生活中，需要进行判断和选择的情况是很多的。 如果你在家，我去拜访你 如果考试不及格，要补考 如果遇到红灯，要停车等待 周末我们去郊游 70岁以上的老年人，入公园免票

1. if语句 if (布尔表达式) 语句 语句1 else 语句2 简单语句 复合语句 布尔表达式 语句 true false 布尔表达式

public static void main(String args[]) int x, y, min; 例：通过命令行输入2个整数，输出较小者 public class MinNum { public static void main(String args[]) int x, y, min; x=Integer.parseInt(args[0]); x=Integer.parseInt(args[1]); if(x<y) min=x; else min=y; System.out.println("x="+x); System.out.println("y="+y); System.out.println("min="+min); }} 布尔表达式 语句2 false true 语句1

例:求解方程 ax+b=0(a≠0)的根 public class Root { public static void main(String args[]) float a, b, x; a=Float.parseFloat (args[0]); b=Float.parseFloat (args[1]); if ( Math.abs(a)>0 ) x=-b/a; System.out.println("x="+x); }

练习 例：已知两个数x和y，比较它们的大小，使得x大于y If （x<y） { t=x; x=y; y=t; } 10 10 6 6

练习 已知三个数a,b,c，输出其中最大的数。 max=a; if (max<b) max=b; if (max<c) max=c; System.out.println(max); 画流程图

练习 例: 已知△三边a、b、c的长，编程求△面积。 F T 输出s 结束 开始 输入a,b,c 求半周长L 提示 数据错 求s△ 两边之和大于第三边？ F 提示 数据错 求半周长L T 求s△ 输出s 结束

if 语句嵌套 if语句中可以包含if语句，形成if语句的嵌套。

从第一个else开始，总是与它上面最近的未配对的if配对 嵌套的一般形式 有问题 if (expr1) if (expr2) statement1 else statement2 内嵌if if (expr1) if (expr2) statement1 else statement3 内嵌if { } if (expr1) statement1 else if(expr3) statement3 statement4 内嵌if if (expr1) if (expr2) statement1 else statement2 else if(expr3) statement3 else statement4 内嵌if

多分支的if语句 if（布尔表达式1） 语句1 else if（布尔表达式2） 语句2 … else if（布尔表达式n） 语句n

x y public class Function { public static void main(String args[]) float x, y; x=Float.parseFloat (args[0]); if ( x<0 ) y = 0; else if ( x >0 && x <= 10 ) y = x; else if ( x > 10 && x <= 20 ) y = 10; else y = -0.5 * x + 20; System.out.println("x="+x); System.out.println("y="+y); } 例：编写分段函数程序。 x y x<0 0<x<=10 10<x<=20 10 20<x 0.5x+20

2 Switch语句 switch（表达式） { case 值1：语句块1； case 值2：语句块2； ……… case 值n：语句块n； int、byte、char、short 常量 switch（表达式） { case 值1：语句块1； case 值2：语句块2； ……… case 值n：语句块n； [default： 语句块n+1；] }

2. Switch语句 switch（表达式） { case 值1：语句块1； break； case 值2：语句块2； ……… case 值n：语句块n； [default： 语句块n+1；] }

break；语句用于结束当前switch语句，执行其后的语句。 import java.io.*; public class Test{ public static void main(String args[])throws IOException{ char grade; grade=(char)System.in.read(); System.out.print("Your score:"); switch(grade) { case 'A': System.out.print("85～100\n");break; case 'B': System.out.print("70～84\n");break; case 'C': System.out.print("60～69\n");break; case 'D': System.out.print("<60\n");break; default: System.out.print("enter data error!\n"); } } } break；语句用于结束当前switch语句，执行其后的语句。

grade=(char)System.in.read(); System.out.print("Your score:"); switch(grade) { case 'A': System.out.print("85～100\n");break; case 'B': System.out.print("70～84\n");break; case 'C': System.out.print("60～69\n");break; case 'D': System.out.print("<60\n");break; default: System.out.print("enter data error!\n"); }

2. Switch语句 例: 将百分制成绩转化为优秀、良好、中等、及格和不及格的5级制成绩。标准为: 优秀: 90~100分; 良好: 80~89分; 中等: 70~79分; 及格: 60~69分; 不及格: 60分以下。

public class Level { public static void main(String args[]) short newGrade, grade; grade=Short.parseShort(args[0]); switch (grade/10) case 10: case 9: newGrade = 1; break; case 8: newGrade = 2; break; case 7: newGrade = 3; break; case 6: newGrade = 4; break; default: newGrade = 5; }

System.out.print(grade); switch (newGrade) { case 1: System.out.println(",优秀"); break; case 2: System.out.println(",良好"); break; case 3: System.out.println(",中等"); break; case 4: System.out.println(",及格"); break; case 5: System.out.println(",不及格"); }

2.2.4 循环结构 循环语句的作用是在一定条件下，反复执行一段程序代码，被反复执行的程序称为循环体。 2.2.4 循环结构 循环语句的作用是在一定条件下，反复执行一段程序代码，被反复执行的程序称为循环体。 Java提供的循环语句有：while语句、do…while语句和for语句。

1. while语句 while（布尔表达式） { 循环体 } 当布尔表达式为true时，重复执行循环体。 false 布尔表 达式?

例：计算10! public class Factorial { public static void main(String args[ ]) { int i; double s; i=1; s=1; while (i<=10) { s=s*i; i=i+1; } System.out.println("10!="+s); }}

2 . do…while语句 do{ 循环体 }while（布尔表达式）; 重复执行循环体，直到布尔表达式为false。 循环体 true 循环体 布尔表 达式？ false do{ 循环体 }while（布尔表达式）; 重复执行循环体，直到布尔表达式为false。

例：计算1+3+5+…+99 public class Sum1 { public static void main(String args[ ]) int i=1, s=0; do s=s+i; i=i+2; } while (i<100); System.out.println("sum="+s); }

例: 计算1～50之间的奇数和、偶数和 public class Sum2{ public static void main(String args[]) { int i=1,oddSum=0,evenSum=0; do { if(i%2==0) //如果i是偶数 evenSum+=i; //求偶数和 else //如果i是奇数 oddSum+=i; //求奇数和 i++; }while(i<=50); //判断i的值是否在1～50之间 System.out.println("Odd sum="+oddSum); System.out.println ("Even sum="+evenSum); }

3 . for语句 for(表达式1;表达式2;表达式3) { 循环体 } 表达式1：循环初值； 表达式2：布尔表达式，判断循环是否继续； true 表达式1 表达式2 表达式3 false 循环体 for(表达式1;表达式2;表达式3) { 循环体 } 表达式1：循环初值； 表达式2：布尔表达式，判断循环是否继续； 表达式3：修改循环变量值。

public static void main(String args[]) int count, sum=0; public class Sum3 { public static void main(String args[]) int count, sum=0; for (count =1; count <=100; count ++) sum+= count; System.out.println("sum="+sum); } 用while和do-while语句改写

1-100求和的Java实现 比较三种循环语句的差异 2 使用for语句 1 使用while语句 int count=1; int sum=0; while(count<=100){ sum+=count; count++; } 3 使用do…while语句 int count=1; int sum=0; do{ sum+=count; count++; } while(count<=100); 比较三种循环语句的差异 2 使用for语句 int sum=0,count; for(count=1;count<=100;count++) sum+=count;

4. 循环嵌套 例如： for( ; ; ) //外循环开始 { …. } //外循环结束 for( ; ; ) //内循环开始 4. 循环嵌套 例如： for( ; ; ) //外循环开始 { …. for( ; ; ) //内循环开始 { ……} //内循环结束 while(condition) //内循环开始 {…….} //内循环结束 } //外循环结束

内层循环的作用是什么？内层循环的循环条件和外层循环有何关系？ 4 . 循环嵌套 int i, j; long fact, sum=0; for (i=1; i<=10; i++) { fact=1; for (j=1;j<=i; j++) fact*=j; sum+=fact; } 问题：求1!+2!+3!+…+10! 内层循环的作用是什么？内层循环的循环条件和外层循环有何关系？

例：求Fibonacci数列中的前20项。 public class Fibonacci { public static void main(String args[]) long f1=1, f2=1; for (int i=1; i<=10; i++) System.out.print(f1+" "+f2+" "); f1=f1+f2; f2=f1+f2; }

素数是指除1及自身外，不能被其它数整除的自然数。 start 例: 判断素数（质数） 素数是指除1及自身外，不能被其它数整除的自然数。 输入k,i=2 true k%i==0 或i>k-1 false true i==k? i=i+1 false k是素数 k非素数 end

public static void main(String args[]) { public class Prime { public static void main(String args[]) { short i, k; k=Short.parseShort(args[0]); for (i=2; i<=k-1; i++) if (k % i ==0) break; if (i == k) System.out.println(k+" is a prime."); else System.out.println(k+" is not a prime."); }

public static void main(String args[]) { final int MAX=50; int i, k; 例：求2~50之间的所有素数。 public class Primes{ public static void main(String args[]) { final int MAX=50; int i, k; for(k=2; k<=MAX; k++) { for (i=2; i<=k-1; i++) if (k % i ==0) break; if (i==k) System.out.print(k); }

2.2.5 跳转语句 break语句： 与switch语句组合使用，表示从switch语句中跳出，转去执行其后的语句； 2.2.5 跳转语句 break语句： 与switch语句组合使用，表示从switch语句中跳出，转去执行其后的语句； 用于循环语句中，表示从循环语句中跳出，立即终止循环，转去执行其后的语句。

2.2.5 跳转语句 （1）不带标号的break语句。 break; 2.2.5 跳转语句 （1）不带标号的break语句。 break; （2）带标号的break语句。用在多重循环语句中，跳出标号所指定的语句块，并从紧跟该块后的第一条语句处执行。 break 标号语句;

Java控制语句 a:{ //标记代码块a …… b:{ //标记代码块b c:{ //标记代码块c break b; …… //这段语句将不执行 } //代码块c结束 …… //这段语句也不执行 } //代码块b结束 …… //从这段语句开始执行 } //代码块a结束

2.2.5 跳转语句 continue语句 无条件使控制转移到循环语句的条件判定部分，终止本次循环，直接进入下一次循环。

2.2.5 跳转语句 continue; continue 标号语句; （1）不带标号的continue语句。 2.2.5 跳转语句 用在 while 和 do-while 语句 中，表示转去执行条件判断， 以决定是否开始新一轮循环。 用在 for 循环语句中，表示 转去执行 “表达式3” ，再进行 条件判断，以决定是否开始 新一轮循环。 （1）不带标号的continue语句。 continue; （2）带标号的continue语句。用在多重循环语句中，跳转到标号指明的循环中。 continue 标号语句;

跳转语句示例： outer: for( int i=0; i<10; i++ ) { for( int j=0; j<10; j++ ) if( i<j ) …… continue outer; } } //内层循环结束 } //外层循环结束 for( int i= 0; i <10; i++ ) { if( i == 5 ) continue; System.out.print(i); }

例：找素数 public class PrimeNumber{ public static void main(String args[]) { int i,j,k; boolean flag; for(i=2; i<=50; i++) { flag=true; k=i/2; for(j=2;j<=k;j++) if(i%j==0) //如果该数可以整除其余数，则不可能是质数 { flag=false; break; } } if(flag) System.out.print(i+" ");

或 return ([expression]); 注意，如果一个方法的返回值类型定义为void，则方法体中不需要有return语句。 将返回的结果

例：continue语句在三种循环语句中的应用。 public class ExampleContinue { public static void main(String args[ ]) int i=1; do if(i==5) continue; System.out.print(i+" "); i++; }while(i<10); } int i=1; while (i<10) { if (i==5) continue; System.out.print(i+" "); i++; } for (int i=1;i<10;i++) { if (i==5) continue; System.out.print(i+" "); }

2.3.1 数组的基本概念 2.3.2 一维数组的创建与使用 2.3.3 多维数组 2.3 数组 2.3.1 数组的基本概念 2.3.2 一维数组的创建与使用 2.3.3 多维数组

问题 引例 JAVA考试结束，需要计算全班（30个同学）的平均成绩？ 太麻烦 int stu1=92 ; int stu2=87 ; …… int stu30=86; 太麻烦 30个变量 问题

2.3.1 数组的基本概念 int,long,float,char等都是基本数据类型，一个变量表示一个数据，称为简单变量。 2.3.1 数组的基本概念 int,long,float,char等都是基本数据类型，一个变量表示一个数据，称为简单变量。 对于有些数据，只用简单的数据类型是不够的。例如：要处理100个学生的考试成绩。 数组是一种最简单的复合数据类型（引用数据类型）。数组是有序数据的集合，数组中的每个元素具有相同的数据类型。

数组概念的定义 data 数组：相同数据类型的变量按一定顺序排列的集合 。 这些相同数据类型的变量，称为数组元素。 通过数组名和下标来使用数组中的元素。 data data[0] data[1] data[2] data[3] data[4] 3 8 12 7 数组名 下标

数组的分类 数组分为一维数组、二维数组和多维数组,如： arr1[3] arr2[3][4] arr3[3][4][3] 数组要先声明和并分配空间后才能使用。

2.3.2 一维数组的创建与使用 数组的声明 作用：声明数组的名称 和 元素的数据类型。 语法格式1： 数组类型 数组名[ ]； 2.3.2 一维数组的创建与使用 数组的声明 作用：声明数组的名称 和 元素的数据类型。 数据类型可以是简单数据类型，也可以是某一对象类型。 语法格式1： 数组类型 数组名[ ]； 语法格式2： 数组类型[ ] 数组名； 如： int[ ] a ; Student stu[ ] ; int a[ 10 ] ; 注：Java不允许在声明数组时指定元素个数。

创建数组---分配内存空间 定义好的数组必须创建数组空间后才可以使用。创建时须指明数组长度，以确定所开辟内存空间的大小。 语法格式： 数组名= new 数组类型[数组元素个数] 例： a =new int[10]； stu= new Student [30] ; 提问： int x=10; double n[ ]= new double[x ] 可以吗？ 注：Java中允许使用int型变量的值指定数组长度 数组声明 和 创建数组 可以用一条语句完成。 如： int[ ] a =new int[10]；

在Java中声明并创建了数组之后，依数据类型的不同，会预设不同的初值 。 数 据 类 型 初  始  值 byte float 0.0f short double 0.0d int char \u0000 long 0L boolean false

数组的初始化 data 如果数组元素类型是基本数据类型，可以在声明数组的同时给数组元素赋初值。 如： float[ ] data={23.2f,25.0f,171.4f,54.5f,81.3f,59.6f}; 用 逗号 分隔数组的各个元素，系统自动为数组分配空间。 对于对象类型为数组元素的数组，则必须利用构造函数来初始化每个数组元素，一般用循环结构来完成。 例： for ( int i=0; i<stu . length;i++) { stu[i]= new Student(201202000+ i , “计算机专业”); } data data[0] data[1] data[2] data[3] data[4] data[5] 23.2 25.0 171.4 54.5 81.3 59.6

数组的使用 声明并创建一个数组后， 可以使用数组名和下标访问数组中的每个元素。 数组元素的访问方式为： 数组名[下标] 下标从0开始，一直到数组的长度减1。 数组使用注意事项： （1）数组元素的下标从0开始，至数组元素个数-1个为止；下标必须是整型数或是可以转化成整型的量。 （2）所有数组都有一个属性 length ，存储的是数组元素的个数。 使用方法: 数组名. length 如: int[ ] a =new int[3]； 它有3个元素，分别为： a[0]， a [1]， a [2] 注意：没有 a[3]。 a a[0] a[1] a[2]

例 ：数组的使用 public class ArrayTest1 { public static void main(String args[]) { int i ; int a[ ] = new int[5] ; for( i=0 ; i<5 ; i++) a[i] = i ; for( i=a.length - 1 ; i>=0 ; i--) System.out.println(“ a["+i+"]="+a[i]) ; }

例：用数组绘制多边形 import java.awt.*; import java.applet.Applet; public class ArrayTest2 extends Applet { public void paint(Graphics g) { g.setColor(new Color(25,40,180)); int[] x={15, 40,80,90, 80,150,140}; int[] y={10,140,60,80,160,140,170}; g.drawPolygon( x, y, 7); }

例：计算100个学生的平均成绩。 float sum=0; int i; int score[ ]; score=new int[100]; for (i=0; i<100; i++) score[i]=Integer.parseInt(args[i]) ; sum=sum + score[i] ; sum=sum/100; 引用数组元素时下标不要越界（不要引用不存在的数组元素）

例：对10个数组元素依次赋值为0,1,2,3,4,5,6,7,8,9，要求按逆序输出。 解题思路： 定义一个长度为10的数组，数组定义为整型 要赋的值是从0到9，可以用循环来赋值 用循环按下标从大到小输出这10个元素

使a[0]～a[9]的值为0～9 public class ArrayExample{ public static void main(String args[]) { int i; int a[ ]=new int[10]; for (i=0; i<=9;i++) a [i]=i; for(i=9;i>=0; i--) System.out.print (a[i]+ “ “); System.out.println; } 使a[0]～a[9]的值为0～9 a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]a[8]a[9] 1 2 3 4 5 6 7 8 9

public class ArrayExample{ public static void main(String args[]) { int i; int a[ ]=new int[10]; for (i=0; i<=9;i++) a[i]=i; for(i=9;i>=0; i--) System.out.print (a[i]+ ” ”); System.out.println; } 先输出a[9]，最后输出a[0] a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]a[8]a[9] 1 2 3 4 5 6 7 8 9

练习 判断下面程序段是否正确?如有错误请改正。 1、 int array[10]; for (int i=0 ; i<array.length ; i++) array[i]=i+1; 2、 int array[ ]=new int[10]; array[10]=10; // int array[ ]=new int[10]; // array[9]=10;

如果在评委的给分中，去掉一个最高分和一个最低分，然后计算最后得分 3. 编写一个大奖赛统计选手得分的程序 利用随机数方法产生10个80～100分之间的随机整数，输出在窗口上，并将选手的最后得分也显示出来。 最后得分= 分析：由随机数方法生成80～100之间的一个数据 累加求和 最后求平均值 思考题： 如果在评委的给分中，去掉一个最高分和一个最低分，然后计算最后得分

JAVA考试结束，需要计算全班（30个）同学的平均成绩？利用数组编程实现。 数组的概念 数组的声明、创建、使用 JAVA考试结束，需要计算全班（30个）同学的平均成绩？利用数组编程实现。 作 业

2.3.2 多维数组 在Java中，对多维数组的定义是通过对一维数组的嵌套式定义来实现，即数组的数组。 arryName[ ][ ]; 多维数组的创建方法同一维数组。

2.3.2 多维数组 请练习创建一个2行3列的二维数组。 a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] int a[ ][ ]; a=new int[2][3]; a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2] int [ ][ ] a=new int[2][3]; int a[ ][ ]={{1,2,3},{4,5,6}};

例：分析例题代码片断的功能 int m1 , m2 ; int [ ] [ ] a; m1=2 ; m2=3; a=new int[m1][m2]; for (int i=0 ; i<m1 ; i++) for (int j=0 ; j<m2; j++) a [i][j] = i*j ; for (int i=0 ; i<a.length ; i++) { for (int j=0 ; j<a[i].length ; j++) System.out.print(a[i][j] + ”\t”); System.out.println(" "); }

给出以下程序的运行结果。 public class TwoDimArray2 {     public static void main(String[] args) {         int[][] arr = {{1, 2, 3}, {4, 5, 6}};         int[] foo = arr[0];         for (int i = 0; i < foo.length; i++)             System.out.print(foo[i] + " ");         System.out.println();         foo = arr[1];     }}

对称数组和不对称数组 对称二维数组 直接为每一维分配空间 如：int a[][]=new int[2][3]; 不对称二维数组 从最高维开始，分别为每一维分配空间， 如: int b[][]=new int[2][]; b[0]=new int[3]; b[1]=new int[5];

2.4 Java的字符串 2.4.1 String类 Java中字符串常量用String类的对象表示，对所有用双引号括起的字符串常量，系统都会创建一个无名的String类。 （1）创建字符串常量String对象 创建String对象时，通常需要向String类的构造函数传递参数来指定所创建的字符串的内容。 String类的构造函数： 1）public String（）——创建一个空的字符串常量 2）public String(String value)——利用一个已经存在的字符串常量创建一个新的String对象，该对象的内容与给出的字符串常量一致。

3）public String(StringBuffer buffer)——利用一个已经存在的StringBuffer对象为新建的对象String初始化。 4）public String(char value[ ])——利用已经存在的字符数组的内容初始化新建的String对象。 创建实例： ① String s; //声明一个对象s s=new String(“ABC”); //为s赋值 ② String s=new String(“ABC”); //声明的同时赋值 ③ String s= “ABC”; //简化的直接赋值方法

（2）字符串常量的操作 求字符串的长度的方法： public int length（）； 例： String s=“Study”,s1=“学习”； System.out.println(s.length( ))；//显示5 System.out.println(s1.length( ))；//显示2 注意:在java中,每个字符(不论中文还是西文)都是占用16个比特的Unicode字符，故都只要一个字符表示。 （3）判断字符串的前缀和后缀 public boolean startsWith(String prefix); public boolean endsWith(String suffix); 这两个方法分别用来判断当前字符串的前缀和后缀是否为指定的字符子串。

例：String s=User.getID（）； if （s.startsWith（”320705”）） { System.out.println(“此人是连云港的”); } （4）字符串中单个字符的查找 public int indexOf(int ch); 从前往后查找字符ch在当前字符串中第一次出现的位置，并返回字符ch出现的位置，若找不到返回-1。 public int indexOf(int ch，int fromIndex); 在当前字符串中自fromIndex位字符之后向后查找，并返回该字符首次出现的位置。 与上面对应的从后往前找的方法： public int lastindexOf(int ch); public int lastindexOf(int ch，int fromIndex);

（5）字符串中子串的查找 public int indexOf(String str); public int indexOf(String str，int fromIndex)； public int lastindexOf(String str); public int lastindexOf(String str,int fromIndex); 获取字符串中某个(index表示位置)字符的方法： public char charAt(int index); （6）连接字符子串 public String concat(String str); 将参数字符串连接在当前字符串的尾部。 例：String s=“早上好，”； System.out.println（s.concat（”同学们”））；

（7）比较两个字符串 public int compareTo(String anotherString); 若当前字符串与参数字符串完全相同/大于/小于时，则返回0/1/-1。 public boolean equals(Object anObject); 比较两个字符串，区分大小写，相同时返回真值，否则为假。 public boolean equalsIgnoreCase(String anotherString); 比较两个字符串，忽略大小写，相同时返回真值，否则为假。 例：String s1=“Hello”, s2=“hello”; boolean b1=s1.equals(s2); //返回假 boolean b1=s1.equalsIgnoreCase (s2); //返回真

2.4.2 StringBuffer类 用来存放字符串变量的对象属于StringBuffer类。 构造函数： public StringBuffer( ); 创建一个空StringBuffer对象，需要扩充后才可以使用。 public StringBuffer(int length); 创建一个长度为length的StringBuffer对象。 public StringBuffer(String str); 利用一个已存在的字符串String对象来初始化StringBuffer对象。

（2）字符串变量的扩充、修改与操作 追加的方法： public StringBuffer append(参数对象类型 参数对象名); 将指定的参数对象转化成字符串，附加在原StringBuffer字符串对象之后。 插入的方法： public StringBuffer insert(int 插入位置，参数对象类型 参数对象名); 在指定位置插入给出的参数对象所转化而得的字符串。 附加或插入的参数对象可以是各种数据类型的数据。 如果希望将StringBuffer在屏幕上显示出来，则必须首先调用toString方法把它变成字符串常量。

修改的方法： public void setCharAt(int index, char ch); 将指定位置处的字符用给定的另一个字符来替换。 （3）字符串的赋值和加法 String MyStr=“Hello,”; MyStr = MyStr +”World”; 相当于： String MyStr= new StringBuffer(). append(“Hello,”).toString(); MyStr= new StringBuffer(). append(MyStr) .append(“World,”).toString();

使用示例 //String类与StringBuffer类的使用示例 import java.awt.Graphics; import java.applet.Applet; public class TestString extends Applet { public void paint(Graphics g) String s1="大学生"; String s2="淮海工学院"; String s3="计算机系"; String s4="Student",s6="student"; String s5; StringBuffer s7=new StringBuffer("Hello,boys!"),s8=new StringBuffer(); int L=s1.length(); //求字符串长度 int i=0,j=0,k=2; boolean b1,b2;

if (s2.startsWith("海")|| s1.endsWith("学生")) //判断字符串的前缀、后缀 s5=s2+s1; else s5=s1.concat(s2); //连接字符子串 i=s5.indexOf((int)‘学’); //查找单个字符 j=s5.indexOf(“学生”,2); //查找子串字符 b1=s6.equals(s4); //比较两个字符串 b2=s6.equalsIgnoreCase(s4); //比较两个字符串,忽略大小写 s8.append("Hello,girls!"); //字符串扩充 s7.insert(6,"girls"); //字符串插入 s8.setCharAt(6,'G'); g.drawString("****操作结果**** ",10,20); g.drawString(s1,10,40); g.drawString(s2,10,60); g.drawString(s3,10,80); g.drawString(s4,10,100); g.drawString(s5,10,120); g.drawString(Integer.toString(L),10,140); g.drawString(Integer.toString(i),10,160); g.drawString(Integer.toString(j),10,180); g.drawString(Integer.toString(k),10,200); g.drawString(s7.toString(),10,220); g.drawString(s8.toString(),10,240); g.drawString(Boolean.toString(b1)+" "+Boolean.toString(b2),10,280); }

2.4.3 StringTokenizer类 该类用来对字符串进行分隔，位于java.util包中，有两个构造函数： StringTokenizer( String s) 为字符串s构造一个分析器，使用默认的分隔符集合进行划分，包括：空格符、换行符、回车符、Tab符和进纸符。 2) StringTokenizer( String s, String delim) 为字符串s构造一个分析器，用参数delim中的字符来分隔，该参数可包含多个符号。

import java.util.*; public class testStringTokenizer { public static void main(String[] args) String str1="我们有幸拥有了这份橄榄绿，就有了希望，有了动力，让我们共同努力，让我们的队伍更加生机勃勃，让我们的事业一路阳光"; StringTokenizer fenxi; int number=0; fenxi=new StringTokenizer(str1,"我们"); //用分隔符“我们”分隔字符串 number=fenxi.countTokens(); //统计字符串个数 System.out.println("字符串中共有："+number+"个我们"); }

本章小结 Java的数据类型 标识符和关键字 运算符和表达式 顺序结构 分支结构（if-else，switch-case） 循环结构 （while，do-while、for） 数组 字符串