方 法

已于 2024-06-18 21:44:38 修改
阅读量303 收藏 3
点赞数 6
分类专栏： Java 文章标签： Java
于 2024-06-16 14:19:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chengkai730/article/details/139719816
版权

方法的定义

方法是程序中最小的执行单元。

main() 方法也叫主方法。

方法的定义的位置可以在调用的位置的上面或下面，位置无所谓，只要定义了这个方法，这个方法就能被调用。

方法的定义要写在 main() 的外面，类的里面。main() 也是方法，方法不能嵌套定义。

方法的编写顺序和执行顺序无关，执行顺序要根据调用顺序来看。

方法名遵循驼峰法。

方法与方法之间是平级关系，不能嵌套定义。谁在前谁在后无所谓，但是为了程序的可读性，一般都是将 main() 方法放在第一个，表示程序的主入口。

不带返回值的方法，不要写 return 语句，如果写也行，但是只能是单独的一条 return 语句，后面不能跟别的内容，即 return;。

方法的定义的格式：

public static 返回值类型 方法名(参数) {
    方法体;
    return 返回值;
}

最简单的方法的定义和调用

public class MethodDemo1 {
    public static void main(String[] args) {
        greeting();
        System.out.println("++++++++++++++++++++++++++++");
        greeting();
    }

    public static void greeting() {
        System.out.println("Good Morning");
        System.out.println("Good Afternoon");
        System.out.println("Good Night");
    }
}

执行结果：

Good Morning
Good Afternoon
Good Night
++++++++++++++++++++++++++++
Good Morning
Good Afternoon
Good Night

程序示例：

public class method1 {
    public static void main(String[] args) {
        System.out.println("m");
        method1();
        System.out.println("n");
        method2();
        System.out.println("k");
    }

    public static void method1() {
        System.out.println("a");
        System.out.println("b");
        method2();
        System.out.println("u");
    }

    public static void method2() {
        System.out.println("d");
        System.out.println("c");
    }
}

执行结果：

m
a
b
d
c
u
n
d
c
k

程序示例：

public class method1 {
    public static void main(String[] args) {
        getSum();
    }

    public static void getSum() {
        int a = 10;
        int b = 20;
        System.out.println(a + b);
    }
}

执行结果：

30

带参数的方法

形参：形式参数，是方法定义中所用参数。

实参：实际参数，是方法调用中所用参数。

程序示例：

public class method1 {
    public static void main(String[] args) {
        getSum(10, 20);
    }

    public static void getSum(int a, int b) {
        System.out.println(a + b);
    }
}

执行结果：

30

传递参数允许自动类型转换，例如下面的程序涉及将 float 转换为 double 以及将 int 转换为 double。

public class method1 {
    public static void main(String[] args) {
        System.out.println(getSum(10.0F, 20));
    }

    public static double getSum(double a, double b) {
        return a + b;
    }
}

执行结果：

30.0

程序示例：

// 计算长方形的面积
import java.util.Scanner;

public class method1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("输入长方形的长：");
        int length = sc.nextInt();
        System.out.print("输入长方形的宽：");
        int weight = sc.nextInt();
        System.out.println("长方形的面积为" + getArea(length, weight));
    }

    public static int getArea(int a, int b) {
        return a * b;
    }
}

执行结果：

输入长方形的长：3
输入长方形的宽：4
长方形的面积为12

带返回值的方法

直接调用，不对返回值做任何处理：

方法名(实参);

赋值调用：

数据类型 变量 = 方法名(实参);

输出调用：

System.out.println(方法名(实参));

程序示例：

public class method1 {
    public static void main(String[] args) {
        System.out.println(getSum(10, 20));
    }

    public static int getSum(int a, int b) {
        return a + b;
    }
}

执行结果：

30

方法返回类型和实际 return 的计算结果的类型不同时，允许自动类型转换，即 return 的结果自动类型转换到方法定义中的指定类型，最终的返回值的类型以方法定义中指定的类型为准。

例如，下面的程序中，return 语句的结果为 int 类型，但是方法定义指定了返回类型为 double 类型，最终方法返回的类型为 double，因为将 int 自动转换为 double 了。

// 计算长方形的面积

import java.util.Scanner;

