JAVA 刷题练习

最新推荐文章于 2024-03-29 03:19:27 发布

白菜园子

最新推荐文章于 2024-03-29 03:19:27 发布

阅读量2.4k

点赞数 1

文章标签：蓝桥杯 java 职场和发展

本文链接：https://blog.csdn.net/qq_45927587/article/details/125328099

版权

1、分析并完成以下需求:

1.商场根据消费金额不同，折扣也不同，折扣的规则如下（P代表消费的总金额）
P >= 2000 7折
1000 <= P < 2000 8折
500 <= P < 1000 9.5折
P < 500 不打折
2.要求根据输入的消费金额，输出对应的折扣和折扣前后的金额。

package com.itheima04;

import java.util.Scanner;

// 1.商场根据消费金额不同，折扣也不同，折扣的规则如下（P代表消费的总金额）
//        P >= 2000 7折
//		1000 <= P < 2000 8折
//        500 <= P < 1000 9.5折
//        P < 500 不打折
//    2.要求根据输入的消费金额，输出对应的折扣和折扣前后的金额。
public class Lian01 {
    public static void main(String[] args) {
        //键盘录入消费金额
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的消费金额:");
        //方法一
       /* double p= sc.nextInt();
        //判断打几折
        if(p>=7000){
            System.out.println("您共消费"+p+"元,为您打7折,折后需要支付"+p*0.7+"元");
        }else if(1000 <= p&&p < 2000){
            System.out.println("您共消费"+p+"元,为您打8折,折后需要支付"+p*0.8+"元");
        }else if(500 <= p&&p < 1000){
            System.out.println("您共消费"+p+"元,为您打9.5折,折后需要支付"+p*0.95+"元");
        }else{
            System.out.println("您共消费"+p+"元,未达到折扣标准,不打折");
        }*/

        //方法二:
        int price = sc.nextInt();
        if (price >= 7000) {
            dazhe(price,0.7);
        } else if (1000 <= price && price < 2000) {
            dazhe(price,0.8);
        } else if (500 <= price && price < 1000) {
            dazhe(price,0.95);
        } else {
            dazhe(price,0.1);
        }
    }

    //定义一个方法,算出折旧后的金额和,折扣
    public static void dazhe(int price, double zhe) {
        double finalprice = price * zhe;
        double zhekou = zhe * 10;
        System.out.println("您共消费" + price + "元,为您打"+zhe +"折,折后需要支付" + finalprice + "元");
    }
}

2、分析并完成以下需求:

   1.模拟计算器，提示用户选择运算方式，[1加法/2减法/3乘法/4除法/5取余/0退出程序]
   2.提示用户分别录入两个整数，然后根据运算方式进行计算
   3.打印用户选择的运算方式，和运算结果（使用字符串拼接算式和结果）

方法一:

package com.itheima04;

import java.util.Scanner;

//1.模拟计算器，提示用户选择运算方式，[1加法/2减法/3乘法/4除法/5取余/0退出程序]
//	2.提示用户分别录入两个整数，然后根据运算方式进行计算
//	3.打印用户选择的运算方式，和运算结果（使用字符串拼接算式和结果）
public class Lian02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ol://结束死循环
        //创建死循环,模拟计算机.不退出一直运算
        while (true) {
            System.out.println("[1加法/2减法/3乘法/4除法/5取余/0退出程序]");
            System.out.println("请选择运算方式:");
            //输入数字选择运算模式
            int num = sc.nextInt();
            //提示输入两个整数
            System.out.println("请输入两个整数:");
            int num1 =sc.nextInt();
            int num2 =sc.nextInt();
            //定义一个结果变量,用来接收各运算式的结果
            int result = 0;
            //采用switch进行判断
            switch (num){
                case 0:
                    //退出程序
                    break ol;
                case 1:
                    //加法
                    result = num1+num2;
                    System.out.println("您选择的运算方式是:加法");
                    System.out.println("运算结果为"+num1+"+"+num2+"="+result);
                    break;
                case 2:
                    //减法
                    result = num1-num2;
                    System.out.println("您选择的运算方式是:减法");
                    System.out.println("运算结果为"+num1+"-"+num2+"="+result);
                    break;
                case 3:
                    //乘法
                    result = num1*num2;
                    System.out.println("您选择的运算方式是:乘法");
                    System.out.println("运算结果为"+num1+"*"+num2+"="+result);
                    break;
                case 4:
                    //除法
                    result = num1/num2;
                    System.out.println("您选择的运算方式是:除法");
                    System.out.println("运算结果为"+num1+"/"+num2+"="+result);
                    break;
                case 5:
                    //取余
                    result = num1%num2;
                    System.out.println("您选择的运算方式是:取余");
                    System.out.println("运算结果为"+num1+"%"+num2+"="+result);
                    break;

                default:
                    System.out.println("俺不干了");
                    break ol;
            }

        }
    }
}

