Java基础教程-04-方法
1. 方法简介
1.1 概述
方法(method)，也叫函数，是将具有独立功能的代码块组织成为一个整体，使其成为具有特殊功能的代码集.
例如: 现实生活中, 拿牙刷, 挤牙膏, 刷上排牙, 刷下排牙, 漱口, 这些单独的动作合起来, 就完成了刷牙的动作.
又例如: 让我们获取元素10和20的最大值, 我们可以通过if语句或者三元运算符实现, 如果再让我们获取22和11之间的最大值, 我们还需要把刚才的逻辑代码在写一次. 这样做很繁琐. 针对于这种情况, 我们就可以把获取两个整数最大值的逻辑代码封装到方法中, 当我们需要比较的时候, 直接调用方法就可以了. 这样做, 非常方便.
2.2 定义格式
修饰符 返回值的数据类型 方法名(参数类型 参数名1, 参数类型 参数名2) { //这里可以写多个参数
//方法体;
return 具体的返回值; //加工好的饲料
}
public static void main(String[] args) {
}
1.3 格式解释
• 修饰符: 目前记住这里是固定格式public static
• 返回值的数据类型: 用于限定返回值的数据类型的.
注意:
1. 返回值的数据类型是int类型, 则说明该方法只能返回int类型的整数.
2. 如果方法没有具体的返回值, 则返回值的数据类型要用void来修饰.
• 方法名: 方便我们调用方法.
• 参数类型: 用于限定调用方法时传入的数据的数据类型.
例如: 参数类型是String类型, 说明我们调用方法时, 只能传入字符串.
• 参数名: 用于接收调用方法时传入的数据的变量.
• 方法体: 完成特定功能的代码.
• return 返回值: 用来结束方法的, 并把返回值返回给调用者.
解释: 如果方法没有明确的返回值, 则return关键字可以省略不写.
1.4 注意事项
- 方法与方法之间是平级关系, 不能嵌套定义.
- 方法必须先创建才可以使用, 该过程称为: 方法定义.
- 方法自身不会直接运行, 而是需要我们手动调用方法后, 它才会执行, 该过程称为方法调用.
- 方法的功能越单一越好.
- 定义方法的时候写在参数列表中的参数, 都是: 形参.
形参: 形容调用方法的时候, 需要传入什么类型的参数. - 调用方法的时候, 传入的具体的值(变量或者常量都可以), 叫实参.
实参: 调用方法时, 实际参与运算的数据.
2. 无参无返回值的方法
2.1 定义无参无返回值的方法
定义方法时, 要做到三个明确, 这样定义方法就会变得非常简单了:
- 明确方法名, 即: 方法名要符合小驼峰命名法, 且要见名知意, 方便我们调用.
- 明确方法的参数列表. 即: 调用方法时, 我们需要给它(方法)什么数据.
- 明确方法的返回值类型, 即: 调用方法完毕后, 方法会返回给我们一个什么类型的数据.
具体格式
public static void 方法名() {
//方法体;
}
需求 定义printHello()方法, 用来打印"Hello World!"字符串.
参考代码
public static void printHello() {
System.out.println("Hello World!);
}
2.2 调用无参无返回值的方法
格式
方法名();
解释: 通过方法名();的形式, 可以直接根据方法名调用指定的方法.
2.3 方法调用图解
方法的好处:
可以提高代码的复用性, 方便我们维护程序.
即: 当一些代码被反复使用时，可以把它们提取出来，放到一个方法里，以方法的形式来使用这些代码。
2. 有参无返回值的方法
有参无返回值的方法的意思是: 调用方法时, 我们需要传入具体的参数, 但是方法执行完毕后, 并不会给我们返回具体的结果.
具体定义格式
public static void 方法名(参数类型 参数名1, 参数类型 参数名2) { //这里可以写多个参数
//方法体;
}
具体调用格式
方法名(参数值1, 参数值2); //注意: 参数的个数, 以及对应的参数类型都要和定义方法的参数列表保持一致.
需求
- 定义方法isEvenNumber(), 该方法接收一个int类型的整数num.
- 判断num是奇数还是偶数, 并打印结果.
参考代码
public static void isEvenNumber(int num) { //参数列表, 形容调用方法的时候需要传入什么类型的数据.
//即: 判断传过来的num是奇数还是偶数, 并将结果打印到控制台上.
if (num % 2 == 0) {
System.out.println(num + " 是偶数");
} else {
System.out.println(num + " 是奇数");
}
}
4. 无参有返回值的方法
无参有返回值的方法的意思是: 调用方法时, 我们不需要传入具体的参数, 但是方法执行完毕后, 会给我们返回具体的结果.
具体定义格式
public static 返回值的数据类型 方法名() {
//方法体;
return 具体的返回值;
}
具体调用格式
//直接调用, 无意义.
方法名();
//输出调用, 在课堂上我可能会经常用, 因为简单.
System.out.println(方法名());
//赋值调用, 实际开发中推荐使用.
数据类型 变量名 = 方法名();
4.1 示例一: 定义求和方法
需求
- 定义方法getSum(), 该方法内部有两个int类型的整数.
- 获取上述两个整数的和, 并返回.
- 在main方法中调用getSum()方法, 并打印结果.
参考代码
public class MethodDemo03 {
public static void main(String[] args) {
int sum = getSum();
//打印求和结果
System.out.println(sum);
}
public static int getSum() {
//1.1 该方法内部有两个int类型的整数.
int a = 10;
int b = 20;
return a + b;
}
}
运行结果为:
30
4.2 示例二: 判断奇偶数
需求
- 定义方法isEvenNumber(), 该方法内部有一个整数num.
- 判断num是奇数还是偶数, 并返回结果.
- 在main方法中调用isEvenNumber()方法, 并打印结果.
参考代码
public class MethodDemo04 {
public static void main(String[] args) {
boolean flag = isEvenNumber();
System.out.println(flag);
}
public static boolean isEvenNumber() {
//1. 该方法内部有一个整数num.
int num = 26;
//2.判断num是奇数还是偶数, 并返回结果.
if (num % 2 == 0) {
return true;
} else {
return false;
}
}
}
运行结果为:
true
5. 有参有返回值的方法
有参有返回值的方法的意思是: 调用方法时, 我们不仅需要传入具体的参数, 方法执行完毕后, 还会给我们返回具体的结果.
具体定义格式
下述这个格式就是方法的通用格式.
public static 返回值的数据类型 方法名(参数类型 参数1, 参数类型 参数2) {
//方法体;
return 具体的返回值;
}
具体调用格式
//直接调用
方法名(参数值1, 参数值2); //参数的个数, 及对应参数的类型要和定义方法时的参数列表保持一致.
//输出调用
System.out.println(方法名());
//赋值调用
数据类型 变量名 = 方法名();
5.1 示例一: 定义求和方法
需求
- 定义方法getSum(), 接收两个int类型的整数.
- 获取上述两个整数的和, 并返回.
- 在main方法中调用getSum()方法, 并打印结果.
参考代码
public class MethodDemo05 {
public static void main(String[] args) {
System.out.println("start");
int sum = getSum(10, 21);
System.out.println("sum: " + sum);
System.out.println("end");
}
public static int getSum(int a, int b) {
return a + b;
}
}
运行结果为:
start
sum: 31
end
5.2 示例二: 判断奇偶数
需求
- 定义方法isEvenNumber(), 该方法接收一个int类型的整数num.
- 判断num是奇数还是偶数, 并返回结果.
- 在main方法中调用isEvenNumber()方法, 并打印结果.
参考代码
public class MethodDemo06 {
public static void main(String[] args) {
boolean flag = isEvenNumber(22);
System.out.println(flag);
}
public static boolean isEvenNumber(int num) {
return num % 2 == 0;
}
}
运行结果为:
true
5.3 实例三: 获取最大值
需求
- 定义方法getMax(), 该方法接收两个整数.
- 通过该方法, 获取两个整数的最大值, 并返回.
- 在main方法中调用getMax()方法, 获取最大值并打印.
参考代码
public class MethodDemo07 {
public static void main(String[] args) {
//3.在main方法中调用getMax()方法, 获取最大值并打印.
int max = getMax(11, 22);
System.out.println("最大值是: " + max);
//return; 如果方法没有明确的返回值, 则return可以省略, 对结果没有影响.
}
//1.定义方法getMax(), 该方法接收两个整数.
//参数列表: int a, int b, 返回值类型: int
public static int getMax(int a, int b) {
//2.通过该方法, 获取两个整数的最大值, 并返回.
return a > b ? a : b;
}
}
运行结果为:
最大值是: 22
6. 练习
6.1 案例一: 遍历数组
需求
- 定义方法printArray(), 接收一个int类型的数组.
- 通过该方法, 实现遍历数组的功能.
- 在main方法中, 调用方法, 打印指定的数组.
参考代码
public class MethodDemo01 {
public static void main(String[] args) {
//3.在main方法中, 调用方法, 打印指定的数组.
int[] arr = {11, 22, 33, 44, 55};
printArray(arr); //ctrl + 字母Q 查看方法的解释说明
}
/**
* 方法功能: 该方法是用来遍历int类型的数组的
*
* @param arr 形参列表: 表示具体要遍历的int[]
*/
public static void printArray(int[] arr) {
//2.通过该方法, 实现遍历数组的功能.
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
运行结果为:
11
22
33
44
55
6.2 案例二: 获取数组最值
需求
- 定义方法getMax(), 接收一个int类型的数组.
- 通过该方法, 获取数组元素中的最大值.
- 在main方法中, 调用方法, 打印对应的结果.
参考代码
public class MethodDemo02 {
public static void main(String[] args) {
//3.在main方法中, 调用方法, 打印对应的结果.
int[] arr = {11, 22, 33, 44, 55};
int max = getMax(arr);
System.out.println(max);
}
//1.定义方法getMax(), 接收一个int类型的数组.
//参数列表: int[] 返回值的数据类型: int
/**
* 该方法是用来获取int数组的元素的最大值的.
*
* @param arr 要用来获取最大值的 数组.
* @return 数组中元素的最大值.
*/
public static int getMax(int[] arr) {
//2.通过该方法, 获取数组元素中的最大值.
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
}
运行结果为:
55
6.3 案例三: 模拟计算器
需求
- 定义方法, 接收两个int类型的整数.
- 分别获取这两个整数的加减乘除的运算结果, 然后返回.
- 在main方法中调用该方法, 并打印结果.
参考代码
public class MethodDemo03 {
public static void main(String[] args) {
//3.在main方法中调用该方法, 并打印结果.
int[] arr = calculate(10, 3);
System.out.println("加: " + arr[0]);
System.out.println("减: " + arr[1]);
System.out.println("乘: " + arr[2]);
System.out.println("除: " + arr[3]);
}
/**
* 模拟计算器,用来获取两个整数的: 加减乘除的结果的.
*
* @param a 第一个整数
* @param b 第二个整数
* @return 一个数组, 有4个元素, 分别表示: 加减乘除结果.
*/
public static int[] calculate(int a, int b) {
//2.分别获取这两个整数的加减乘除的运算结果, 然后返回.
int[] arr = new int[4];
arr[0] = a + b;
arr[1] = a - b;
arr[2] = a * b;
arr[3] = a / b;
return arr;
}
}
运行结果为:
加: 13
减: 7
乘: 30
除: 3
7. 方法重载
7.1 概述
同一个类中, 出现方法名相同, 但是参数列表不同的两个或以上的方法时称为方法重载. 方法重载与方法的返回值的数据类型无关.
注意: 参数列表不同分为两种情况
- 参数的个数不同.
- 对应参数的数据类型不同.
7.2 示例代码
• 正确示例
public class MethodDemo01 {
public static void fn(int a) { //function
//方法体
}
public static int fn(double a) {
//方法体
}
}
public class MethodDemo02 {
public static float fn(int a) {
//方法体
}
public static int fn(int a , int b) {
//方法体
}
}
7.3 案例: 判断数据是否相等
需求
- 定义方法compare(), 用来比较两个整型数据是否相等.
- 要求兼容所有的整数类型, 即(byte, short, int, long)
参考代码
public class MethodDemo01 {
public static void main(String[] args) {
//定义不同数据类型的变量
byte a = 10;
byte b = 20;
short c = 10;
short d = 20;
int e = 10;
int f = 10;
long g = 10;
long h = 20;
// 调用
System.out.println(compare(a, b));
System.out.println(compare(c, d));
System.out.println(compare(e, f));
System.out.println(compare(g, h));
}
// 两个byte类型的
public static boolean compare(byte a, byte b) {
System.out.println("byte");
return a == b;
}
// 两个short类型的
public static boolean compare(short a, short b) {
System.out.println("short");
return a == b;
}
// 两个int类型的
public static boolean compare(int a, int b) {
System.out.println("int");
return a == b;
}
// 两个long类型的
public static boolean compare(long a, long b) {
System.out.println("long");
return a == b;
}
}
运行结果为:
byte
false
short
false
int
true
long
false
8. 参数传递问题
8.1 概述
- 如果方法有参数列表, 则我们在调用该方法时, 需要传入指定的参数. 例如:
- 方法有两个整型参数, 则我们在调用方法时就得传入两个int类型的值.
- 方法有一个double类型的参数, 则我们在调用方法时就得传入一个double类型的值.
- 方法有一个String类型的参数, 则我们在调用方法时就得传入一个字符串值.
解释:
- 定义方法时，参数列表中的变量，我们称为形式参数.
- 调用方法时，传入给方法的数值，我们称为实际参数.
8.2 形参是基本类型
观察下述代码, 打印结果是什么呢?
public class MethodDemo02 {
public static void main(String[] args) {
int number = 100;
System.out.println("调用change方法前：" + number);
change(number); //实参.
System.out.println("调用change方法后：" + number);
}
public static void change(int number) { //形参.
number = 200;
}
}
运行结果为:
调用change方法前：100
调用change方法后：100
==记忆: 基本类型作为参数时, 形参的改变对实参没有任何影响. ==
8.3 形参是引用类型
观察下述代码, 打印结果是什么呢?
public class MethodDemo03 {
public static void main(String[] args) {
int[] arr = {10, 20, 30};
System.out.println("调用change方法前：" + arr[1]);
change(arr);
System.out.println("调用change方法后：" + arr[1]);
}
public static void change(int[] arr) {
arr[1] = 200;
}
}
运行结果为:
调用change方法前：20
调用change方法后：200
记忆: 引用类型作为参数时, 形参的改变直接影响实参.
8.4 结论
- 基本类型作为形参时, 传递的是数值, 所以形参的改变对实参没有任何影响.
- 引用类型作为形参时, 传递的是地址值, 所以形参的改变直接影响实参.
注意: String类型除外, 它当做形参时, 用法和基本类型一样, 传递的是数值(规定).
9. 案例: 遍历数组
需求
- 定义方法printArray(), 该方法用来打印数组.
- 打印格式为: [11, 22, 33, 44, 55]
参考代码
public class MethodDemo04 {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + (i == arr.length - 1 ? "]\r\n" : ", "));
}
}
}
运行结果为:
[11, 22, 33, 44, 55]
10.作业
- 通过键盘录入的方式输入星期数(1-7的整数)，显示今天的减肥活动，使用switch和if两种判断语句分别完成。
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿
代码:
//if版：
public class Test01 {
public static void main(String[] args) {
//键盘录入一个星期数，用一个变量接收
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数：");
int week = sc.nextInt();
//对星期数进行判断，这里用 if 语句实现
if (week < 1 || week > 7) {
System.out.println("你输入的星期数有误");
} else if (week == 1) {
System.out.println("跑步");
} else if (week == 2) {
System.out.println("游泳");
} else if (week == 3) {
System.out.println("慢走");
} else if (week == 4) {
System.out.println("动感单车");
} else if (week == 5) {
System.out.println("拳击");
} else if (week == 6) {
System.out.println("爬山");
} else {
System.out.println("好好吃一顿");
}
}
}
//switch版：
public class Test02 {
public static void main(String[] args) {
//键盘录入一个星期数，用一个变量接收
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数：");
int week = sc.nextInt();
//对星期数进行判断，这里用 switch 语句实现
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("你输入的星期数有误");
}
}
}
- 朋友聚会的时候可能会玩一个游戏：逢七过。
规则是：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。
为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过规则的数据。
这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。
步骤:
1:数据在1-100之间，用for循环实现数据的获取。
2:根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除。
3:在控制台输出满足规则的数据。
代码:
public class Test03 {
public static void main(String[] args) {
//数据在1-100之间，用for循环实现数据的获取
for(int x=1; x<=100; x++) {
//根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
if(x%10==7 || x/10%10==7 || x%7==0) {
//在控制台输出满足规则的数据
System.out.println(x);
}
}
}
}
- 有一个很有名的数学逻辑题叫做不死神兔问题。有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
步骤
1:为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20。
2:因为第1个月，第2个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素值也都是1。
3:用循环实现计算每个月的兔子对数。
4:输出数组中最后一个元素的值，就是第20个月的兔子对数。
代码:
public class Test04 {
public static void main(String[] args) {
//为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
int[] arr = new int[20];
//因为第1个月，第2个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素值也都是1
arr[0] = 1;
arr[1] = 1;
//用循环实现计算每个月的兔子对数
for(int x=2; x<arr.length; x++) {
arr[x] = arr[x-2] + arr[x-1];
}
//输出数组中最后一个元素的值，就是第20个月的兔子对数
System.out.println("第二十个月兔子的对数是：" + arr[19]);
}
}
- 我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。
百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
步骤
1:第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20。
2:第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0，判断条件是y<=33。
3:这个时候，用于表示鸡雏的变量 z = 100 – x – y。
4:判断表达式 z%3==0 和表达式 5x + 3y + z/3 = 100 是否同时成立，如果成立，输出对应的 x，y，z 的值，
就是对应的鸡翁，鸡母，鸡雏的值。
代码:
public class Test05 {
public static void main(String[] args) {
//第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20
for(int x=0; x<=20; x++) {
//第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0，判断条件是y<=33
for(int y=0; y<=33; y++) {
//这个时候，用于表示鸡雏的变量 z = 100 – x – y
int z = 100 - x - y;
//判断表达式 z%3==0 和表达式 5*x + 3*y + z/3 = 100 是否同时成立
if(z%3==0 && 5*x+3*y+z/3==100) {
System.out.println(x+","+y+","+z);
}
}
}
}
}
- 有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和，
要求是：求和的元素个位和十位都不能是7，并且只能是偶数。
步骤
1:定义一个数组，用静态初始化完成数组元素的初始化。
2:定义一个求和变量，初始值是0。
3:遍历数组，获取到数组中的每一个元素。
4:判断该元素是否满足条件，如果满足条件就累加。
5:输出求和变量的值。
代码:
public class Test06 {
public static void main(String[] args) {
//定义一个数组，用静态初始化完成数组元素的初始化
int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};
//定义一个求和变量，初始值是0
int sum = 0;
//遍历数组，获取到数组中的每一个元素
for(int x=0; x<arr.length; x++) {
//判断该元素是否满足条件，如果满足条件就累加
if(arr[x]%10!=7 && arr[x]/10%10!=7 && arr[x]%2==0) {
sum += arr[x];
}
}
//输出求和变量的值
System.out.println("sum:" + sum);
}
}
- 设计一个方法，用于比较两个数组的内容是否相同。
步骤
1:定义两个数组，分别使用静态初始化完成数组元素的初始化。
2:定义一个方法，用于比较两个数组的内容是否相同。
3:比较两个数组的内容是否相同，按照下面的步骤实现就可以了。
3.1.首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false。
3.2.其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false。
3.3.最后循环遍历结束后，返回true。
4:调用方法，用变量接收。
5:输出结果。
代码:
public class Test07 {
public static void main(String[] args) {
//定义两个数组，分别使用静态初始化完成数组元素的初始化
int[] arr = {11, 22, 33, 44, 55};
//int[] arr2 = {11, 22, 33, 44, 55};
int[] arr2 = {11, 22, 33, 44, 5};
//调用方法，用变量接收
boolean flag = compare(arr,arr2);
//输出结果
System.out.println(flag);
}
//定义一个方法，用于比较两个数组的内容是否相同
public static boolean compare(int[] arr, int[] arr2) {
//首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false
if(arr.length != arr2.length) {
return false;
}
//其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
for(int x=0; x<arr.length; x++) {
if(arr[x] != arr2[x]) {
return false;
}
}
//最后循环遍历结束后，返回true
return true;
}
}
- 已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据。定义一个方法，完成查找该数据在数组中的索引，并在控制台输出找到的索引值。
步骤
1:定义一个数组，用静态初始化完成数组元素的初始化。
2:键盘录入要查找的数据，用一个变量接收。
3:定义一个索引变量，初始值为-1。
4:遍历数组，获取到数组中的每一个元素。
5:拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量,并结束循环。
6:输出索引变量。
代码:
public class Test08 {
public static void main(String[] args) {
//定义一个数组，用静态初始化完成数组元素的初始化
int[] arr = {19, 28, 37, 46, 50};
//键盘录入要查找的数据，用一个变量接收
Scanner sc = new Scanner(System.in);
System.out.println("请输入要查找的数据：");
int number = sc.nextInt();
//调用方法
int index = getIndex(arr, number);
//输出索引变量
System.out.println("index: " + index);
}
//查找指定的数据在数组中的索引
public static int getIndex(int[] arr, int number) {
//定义一个索引变量，初始值为-1
int index = -1;
//遍历数组，获取到数组中的每一个元素
for(int x=0; x<arr.length; x++) {
//拿number和数组中的每一个元素进行比较
//如果值相同，就把该值对应的索引赋值给索引变量,并结束循环
if(arr[x] == number) {
index = x;
break;
}
}
//返回索引
return index;
}
}
- 已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值反转(在原数组中操作，不能定义第二个数组)，反转后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出反转后的数组元素。
步骤
1:定义一个数组，用静态初始化完成数组元素的初始化。
2:循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引。
3:使用第三个临时变量，完成数组中两个元素的交换。
4:遍历数组。
代码:
public class Test09 {
public static void main(String[] args) {
//定义一个数组，用静态初始化完成数组元素的初始化
int[] arr = {19, 28, 37, 46, 50};
//调用反转的方法
reverse(arr);
//遍历数组
printArray(arr);
}
//定义反转方法
public static void reverse(int[] arr) {
//循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
//变量交换
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
//定义用于打印数组的方法
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x] + ", ");
}
}
System.out.println("]");
}
}
- 在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
步骤
1:定义一个数组，用动态初始化完成数组元素的初始化，长度为6。
2:键盘录入评委分数。
3:由于是6个评委打分，所以，接收评委分数的操作，用循环改进。
4:定义方法实现获取数组中的最高分(数组最大值)，调用方法。
5:定义方法实现获取数组中的最低分(数组最小值) ，调用方法。
6:定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法。
7:按照计算规则进行计算得到平均分。
8:输出平均分。
代码:
public class Test10 {
public static void main(String[] args) {
//定义一个数组，用动态初始化完成数组元素的初始化，长度为6
int[] arr = new int[6];
//键盘录入评委分数
Scanner sc = new Scanner(System.in);
//由于是6个评委打分，所以，接收评委分数的操作，用循环改进
for(int x=0; x<arr.length; x++) {
System.out.println("请输入第" + (x + 1) + "个评委的打分：");
arr[x] = sc.nextInt();
}
//调用方法获取数组中的最高分
int max = getMax(arr);
//调用方法获取数组中的最低分
int min = getMin(arr);
//调用方法获取数组中的所有元素的和
int sum = getSum(arr);
//按照计算规则进行计算得到平均分
int avg = (sum - max - min) / (arr.length - 2);
//输出平均分
System.out.println("选手的最终得分是：" + avg);
}
//定义求和方法
public static int getSum(int[] arr) {
int sum = 0;
for(int x=0; x<arr.length; x++) {
sum += arr[x];
}
return sum;
}
//定义求最小值方法
public static int getMin(int[] arr) {
int min = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] < min) {
min = arr[x];
}
}
return min;
}
//定义求最大值方法
public static int getMax(int[] arr) {
int max = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
return max;
}
//定义遍历数组方法
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x] + ", ");
}
}
System.out.println("]");
}
}
464
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