public class method1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("输入长方形的长：");
        int length = sc.nextInt();
        System.out.print("输入长方形的宽：");
        int weight = sc.nextInt();
        System.out.println("长方形的面积为" + getArea(length, weight));
    }

    public static double getArea(int a, int b) {
        return a * b;
    }
}

执行结果：

输入长方形的长：3
输入长方形的宽：4
长方形的面积为12.0

方法的重载

方法的重载：在同一个类中，定义了多个同名的方法，功能都相同或类似，但是形参列表不同，可以是类型不同或者是个数不同或者顺序不同，只要有一个不同就可以。

方法的重载与返回值无关。

构成重载的方法必须是同一个类中的，不同的类中的同名方法不构成重载。

不建议书写仅有形参顺序不同的重载函数。

程序示例：

// 需求：使用方法重载的思想，设计比较两个整数是否相同的方法。
// 要求：兼容全整数类型（byte,short,int,long）

public class method1 {
    public static void main(String[] args) {
        byte m1 = 1, n1 = 2;
        System.out.println(compare(m1, n1));
        short m2 = 1, n2 = 2;
        System.out.println(compare(m2, n2));
        int m3 = 1, n3 = 2;
        System.out.println(compare(m3, n3));
        long m4 = 1, n4 = 2;
        System.out.println(compare(m4, n4));
    }

    public static boolean compare(byte a, byte b) {
        System.out.println("调用byte类型方法");
        return a == b;
    }

    public static boolean compare(short a, short b) {
        System.out.println("调用short类型方法");
        return a == b;
    }

    public static boolean compare(int a, int b) {
        System.out.println("调用int类型方法");
        return a == b;
    }

    public static boolean compare(long a, long b) {
        System.out.println("调用long类型方法");
        return a == b;
    }
}

执行结果：

调用byte类型方法
false
调用short类型方法
false
调用int类型方法
false
调用long类型方法
false

程序示例：

// 需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]

public class Exercise1 {
    public static void main(String[] args) {
        int[] nums = {11, 22, 33, 44, 55};
        traverse(nums);
    }

    public static void traverse(int[] strings) {
        System.out.print("[");
        for (int i = 0; i < strings.length; i++) {
            if (i == strings.length - 1)
                System.out.print(strings[i]);
            else System.out.print(strings[i] + ", ");
        }
        System.out.println("]");
    }
}

执行结果：

[11, 22, 33, 44, 55]

程序示例：

// 需求：设计一个方法求数组的最大值，并将最大值返回

public class Exercise1 {
    public static void main(String[] args) {
        int[] nums = {11, 22, 33, 44, 55};
        System.out.println("数组最大值为 " + getMax(nums));
    }

    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            max = max > arr[i] ? max : arr[i];
        }
        return max;
    }
}

执行结果：

数组最大值为 55

程序示例：

// 定义一个方法判断数组中的某一个数是否存在，将结果返回

import java.util.Scanner;

public class Exercise1 {
    public static void main(String[] args) {
        int[] nums = {11, 22, 33, 44, 55};
        Scanner sc = new Scanner(System.in);
        System.out.print("输入要寻找的数：");
        int find = sc.nextInt();
        System.out.println("要寻找的数的索引为：" + getIndex(nums, find));
    }

    public static int getIndex(int[] arr, int n) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == n)
                return i;
        }
        return -1;
    }
}

执行结果：

输入要寻找的数：22
要寻找的数的索引为：1

程序示例：

// 需求：
// 功能：
// 定义一个方法 copyOfRange(int[] arr, int from, int to)
// 将数组 arr 中从索引 from（包含 from）开始，
// 到索引 to 结束（不包含to）的元素复制到新数组中，
// 将新数组返回。

import java.util.Scanner;

public class Exercise1 {
    public static void main(String[] args) {
        int[] nums = {0, 11, 22, 33, 44, 55, 66, 77, 88, 99};
        Scanner sc = new Scanner(System.in);
        System.out.print("输入要复制的起始索引：");
        int start = sc.nextInt();
        System.out.print("输入要复制的终止索引：");
        int end = sc.nextInt();
        int[] newNums = copyOfRange(nums, start, end);
        System.out.println("复制出来的数组为：");
        for (int i = 0; i < newNums.length; i++) {
            System.out.print(newNums[i] + "  ");
        }
    }