优化:为了防止输入0或者一到五以外的数之后,还要再输入两次整数才能退出的现象

在循环中,switch之前加个判断,把0和default的功能单拎出来

package com.itheima04;

import java.util.Scanner;

//1.模拟计算器，提示用户选择运算方式，[1加法/2减法/3乘法/4除法/5取余/0退出程序]
//	2.提示用户分别录入两个整数，然后根据运算方式进行计算
//	3.打印用户选择的运算方式，和运算结果（使用字符串拼接算式和结果）
public class Lian02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ol://结束死循环
        //创建死循环,模拟计算机.不退出一直运算
        while (true) {
            System.out.println("[1加法/2减法/3乘法/4除法/5取余/0退出程序]");
            System.out.println("请选择运算方式:");
            //输入数字选择运算模式
            int num = sc.nextInt();
            if(num==0){
                    //退出程序
                    break ol;
            }else if(num!=1||num!=2||num!=3||num!=4||num!=5){
                System.out.println("俺不干了");
                break ol;
            }
            //提示输入两个整数
            System.out.println("请输入两个整数:");
            int num1 =sc.nextInt();
            int num2 =sc.nextInt();
            //定义一个结果变量,用来接收各运算式的结果
            int result = 0;
            //采用switch进行判断
            switch (num){

                case 1:
                    //加法
                    result = num1+num2;
                    System.out.println("您选择的运算方式是:加法");
                    System.out.println("运算结果为"+num1+"+"+num2+"="+result);
                    break;
                case 2:
                    //减法
                    result = num1-num2;
                    System.out.println("您选择的运算方式是:减法");
                    System.out.println("运算结果为"+num1+"-"+num2+"="+result);
                    break;
                case 3:
                    //乘法
                    result = num1*num2;
                    System.out.println("您选择的运算方式是:乘法");
                    System.out.println("运算结果为"+num1+"*"+num2+"="+result);
                    break;
                case 4:
                    //除法
                    result = num1/num2;
                    System.out.println("您选择的运算方式是:除法");
                    System.out.println("运算结果为"+num1+"/"+num2+"="+result);
                    break;
                case 5:
                    //取余
                    result = num1%num2;
                    System.out.println("您选择的运算方式是:取余");
                    System.out.println("运算结果为"+num1+"%"+num2+"="+result);
                    break;

            }

        }
    }
}

3、分析并完成以下需求:

1.使用随机数生成一个[1-100]的整数，提示用户猜一个整数
2.根据用户猜的整数，与随机数比较判断，打印用户猜的结果（猜对了或猜小了、猜大了）
3.多次游戏，猜对了停止游戏

package com.itheima04;

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

//3、分析并完成以下需求:
//    1.使用随机数生成一个[1-100]的整数，提示用户猜一个整数
//    2.根据用户猜的整数，与随机数比较判断，打印用户猜的结果（猜对了或猜小了、猜大了）
//    3.多次游戏，猜对了停止游戏
public class Lian03 {
    public static void main(String[] args) {
        //使用随机数生成一个[1-100]的整数
        Random r = new Random();
        int num = r.nextInt(100)+1;
        //bound 100:代表0-99,故1-100为(100)+1
        //提示用户猜一个整数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你心中的那个数字,对,不要犹豫,就是它:");
        //创建一个死循环,多次游戏，猜对了停止游戏
        while (true) {
            //输入整数
            int num1 = sc.nextInt();
            if (num1==num) {
                System.out.println("好厉害,你猜中啦,可惜没有奖励");
                //猜中了就结束循环
                break;
            }else if(num1>num){
                System.out.println("猜大了猜大了,重新来");
            }else{
                System.out.println("猜小了猜小了,加油再来");
            }
        }
    }
}

