1 Java基本语法
1.1 基本格式
Java程序代码必须放在一个类中，初学者可以简单地把一个类理解为一个Java程序。类使用class关键字定义，在class前面可以有类的修饰符，类的定义格式如下所示：
修饰符 class 类名{
程序代码
}
四点注意事项
- 1 Java程序代码可分为结构定义语句和功能执行语句，其中，结构定义语句用于声明一个类或方法，功能执行语句用于实现具体的功能。每条功能执行语句的最后必须用分号(;)结束
- 2 Java语言是严格区分大小写的。在定义类时，不能将class写成Class，否则编译器会报错。程序中定义一个computer类的同时，还可以定义一个Computer类，computer和Computer是两个完全不同的符号，在使用时务必注意。
- 3 在编写Java程序时，出于可读性的考虑，应该让自己编写的程序代码整齐美观、层次清晰。常用的编排方式是一行只写一条语句，符号“{”与语句同行，符号“}”独占一行。
public class HelloWorld {
public static void main(String[] args) {
System.out.println("这是第一个Java程序！");
}
}
- 4 Java程序中一个连续的字符串不能分成两行书写。可以先将字符串分成两个字符串，然后用加号(+)将这两个字符串连起来，在加号(+)处换行
1.2 注释
单行注释
//注释局部变量
多行注释 它以符号/*开头，以符号*/结尾
文档注释是以/**开头，并在注释内容末尾以*/结束。
文档注释是对一段代码概括性的解释说明，可以使用javadoc命令将文档注释提取出来生成帮助文档。
/**
*@author 黑马程序员
*@version 1.0
*/
常用的标签
| 标签 | 描述 |
|---|---|
| @author | 标识作者 |
| @deprecated | 标识过期的类或成员 |
| @exception | 标识抛出的异常 |
| @param | 标识方法的参数 |
| @return | 标识方法的返回值 |
| @see | 标识指定参数的内容 |
| @serial | 标识序列化属性 |
| @version | 标识版本 |
| @throws | 标识引入一个特定的变化 |
1.3 标识符
在编程过程中，经常需要在程序中定义一些符号，用来标记一些名称，如包名、类名、方法名、参数名、变量名等，这些符号被称为标识符。标识符可以由字母、数字、下画线（_）和美元符号（$）组成，但标识符不能以数字开头，不能是Java中的关键字。
- （1）包名所有字母一律小写。例如：cn.itcast.test。
- （2）类名和接口名每个单词的首字母都大写。例如：ArrayList、Iterator。
- （3）常量名所有字母都大写，单词之间用下画线连接。例如：DAY_OF_MONTH。
- （4）变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。例如：lineNumber、getLineNumber。
- （5）在程序中，应该尽量使用有意义的英文单词定义标识符，使得程序便于阅读。例如，使用userName定义用户名，password定义密码。
1.4关键字
| 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 |
（1）所有的关键字都是小写。
（2）不能使用关键字命名标识符。
（3）const和goto是保留的关键字，虽然在Java中还没有任何意义，但在程序中不能
用来作为自定义的标识符。
（4）true、false和null虽然不属于关键字，但它们具有特殊的意义，也不能作为标识
符使用。
1.5 常量
整型常量是整数类型的数据，有二进制、八进制、十进制和十六进制4种表示形式
- 二进制：由数字0和1组成的数字序列。从JDK 7开始，允许使用字面值表示二进制数，前面要以0b或0B开头，目的是为了和十进制进行区分，如0b01101100、0B10110101。
- 八进制：以0开头并且其后由0~7范围内（包括0和7）的整数组成的数字序列，如0342。
- 十进制：由数字0~9范围内（包括0和9）的整数组成的数字序列，第一位不能是0，0本身除外，如198、0。
- 十六进制：以0x或者0X开头并且其后由09、AF(包括0和9、A和F，字母不区分大小写)组成的数字序列，如0x25AF、0xaf3、0Xff 。
浮点数常量就是在数学中用到的小数，Java中的浮点数分为单精度浮点数（float）和双精度浮点数（double）两种类型。其中，单精度浮点数后面以F或f结尾，而双精度浮点数则以D或d结尾
字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号（‘’）括起来。字符常量可以是英文字母、数字、标点符号、以及由转义序列表示的特殊字符。具体示例如下。‘\u0000’表示一个空白字符，即在单引号之间没有任何字符。
字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号（" "）括起来，具体示例如下。“HelloWorld”
布尔常量即布尔型的值，用于区分事物的真与假。布尔常量有true和false两个值。
null常量只有一个值null，表示对象的引用为空。
2 变量
2.1 变量的定义
变量：在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在内存单元中，每个内存单元都用一个标识符标识，这些用于标识内存单元的标识符就称为变量，内存单元中存储的数据就是变量的值。
- 数据类型分类
2.2 整型数据变量
- 整型类型变量
- 注意：在为一个long类型的变量赋值时，所赋值的后面要加上字母L（或小写l），说明赋值为long类型。如果赋的值未超出int类型的取值范围，则可以省略字母L（或小写l）。
- “浮点数类型变量”用于存储小数数值。double类型所表示的浮点数比float类型更精确，两种浮点数所占存储空间的大小以及取值范围（变量存储的值不能超出的范围）如表所示。
3. 字符类型变量
在Java中，字符型变量用char表示，用于存储一个单一字符。Java中每个char类型的字符变量都会占用2个字节。在给char类型的变量赋值时，需要用一对英文半角格式的单引号（’ ‘）把字符括起来，如’a’。
- 布尔类型变量
在Java中，使用boolean定义布尔型变量，布尔型变量只有true和false两个值。
定义字符型变量，具体示例如下。
boolean flag = false; // 定义一个布尔型的变量flag，初始值为false
flag = true; // 改变变量flag的值为true
2.3 变量的类型转换
1 自动类型转化
自动类型转换也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明，由编译器自动完成。自动类型转换必须同时满足以下两个条件：
（1）两种数据类型彼此兼容。
（2）目标类型的取值范围大于源类型的取值范围。
2 强制类型转换
强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。
由上图可知，程序提示数据类型不兼容，不能将int类型转换成byte类型，原因是将一个int类型的值赋给byte类型的变量b时，由于int类型的取值范围大于byte类型的取值范围，这样的赋值会导致数值溢出，也就是说1字节的变量无法存储4字节的整数值。
强制类型转化格式:
目标类型 变量 = （目标类型）值
2 数据精度丢失
298转化整二进制观察,易分析出a=42的原因
2.4 作用域
2.3 运算符
2.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; |
（1）在进行自增（++）和自减（–）运算时，如果运算符++或–放在操作数的前面，则先进行自增或自减运算，再进行其他运算。反之，如果运算符放在操作数的后面，则先进行其他运算再进行自增或自减运算。
（2）在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果会是一个小数。
（3）在进行取模（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数）的符号无关。(-5)%3=-2，而5%(-3)=2。
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; |
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 |
3.5 运算符的优先级
| 优先级 | 运算符 |
|---|---|
| 1 | . [] () |
| 2 | ++ – ~ ! (数据类型) |
| 3 | * / % |
| 4 | + - |
| 5 | << >> >>> |
| 6 | < > <= >= |
| 7 | == != |
| 8 | & |
| 9 | ^ |
| 10 | | |
| 11 | && |
| 12 | || |
| 13 | ?: |
| 14 | = *= /= %= += -= <<= >>= >>>= &= ^= |= |
4 选择结构语句
4.1 if条件语句
public class Summary {
public static void main(String[] args) {
int grade = 75; // 定义学生成绩
if (grade > 80)
System.out.println("该成绩的等级为优"); // 满足条件 grade > 80
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
public class Summary {
public static void main(String[] args) {
int x = 0;
int y = 1;
int max = x > y ? x : y;
System.out.println(max);
}
}
（1）三元运算符“？”和“：”是一对运算符，不能分开单独使用。
（2）三元运算符的优先级低于关系运算符与算术运算符，但高于赋值运算符。
（3）三元运算符可以进行嵌套，结合方向自右向左。
4.3 switch条件语句
switch (表达式){
case 目标值1:
执行语句1
break;
case 目标值2:
执行语句2
break;
．．．．．．
case 目标值n:
执行语句n
break;
default:
执行语句n+1
break;
}
public class Example11 {
public static void main(String[] args) {
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循环语句会反复地进行条件判断，只要条件成立，{}内的执行语句就会执行，直到循环条件不成立，while循环结束。
while(循环条件){
执行语句
...
}
在上面的语法结构中，{}中的执行语句被称作循环体，循环体是否执行取决于循环条件。
当循环条件为true时，循环体就会执行。循环体执行完毕，程序继续判断循环条件，如
果条件仍为true则继续执行循环体，直到循环条件为false时，整个循环过程才会结束。
while循环的执行流程如下图所示。
//循环语句结构while
public class Example12 {
public static void main(String[] args) {
int x = 1; // 定义变量x，初始值为1
while (x <= 4) { // 循环条件
System.out.println("x = " + x); // 条件成立，打印x的值
x++; // x进行自增
}
}
}
5.2 do…while
do {
执行语句
...
} while(循环条件);
在上面的语法结构中，关键字do后面{}中的执行语句是循环体。do…while循环语句将循环条件放在了循环体的后面。这也就意味着，循环体会无条件执行一次，然后再根据循环条件决定是否继续执行。
public class Example13 {
public static void main(String[] args) {
int x = 1;
do {
System.out.println("x = " + x);
x++;
} while (x <= 7);
}
}
5.3 for循环
for（初始化表达式; 循环条件; 操作表达式）{
执行语句
...
}
用①表示初始化表达式，②表示循环条件，③表示操作表达式，④表示循环体，通过序号分析for循环的执行流程，具体分析如下。
for（① ; ② ; ③）{
④
}
第一步，执行①
第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
第三步，执行④
第四步，执行③，然后重复执行第二步
第五步，退出循环
public class Example14 {
public static void main(String[] args) {
int sum = 0; // 定义变量sum，用于存储累加的和
for (int i = 1; i <= 5; i++) { // i的值会从1变到5
sum += i; // 实现sum与i的累加
}
System.out.println("sum = " + sum); // 打印累加的和
}
}
- while和do…while适用于循环次数不确定的场景；for适用于循环次数确定的场景。
- while和for是先判断循环条件，再执行循环体；do…while是先执行循化体，再判断循环条件。
5.4循环嵌套
就是循环里面再加循环
5.5 跳转语句 break continue
1 break
在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行循环后面的代码。
public class Example17 {
public static void main(String[] args) {
int x = 1; // 定义变量x，初始值为1
while (x <= 4) { // 循环条件
System.out.println("x = " + x); // 条件成立，打印x的值
if (x == 2) {
break;
}
x++; // x进行自增
}
}
}
//x = 1
//x = 2
2 continue
continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。
//1-100奇数的和（continue）
public class Example19 {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
continue; // i是偶数，跳过
}
sum += i;
}
System.out.println("sum=" + sum);
}
}
//sum=2500
6 方法
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．){
执行语句
...
return 返回值;
}
修饰符：方法的修饰符比较多，例如，对访问权限进行限定的修饰符，static修饰符，final修饰符等，这些修饰符在后面的学习过程中会逐步介绍。
返回值类型：用于限定方法返回值的数据类型。
参数类型：用于限定调用方法时传入参数的数据类型。
参数名：是一个变量，用于接收调用方法时传入的数据。
return关键字：用于返回方法指定类型的值并结束方法。
返回值：被return语句返回的值，该值会返回给调用者。
public class Example20 {
public static void main(String[] args) {
printRectangle(3, 5);
int area = getArea(3, 5);
System.out.println("area:" + area);
}
//定义一个printRectangle方法
public static void printRectangle(int height, int width) {
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
System.out.print("* ");
}
System.out.println();
}
System.out.println();
}
//定义一个求矩形面级的方法
public static int getArea(int x, int y) {
return x * y;
}
}
方法的重载
方法重载，就是在同一个作用域内，方法名相同但参数个数或者参数类型不同的方法。例如，在同一个作用域内同时定义三个add()方法，这三个add()方法就是重载方法。
定义三个add()方法，分别用于实现两个整数相加、三个整数相加以及两个小数相加的功能。
//重载方法：在一个作用域内，方法名相同但参数个数或者类型不同的方法。
public class Example21 {
public static void main(String[] args) {
// 下面是针对求和方法的调用
int sum1 = add(1, 2);
int sum2 = add(1, 2, 3);
double sum3 = add(1.2, 2.3);
// 下面的代码是打印求和的结果
System.out.println("sum1=" + sum1);
System.out.println("sum2=" + sum2);
System.out.println("sum3=" + sum3);
}
// 下面的方法实现了两个整数相加
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个基本元素构成：数组名称、数组元素、元素索引、数据类型。在Java中，声明数组的方式如下。
数据类型[]数组名;
数组名= new数据类型[长度];
int[] x;// 声明一个int[]类型的变量
x = new int[100];// 为数组x分配100个元素空间
在代码“int[] x;”中，声明了一个变量x，该变量的类型为int[]，即声明了一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值。
在代码“x = new int[100]; ”中，创建了一个数组，将数组的地址赋值给变量x。在程序运行期间可以使用变量x引用数组，这时变量x在内存中的状态会发生变化。
7.2 数组的简单使用
根据元素类型的不同，默认初始化的值也是不一样的。不同类型数组元素的默认值如下表所示。
| 数据类型 | 默认初始化值 |
|---|---|
| byte、short、int、long | 0 |
| float、double | 0.0 |
| char | 一个空字符，即’\u0000’ |
| boolean | false |
| 引用数据类型 | null，表示变量不引用任何对象 |
public class Example23 {
public static void main(String[] args) {
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]);
}
}
数组的静态初始化方式
在定义数组时只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化。在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有以下两种方式。
类型[] 数组名 = new 类型[]{元素,元素,……};
类型[] 数组名 = {元素,元素,元素,……};
public class Summary {
public static void main(String[] args) {
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]);
}
}
数组索引越界
数组是一个容器，存储到数组中的每个元素，都有自己的自动编号，最小值为0，最大值为数组长度-1，如果要访问数组存储的元素，必须依赖于索引。在访问数组的元素时，索引不能超出0~length-1范围，否则程序会报错。
7.3 数组的常见操作
1 数组的遍历
public class Example27 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
// 使用for循环遍历数组的元素
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]); // 通过索引访问元素
}
}
}
2 数组中最值的获取
在操作数组时，经常需要获取数组中元素的最值。例如在一组数组中，找到最大的一个数或者最小的一个数
public class Example28 {
public static void main(String[] args) {
// 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 数组的指定位置插入一条数据
现有数组int[] arr={10,11,13,14,15}，要求将12插入到索引为2的位置。实现插入的思路如下。
（1）初识化数组长度为5，现要求插入一个元素。因为数组一旦创建后长度是不可改变的，所以首先需要创建一个长度为6的新数组来存储插入后的所有元素。
（2）再将原数组中的值复制到新的数组中，同时在指定位置后的元素依次向后移动一位。
（3）最后将目标元素保存到指定位置即可。
public class Example28 {
public static void main(String[] args) {
int[] arr = {10, 11, 13, 14, 15};
int score = 12;
int[] arr2 = new int[arr.length + 1];//定义一个比arr数组长度多1的新数组
for (int i = 0; i < 3; i++) {//将arr拆分成两部分，将12插入到拆分的两个数组中间
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.print("添加新元素之后的arr2数组：");
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i] + ",");
}
}
}
4 冒泡排序
public class Summary {
public static void main(String[] args) {
int arr[] = {3, 6, 9, 2, 5, 8, 1, 4, 7};
//外层循环比较 n-1 次
for (int i = 1; i < arr.length; i++) {
//内循环比较第 i 轮的两个数（防止越界）
for (int j = 0; j < arr.length - 1; j++) {
if (arr[j] > arr[j + 1]) {
int t = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = t;
}
}
}
//完成排序后，打印
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + ",");
}
}
}
7.4 二维数组
二维数组就是指维数为2的数组，即数组有两个索引。二维数组的逻辑结构按行列排列，两个索引分别表示行列，通过行列可以准确标识一个元素。
第一种方式是定义一个确定行的个数和列的个数的二维数组
数据类型[][] 数组名 = new数据类型[行的个数][列的个数];
int[][] xx= new int[3][4];
上面的代码相当于定义了一个3*4的二维数组，即3行4列的二维数组，二维数组xx[3][4]的逻辑结构如下所示:
第二种定义方式种方式是定义一个确定行数但不确定列的个数的二维数组，格式如下所示：
数据类型[][] 数组名 = new int[行的个数][];
int[][] xx= new int[3][4];
第二种方式和第一种方式类似，只是数组的列数不确定，接下来通过一个图表示二维数组xx[3][]元素存储情况，如下所示：
第三种方式是定义一个确定元素值的二维数组，格式如下所示：
数据类型[][] 数组名= {{第0行初始值},{第1行初始值},...,{第n行初始值}};
int[][] xx= {{1,2},{3,4,5,6},{7,8,9}};
上面的二维数组xx中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}，接下来通过一个图表示在二维数组中元素存储的形式，如下所示：
public class Example22 {
public static void main(String[] args) {
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 += arr[i][j];
}
sum = sum + groupSum; // 累加小组销售额
System.out.println("第" + (i + 1) + "小组销售额为：" + groupSum + " 万元。");
}
System.out.println("总销售额为: " + sum + " 万元。");
}
}
本章首先介绍了Java语言的基本语法，包括Java程序的基本格式、注释、标识符等；
其次介绍了Java中的变量和运算符；
接着介绍了选择结构语句、循环结构语句和跳转语句；
然后介绍了方法，包括方法的概念、定义、调用以及重载；
最后介绍了数组，包括数组的定义、数组的常见操作、多维数组。
291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