    public static int[] copyOfRange(int[] arr, int from, int to) {
        int[] newArr = new int[to - from];
        for (int i = 0, j = from; i < newArr.length; i++, j++) {
            newArr[i] = arr[j];
        }
        return newArr;
    }
}

执行结果：

输入要复制的起始索引：1
输入要复制的终止索引：6
复制出来的数组为：
11  22  33  44  55

方法占用的内存分析

每一个软件在运行时都要占用内存，JVM 也是如此，为了更好地利用内存，JVM 将内存进行分块。

方法刚开始执行时要进栈，执行完了后立刻出栈。栈的特点：先进后出。

引用数据类型的变量，存储的是地址值。引用指的是使用了其他空间的数据。

基本数据类型的值是存储在自己的空间当中的。

基本数据类型的变量都是在栈中，引用数据类型的变量的实际内容是在堆中。

传递基本数据类型时，传递的是真实的数据，形参的改变不会影响实参，除非用返回值的形式修改原来的值。

程序示例：

// 值传递

public class Exercise1 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println(number);    // 100
        change(number);
        System.out.println(number);    // 100
    }

    public static void change(int number) {
        number = 200;
    }
}

传递引用数据类型时，传递的是地址值，形参的改变会影响实参的值。

程序示例：

// 引用传递

public class Exercise1 {
    public static void main(String[] args) {
        int[] number = {100, 200, 300};
        System.out.println(number[0]);    // 100
        change(number);
        System.out.println(number[0]);    // 200
    }

    public static void change(int[] number) {
        number[0] = 200;
    }
}

练习

练习题 1

// 需求：
// 机票价格按照淡季旺季、头等舱和经济舱收费，输入机票原价、月份和头等舱或经济舱。
// 按照如下规则计算机票价格：旺季（5-10月）头等舱 9 折，经齐舱 8.5 折，淡季（11 月到来年 4 月）头等舱 7 折，经济舱 6.5 折。

import java.util.Scanner;

public class Exercise2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入机票原价：");
        int original_Price = sc.nextInt();
        System.out.print("请输入月份：");
        int month = sc.nextInt();
        System.out.print("请输入是头等舱还是经济舱：");
        String seat = sc.next();
        double discounted_Price;
        if (month >= 5 && month <= 10) {
            if (seat.equals("头等舱"))
                discounted_Price = 0.9 * original_Price;
            else discounted_Price = 0.85 * original_Price;
        } else {
            if (seat.equals("头等舱"))
                discounted_Price = 0.7 * original_Price;
            else discounted_Price = 0.65 * original_Price;
        }
        System.out.println("机票的折扣价为：" + discounted_Price);
    }
}

执行结果：

请输入机票原价：100
请输入月份：4
请输入是头等舱还是经济舱：头等舱
机票的折扣价为：70.0

改写代码：

// 需求：
// 机票价格按照淡季旺季、头等舱和经济舱收费，输入机票原价、月份和头等舱或经济舱。
// 按照如下规则计算机票价格：旺季（5-10月）头等舱 9 折，经齐舱 8.5 折，淡季（11 月到来年 4 月）头等舱 7 折，经济舱 6.5 折。

import java.util.Scanner;

public class Exercise2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入机票原价：");
        int original_Price = sc.nextInt();
        System.out.print("请输入月份：");
        int month = sc.nextInt();
        System.out.print("请输入是头等舱还是经济舱：");
        String seat = sc.next();
        double discounted_Price;
        if (month >= 5 && month <= 10) {
            discounted_Price = getDiscounted_price(original_Price, seat, 0.9, 0.85);
        } else {
            discounted_Price = getDiscounted_price(original_Price, seat, 0.7, 0.65);
        }
        System.out.println("机票的折扣价为：" + discounted_Price);
    }

    private static double getDiscounted_price(int original_Price, String seat, double v1, double v2) {
        double discounted_Price;
        if (seat.equals("头等舱"))
            discounted_Price = v1 * original_Price;
        else discounted_Price = v2 * original_Price;
        return discounted_Price;
    }
}

练习题 2