4、分析并完成以下需求:

1.获取一个[10-100]之间的int类型随机数num，统计[10-num]之间，奇数的个数
2.最终在控制台打印所有的奇数，和个数

package com.itheima04;

import java.util.Random;

//4、分析并完成以下需求:
//    1.获取一个[10-100]之间的int类型随机数num，统计[10-num]之间，奇数的个数
//    2.最终在控制台打印所有的奇数，和个数
public class Lian04 {
    public static void main(String[] args) {
        //获取一个[10-100]之间的int类型随机数num
        Random r = new Random();
        int num = r.nextInt(91)+10;
        //输出随机数,更为直观一点
        System.out.println("随机生成的奇数为:"+num);
        //bound 91:代表0-90------->bound91)+10:代表10-100
        //计数器,统计[10-num]之间，奇数的个数
        int count = 0;
        //循环遍历10-num之间的所有数,控制台打印所有的奇数，和个数
        for (int i = 10; i <=num ; i++) {
            if(i%2!=0){
                //打印奇数
                System.out.println(i);
                //计数器累加
                count++;
            }
        }
        System.out.println("奇数的个数共有:"+count+"个");
    }
}

5、分析并完成以下需求:

1.打印[1-1000]之间的整数，数字中包含5，或者是5的倍数的数字要跳过
2.要求控制台每行打印6个满足条件的数，之间用空格分隔

方法一

package com.itheima04;

//5、分析并完成以下需求:
//    1.打印[1-1000]之间的整数，数字中包含5，或者是5的倍数的数字要跳过
//    2.要求控制台每行打印6个满足条件的数，之间用空格分隔
public class Lian05 {
    public static void main(String[] args) {
        //计数器,一行够6个就换行
        int count = 0;
        //打印[1-1000]之间的整数，数字中包含5，或者是5的倍数的数字要跳过
        //循环遍历1-1000之间的整数
        for (int i = 1; i <= 1000; i++) {
            //数字中包含5，或者是5的倍数的数字要跳过
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100 % 10;
            if (ge == 5 || shi == 5 || bai == 5 || i % 5 == 0) {
                continue;
            }
            //要求控制台每行打印6个满足条件的数，之间用空格分隔
            System.out.print(i+" ");
            count++;
            if(count%6==0){
                //满足6个.换行
                System.out.println();
            }
        }
    }
}

方法二:优化

String.valueOf(i):将int类型转化为String类型
contains("5"):是否包含5

package com.itheima04;

//5、分析并完成以下需求:
//    1.打印[1-1000]之间的整数，数字中包含5，或者是5的倍数的数字要跳过
//    2.要求控制台每行打印6个满足条件的数，之间用空格分隔
public class Lian05 {
    public static void main(String[] args) {
        //计数器,一行够6个就换行
        int count = 0;
        //打印[1-1000]之间的整数，数字中包含5，或者是5的倍数的数字要跳过
        //循环遍历1-1000之间的整数
        for (int i = 1; i <= 1000; i++) {
            //数字中包含5，或者是5的倍数的数字要跳过
           /* int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100 % 10;
            if (ge == 5 || shi == 5 || bai == 5 || i % 5 == 0) {
                continue;
            }*/
            
            //String.valueOf(i):将int类型转化为String类型
            //contains("5"):是否包含5
            //判断意为:数值转换后不包含5或者对5取余不等于0的数,在控制台打印
            if (!String.valueOf(i).contains("5") || (i % 5 != 0)) {
                System.out.print(i + " ");
            }
            //要求控制台每行打印6个满足条件的数，之间用空格分隔
            count++;
            if (count % 6 == 0) {
                //满足6个.换行
                System.out.println();
            }
        }
    }
}

6、分析并完成以下需求:

1.中国有闰年的说法。闰年的规则是：四年一闰，百年不闰，四百年再闰（年份能够被4整除但不能被100整除算是闰年，年份能被400整除也是闰年）
2.请打印出1988年到2022年的所有闰年年份

