基础知识案例练习

案例1：减肥计划

需求：输入星期数，显示今天的减肥活动

周一：跑步        

周二：游泳

周三：慢走

周四：动感单车

周五：拳击

周六：爬山

周日：好好吃一顿

减肥计划if版

package com.itheima;

import java.util.Scanner;

/*
* 需求：输入星期数，显示今天的减肥活动
        周一：跑步
        周二：游泳
        周三：慢走
        周四：动感单车
        周五：拳击
        周六：爬山
        周日：好好吃一顿
    实现思路：
    * 导包---提示输入数据----调用方法
    * 定义一个方法 用if else语句判断输入的数字
    * if(){
    * }


* */
public class Test01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
//        提醒用户输入一个数字
        System.out.println("请输入一个数字（范围1-7）");
        int week = sc.nextInt();
//        下一步对输入的数字进行处理，调用一个方法来实现
        getWeek(week);
    }

    public static void getWeek(int week) {
        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版

package com.itheima;


import java.util.Scanner;

// * 需求：输入星期数，显示今天的减肥活动
//         周一：跑步
//         周二：游泳
//         周三：慢走
//         周四：动感单车
//         周五：拳击
//         周六：爬山
//         周日：好好吃一顿
//     实现思路：
//     * 导包---提示输入数据----调用方法
//     * 定义一个方法 用switch语句判断输入的数字
//      switch(变量名){
//         case 1:
//         sout("提示内容")
//         break;
//         default;
//     }
//    当case的值都不满足时就执行default，当遇到break时语句就结束
//          导包的三种方式
/*                  ①自己输入
                    ②Alt+Enter
                    ③根据提醒按enter
      */
//
// *
public class Test02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期数");
        int week =sc.nextInt();
        getWeek(week);
    }

    public static void getWeek(int week) {
        switch(week){
//            case:冒号应该是英文的
            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("你输入的数据有误");

            }
        }
}

switch语句用注意case和default后面都要都是英文冒号

switch(变量名){                  

        case 1 :                      

                break;                 

        case 2:                        

                break;                 

        case 3:                        

                break;                  

        default :                       

}                                          

案例2：逢七过

需求：1-100任取一个数字，7的倍数，或者含有7的数字都说过

思路：

分三种情况满足一个就可以了，所以用或 "||"  

能被7整除的  x%7==0

个位含有7的数  x/10==7

十位含有7的数  x/10%7==0

package com.itheima;


import java.util.Scanner;

/*需求：1-100任取一个数字，7的倍数，或者含有7的数字都说过

        思路：

        分三种情况满足一个就可以了，所以用或 "||"

        能被7整除的 x%7==0

        个位含有7的数 x/10==7

        十位含有7的数 x/10%7==0*/
public class Test03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数");
        int x =sc.nextInt();
        getNumber(x);

    }

    public static void getNumber(int x) {
        if (x%7==0||x/10%7==0||x%10==7){
                System.out.print("过");
        }else{
            System.out.println("你输入的数据不符合游戏规则");
        }

    }
}

案例3：不死神兔

需求：有一对兔子，从出生后第三个月开始每个月都生一对兔子，小兔子增长到第三个月后每个月又生一对兔子。假如兔子不死，问第十二个月的兔子对数为多少？

每个月兔子对数是  1，1，2，3，5，8...刚好后一项等于前两项相加

package com.itheima;

public class Test04 {
    public static void main(String[] args) {
//        定义一个数组，动态初始化，长度为20   长度比索引的数值小1
        int[] arr = new int[20];
//          前两个月的值都是1
        arr[0] = 1;
        arr[1] = 1;
//        int sum = getNumber(arr);
        getNumber(arr);
//        System.out.println(sum);
    }