public class test2 {
    // 需求：判断 101 - 200 之间有多少个素数，并输出所有的素数
    public static void main(String[] args) {
        int count = 0;
        for (int i = 101; i <= 200; i++) {
            boolean flag = true;
            for (int j = 2; j * j <= i; j++) {
                if (i % j == 0) {
                    flag = false;
                    break;
                }
            }
            if (flag == true) {
                System.out.println(i);
                ++count;
            }
        }
        System.out.println(count);
    }
}

执行结果：

101
103
107
109
113
127
131
137
139
149
151
157
163
167
173
179
181
191
193
197
199
21

优化的代码：

public class test2 {
    // 需求：判断 101 - 200 之间有多少个素数，并输出所有的素数
    public static void main(String[] args) {
        int start = 101;
        int end = 200;
        int count = 0;
        System.out.println("从" + start + "到" + end + "的所有素数为：");
        for (int i = start; i <= end; i++) {
            if (isPrime(i)) {
                ++count;
                System.out.print(i + " ");
            }
        }
        System.out.println("\n从" + start + "到" + end + "有" + count + "个素数。");
    }

    public static boolean isPrime(int num) {
        for (int i = 2; i * i <= num; i++)
            if (num % i == 0)
                return false;
        return true;
    }
}

执行结果：

从101到200的所有素数为：
101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 
从101到200有21个素数。

练习题 3

// 需求：
// 定义方法实现随机产生一个 5 位的验证码
// 验证码格式：
// 长度为 5
// 前四位是大写字母或者小写字母
// 最后一位是数字

import java.util.Random;

public class Exercise2 {
    public static void main(String[] args) {
        char[] arr = new char[52];
        for (int i = 0; i < 26; i++)
            arr[i] = (char) ('a' + i);
        for (int i = 26; i < 52; i++)
            arr[i] = (char) ('A' + i - 26);
        char[] nums = new char[10];
        for (int i = 0; i < 10; i++)
            nums[i] = (char) (i + '0');         // 将数字转为字符
        Random r = new Random();
        char[] verificationCode = new char[5];  // 用字符数组存储验证码
        for (int i = 0; i <= 3; i++)
            verificationCode[i] = arr[r.nextInt(arr.length)];
        verificationCode[4] = nums[r.nextInt(nums.length)];
        System.out.println(verificationCode);  // 字符数组用这个方式打印，结果是数组内容，而不是地址，别的类型的数组，用这个方式打印，将显示地址
    }
}

执行结果：

OiKA1

改写代码，用字符串存储验证码：

// 需求：
// 定义方法实现随机产生一个 5 位的验证码
// 验证码格式：
// 长度为 5
// 前四位是大写字母或者小写字母
// 最后一位是数字

import java.util.Random;

public class Exercise2 {
    public static void main(String[] args) {
        char[] arr = new char[52];
        for (int i = 0; i < 26; i++)
            arr[i] = (char) ('a' + i);
        for (int i = 26; i < 52; i++)
            arr[i] = (char) ('A' + i - 26);
        Random r = new Random();
        String verificationCode = "";                           // 用字符串存储验证码
        for (int i = 0; i <= 3; i++)
            verificationCode += arr[r.nextInt(arr.length)];     // 字符串拼接
        verificationCode += r.nextInt(10);                      // 数字拼接到字符串
        System.out.println(verificationCode);
    }
}

练习题 4

// 需求：把一个数组中的元素复制到另一个新数组中去。

public class Exercise2 {
    public static void main(String[] args) {
        // 老数组
        int[] nums = {1, 2, 3, 4, 5};
        System.out.println("老数组：");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }
        int[] newNums = new int[nums.length];
        for (int i = 0; i < newNums.length; i++) {
            newNums[i] = nums[i];
        }
        System.out.println("\n新数组：");
        for (int i = 0; i < newNums.length; i++) {
            System.out.print(newNums[i] + "\t");
        }
    }
}

执行结果：

老数组：
1        2        3        4        5        
新数组：
1        2        3        4        5

练习题 5

// 需求：在唱歌比赛中，有 6 名评委给选手打分，分数范围是 [0-100] 之间的整数。选手的最后得分为：去掉最高分、最低分后的 4 个评委的平均分，请完成上述过程并计算出选手的得分。

