Java基础教程-04-方法

最新推荐文章于 2023-11-02 16:17:49 发布
最新推荐文章于 2023-11-02 16:17:49 发布
阅读量686 收藏 3
点赞数
分类专栏： java基础 java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kc44601/article/details/123959704
版权

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 注意事项

  1. 方法与方法之间是平级关系, 不能嵌套定义.
  2. 方法必须先创建才可以使用, 该过程称为: 方法定义.
  3. 方法自身不会直接运行, 而是需要我们手动调用方法后, 它才会执行, 该过程称为方法调用.
  4. 方法的功能越单一越好.
  5. 定义方法的时候写在参数列表中的参数, 都是: 形参.
    形参: 形容调用方法的时候, 需要传入什么类型的参数.
  6. 调用方法的时候, 传入的具体的值(变量或者常量都可以), 叫实参.
    实参: 调用方法时, 实际参与运算的数据.

2. 无参无返回值的方法

2.1 定义无参无返回值的方法

定义方法时, 要做到三个明确, 这样定义方法就会变得非常简单了:

  1. 明确方法名, 即: 方法名要符合小驼峰命名法, 且要见名知意, 方便我们调用.
  2. 明确方法的参数列表. 即: 调用方法时, 我们需要给它(方法)什么数据.
  3. 明确方法的返回值类型, 即: 调用方法完毕后, 方法会返回给我们一个什么类型的数据.

具体格式

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);	//注意: 参数的个数, 以及对应的参数类型都要和定义方法的参数列表保持一致.

需求

  1. 定义方法isEvenNumber(), 该方法接收一个int类型的整数num.
  2. 判断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 示例一: 定义求和方法

需求

  1. 定义方法getSum(), 该方法内部有两个int类型的整数.
  2. 获取上述两个整数的和, 并返回.
  3. 在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 示例二: 判断奇偶数

需求

  1. 定义方法isEvenNumber(), 该方法内部有一个整数num.
  2. 判断num是奇数还是偶数, 并返回结果.
  3. 在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 示例一: 定义求和方法

需求

  1. 定义方法getSum(), 接收两个int类型的整数.
  2. 获取上述两个整数的和, 并返回.
  3. 在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 示例二: 判断奇偶数

需求

  1. 定义方法isEvenNumber(), 该方法接收一个int类型的整数num.
  2. 判断num是奇数还是偶数, 并返回结果.
  3. 在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 实例三: 获取最大值

需求

  1. 定义方法getMax(), 该方法接收两个整数.
  2. 通过该方法, 获取两个整数的最大值, 并返回.
  3. 在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 案例一: 遍历数组

需求

  1. 定义方法printArray(), 接收一个int类型的数组.
  2. 通过该方法, 实现遍历数组的功能.
  3. 在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 案例二: 获取数组最值

需求

  1. 定义方法getMax(), 接收一个int类型的数组.
  2. 通过该方法, 获取数组元素中的最大值.
  3. 在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 案例三: 模拟计算器

需求

  1. 定义方法, 接收两个int类型的整数.
  2. 分别获取这两个整数的加减乘除的运算结果, 然后返回.
  3. 在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 概述

同一个类中, 出现方法名相同, 但是参数列表不同的两个或以上的方法时称为方法重载. 方法重载与方法的返回值的数据类型无关.
注意: 参数列表不同分为两种情况

  1. 参数的个数不同.
  2. 对应参数的数据类型不同.

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 案例: 判断数据是否相等