package com.itheima04;
//6、分析并完成以下需求:
//    1.中国有闰年的说法。闰年的规则是：四年一闰，百年不闰，四百年再闰（年份能够被4整除但不能被100整除算是闰年，年份能被400整除也是闰年）
//    2.请打印出1988年到2022年的所有闰年年份
public class Lian06 {
    public static void main(String[] args) {
       
        //循环遍历1988年到2022年的所有闰年年份
        for (int i = 1988; i <=2022 ; i++) {
            //年份能够被4整除但不能被100整除算是闰年，年份能被400整除也是闰年
            if((i%4==0&&i%100!=0)||i%400==0){
                //在控制台打印闰年年份
                System.out.println(i);
            }
        }
    }
}

7、分析并完成以下需求：

1.完成逢七过游戏
2.获取范围[1-100]的整数，如果是7的倍数的、或者包含7的要跳过，打印满足条件的数字

重点:

String.valueOf(i).contains("7"):判断是否含7

package com.itheima04;
//7、分析并完成以下需求：
//	1.完成逢七过游戏
//	2.获取范围[1-100]的整数，如果是7的倍数的、或者包含7的要跳过，打印满足条件的数字
public class Lian07 {
    public static void main(String[] args) {
        //循环遍历1-100之间的数
        for (int i = 1; i <=100 ; i++) {
            //String.valueOf(i).contains("7"):判断是否含7
            //i%7==0:判断是否为7的倍数
            if(String.valueOf(i).contains("7")||(i%7==0)){
                System.out.println(i);
            }
        }
    }
}

8、分析并完成以下需求：

    1.按照从大到小的顺序输出四位数中的：个位+百位=十位+千位 的数字及个数
    2.每行输出5个满足条件的数，之间用空格分隔
        如：9999 9988 9977 9966 9955

package com.itheima04;

/*  8、分析并完成以下需求：
  1.按照从大到小的顺序输出四位数中的：个位+百位=十位+千位 的数字及个数
  2.每行输出5个满足条件的数，之间用空格分隔
  如：9999 9988 9977 9966 9955
  */
public class Lian08 {
    public static void main(String[] args) {
        //计数器,统计符合条件的个数
        int count = 0;
        //从大到小循环遍历四位数
        for (int i = 9999; i >= 1000; i--) {
            int ge = i % 10;//个位
            int shi = i / 10 % 10;//十位
            int bai = i / 100 % 10;//百位
            int qian = i / 1000 % 10;//千位
            if ((ge + bai) == (shi + qian)) {
                System.out.print(i + " ");
                count++;
                //每5个换行
                if (count % 5 == 0) {
                    System.out.println();
                }
            }
        }
    }
}

9、分析并完成以下需求：（练习）

1.计算出5位数的回文数和7位数的回文数相差了多少个?
2.回文数是一种数字如：98789倒读也为98789正读倒读都一样这种数字就叫回文数

package com.itheima04;

//9、分析并完成以下需求：（练习）
//    1.计算出5位数的回文数和7位数的回文数相差了多少个?
//    2.回文数是一种数字如：98789倒读也为98789正读倒读都一样这种数字就叫回文数
public class Lian09 {
    public static void main(String[] args) {
        //定义两个计数器,比较5位数的回文数和7位数的回文数相差了多少
        int count = 0;
        int count1 = 0;
//循环遍历五位数
        for (int i = 10000; i < 99999; i++) {
            int ge = i % 10;//个位
            int shi = i / 10 % 10;//十位
            int bai = i / 100 % 10;//百位
            int qian = i / 1000 % 10;//千位
            int wan = i / 10000 % 10;//万位
            if (wan == ge && shi == qian) {
                count++;
            }
        }
//循环遍历七位数
        for (int i = 1000000; i < 9999999; i++) {
            int ge = i % 10;//个位
            int shi = i / 10 % 10;//十位
            int bai = i / 100 % 10;//百位
            int qian = i / 1000 % 10;//千位
            int wan = i / 10000 % 10;//万位
            int shiwan = i / 100000 % 10;//十万位
            int baiwan = i / 1000000 % 10;//百万位
            if (baiwan == ge && shiwan == shi&&wan==bai) {
                count1++;
            }
        }
//将五位回文数个数和七位回文数个数作比较
        if(count>count1){
            System.out.println("5位数的回文数和7位数的回文数相差"+(count-count1));
        }else {
            System.out.println("5位数的回文数和7位数的回文数相差"+(count1-count));
        }
    }
}