import java.util.Scanner;

public class Exercise2 {
    public static void main(String[] args) {
        int[] scores = creatScores();
        int max = getMax(scores);
        int min = getMin(scores);
        int sum = getSum(scores);
        int avg = (sum - max - min) / (scores.length - 2);
        System.out.println("选手的得分为：" + avg);
    }

    public static int[] creatScores() {
        Scanner sc = new Scanner(System.in);
        int[] scores = new int[6];
        for (int i = 0; i < scores.length; ) {
            System.out.print("请输入评委打分：");
            int score = sc.nextInt();
            if (score >= 0 && score <= 100) {
                scores[i] = score;
                ++i;
            } else System.out.println("输入的分数不在范围内，请重新输入。");
        }
        return scores;
    }

    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++)
            max = max > arr[i] ? max : arr[i];
        return max;
    }

    public static int getMin(int[] arr) {
        int min = arr[0];
        for (int i = 0; i < arr.length; i++)
            min = min < arr[i] ? min : arr[i];
        return min;
    }

    public static int getSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
}

执行结果：

请输入评委打分：100
请输入评委打分：90
请输入评委打分：80
请输入评委打分：70
请输入评委打分：60
请输入评委打分：50
选手的得分为：75

练习题 6

// 需求：
// 某系统的数字密码（大于 0），比如 1983，采用加密方式进行传输。
// 规则如下：先得到每位数，然后每位数都加上 5 然后对 10 求余，最后将所有数字反转，得到一串新数。

import java.util.Scanner;

public class Exercise2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("输入原始密码：");
        int passwd = sc.nextInt();
        int n;
        int newPasswd = 0;
        while (passwd != 0) {
            n = passwd % 10;
            n=(n + 5)%10
            passwd /= 10;
            newPasswd = newPasswd * 10 + n;
        }
        System.out.println("新密码为：" + newPasswd);
    }
}

执行结果：

输入原始密码：1983
新密码为：8346

将上述加密过程进行解密：

[图片]

// 需求：将上述加密过程进行解密

import java.util.Scanner;

public class Exercise2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("输入新密码：");
        int newPasswd = sc.nextInt();
        int n;
        int passwd = 0;
        while (newPasswd != 0) {
            n = newPasswd % 10;
            newPasswd /= 10;
            if (n >= 0 & n <= 4)
                n += 10;
            n -= 5;
            passwd = passwd * 10 + n;
        }
        System.out.println("原始密码为：" + passwd);
    }
}

执行结果：

输入新密码：8346
原始密码为：1983

练习题 7

// 需求：
// 一个大 V 直播抽奖，奖品是现金红包，分别有 {2, 588, 888, 1000, 10000} 五个奖金。请使用代码模拟抽奖，
// 打印出每个奖项，奖项的出现顺序要随机且不重复。打印效果如下：(随机顺序，不一定是下面的顺序)

import java.util.Random;

public class Exercise2 {
    public static void main(String[] args) {
        int[] arr = {2, 588, 888, 1000, 10000};         // 奖池
        int[] exist = new int[arr.length];              // 存储已经被抽走的奖项
        int existIndex = 0;
        Random r = new Random();
        for (int j = 0; j < arr.length; ) {
            int index = r.nextInt(arr.length);          // 生成一个随机索引
            int n = arr[index];                         // 随机抽到的奖项
            boolean in = false;
            for (int i = 0; i < exist.length; i++) {    // 检查该奖项是否已经被抽走
                if (exist[i] == n) {
                    in = true;
                    break;
                }
            }
            if (!in) {                                  // 该奖项仍存在于奖池中
                System.out.println(n + "元的奖金被抽出。");
                exist[existIndex++] = n;                // 将该奖项标记为已经抽走了
                ++j;                                    // 开始抽下一个奖
            }
        }
    }
}

执行结果：

888元的奖金被抽出。
1000元的奖金被抽出。
2元的奖金被抽出。
588元的奖金被抽出。
10000元的奖金被抽出。

优化的写法：