    //    定义一个方法用来计算第20个月时兔子的对数
    /*public static void getNumber(int[] arr) {
用for循环语句来实现每个月兔子对数的加法
        第一个错误：不能用sum来表示下一项的值
        第二个错误，for语句结束后我们应该把输出语句放在循环外输出循环最终结果
        int sum = arr[0];
        for (int x = 1; x < arr.length; x++) {
        用sum会导致，从地3个元素开始人arr[x]都是0  也就是数组arr{1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
         所以最终输出来的结果是2
            sum += arr[x];
        }
        System.out.println(sum);
    }*/
    public static void getNumber(int[] arr) {
        for (int x = 2; x < arr.length; x++) {
            arr[x]=arr[x-1]+arr[x-2];
        }
//        arr[19]   这里的19是索引，表示数组中第20是个元素
        System.out.println("第二十个月兔子对数之和为"+arr[19]);
    }
}

案例4：百钱百鸡

需求：100块钱去买100只鸡

公鸡5块钱一只  设共有x只公鸡      0<=x<=20

母鸡3块钱一只 设共有y只母鸡        0<=y<=33                     

鸡仔1/3元一只  设有z只小鸡           0<=y<=100     因为总共只有100只

x+y+z=100

5*x+3*y+z/3=100

求出x，y，z

package com.itheima;

/*
* 需求：100块钱去买100只鸡

公鸡5块钱一只 设共有x只公鸡 0<=x<=20

母鸡3块钱一只 设共有y只母鸡 0<=y<=33

鸡仔1/3元一只 设有z只小鸡 0<=y<=100   因为总共只有100只

x+y+z=100

5*x+3*y+z/3=100

求出x，y，z
* 思路:
*①第一层循环：用于表示公鸡的范围，初始化表达式的变量定义为 x=0，判断条件为0<=x<=20
*②第2层循环：用于表示母鸡的范围，初始化表达式的变量定义为 y=0，判断条件为0<=y<=33
*③小鸡的值z=100-x-y
*④判断表达式 z%3==0  和5*x+3*y+z/3=100是否同时成立，输出对应的x，y，z 的值
* */
public class Test05 {
    public static void main(String[] args) {
//    ①第一层循环：用于表示公鸡的范围，初始化表达式的变量定义为 x=0，判断条件为0<=x<=20
        for (int x = 0; x <= 20; x++) {
//   ②第2层循环：用于表示母鸡的范围，初始化表达式的变量定义为 y=0，判断条件为0<=y<=33
            for (int y = 0; y <= 33; y++) {
                    int z=100-x-y;
//         *④判断表达式 z%3==0  和5*x+3*y+z/3=100是否同时成立，输出对应的x，y，z 的值
                if (z %3==0 && 5*x+3*y+z/3==100) {
                    System.out.println(x+","+y+","+z);
                }
            }
        }
    }
}

案例5：数组元素求和

需求：求给定数组中符合条件的元素之和，例如：数组{68，27，95，88，171，996，51，210}           求和的元素个位和十位都不能是7，并且只能是偶数

分析思路：

要把数组中的元素遍历出来

然后用if语句取判断满足条件的元素

将满足条件的元素加起来

x%10!=7&&x/10%10!=0&&x%2==0

package com.itheima;

/*
* 需求：求给定数组中符合条件的元素之和，
* 例如：数组{68，27，95，88，171，996，51，210}求和的元素个位和十位都不能是7，并且只能是偶数

* 分析思路：
*       用静态初始化定义一个数组
        定义一个方法，用来遍历数组元素
        然后用if语句取判断满足条件的元素

        将满足条件的元素加起来

x%7!=0&&x/10%7!=0&&x%2=0
* */
public class Test06 {
    public static void main(String[] args) {
        int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};
        getNumber(arr);
    }

    public static void getNumber(int[] arr) {
        int sum = 0;
        for (int x = 0; x < arr.length; x++) {
//            System.out.println(arr[x]);
            if (arr[x] % 10 != 7 && arr[x] / 10 % 10 != 7&&arr[x] % 2 == 0) {
                    sum += arr[x];
            }
//            System.out.println(a);
        }
        System.out.println("满足条件的元素之和为" + sum);
    }
}

注意事项：再用逻辑运算符时 ，运算符两边的值类型应该相同

x%10!=7&&x/10%10!=0&&x%2=0

错在最后的条件语句没有写成==，系统报错：前面两个是Boolean后面是int类

案例6：数组内容相同