10、给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target的那两个整数，并返回它们的数组下标。

示例：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

方法一:

package com.itheima04;

//10、给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target的那两个整数，并返回它们的数组下标。
//示例：
//输入：nums = [2,7,11,15], target = 9
//输出：[0,1]
//解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
public class Lian10 {
    public static void main(String[] args) {
        int[] nums = {2, 7, 11, 15};
        int target = 22;
        System.out.print("[");
        //循环遍历数组
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    System.out.print(i + ", " + j);
                }
            }
        }
        System.out.print("]");
    }
}

方法二:定义一个新数组接一下

package com.itheima04;

//10、给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target的那两个整数，并返回它们的数组下标。
//示例：
//输入：nums = [2,7,11,15], target = 9
//输出：[0,1]
//解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
public class Lian10 {
    public static void main(String[] args) {
        int[] nums = {2, 7, 11, 15};
        int target = 22;
        //定义一个新数组接收索引
        int[] newArr = new int[2];
        //循环遍历数组
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                   newArr[0]=i;
                   newArr[1] = j;
                }
            }
        }
        for (int i = 0; i < newArr.length; i++) {
            System.out.println(newArr[i]+" ");
        }
    }
}

11、分析并完成以下需求:

1.控制台提示并键盘录入，总共6个评委给1名选手打分，分数为[1-100]之间的int类型整数
2.对录入分数进行判断，超出范围给出提示，重新录入
3.将分数存储到合适的数组中
4.去除一个最高分、一个最低分，统计该选手的平均成绩，并在控制台打印

package com.itheima04;

import java.util.Scanner;

//11、分析并完成以下需求:
//    1.控制台提示并键盘录入，总共6个评委给1名选手打分，分数为[1-100]之间的int类型整数
//    2.对录入分数进行判断，超出范围给出提示，重新录入
//    3.将分数存储到合适的数组中
//    4.去除一个最高分、一个最低分，统计该选手的平均成绩，并在控制台打印
public class Lian11 {
    public static void main(String[] args) {
        //定义一个动态数组
        int[] arr = new int[6];
        //创建键盘对象
        Scanner sc = new Scanner(System.in);
        //循环六次,实现评委打分,并将分数存入数组中
        for (int i = 0; i < arr.length; i++) {
            //控制台提示
            System.out.println("请第" + (i + 1) + "位评委打分");
            //键盘录入
            int price = sc.nextInt();
            //判断分数是否合法,若合法将其存入数组,否则重新输入
            if (price > 0 && price <= 100) {
                arr[i] = price;
            } else {
                System.out.println("请重新输入");
                i--;
            }
        }

        //遍历数组,输出所有分数
        for (int i = 0; i < arr.length; i++) {
        //一行输出,用空格隔开
            System.out.print(arr[i]+" ");
        }

        System.out.println("最大值为"+getMax(arr));
        System.out.println("最小值为"+getMin(arr));
        System.out.println("平均值为"+getAvg(arr));
    }

    //定义方法,求最大值getMax
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return max;
    }

    //定义方法,求最小值getMin
    public static int getMin(int[] arr) {
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (min > arr[i]) {
                min = arr[i];
            }
        }
        return min;
    }

    //定义方法,求平均值getAvg
    public static int getAvg(int[] arr) {
        int sum = 0;
        int avg = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        //和减去最小值和最大值的差除4求平均值
        return avg = (sum -  getMin(arr) - getMax(arr)) / 4;
    }
}

12、分析并完成以下需求:

1.定义一个长度为5的int类型数组arr，数组元素为[7-67]之间的随机整数
2.遍历数组arr，打印所有元素
3.提示用户输入[3-5]之间的一个整数num，输入数字不需要判断
4.筛选出数组arr中是num倍数的元素，并打印在控制台

package com.itheima04;

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