// 需求：
// 一个大 V 直播抽奖，奖品是现金红包，分别有 {2, 588, 888, 1000, 10000} 五个奖金。请使用代码模拟抽奖，
// 打印出每个奖项，奖项的出现顺序要随机且不重复。打印效果如下：(随机顺序，不一定是下面的顺序)

import java.util.Random;

public class Exercise2 {
    public static void main(String[] args) {
        int[] arr = {2, 588, 888, 1000, 10000};         // 奖池
        int[] exist = new int[arr.length];              // 存储已经被抽走的奖项
        Random r = new Random();
        for (int i = 0; i < arr.length; ) {
            int index = r.nextInt(arr.length);          // 生成一个随机索引
            int n = arr[index];                         // 随机抽到的奖项
            boolean in = isIn(exist, n);
            if (!in) {                                  // 该奖项仍存在于奖池中
                System.out.println(n + "元的奖金被抽出。");
                exist[i] = n;                           // 将该奖项标记为已经抽走了，exist的索引和arr相同即可。
                ++i;                                    // 开始抽下一个奖
            }
        }
    }

    // 判断一个数是否存在于一个数组中
    private static boolean isIn(int[] exist, int n) {
        for (int i = 0; i < exist.length; i++)          // 检查该奖项是否已经被抽走
            if (exist[i] == n)
                return true;
        return false;
    }
}

继续优化：只需要打乱原来的奖池即可。

代码：

// 需求：
// 一个大 V 直播抽奖，奖品是现金红包，分别有 {2, 588, 888, 1000, 10000} 五个奖金。请使用代码模拟抽奖，
// 打印出每个奖项，奖项的出现顺序要随机且不重复。打印效果如下：(随机顺序，不一定是下面的顺序)

import java.util.Random;

public class Exercise2 {
    public static void main(String[] args) {
        int[] prices = {2, 588, 888, 1000, 10000};
        Random r = new Random();
        for (int i = 0; i < prices.length; i++) {
            int index = r.nextInt(prices.length);
            int tmp = prices[i];
            prices[i] = prices[index];
            prices[index] = tmp;
        }
        for (int i = 0; i < prices.length; i++) {
            System.out.println(prices[i] + "元的奖金被抽出。");
        }
    }
}

练习题 8

投注号码由 6 个红色球号码和 1 个蓝色球号码组成。红色球号码从 1-33 中选择；蓝色球号码从 1-16 中选择。红色球之间不能重复，蓝色可以与红色相同。

[图片]

import java.util.Random;
import java.util.Scanner;

public class Exercise2 {
    public static void main(String[] args) {
        int[] winningNum = createNumbers();
        System.out.println("中奖号码为：");
        for (int i = 0; i < winningNum.length; i++) {
            System.out.print(winningNum[i] + "  ");
        }
        System.out.println();
        int[] buyNum = buy();
        System.out.println("顾客买的号码为：");
        for (int i = 0; i < buyNum.length; i++) {
            System.out.print(buyNum[i] + "  ");
        }
        int redCount = 0, blueCount = 0;
        for (int i = 0; i < winningNum.length - 1; i++) {
            for (int j = 0; j < buyNum.length - 1; j++) { // 这里不能直接调用isIn方法，因为蓝球号码可以和红球相同
                if (winningNum[i] == buyNum[j]) {
                    ++redCount;
                    break;
                }
            }
        }
        if (winningNum[6] == buyNum[6])
            ++blueCount;
        System.out.println("\n红球中了 " + redCount + " 个。");
        System.out.println("蓝球中了 " + blueCount + " 个。");

        // 输出中奖情况
        if (redCount == 6 && blueCount == 1)
            System.out.println("恭喜你，中了一等奖，奖金1000万。");
        else if (redCount == 6 && blueCount == 0)
            System.out.println("恭喜你，中了二等奖，奖金500万。");
        else if (redCount == 5 && blueCount == 1)
            System.out.println("恭喜你，中了三等奖，奖金3000元。");
        else if (redCount == 5 && blueCount == 0)
            System.out.println("恭喜你，中了四等奖，奖金200元。");
        else if (redCount == 4 && blueCount == 1)
            System.out.println("恭喜你，中了四等奖，奖金200元。");
        else if (redCount == 4 && blueCount == 0)
            System.out.println("恭喜你，中了五等奖，奖金10元。");
        else if (redCount == 3 && blueCount == 1)
            System.out.println("恭喜你，中了五等奖，奖金10元。");
        else if (redCount == 2 && blueCount == 1)
            System.out.println("恭喜你，中了六等奖，奖金5元。");
        else if (redCount == 1 && blueCount == 1)
            System.out.println("恭喜你，中了六等奖，奖金5元。");
        else if (redCount == 0 && blueCount == 1)
            System.out.println("恭喜你，中了六等奖，奖金5元。");
        else System.out.println("谢谢参与！！！");
    }

