第2章 Java编程基础
学习目标
- 掌握Java的基本语法，能够根据Java程序的基本格式编写Java程序
- 掌握变量的定义和使用，能够熟练定义各种变量并实现变量间的类型转换
- 掌握运算符的使用，能够正确使用运算符解决程序中的运算问题
- 掌握选择结构语句的使用，能够熟练使用条件语句和三元运算符解决程序中的选择问题
- 掌握循环结构语句的使用，能够熟练使用循环语句解决程序中的循环问题
- 掌握方法的定义与重载，能够独立完成方法的定义与调用
- 掌握数组的定义与使用，能够熟练使用数组处理批量数据
1 Java基本语法
1.1 Java程序的基本格式
修饰符 class 类名{
程序代码
}
- Java程序代码可分为结构定义语句和功能执行语句，其中：
- 结构定义语句用于声明一个类或方法，
- 功能执行语句用于实现具体的功能。
- 每条功能执行语句的最后必须用分号(;)结束,
- Java语言是严格区分大小写的。
- 整齐美观、层次清晰。常用的编排方式是一行只写一条语句，符号“{”与语句同行，符号“}”独占一行。建议缩格书写
public class HelloWorld {
public static void main(String[] args) {
System.out.println("这是第一个Java程序！");
}
}
- Java程序中一个连续的字符串不能分成两行书写。较长的字符串分两行书写，可以先将字符串分成两个字符串，然后用加号(+)将这两个字符串连起来，在加号(+)处换行，上面的语句可以修改成如下形式。
1.2 Java中的注释
- 单行注释: //
- 多行注释: / 开头， /结尾
/* 注释内容 */ 文档注释：文档注释是对一段代码概括性的解释说明，可以使用javadoc命令将文档注释提取出来生成帮助文档。
/** * @author 黑马程序员 * @version 1.0 */ /** * 下面这段代码是快速排序的算法 */
文档注释的常用标签
| 标签 | 描述 |
|---|---|
| @author | 标识作者 |
| @deprecated | 标识过期的类或成员 |
| @exception | 标识抛出的异常 |
| @param | 标识方法的参数 |
| @return | 标识方法的返回值 |
| @see | 标识指定参数的内容 |
| @serial | 标识序列化属性 |
| @version | 标识版本 |
| @throws | 标识引入一个特定的变化 |
注释嵌套使用
- 多行注释“/…/”中可以嵌套使用单行注释//
/* int c = 10; // 定义一个整型的c int x = 5; */ - 多行注释“/…/”中不能嵌套使用多行注释“/…/“ ---- 无法通过编译
1.3 Java中的标识符
标识符可以由字母(此处的字母包括汉字)、数字、下画线（_）和美元符号（$）组成，但标识符不能以数字开头，不能是Java中的关键字。
1.4 Java中的关键字
| abstract | continue | for | new | switch |
|---|---|---|---|---|
| assert | default | goto | package | synchronized |
| boolean | do | if | private | this |
| break | double | implements | protected | throw |
| byte | else | import | public | throws |
| case | enum | instanceof | return | transient |
| catch | extends | int | short | try |
| char | final | interface | static | void |
| class | finally | long | strictfp | volatile |
| const | float | native | super | while |
关键字使用的注意事项
- 所有的关键字都是小写。
- 不能使用关键字命名标识符。
- const和goto是保留的关键字，虽然在Java中还没有任何意义，但在程序中不能用来作为自定义的标识符。
- true、false和null虽然不属于关键字，但它们具有特殊的意义，也不能作为标识符使用。
// 合法标识符
username
username123
user_name
_userName
$username
用户名
姓名
年龄
// 不合法标识符
123name //不能以数字开头
Class //不能是关键字
98.3 //不能是数字开头也不能包含特殊符号“.”
Hello World //不能包含空格特殊字符
标识符书写规范
- 包名所有字母一律小写。例如：cn.itcast.test。
- 类名和接口名每个单词的首字母都大写。例如：ArrayList、Iterator。
- 常量名所有字母都大写，单词之间用下画线连接。例如：DAY_OF_MONTH。
- 变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。例如：lineNumber、getLineNumber。
- 在程序中，应该尽量使用有意义的英文单词定义标识符，使得程序便于阅读。例如，使用userName定义用户名，password定义密码。
创建新项目
在src下创建cn.zxx软件包。
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
// 变量命名字母可用汉字
int 年龄 = 60, 人数;
人数 = 42;
System.out.println("年龄="+年龄);
System.out.println("人数="+人数);
float f = 123.4f; // 为一个float类型的变量赋值，后面必须加上字母f
double d1 = 100.1; // 为一个double类型的变量赋值，后面可以省略字母d
double d2 = 199.3d; // 为一个double类型的变量赋值，后面可以加上字母d
float f2 = 100; // 声明一个float类型的变量并赋整数值
double d = 100; // 声明一个double类型的变量并赋整数值
//int i1 = 100.;
//float f3 = 100.;
float f4 = 100f;
char c = 'a'; // 为一个char类型的变量赋值字符a
char ch = 98;
char c2 = '杜'; // 为一个char类型的变量赋值字符 杜
char c3 = 26460;
System.out.println("ch="+ch);
System.out.println("c3="+c3);
System.out.println("c2="+(c2+1));
int x = 0,y;
System.out.println("1. x="+x);
// System.out.println(" y="+y); //变量 'y' 可能尚未初始化
y = x+3;
System.out.println("2. x="+x);
System.out.println(" y="+y);
// 后置 ++ ，先参加运行后++
int a = 1;
int b = 2;
int z = a + (b++);
System.out.println("1. b="+b);
System.out.println(" z="+z);
// 前置 ++
a = 1;
b = 2;
z = a + (++b);
System.out.println("2. b="+b);
System.out.println(" z="+z);
System.out.println("3. 5/2="+(5 / 2));
System.out.println(" 5./2="+(5. / 2));
System.out.println(" 5/2.="+(5 / 2.));
System.out.println("4. (-5)%3="+((-5)%3));
System.out.println(" 5%(-3)="+(5%(-3)));
}
}
1.5 Java中的常量
Java中的常量: 整型常量、浮点数常量、布尔常量、字符常量、字符串常量
(1) 整型常量
| 进制 | 数字序列 | 特定标识 | 举例(可以是负数) |
|---|---|---|---|
| 二进制 | 0,1 | 0b,0B开头 | 0b01101100、0B10110101 |
| 八进制 | 0,1,...,7 | 0开头 | 0342、077、0100 |
| 十进制 | 0,1,...,9 | 第一位不能是0，0本身除外。 | 0、62、-78 |
| 十六进制 | 0,1,...9,a,...,f | 0x,0X开头，字母不区分大小写 | 0x25AF、0xaf3、0Xff |
(2) 浮点数常量
| 类型 | 精度 | 结尾 | 举例 |
|---|---|---|---|
| float | 单精度浮点数 | F或f | 2e3f、0f、2f、5.022e+23f |
| double | 双精度浮点数 | D或d | 3.84d、0.、2.、3.14 |
默认浮点数为double类型的浮点数，如3.14、2.。
(3) 字符常量 单引号（''）括起来
字符常量可以是英文字母(汉字)、数字、标点符号、以及由转义序列表示的特殊字符。如：
'a' '1' '&' '杜' '\r' '\u0000' '\u26460'
Java内部(程序运行)处理采用的是Unicode字符集，Unicode字符以\u开头，空白字符在Unicode码表中对应的值为‘\u0000‘。
Unicode编码范围:
汉字: [0x4e00,0x9fa5](或十进制[19968,40869])
数字: [0x30,0x39](或十进制[48，57])
小写字母: [0x61,0x7a](或十进制[97，122])
大写字母: [0x41,0x5a]（或十进制[65，90])
1. \\: 表示反斜杠本身。
2. \": 表示双引号。
3. \': 表示单引号。
4. \n: 表示换行。
5. \t: 表示制表符(Tab)。
6. \r: 表示回车。
7. \b: 表示退格。
8. \f: 表示换页(form feed)。
(4) 字符串常量
字符串常量用于表示一串连续的字符，双引号（" "）括起来
"HelloWorld" "123" "Welcome \n XXX" "山西传媒学院"
"" -- 空串
(5) 布尔常量
真与假 true、false
(6) null常量
null常量只有一个值null，表示对象的引用为空。
进制转换
- 十进制数转二进制数：除以2取余数倒排序
- 二进制数转十进制数
<p>二进制 0110 0100 0 1 1 0 0 1 0 0 </p>
十进制 0*2^7+1*2^6+1*2^5+0*2^4+0*2^3+1*2^2+0*2^1+0*2^0
= 1*2^6+1*2^5+1*2^2
= 64+32+4 = 100
2 Java中的变量
2.1 变量的定义
用于标识内存单元的标识符就称为变量，内存单元中存储的数据就是变量的值。
int x = 0,y;
System.out.println("1. x="+x);
// System.out.println(" y="+y); //变量 'y' 可能尚未初始化
y = x+3;
System.out.println("2. x="+x);
System.out.println(" y="+y);
2.2 变量的数据类型
(1) 整型类型变量
| 类型 | 占用空间 | 取值范围 | ||
|---|---|---|---|---|
| 字节型 | byte | 8位（1个字节） | -2^7 ～ 2^7-1 | -128～127 |
| 短整型 | short | 16位（2个字节） | -2^15 ～ 2^15-1 | -32768～32767 |
| 整型 | int | 32位（4个字节） | -2^31 ～ 2^31-1 | -2147483648 21亿 |
| 长整型 | long | 64位（8个字节） | -2^63 ～ 2^63-1 | 922亿亿 |
注意：在为一个long类型的变量赋值时，所赋值的后面要加上字母L（或小写l），说明赋值为long类型。如果赋的值未超出int类型的取值范围，则可以省略字母L（或小写l）。
(2) 浮点数类型变量
用于存储小数数值，double类型所表示的浮点数比float类型更精确。
| 类型名 | 占用空间 | 取值范围 |
|---|---|---|
| float | 32位（4个字节） | -3.4E+38 ～ -1.4E-45，1.4E-45 ～ 3.4E+38 |
| double | 64位（8个字节） | -1.7E+308 ～ -4.9E-324，4.9E-324 ～ 1.7E+308 |
(3) 字符类型变量
在Java中，字符型变量用char表示，用于存储一个单一字符。Java中每个char类型的字符变量都会占用2个字节。
char c = 'a'; // 为一个char类型的变量赋值字符a
char ch = 98;
char c2 = '贾'; // 为一个char类型的变量赋值字符 贾
char c3 = 26460;
System.out.println("ch="+ch);
System.out.println("c3="+c3);
System.out.println("c2="+(c2+1));
(4) 布尔类型变量
在Java中，使用boolean定义布尔型变量，布尔型变量只有true和false两个值。
2.3 变量的类型转换
(1) 自动类型转换
自动类型转换也叫隐式类型转换，不需要显式地进行声明，由编译器自动完成。自动类型转换必须同时满足以下两个条件：
- 1）两种数据类型彼此兼容。
2）目标类型的取值范围大于源类型的取值范围。
char(2)--->int(4)--->long(8)--->float(4)--->double(8)
- byte(1)---->short(2)--->int(4)---->long(8)--->double(8)
- 但是(byte,short)和char不能相互转换
自动类型转换的情况
- （1）整数类型之间可以实现转换。例如，byte类型的数据可以赋值给short、int、long类型的变量；short、char类型的数据可以赋值给int、long类型的变量；int类型的数据可以赋值给long类型的变量。
- （2）整数类型转换为float类型。例如，byte、char、short、int类型的数据可以赋值给float类型的变量。
- （3）其他类型转换为double类型。例如，byte、char、short、int、long、float类型的数据可以赋值给double类型的变量。
(2) 强制类型转换
强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例1】强制类型转换 -- 张晓轩");
int num = 4;
// byte b = num; // 需要的类型是 byte，提供的类型是int
byte b = (byte)num;
System.out.println(b);
byte c = (byte)300;
System.out.println(c);
}
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例2】数据精度丢失 -- 张晓轩");
byte a; //定义byte类型的变量a
int b = 298; //定义int类型的变量b
a = (byte)b;
System.out.println("b="+b);
System.out.println("a="+a);
}
}
表达式类型自动提升
一个byte类型的变量在运算期间类型会自动提升为int类型。
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例3】byte类型运算会自动提升int -- 张晓轩");
byte b1 = 3; //定义一个byte类型的变量
byte b2 = 4;
// byte b3 = b1 + 0; // 一个byte类型的变量在运算期间类型会自动提升为int类型
// byte b3 = b1 + b2; // 一个byte类型的变量在运算期间类型会自动提升为int类型
byte b3 = (byte)(b1 + b2); //两个byte类型的变量相加，赋值给一个byte类型的变量
System.out.println("b3="+b3);
}
}
2.4 变量的作用域
变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例4】变量的作用域 -- 张晓轩");
int x = 12; //定义了变量x 5-12行的main方法作用域
{ // 6-9行块作用域
int y = 96; //定义了变量y
System.out.println("x 在6-9行块作用域="+x); //访问变量x
System.out.println("y 在6-9行块作用域="+y); //访问变量y
}
// y = x; //访问变量x，为变量y赋值 -- 无法解析符号 'y'
System.out.println("x 在5-12行的main方法作用域 = "+x); //访问变量x
}
}
3 Java中的运算符
算术运算符: +，-，*，/，%，++，--
赋值运算符: =
扩展后的赋值运算符: +=，-=，*=，/=，%=，&=，=，^=，<<=，>>=，>>>=
关系比较运算符: >，>=，<，<=，==
逻辑运算符: &&，&，||，|，!，^
位运算符: &，|，~，^，<<，>>，>>>
其他运算符（三目运算符): ? :
3.1 算术运算符 加、减、乘、除
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| + | 正号 | +3 | 3 |
| - | 负号 | b=4;-b | -4 |
| + | 加 | 5+5 | 10 |
| - | 减 | 6-4 | 2 |
| * | 乘 | 3*4 | 12 |
| / | 除 | 5/5 | 1 |
| % | 取模（求余） | 7%5 | 2 |
| ++ | 自增（前） | a=2;b=++a; | a=3;b=3; |
| ++ | 自增（后） | a=2;b=a++; | a=3;b=2; |
| -- | 自减（前） | a=2;b=--a; | a=1;b=1; |
| -- | 自减（后） | a=2;b=a--; | a=1;b=2; |
使用算术运算符的注意事项
- 在进行自增（++）和自减（--）运算时，
- 如果运算符放在操作数的前面，则先进行自增或自减运算，再进行其他运算。
- 反之，如果运算符放在操作数的后面，则先进行其他运算再进行自增或自减运算。
- 在进行除法运算时，
- 当除数和被除数都为整数时，得到的结果也是一个整数。
- 如果除法运算有小数参与，得到的结果会是一个小数。
- 进行取模（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数）的符号无关。
int a = 1;
int b = 2;
int z = a + (b++);
System.out.println("1. b="+b);
System.out.println(" z="+z);
a = 1;
b = 2;
z = a + (++b);
System.out.println("2. b="+b);
System.out.println(" z="+z);
System.out.println("3. 5/2="+(5 / 2));
System.out.println(" 5./2="+(5. / 2));
System.out.println(" 5/2.="+(5 / 2.));
System.out.println("4. (-5)%3="+((-5)%3));
System.out.println(" 5%(-3)="+(5%(-3)));
3.2 赋值运算符
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| = | 赋值 | a=3;b=2; | a=3;b=2; |
| += | 加等于 | a=3;b=2;a+=b; | a=5;b=2; |
| -= | 减等于 | a=3;b=2;a-=b; | a=1;b=2; |
| *= | 乘等于 | a=3;b=2;a*=b; | a=6;b=2; |
| /= | 除等于 | a=3;b=2;a/=b; | a=1;b=2; |
| %= | 模等于 | a=3;b=2;a%=b; | a=1;b=2; |
使用赋值运算符的注意事项
- （1）在Java中可以通过一条赋值语句对多个变量进行赋值
int x, y, z;
x = y = z = 5;// 为三个变量同时赋值
- （2）除了“=”，其他的都是特殊的赋值运算符，以“+=”为例，x += 3就相当于x = x + 3，表达式首先会进行加法运算x+3，再将运算结果赋值给变量x。-=、*=、/=、%=赋值运算符都可以此类推。
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例5】使用+=、-=、*=、/=、%= 时，会自动完成强制类型转换 -- 张晓轩");
short s = 3;
System.out.println("s 的变量类型：");
// s = s + 0; // 需要的类型是short，提供的类型是 int
int i = 5;
s += i;
System.out.println("s = "+ s);
}
}
3.3 比较运算符
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 等于 | 4 == 4 | false |
| != | 不等于 | 4 != 3 | true |
| < | 小于 | 4 < 3 | false |
| > | 大于 | 4 > 3 | true |
| <= | 小于或等于 | 4 <= 3 | false |
| >= | 大于或等于 | 4 >= 3 | true |
注意：在比较运算中，不能将比较运算符“==”误写成赋值运算符“=”。
3.4 逻辑运算符
| 运算符 | 运算 | 范例 | 结果 | ||||
|---|---|---|---|---|---|---|---|
| & | 与 | true & true | true | ||||
| true & false | false | ||||||
| false & false | false | ||||||
| false &true | false | ||||||
| \ | 或 | true \ | true | true | |||
| true \ | false | true | |||||
| false\ | false | false | |||||
| false\ | true | true | |||||
| ^ | 异或 | true ^ true | false | ||||
| true ^ false | true | ||||||
| false ^ false | false | ||||||
| false ^ true | true | ||||||
| ! | 非 | !true | false | ||||
| !false | true | ||||||
| && | 短路与 | true && true | true | ||||
| true && false | false | ||||||
| false && false | false | ||||||
| false && true | false | ||||||
| \ | \ | 短路或 | true \ | \ | true | true | |
| true \ | \ | false | true | ||||
| false\ | \ | false | false | ||||
| false\ | \ | true | true |
使用逻辑运算符的注意事项
- 逻辑运算符可以针对结果为布尔值的表达式进行运算。
- 运算符“&”和“&&”都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则结果为false。运算符“&”和“&&”都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则结果为false。
- 在使用“&”进行运算时，不论左边为true或者false，右边的表达式都会进行运算。
- 在使用“&&”进行运算，当左边为false时，右边的表达式就不再进行运算，因此“&&”被称作短路与。
- 运算符“|”和“||”都表示或操作，当运算符两边的任一表达式值为true时，其结果为true。只有两边表达式的值都为false时，其结果才为false。
- 在使用“|”进行运算时，不论左边为true或者false，右边的表达式都会进行运算。
- 在使用“||”进行运算，当运算符“||”的左边为true时，右边的表达式不再进行运算。因此“||”被称为短路或。
- 运算符“^”表示异或操作，当运算符两边的布尔值相同时（都为true或都为false），其结果为false。当两边表达式的布尔值不相同时，其结果为true。
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例6】& 与 && 逻辑运算比较 -- 张晓轩");
int x = 0; //定义变量x，初始值为0
int y = 0; //定义变量y，初始值为0
int z = 0; //定义变量z，初始值为0
boolean a,b,c; //定义布尔型变量a,b和c
a = x > 0 & y++ > 1; //逻辑运算符&对表达式进行运算
System.out.println(a);
System.out.println("y = "+y);
b = x > 0 && z++ > 1;
System.out.println(b); //逻辑运算符&&对表达式进行运算 -- 短路与
System.out.println("z = "+z);
c = x >= 0 && z++ >= 0;
System.out.println(c); //逻辑运算符&&对表达式进行运算 -- 短路与
System.out.println("z = "+z);
}
}
3.5 运算符的优先级
| 优先级 | 运算符 | |||
|---|---|---|---|---|
| 1 | .、 [] 、 () | |||
| 2 | 一元运算符 | ++、+(正)、--、-(负)、~(按位取反)、!(逻辑非)、( 数据类型 ) 强制类型 | ||
| 3 | 乘、除、取余 | *、/、% | ||
| 4 | 加法和减法 | +、- | ||
| 5 | 移位运算符 | <<(左移)、>>(带符号右移)、>>>(无符号右移) | ||
| 6 | 关系运算符 | <、>、<=、>= | ||
| 7 | 相等运算符 | ==、!= | ||
| 8 | 按位与 | & | ||
| 9 | 按位异或 | ^ | ||
| 10 | 按位或 | \ | ||
| 11 | 逻辑与 | && | ||
| 12 | 逻辑或 | \ | \ | |
| 13 | 三元运算符 | ? : | ||
| 14 | 赋值运算符 | =、*=、/=、%=、+=、-=、<<=、>>=、>>>=、&=、^=、\ | = |
数字越小优先级越高。
int a =2;
int b = a + 3*a;
System.out.println(b);
int a1 =2;
int b1 = (a1+3) * a1;
System.out.println(b1);
4 选择结构语句
4.1 if条件语句
(1) if语句
if (判断条件) {
执行语句
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例7】if(){}举例 -- 张晓轩");
int x = 5;
if(x < 1){
//if(x < 10){
x++;
}
System.out.println("x = "+x);
}
}
(2) if…else语句
if (判断条件) {
执行语句1
...
}
else
{
执行语句2
...
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例8】if...else举例 -- 张晓轩");
int num = 19;
//num = 20;
if(num % 2 == 0){
//判断条件成立，num被2整除
System.out.println("num是一个偶数");
}else{
System.out.println("num是一个奇数");
}
}
}
(3) if…else if…else语句
if (判断条件1) {
执行语句1
}
else if (判断条件2) {
执行语句2
}
...
else if (判断条件n) {
执行语句n
}
else {
执行语句n+1
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例9】if...else if...else举例 -- 张晓轩");
int grade = 75; //定义学生成绩
if (grade > 80){
//满足条件 grade > 80
System.out.println("该成绩的等级为优");
}else if (grade > 70){
//不满足条件 grade > 80，但满足条件 grade > 70
System.out.println("该成绩的等级为良");
}else if (grade > 60){
//不满足条件 grade > 70，但满足条件 grade > 60
System.out.println("该成绩的等级为中");
}else {
//不满足条件 grade > 60
System.out.println("该成绩的等级为差");
}
}
}
4.2 三元运算符
判断条件 ? 表达式1 : 表达式2
三元运算符使用注意事项
- （1）三元运算符“？”和“：”是一对运算符，不能分开单独使用。
- （2）三元运算符的优先级低于关系运算符与算术运算符，但高于赋值运算符。
- （3）三元运算符可以进行嵌套，结合方向自右向左。例如，a>b?a:c>d?c:d应该理解为a>b?a:(c>d?c:d)，
// if语句实现
int x = 0;
int y = 1;
int max;
if (x > y) {
max = x;
} else {
max = y;
}
System.out.println(max);
// 三元表达式实现
int x1 = 0;
int y1 = 1;
int max1 = x1 > y1? x1 : y1;
System.out.println(max1);
4.3 switch条件语句
switch (表达式){
case 目标值1:
执行语句1
break;
case 目标值2:
执行语句2
break;
．．．．．．
case 目标值n:
执行语句n
break;
default:
执行语句n+1
break;
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例10】switch举例 -- 张晓轩");
// int week = 5;
int week = 8;
switch (week){
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("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期天");
break;
default:
System.out.println("输入的数字不正确...");
break;
}
}
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例11】switch举例2 -- 张晓轩");
int week = 2;
switch (week){
case 1:
case 2:
case 3:
case 4:
case 5:
//当week值为1、2、3、4、5中任意一个时，处理方式相同
System.out.println("今天是工作日");
break;
case 6:
case 7:
//当week值为6、7中任意一个时，处理方式相同
System.out.println("今天是休息日");
break;
}
}
}
5 循环结构语句
5.1 while循环语句
while(循环条件){
执行语句
...
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例12】打印1~6之间的数演示while语句 -- 张晓轩");
int x = 1; // 定义变量x，初始值为1
while (x <= 6) { // 循环条件
System.out.println("x = " + x); // 条件成立，打印x的值
x++; // x进行自增
}
}
}
5.2 do…while循环结构语句
do {
执行语句
...
} while(循环条件);
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例13】打印1~6之间的数演示do while语句 -- 张晓轩");
int x = 1; // 定义变量x，初始值为1
do {
System.out.println("x = " + x); // 打印x的值
x++; // 将x的值自增
} while (x <= 6); // 循环条件
}
}
5.3 for循环语句
for（初始化表达式; 循环条件; 操作表达式）{
执行语句
...
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例14】对自然数1~9求和演示for循环 -- 张晓轩");
int sum = 0; // 定义变量sum，用于存储累加的和
for (int i = 1; i <= 9; i++) { // i的值会从1变到5
sum += i; // 实现sum与i的累加
}
System.out.println("sum = " + sum); // 打印累加的和
}
}
while、do…while和for循环的区别
相同点：这3种循环都遵循循环四要素，即初始化循环变量、循环条件、循环体、更新循环变量。
不同点：
- while和do...while适用于循环次数不确定的场景；for适用于循环次数确定的场景。
- while和for是先判断循环条件，再执行循环体；do...while是先执行循化体，再判断循环条件。
package cn.zxx;
public class Ex00_zxx_ {
public static void main(String[] args){
System.out.println("【例14_】while、do…while和for循环比较 -- 张晓轩");
//while循环
System.out.println("while循环");
int num = 0;
while (num <= 10){
if (num % 2 != 0){
System.out.print(num + ",");
}
num++;
}
System.out.println("\n\ndo...while循环");
//do...while循环
int num2 = 0;
do {
if(num2 % 2 != 0){
System.out.print(num2 + ",");
}
num2++;
}while (num2 <= 10);
System.out.println("\n\nfor循环");
//for循环
for (int i=1;i<=10;i++){
if (i%2!=0){
System.out.print(i+",");
}
}
}
}
5.4 循环嵌套
循环嵌套是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，其中最常见的是在for循环中嵌套for循环。
for循环嵌套语句的语法格式
for(初始化表达式; 循环条件; 操作表达式) {
...
for(初始化表达式; 循环条件; 操作表达式) {
执行语句
...
}
...
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例15】for循环嵌套 -- 张晓轩");
int i, j; // 定义两个循环变量
for (i = 1; i <= 9; i++) { // 外层循环
for (j = 1; j <= i; j++) { // 内层循环
System.out.print("*"); // 打印*
}
System.out.print("\n"); // 换行
}
}
}
5.5 跳转语句
(1) break跳出语句
在switch条件语句和循环语句中都可以使用break语句跳出switch或循环结构，执行switch或循环后面的代码。
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例16】break语句举例1 -- 张晓轩");
int x = 1; // 定义变量x，初始值为1
while (x <= 6) { // 循环条件
System.out.println("x = " + x); // 条件成立，打印x的值
if (x == 3) {
break;
}
x++; // x进行自增
}
}
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例17】break语句举例2 -- 张晓轩");
int i, j; // 定义两个循环变量
for (i = 1; i <= 9; i++) { // 外层循环
if (i > 4) { // 判断i的值是否大于4
break; // 跳出外层循环
}
for (j = 1; j <= i; j++) { // 内层循环
System.out.print("*"); // 打印*
}
System.out.print("\n"); // 换行
}
}
}
(2) continue语句
continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例18】continue语句举例 -- 张晓轩");
int sum = 0; // 定义变量sum，用于存储和
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) { // i是一个偶数，不累加
continue; // 结束本次循环
}
sum += i; // 实现sum和i的累加
}
System.out.println("sum = " + sum);
}
}
6 方法
6.1 什么是方法
方法就是一段可以重复调用的代码。有些书中也会把方法称为函数。
修饰符 返回值类型 方法名(参数类型 参数名1, 参数类型 参数名2, ．．．){
执行语句
...
return 返回值;
}
方法的语法格式说明
- 修饰符：方法的修饰符比较多，例如，对访问权限进行限定的修饰符，static修饰符，final修饰符等，这些修饰符在后面的学习过程中会逐步介绍。
- 返回值类型：用于限定方法返回值的数据类型。如果方法没有返回值，返回值类型要声明为void，此时，方法中return语句可以省略。
- 参数类型：用于限定调用方法时传入参数的数据类型。
- 参数名：是一个变量，用于接收调用方法时传入的数据。
- return关键字：用于返回方法指定类型的值并结束方法。
- 返回值：被return语句返回的值，该值会返回给调用者。
方法的语法格式注意
- 方法中的“参数类型 参数名1，参数类型 参数名2”被称作参数列表，参数列表用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，即()内不写任何内容。
- 方法的返回值类型必须是方法声明的返回值类型，如果方法没有返回值，返回值类型要声明为void，此时，方法中return语句可以省略。
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例19】方法定义举例 -- 打印矩形 -- 张晓轩");
printRectangle(3, 5); // 调用 printRectangle()方法实现打印矩形
printRectangle(2, 4);
printRectangle(6, 10);
}
// 下面定义了一个打印矩形的方法，接收两个参数，其中height为高，width为宽
public static void printRectangle(int height, int width) {
// 下面是使用嵌套for循环实现*打印矩形
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
System.out.print("*");
}
System.out.print("\n");
}
System.out.print("\n");
}
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例20】方法定义举例2 -- 计算矩形面积 -- 张晓轩");
int area = getArea(3, 5); // 调用 getArea()方法
System.out.println(" 这个矩形的面加是： " + area);
}
// 下面定义了一个求矩形面积的方法，接收两个参数，其中x为高，y为宽
public static int getArea(int x, int y) {
int temp = x * y; // 使用变量temp记住运算结果
return temp; // 将变量temp的值返回
}
}
6.2 方法的重载
所谓方法重载，就是在同一个作用域内，方法名相同但参数个数、参数类型或这参数类型的排列顺序不同的方法。
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例21】方法重载 -- 张晓轩");
// 下面是针对求和方法的调用
System.out.println("add(1, 2)=" + add(1, 2));
System.out.println("add(1, 2, 3)=" + add(1, 2, 3));
System.out.println("add(1.2, 2.3)=" + add(1.2, 2.3));
}
// 下面的方法实现了两个整数相加
public static int add(int x, int y) {
return x + y;
}
// 下面的方法实现了三个整数相加
public static int add(int x, int y, int z) {
return x + y + z;
}
// 下面的方法实现了两个小数相加
public static double add(double x, double y) {
return x + y;
}
}
7 数组
7.1 数组的基本要素
一个数组由4个基本元素构成：数组名称、数组元素、元素索引、数据类型。
(1) 数组的声明方式
数据类型[] 数组名;
数组名 = new 数据类型[长度];
(2) 内存状态
- 变量x的内存状态
int[] x;
在代码“int[] x;”中，声明了一个变量x，该变量的类型为int[]，即声明了一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值。
- 变量x的内存状态
x = new int[];
在代码“x = new int[100]; ”中，创建了一个数组，将数组的地址赋值给变量x。在程序运行期间可以使用变量x引用数组，这时变量x在内存中的状态会发生变化。
(3) 数组使用注意
- 数组中最小的索引是0，
- 最大的索引是“数组的长度-1”。
- 数组的长度，Java提供了一个length属性，在程序中可以通过“数组名.length”的方式获得数组的长度，即元素的个数。
7.2 数组的简单使用
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例22】数组的简单使用1 -- 张晓轩");
int[] arr; // 声明变量
arr = new int[3]; // 创建数组对象
System.out.println("arr[0]=" + arr[0]); // 访问数组中的第1个元素
System.out.println("arr[1]=" + arr[1]); // 访问数组中的第2个元素
System.out.println("arr[2]=" + arr[2]); // 访问数组中的第3个元素
System.out.println("数组的长度是：" + arr.length); // 打印数组长度
}
}
不同类型数组元素的默认值
| 数据类型 | 默认初始化值 |
|---|---|
| byte、short、int、long | 0 |
| float、double | 0.0 |
| char | 一个空字符，即’\u0000’ |
| boolean | false |
| 引用数据类型 | null，表示变量不引用任何对象 |
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例23】数组的简单使用 -- 数组元素赋值 -- 张晓轩");
int[] arr = new int[4]; // 定义可以存储4个元素的整数类型数组
arr[0] = 1; // 为第1个元素赋值1
arr[1] = 2; // 为第2个元素赋值2
//依次打印数组中每个元素的值
System.out.println("arr[0]=" + arr[0]);
System.out.println("arr[1]=" + arr[1]);
System.out.println("arr[2]=" + arr[2]);
System.out.println("arr[3]=" + arr[3]);
}
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例24】数组的简单使用 -- 静态初始化 -- 张晓轩");
int[] arr = { 1, 2, 3, 4 }; // 静态初始化
//依次访问数组中的元素
System.out.println("arr[0] = " + arr[0]);
System.out.println("arr[1] = " + arr[1]);
System.out.println("arr[2] = " + arr[2]);
System.out.println("arr[3] = " + arr[3]);
}
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例25】数组的简单使用 -- 数组索引越界 -- 张晓轩");
int[] arr = new int[4]; // 定义一个长度为4的数组
System.out.println("arr[0]=" + arr[4]); // 通过索引4访问数组元素
}
}
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例26】数组的简单使用 -- 空指针异常 -- 张晓轩");
int[] arr = new int[3]; // 定义一个长度为3的数组
arr[0] = 5; // 为数组的第一个元素赋值
System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
arr = null; // 将变量arr置为null
System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
}
}
7.3 数组的常见操作
(1) 数组的遍历
常用循环语句完成数组的遍历。
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例27】数组的常见操作 -- 循环遍历 -- 张晓轩");
int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
// 使用for循环遍历数组的元素
System.out.println("普通for循环");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]); // 通过索引访问元素
}
System.out.println("增强for循环");
for (int i : arr) { // 增强for循环
System.out.println(i); // 通过索引访问元素
}
}
}
(2) 数组中最值的获取
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例28】数组的常见操作 -- 获取最大值 -- 张晓轩");
// 1.定义一个int[]数组
int[] arr = { 4, 1, 6, 3, 9, 8 };
// 2.定义变量max用于记住最大数，首先假设第一个元素为最大值
int max = arr[0];
// 3.遍历数组，查找最大值
for (int i = 1; i < arr.length; i++) {
// 比较 arr[i]的值是否大于max
if (arr[i] > max) {
// 条件成立，将arr[i]的值赋给max
max = arr[i];
}
}
System.out.println("数组arr中的最大值为：" + max); // 打印最大值
}
}
(3) 在数组的指定位置插入一条数据
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例29】数组的常见操作 -- 插入新元素 -- 张晓轩");
int[] arr={10,11,13,14,15};
int score=12;
//定义一个比arr数组长度多1的新数组
int[] arr2=new int[arr.length+1];
//将arr拆分成两部分，将12插入到拆分的两个数组中间
for (int i=0;i<3;i++){
arr2[i]=arr[i];
}
arr2[2]=score;
for (int i=3;i<arr2.length;i++){
arr2[i]=arr[i-1];
}
System.out.print("添加新元素之前的arr数组：");
for (int i=0;i<arr.length;i++){
System.out.print(arr[i]+",");
}
System.out.println("");
System.out.print("添加新元素之后的arr2数组：");
for (int i=0;i<arr2.length;i++){
System.out.print(arr2[i]+",");
}
}
}
(4) 数组排序
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例30】数组的常见操作 -- 冒泡排序 -- 张晓轩");
int[] arr = { 9, 8, 3, 5, 2 };
//冒泡排序前,先循环打印数组元素
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println(); //用于换行
// 进行冒泡排序
// 外层循环定义需要比较的轮数(两数对比,要比较 n-1 轮)
for (int i= 1; i < arr.length; i++) {
//内层循环定义第 i 轮需要比较的两个数
for (int j = 0; j < arr.length -i; j++) {
if (arr[j] > arr[j + 1]) { //比较相邻元素
// 下面 3 行代码用于交换相邻两个元素
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
//完成冒泡排序后,再次循环打印数组元素
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
7.4 二维数组
二维数组就是指维数为2的数组，即数组有两个索引。二维数组的逻辑结构按行列排列，两个索引分别表示行列，通过行列可以准确标识一个元素。
数据类型[][] 数组名 = new 数据类型[行的个数][列的个数];
数据类型[][] 数组名 = new 数据类型[行的个数][];
数据类型[][] 数组名= {{第0行初始值},{第1行初始值},...,{第n行初始值}};
int[][] xx1 = new int[3][4]; // 3*4的二维数组 -- 矩形数组
int[][] xx2 = new int[3][]; // 3行不确定列数的二维数组 -- 锯齿型数组
int[][] xx3 = {{1,2},{3,4,5,6},{7,8,9}}; // 3行不确定列数的二维数组 -- 锯齿型数组
// 二维数组的访问方式
xx[0][1] // 第0行第1列的数组元素
package cn.zxx;
public class Ex00_zxx {
public static void main(String[] args) {
System.out.println("【例31】二维数组 -- 张晓轩");
int[][] arr = new int[3][]; // 定义一个长度为3的二维数组
arr[0] = new int[] { 11, 12 }; // 为数组的元素赋值
arr[1] = new int[] { 21, 22, 23 };
arr[2] = new int[] { 31, 32, 33, 34 };
int sum = 0; // 定义变量记录总销售额
for (int i = 0; i < arr.length; i++) { // 遍历数组元素
int groupSum = 0; // 定义变量记录小组销售总额
for (int j = 0; j < arr[i].length; j++) { // 遍历小组内每个人的销售额
groupSum = groupSum + arr[i][j];
}
sum = sum + groupSum; // 累加小组销售额
System.out.println("第" + (i + 1) + "小组销售额为：" + groupSum + " 万元。");
}
System.out.println("总销售额为: " + sum + " 万元。");
}
}