需求

  1. 定义方法compare(), 用来比较两个整型数据是否相等.
  2. 要求兼容所有的整数类型, 即(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类型的参数, 则我们在调用方法时就得传入一个字符串值.

解释:

  1. 定义方法时，参数列表中的变量，我们称为形式参数.
  2. 调用方法时，传入给方法的数值，我们称为实际参数.

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 结论

  1. 基本类型作为形参时, 传递的是数值, 所以形参的改变对实参没有任何影响.
  2. 引用类型作为形参时, 传递的是地址值, 所以形参的改变直接影响实参.

注意: String类型除外, 它当做形参时, 用法和基本类型一样, 传递的是数值(规定).

9. 案例: 遍历数组

需求

  1. 定义方法printArray(), 该方法用来打印数组.
  2. 打印格式为: [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. 通过键盘录入的方式输入星期数(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("你输入的星期数有误");
        }
    }
}
  1. 朋友聚会的时候可能会玩一个游戏：逢七过。
    ​ 规则是：从任意一个数字开始报数，当你要报的数字包含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);
            }
        }
    }
}
  1. 有一个很有名的数学逻辑题叫做不死神兔问题。有一对兔子，从出生后第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:第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);
                }
            }
        }
    }
}
  1. 有这样的一个数组，元素是{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. 设计一个方法，用于比较两个数组的内容是否相同。

步骤

​ 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;
    }
}
  1. 已知一个数组 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;
    }
}
  1. 已知一个数组 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("]");
    }
}
  1. 在编程竞赛中，有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("]");
    }
}
落空空。
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java】输入两个数字，计算其加减乘除
choulongpiao9663的博客
04-04 4872
import java.util.Scanner; public class Test01 { public static void main(String[] args) { System.out.println("输入"); Scann...
java基础教程----精华版
09-22
这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**： - **变量**：在Java中，变量是存储...
C# 函数返回多个值的方法
猫敷雪
09-27 6279
值元组，在 .NET Framework 4.7 中引入，是元组类型，用于在 C# 中提供元组的运行时实现。像元组类一样，我们可以使用它以更有效的方式从方法中返回多个值。使用 C# 提供的一些其他功能，我们可以将多个值返回给调用者方法。在这里，想法是返回一个包含我们想要返回的所有字段的类的实例。以下代码示例从使用 struct 的方法返回多个值。下面的例子演示了使用 out 参数从方法返回多个值。下面的示例使用类型推断来解构该方法返回的 2 元组。这就是从 C# 中的方法返回多个值的全部内容。
Java中类与类的关系
Twin_Mirror的博客
10-17 410
Java中类与类的关系：依赖关系、关联关系、继承关系、实现关系（本质也是继承关系） 依赖关系（(use-a）：类A使用到类B中；关系特点：关系脆弱，表现出偶然性与临时性，且类B的变化会直接影响到类A。 A类依赖B类：即B类的对象作为A类的方法参数存在。当且仅当A类调用到含有B类对象作为A类中方法的参数时，B类对象才被临时创建。方法执行结束，临时创建的B类对象立即被回收。（即关系破裂，有点过河拆桥的
Java语言——计算两个数的和差积商
最新发布
weixin_57525135的博客
11-02 636
计算两个数的和差积商后将结果返回。注意乘法和除法中不能有任何一个参与计算的数为0
Java实现两个整数的加减乘除运算
flower1q84的博客
09-20 5297
import java.util.Scanner; public class CountScore { public static void main(String[] args) { // TODO Auto-generated method stub Scanner input=new Scanner(System.in); System.out.println("请输入你要计算的整数："); int a=input.nextInt(); int b=input.nex.
Java程序设计基础教程-课程标准.docx
12-16
Java程序设计基础教程-课程标准 本课程标准为《Java程序设计基础教程》，隶属计算机网络技术专业，课程代码为xxxx，总学时为72学时。该课程旨在培养学生的Java编程技术，掌握Java程序设计的基本技术语法，了解Java...
Java程序设计基础教程-期末试卷B卷.docx
12-16
本资源是 Java 程序设计基础教程的期末试卷 B 卷，涵盖了 Java 程序设计的基础知识点，包括变量、运算符、控制流程、方法、数组、类和对象、继承、多态、接口、异常处理等。 变量和数据类型 * 变量的声明和赋值 * ...
Java基础教程--Good.pdf
03-05
非常基础的一本Java教程，适合Java初学者阅读学习，也适合自学使用。
Java基础教程-1
12-08
适合零基础新人的学习，从基础教起，自我实践，确认有效.
【Java设计模式】简单学解释器模式——加减乘除
winrh的博客
07-29 2037
目录 说明 实现方式 应用场景 其他链接 说明 行为型模式之一，其他还有命令模式、模板方法模式、访问者模式、观察者模式、中介者模式、备忘录模式、迭代器模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式) 解释器模式（Interpreter Pattern）：给定一个语言(表达式)，定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子(表达式) 使用解释器可能带来的问题：解释器模式会引起类膨胀、解释器模式采用递归调用方法，将会导致调.
JAVA简单计算器（简单实现两数加减乘除）
NUT_Prince的博客
01-19 3591
今日的小练习为用户输入两个数，简易实现两数的加减乘除并可重复使用。 实现这个小功能有了大概的思路其实还好，但是我却没有止步于此，为了提升用户的体验性，保证这个小程序的容错率，我花了很长时间去模拟用户错误输入各种情况时去如何保证程序的健壮性。
Java编程实现：写一个方法add，两个整数作为参数，返回这两个整数的和
Chlin.Rei的博客
06-22 4008
Java编程实现：写一个方法add，两个整数作为参数，返回这两个整数的和
java实验（3）Java中类的继承及其应用
m0_60472361的博客
01-09 1345
4、设计一个圆类Circle，具有属性：圆心坐标x和y及圆半径r，除具有设置及获取属性的方法外，还具有计算周长的方法perimeter()和计算面积的方法area()。再设计一个圆柱体类Cylinder，Cylinder继承自Circle，增加了属性：高度h，增加了设置和获取h的方法、计算表面积的方法area()和计算体积的方法volume()。(4)声明测试类，生成2个Student类、1个StudentXW类及1个StudentBZ类对象，并分别计算它们的评测成绩，以及互相进行总成绩的对比。
java中的函数_Java语法基础之函数的使用说明
weixin_32327615的博客
02-12 219
函数四个方面：函数的定义函数的特点函数的应用函数的重载一、函数的定义及特点1) 什么是函数？函数就是定义在类中的具有特定功能的一段独立小程序，函数也称为方法2)Java中函数的格式：修饰符 返回值类型函数名(参数类型 形式参数1，参数类型 形式参数2，。。)｛ 执行语句;return 返回值；｝返回值类型：函数运行后的结果的数据类型参数类型：是形式参数的数据类型形式参数：是一个变量，用于存储调用...
JAVA实验二
qq_45743814的博客
03-26 1666
JAVA实验二 实验二一共10题，附上题目及完整代码。 7187 题目內容: 创建一个立方体类，类中有3个成员变量：长、宽、高，共有两个功能方法，一个是setDemo(int x,int y,int z)，为长宽高赋值；另一个实现计算体积的功能，编写主类，在主方法中，创建一个立方体类的对象，从键盘输入其成员变量，求该立方体对象的体积，结果显示在屏幕上。 输入输出说明: 输入：1 2 3 输出：体积=6 代码编辑: 在这里插入代码片 import java.util.Scanner; class Cube{.
Java实现简单计算器（只支持两个数之间的加减乘除）
u014264466的博客
06-27 1083
Java简单计算器
java方法返回int报错_java方法返回值问题
weixin_32239523的博客
02-13 586
public boolean Find(int target, int[][] array) {//如果array.length小于等于0,跳过for循环,goto label_1，此时该方法无返回值for (int i = 0; i < array.length; i++) {//如果每一个array[i].length都小于等于0，第二个循环始终没有执行，goto label_2for ...
java方法返回int报错_java方法返回值错误
weixin_31061573的博客
02-13 878
做判定素数的代码时，编译出错，返回值必须为int，以下为具体代码，大神们看看为何错误：packageLearnJava;importjava.util.*;publicclass判定素数{/***@paramargs*/publicstaticvoid...做判定素数的代码时，编译出错，返回值必须为int，以下为具体代码，大神们看看为何错误：package LearnJava;import jav...
2022年java入门教程-类的方法.ppt
11-02
2022年的Java入门教程-类的方法.ppt分享了关于Java编程中类的方法的内容。该课程的第三章主要介绍了方法的控制流程、异常处理简介以及方法的重载。通过这个教程，学习者可以全面了解并掌握Java语言中类的方法。 第...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值