    // 中奖号码
    public static int[] createNumbers() {
        int[] arr = new int[7];
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            int redNum = r.nextInt(33) + 1;
            boolean isIn = isIn(arr, redNum);
            if (!isIn) {
                arr[i] = redNum;
                ++i;
            }
        }
        int blueNum = r.nextInt(16) + 1;
        arr[6] = blueNum;
        return arr;
    }

    // 顾客买的号码
    public static int[] buy() {
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[7];
        System.out.println("输入6个红球的号码：");
        for (int i = 0; i < 6; ) {
            System.out.print("输入第 " + (i + 1) + " 个红球的号码：");
            int redNum = sc.nextInt();
            if (redNum < 1 || redNum > 33)
                System.out.println("输入的球号错误，重新输入。");
            else {
                if (isIn(arr, redNum))
                    System.out.println("这个号码买重复了，重新输入。");
                else {
                    arr[i] = redNum;
                    ++i;
                }
            }
        }
        while (true) {
            System.out.print("输入蓝球的号码：");
            int blueNum = sc.nextInt();
            if (blueNum < 1 || blueNum > 16)
                System.out.println("输入错误，重新输入。");
            else {
                arr[6] = blueNum;
                break;
            }
        }
        return arr;
    }


    // 判断一个数是否在一个数组中
    public static boolean isIn(int[] arr, int val) {
        for (int i = 0; i < arr.length; i++)
            if (arr[i] == val)
                return true;
        return false;
    }
}

执行结果：

