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;
    }
}

运行结果为:

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]);
        }
    }
}

运行结果为:

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;
    }
}

运行结果为:

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("]");
    }
}