需求：设计一个方法，用于比较两个数组的内容是否相同

思路：

package com.itheima;
/*需求：设计一个方法，用于比较两个数组的内容是否相同
    思路：
    ①定义两个数组  int []arr1={12,23,34,45,56,67,78}; int []arr2={12,23,34,45,56,67,98};
    ②定义一个方法用来比较两个数组是否相同
    ③比较数组是否相等的方法
             1、比较数组长度
             2、假如数组长度相等，遍历数组中元素并让每一个元素比较是否相等
             if(arr1.length==arr2.length){
                for(int x=0;x<arr1.length;x++){
                    if(arr1[x]==arr2[x]){
                    sout("两数组相等");
                    }
                }
             }
               sout("两数组不相等");

 */
public class Test007 {
    public static void main(String[] args) {
        int []arr1={12,23,34,45,56,67,98};
        int []arr2={12,23,34,45,56,67,908};
        boolean flag = compare(arr1,arr2);
        if (flag==true){
            System.out.println("数组相等");
        }else{
            System.out.println("数组不相等");
        }

//        System.out.println(flag);
    }
    public static boolean compare(int []arr1,int []arr2) {
        if(arr1.length==arr2.length){
//            如果两数组长度相等才执行 遍历数组
            for(int x=0;x<arr1.length;x++){
//                System.out.println(arr1[x]);
//                System.out.println(arr2[x]);
                if(arr1[x]==arr2[x]){
//
                }else{
//                    System.out.println("两数组不相等");
                    return false;
                }
            }
            return true;
//            System.out.println("两数组相等");
        }
//        System.out.println("两数组不相等");
        return false;
    }
}

案例7：查找

需求：已知一个数组arr[19,28,39,46,50];键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引值。

定义方法时，传参一定要要对应，调用方法时也是一样的。用几个参数就传几个参数

package com.itheima;

import java.util.Scanner;

/*

需求：已知一个数组arr{19,28,39,46,50};
     键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引值。

思路
    ①导包
    ②定义一个静态初始化数组
    ③定义一个方法，让数组元素和输入的数字比比较
    ④在方法中我们要将数组元素遍历出来，用到for语句
    然后在用if语句判断
    for(int x=0;x<arr.length;x++){
        if(arr[x]==sc){
         System.out.println(x)
        }
    }
* */
public class Test08 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个数字");
        int agrs=sc.nextInt();
        int []arr={19,28,39,46,50};
         int index=getIndex(agrs,arr);
        System.out.println("index:"+index);
       /* for (int x=0;x<arr.length;x++){
            if(agrs==arr[x]){

                System.out.println("index:"+x);
            }
*/
        }
//        System.out.println("你输的数字不再该数组中");
//        定义一个方法,形参中要有输入的数字，还要有数组中的元素
        public static int getIndex(int agrs,int []arr){
                int index=-1;
            for (int x=0;x<arr.length;x++){
                if(agrs==arr[x]){
                    index=x;
                    break;
                }
            }
            return index;
        }
}

案例8：反转

需求：已知一个数组arr={19,28,37,46,50}用程序实现把数组中的元素值交换。

           交换后的数组arr={50,46,37,28,19}并在控制台输出数组元素

思路：

package com.itheima;

/*
需求：已知一个数组arr={19,28,37,46,50}用程序实现把数组中的元素值交换。
     交换后的数组arr={50,46,37,28,19}并在控制台输出数组元素
思路：
    ①静态初始化，定义一个数组
    ②定义一个方法，在方法中实现数组元素的反转
    ③倒序输出每一个元素，
    ⑤然后把输出的元素赋给新的数组
    ⑥打印新数组
* */
public class Trst09 {
    public static void main(String[] args) {
//         ①静态初始化，定义一个数组
        int[] arr1 = {19, 28, 37, 46, 50};
        int[] arr2 = new int[arr1.length];
        transition(arr1, arr2);
    }