中奖号码为：
10  11  33  22  31  15  9  
输入6个红球的号码：
输入第 1 个红球的号码：10
输入第 2 个红球的号码：11
输入第 3 个红球的号码：22
输入第 4 个红球的号码：33
输入第 5 个红球的号码：31
输入第 6 个红球的号码：15
输入蓝球的号码：9
顾客买的号码为：
10  11  22  33  31  15  9  
红球中了 6 个。
蓝球中了 1 个。
恭喜你，中了一等奖，奖金1000万。
人间造梦工厂
关注
专栏目录
lisp方格网法计算土方量_CAD计算土方方量插件
weixin_33173924的博客
01-27 2550
CAD土方工程量算量插件是一款针对于AutoCAD所推出的土方计算辅助工具。通过使用这款CAD插件，就能帮助用户计算土方工程量算量，节省大量宝贵时间，提升工作效率，可适用于各种复杂地形情况以及场地实际要求的计算，还在等什么，赶紧试试吧！功能特点1、计算土方方法方格网法、三角网法、断面法等多种土石方量计算方法；2、Excel工程量报表输出勾选"自然标高"、"设计标高"、"施工高度"、"计算公式"、"...
中山大学 《 数 值 计 算 方 法 》 期 末 考 试 试 题
01-14
《 数 值 计 算 方 法 》 期 末 考 试 试 题 (A 卷 答案) 考试形式 ： 闭 卷 考 试时间： 2 小 时 一、填空题（25 空×1 分/空=25 分） 1 梯形求积公式为：ò + = - b a a f b f a f x dx b [ ( ) ( )] 2 ( ) 。 2...
幻方的填法
wzlzf3385的博客
06-12 6654
幻方简易填法
罗伯法奇数幻方
qq_41077239的博客
01-14 1215
罗伯法幻方（奇数）
方格的走法
烟波的程序世界
04-07 6994
[TOC]方格走法题目：m×n的方格，如下图所示，从方格的左下角A走到方格的右上角B，请求出所有的路径方法总和。解答：1*1方格的情况从左上角到右下角走法，总共有2种走法。即m=1，n=1 S(1,1)=22*2方格的情况从左上角到右下角走法，总共有6种走法。即m=2, n=2 S(2,2)=S(2,1)+S(1,2)=3+3=6m*n方格的情况从左上角到右下角走法，总共有S(m,n)种走法。
定义一个圆类——Circle，在类的内部提供一个属性：半径(r)，同时 提供 两个 方 法 ： 计算 面积 （ getArea() ） 和 计算 周长（getPerimeter()） 。 通过两个方法
热门推荐
qq_37736906的博客
07-20 1万+
package com.sxt;public class Circle { double r; public Circle(double r){ this.r=r; } public void getArea(){ double l=Math.PI*r*r; System.out.println(l+”的
基 于 已 知 点 的 作 物 行 检 测 方 法
04-05
基 于 已 知 点 的 作 物 行 检 测 方 法
一种基于 PXE 的快速批量安装操作系统的方 法
03-01
一种基于 PXE 的快速批量安装操作系统的方 法
一种高速缓冲存储器的可综合伪随机功 能 验 证 方 法
03-25
一种高速缓冲存储器的可综合伪随机功 能 验 证 方 法
基 于 知 识 图 谱 的 bug问 题 探 索 性 搜 索 方 法
03-01
基 于 知 识 图 谱 的 bug问 题 探 索 性 搜 索 方 法
智能锁（远程开锁、指纹开锁、密码开锁、刷卡开锁）
07-19
按键功能：输入密码，并能根据密码来决定开门还是进入管理员模式 密码功能：能够更换开门密码/管理员密码，且具有掉电不丢失功能 刷卡功能：能够判断卡片是否登记；刷卡开门；删除/登记开门卡片 指纹功能：指纹开门；删除/登记指纹 语音功能：播放不同功能的语言提示 门铃功能：机械开关控制门铃响 阿里云服务器接入：连接阿里云服务器，可以上报设备信息，也可以通过服务器端无线控制，如修改密码、恢复出厂设置、调节音量大小、远程开门等
基于Arduino的循迹小车项目设计与代码
最新发布
07-19
一. 硬件需求： Arduino Uno 或 Nano L298N 电机驱动模块 直流电机与车轮 红外循迹传感器模块 电源（如电池组） 小车底盘 二. 硬件连接： 1.电机驱动连接： 将电机1的两根线连接到L298N的OUT1和OUT2。 将电机2的两根线连接到L298N的OUT3和OUT4。 将L298N的IN1、IN2、IN3和IN4分别连接到Arduino的数字引脚（如：IN1 -> D8, IN2 -> D9, IN3 -> D10, IN4 -> D11）。 将L298N的ENA和ENB分别连接到Arduino的数字引脚（如：ENA -> D5, ENB -> D6，作为PWM控制）。 2.红外循迹传感器连接： 将传感器模块的VCC和GND连接到Arduino的5V和GND。 将传感器模块的输出引脚分别连接到Arduino的模拟或数字引脚（如：传感器1的OUT -> A0，传感器2的OUT -> A1）。
【故障诊断】基于矮猫鼬优化算法DMOA优化长短记忆网络LSTM实现故障诊断附matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【故障诊断】基于金枪鱼优化算法TSO优化长短记忆网络LSTM实现故障诊断附matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【信号分解】基于矮猫鼬优化算法DMOA-CEEMDAN实现信号去躁附matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【信号分解】基于白鹭群优化算法ESOA-ICEEMDAN实现信号去躁附matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
jspm学生综合考评管理系统lw+ppt
07-19
jspm学生综合考评管理系统lw+ppt
19.【Fastdata极数】2021年中国运动健身行业报告.docx
07-19
19.【Fastdata极数】2021年中国运动健身行业报告.docx
基于C++和EasyX绘图库编写的经典贪吃蛇游戏源码+编译好的exe.zip
07-19
编译环境 Visual C++ 6.0 / 2010，EasyX_2011惊蛰版
反 演 谱 分 解 方 法MATLAB代码
03-28
很抱歉，我作为AI语言模型无法提供完整的代码，但我可以给出反演谱分解方法的基本步骤和参考代码。 反演谱分解（Inverted Spectral Decomposition）是一种信号处理方法，用于分离信号中的不同成分。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值