//12、分析并完成以下需求:
//    1.定义一个长度为5的int类型数组arr，数组元素为[7-67]之间的随机整数
//    2.遍历数组arr，打印所有元素
//    3.提示用户输入[3-5]之间的一个整数num，输入数字不需要判断
//    4.筛选出数组arr中是num倍数的元素，并打印在控制台
public class Lian13 {
    public static void main(String[] args) {
        //定义一个长度为5的int类型数组arr
        int[]arr = new int[5];
        Random r = new Random();
        //循环遍历数组
        for (int i = 0; i < arr.length; i++) {
            //定义元素范围[7-67]
            arr[i] = r.nextInt(61)+7;
            //并将数组元素一行打印出来
            System.out.print(arr[i]+" ");
        }
        System.out.println();//换行
        //提示用户输入[3-5]之间的一个整数num，输入数字不需要判断
        System.out.println("请输入一个[3-5]整数:");
        Scanner sc = new Scanner(System.in);
        //定义变量num为用户输入[3-5]之间的一个整数
        int num = sc.nextInt();
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]%num==0){
                System.out.println(arr[i]);
            }
        }
    }
}

13、分析并完成以下需求:

1.定义一个方法，该方法能在一个int类型数组中查询某元素num是否存在，并返回被查找元素的索引
2.main方法中定义一个数组arr={19,28,37,46,50}; 提示并使用键盘录入一个整数
3.调用方法，查询该整数是否在arr数组中，如果在打印索引，如果不在给出提示

package com.itheima04;

import java.util.Scanner;

//13、分析并完成以下需求:
//    1.定义一个方法，该方法能在一个int类型数组中查询某元素num是否存在，并返回被查找元素的索引
//    2.main方法中定义一个数组arr={19,28,37,46,50}; 提示并使用键盘录入一个整数
//    3.调用方法，查询该整数是否在arr数组中，如果在打印索引，如果不在给出提示
public class Lian14 {
    public static void main(String[] args) {
        //定义一个数组arr
        int[] arr = {19, 28, 37, 46, 50};
        //提示并使用键盘录入一个整数
        System.out.println("请输入一个整数:");
        Scanner sc = new Scanner(System.in);
        //定义一个变量var,接收输入的整数
        int var = sc.nextInt();
        //定义一个变量num,接收方法调用后的结果
        int num = Arr(arr, var);//将数组arr的地址值和键盘输入的数据给数组,并接受其返回值
        //调用方法，查询该整数是否在arr数组中，
        System.out.println(num);
    }

    //定义一个方法，该方法能在一个int类型数组中查询某元素num是否存在，并返回被查找元素的索引
    //
    public static int Arr(int[] arr, int var) {

        //遍历数组arr.将数组值与num进行比对
        for (int i = 0; i < arr.length; i++) {
            //如果存在相应的数值,返回对应数组值的下标
            if (var == arr[i]) {
                return i;
            }
        }
        //不存在则返回-1
        return -1;
    }
}

14、分析并完成以下需求:

1.定义一个方法getSum(int start, int end){ … }，该方法完成获取[start-end]范围中的数据的和
2.在main方法中提示，并键盘录入start和end(start小于end，需要判断)，调用方法传递参数，打印结果

package com.itheima04;

import java.util.Scanner;

//14、分析并完成以下需求:
//
//    1.定义一个方法getSum(int start, int end){ … }，该方法完成获取[start-end]范围中的数据的和
//    2.在main方法中提示，并键盘录入start和end(start小于end，需要判断)，调用方法传递参数，打印结果
public class Lian15 {
    public static void main(String[] args) {
        //提示，并键盘录入start和end(start小于end，需要判断)
        System.out.println("请输入开始范围");
        Scanner sc = new Scanner(System.in);
        int start = sc.nextInt();
        System.out.println("请输入结束范围");
        int end = sc.nextInt();
        //调用方法,输出范围内数据的和
        System.out.println(getSum(start, end));
    }

    //定义一个方法getSum(int start, int end){ … }，该方法完成获取[start-end]范围中的数据的和
    public static int getSum(int start, int end) {
        //定义变量求和
        int sum = 0;
        for (int i = start; i <= end; i++) {
            sum += i;
        }
        return sum;
    }
}