    //    ②定义一个方法，在方法中实现数组元素的反转
    public static void transition(int[] arr1, int[] arr2) {

//          ③倒序输出每一个元素，for循环语句
        System.out.print("[");
        for (int x = arr1.length - 1; x >= 0; x--) {

//            将反转后的数组元素赋给新的数组
            arr2[x] = arr1[x];
            System.out.print(arr2[x]);
//                没输出一个arr2元素，就给它添加一个逗号,最后一个元素前不用逗号
            if (x > 0) {
                System.out.print(",");
            }

        }
        System.out.print("]");

    }
}

案例9：评委打分

需求：在编程竞赛中，有6个评委为参赛选手打分，分数为0-100的整数分。

选手的最后得分为：去掉一个最高分和一个最低分后的四个评委的平均值（不考虑小数部分）。

注意：数组动态初始化的格式为：int [ ]arr=new int[数组长度]   一定要注意这两个位置。

第一种方法：

package com.itheima;

import java.util.Scanner;

/*
* 需求：在编程竞赛中，有6个评委为参赛选手打分，分数为0-100的整数分。
       选手的最后得分为：去掉一个最高分和一个最低分后的四个评委的平均值（不考虑小数部分）。
  思路：
  * 输入6个数据，导包每个数据范围  int x; 0<=x<=100
  * 定义一个方：并判断6个数据的最大值和最小值，
  *           final sore=average=（6个数字求和并且减去两个最值）/4
  * 调用该方法
  *
* */
public class Test10 {
    public static void main(String[] args){
        Scanner sc =new Scanner(System.in);
//        new一个动态数组arr[5]，将输入的分数赋给数组
        System.out.println("请输入第1个分数");
        int sore1=sc.nextInt();
        int []arr=new int[6];
        arr[0]=sore1;
        System.out.println("请输入第2个分数");
        int sore2=sc.nextInt();
        arr[1]=sore2;
        System.out.println("请输入第3个分数");
        int sore3=sc.nextInt();
        arr[2]=sore3;
        System.out.println("请输入第4个分数");
        int sore4=sc.nextInt();
        arr[3]=sore4;
        System.out.println("请输入第5个分数");
        int sore5=sc.nextInt();
        arr[4]=sore5;
        System.out.println("请输入第6个分数");
        int sore6=sc.nextInt();
        arr[5]=sore6;
        int average=finalSore( arr);
        System.out.println("最终分数为"+average);
    }
    public static int finalSore(int[]arr){
//       遍历数组元素，并判断6个数据的最大值和最小值
        int max=arr[3];
        int min=arr[3];
        int sum=0;
        for(int x=0;x<arr.length;x++){
            sum+=arr[x];
            if (arr[x]>max){
                max=arr[x];

            }
            if (arr[x]<min){
                min=arr[x];
            }

        }
        System.out.println(max);
        System.out.println(min);
            return (sum-max-min)/(arr.length-2);
    }
}

第二种简化代码分模块调用方法。

package com.itheima;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        int []arr=new int[6];
        Scanner sc =new Scanner(System.in);
        for(int x=0;x<arr.length ;x++){

            System.out.println("请输入第"+(x+1)+"个评委的分数");
            arr[x]=sc.nextInt();
        }
//        调用方法
        int max=getMax(arr);
        System.out.println("最大值："+max);
        int min=getMin(arr);
        System.out.println("最小值："+min);
        int sum=getSum(arr);
        int avg=(sum-max-min)/(arr.length-2);
        System.out.println("最终得分是："+avg);
    }
    public static int getMax(int[]arr){
//       遍历数组元素，并判断6个数据的最大值
        int max=arr[0];
        for(int x=0;x<arr.length;x++){
            if (arr[x]>max){
                max=arr[x];

            }
        }
        return max;
    }
    public static int getMin(int[]arr){
//       遍历数组元素，并判断6个数据的最大值
        int min=arr[0];
        for(int x=0;x<arr.length;x++){
            if (arr[x]<min){
                min=arr[x];

            }
        }
        return min;
    }
    public static int getSum(int[]arr){
//       遍历数组元素，并判断6个数据的最大值
        int sum=0;
        for(int x=0;x<arr.length;x++){
            sum+=arr[x];
        }
        return sum;
    }
}