devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JAVA小白 编程练习500题 超详细!!!带答案!!!持续更新中~_java练习题

作者：从前慢现在也慢 | 2024-06-09 11:10:15

赞

踩

java练习题

练习题：定义两个整数，计算这两个整数加减乘除运算的结果，并把结果打印到控制台

package cn.cxy.exec;

public class TestPrint4 {
    public static void main(String[] args) {
        //1.定义变量保存要计算的第一个数
        int number1 = 1;
        //2.定义变量保存要计算的第二个数
        int number2 = 2;
        //3.打印输出这两个数计算的结果
        System.out.println(number1+number2);
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

练习题：预测身高案例：
其实我们可以通过父母的身高大致推断出子女的身高，假定父母与子女的身高遗传关系如下：
​ 儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2
​ 女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2
那已知：现有父亲身高175CM,母亲身高160CM。
请将预测的子女身高打印输出

package cn.cxy.exec;

public class TestPrint5 {
    public static void main(String[] args) {
        //1.定义变量保存父亲的身高
        double fatherHeight = 175;
        //2.定义变量保存母亲的身高
        double motherHeight = 160;
        //3.计算儿子身高
        double sonHeight = (fatherHeight + motherHeight) * 1.08 / 2;
        //4.计算女儿身高
        double daughterHeight = (fatherHeight * 0.923 + motherHeight) / 2;
        //5.打印输出最终计算的结果
        System.out.println("儿子预计身高" + sonHeight + "厘米");
        System.out.println("女儿预计身高" + daughterHeight + "厘米");
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

练习题：逻辑判断
已知小红同学有25元，她攒了几天钱之后发现自己的现在的钱比原来的2倍还多出10块。而小蓝同学有30元，他攒了几天钱之后发现自己的钱正好是原来的2倍。于是小胖说：小红和小蓝现在的钱一样多，请问，他说的对吗？

package cn.cxy.exec;

public class TestPrint4 {
    public static void main(String[] args) {
        //1.定义变量保存小红原来的钱数
        int red = 25;
        //2.定义变量保存小蓝原来的钱数
        int blue = 30;
        //3.求小红同学现在的钱数
        red = red * 2 + 10;
        //4.求小蓝同学现在的钱数
        blue *= 2; //这是一种简写形式，等同于blue = blue *2;
        //5.判断并输出两个人的钱是否相等
        System.out.println(red == blue);
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

练习题：最优选择
某小伙想定一份外卖，商家的优惠方式如下：鱼香肉丝单点24元，油炸花生米单点8元，米饭单点3元。订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？

public class Demo3 {
    public static void main(String[] args) {
        //1.求不使用优惠时的总价
        double money1 = 24 + 8 + 3;
        //2.判断折后总价
        money1 = (money1 <= 30 ? money1 : money1 * 0.8);
        //3.求使用优惠时的总价
        double money2 = 16 + 8 + 3;
        //4.判断两种花费哪个更少
        double money = money1 < money2 ? money1 : money2;
        //5.打印最终花费
        System.out.println(money);
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

练习题: 接收用户输入的3个整数,并将它们的最大值作为结果输出

package cn.cxy.exec;

import java.util.Scanner;

public class GetMaxNumber {
    public static void main(String[] args) {
        //1.提示并接收用户输入的三个整数,并交由变量a b c来保存
        System.out.println("请输入第一个整数:");
        int a = new Scanner(System.in).nextInt();
        System.out.println("请输入第二个整数:");
        int b = new Scanner(System.in).nextInt();
        System.out.println("请输入第三个整数:");
        int c = new Scanner(System.in).nextInt();

        //2.对接收到的三个值进行比较
        /**三元运算符 1 ? 2 : 3
         * 如果1号位置的表达式结果为true,结果就取2号位置的值,反之,就取3号位置的值*/
        //2.1定义变量max来保存a和b中的最大值
        int max = a>b ? a : b;
        //2.2比较max与c谁最大,并将最大值交由max来保存
        max = max>c ? max : c;
        /**解决方案二:*/
        //int max = a>b?(a>c?a:c):(b>c?b:c);
        //3.输出结果
        System.out.println("三个数的最大值是:"+max);
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

练习题：接收用户输入的数据，判断是奇数还是偶数

package cn.cxy.exec;

import java.util.Scanner;
public class TestNum {
	public static void main(String[] args) {
		//1.提示并接收用户输入的数据
		System.out.println("请输入您要判断的数据");
		int input = new Scanner(System.in).nextInt();
		//2.判断用户输入的数据
		if(input % 2 == 0) {
			System.out.println(input+"是偶数");
		}else {
			System.out.println(input+"是奇数");
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

练习题：输入数字1~7，输出对应星期几

package cn.cxy.exec;

import java.util.Scanner;

public class TestDay {
	public static void main(String[] args) {
		//1.提示并接收用户输入的数据
		System.out.println("请输入数据：");
		int input = new Scanner(System.in).nextInt();
		//2.判断用户输入的数据
		if(input == 1) {
			System.out.println("星期一");
		}else if(input == 2){
			System.out.println("星期二");
		}else if(input == 3){
			System.out.println("星期三");
		}else if(input == 4){
			System.out.println("星期四");
		}else if(input == 5){
			System.out.println("星期五");
		}else if(input == 6){
			System.out.println("星期六");
		}else if(input == 7){
			System.out.println("星期日");
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

练习题: BMI 指数测试 BMI = 体重 (kg) / 身高² (m)
接收用户输入的身高和体重,将判断结果输出
过轻：低于18.5
正常：18.5 ~ 22.9
偏胖：23 ~ 24.9
肥胖：25 ~ 29.9
重度肥胖：高于30
极度肥胖：高于40

package cn.cxy.exec;

import java.util.Scanner;

public class TestBMI {
    public static void main(String[] args) {
        //1.提示并接收用户输入的身高与体重信息
        System.out.print("请输入您的身高(单位为m)：");
        double height = new Scanner(System.in).nextDouble();
        System.out.print("请输入您的体重(单位为kg)：");
        double weight = new Scanner(System.in).nextDouble();

        //2.调用getBMI()方法，根据身高和体重信息,输出结果
        getBMI(height, weight);
    }

    public static void getBMI(double h, double w) {
        //求出BMI指数
        double bmi = w / (h * h);
        //定义一个变量r来保存最终结果
        String r = "";

        //根据 bmi 指数范围，来给r重新赋值
        if (bmi < 18.5) {
            r = "过轻";
        } else if (bmi <= 22.9) {
            r = "正常";
        } else if (bmi <= 24.9) {
            r = "偏胖";
        } else if (bmi <= 29.9) {
            r = "肥胖";
        } else if (bmi <= 40) {
            r = "重度肥胖";
        } else {
            r = "极度肥胖";
        }
        //打印最终结果
        System.out.println("您的BMI指数：" + bmi);

        System.out.println("您的体重属于：" + r);
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

练习题：最优选择2
小蓝同学想买一个价值8888元的新手机，她的旧手机在二手市场能卖1880元，而手机专卖店推出以旧换新的优惠，把她的旧手机交给店家，新手机就能够打7.5折优惠。为了更省钱，小蓝要不要以旧换新？

public class TestChoice {
    public static void main(String[] args) {
        //1.计算不使用以旧换新的花费
        int plan1 = 8888 - 1880;
        //2.计算以旧换新的花费
        double plan2 = 8888 * 0.75;
        //3.判断两种方式
        if(plan1 > plan2){
            System.out.println("使用以旧换新更省钱");
        }else{
            System.out.println("不使用以旧换新更省钱");
        }
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

练习题：求数字的绝对值
绝对值是指一个数在数轴上所对应点到原点的距离，用“| |”来表示。负数的绝对值是他去掉负号以后的值，而非负数（0和正数）的绝对值是他本身。请定义一个方法，接收用户输入的数字，输出绝对值结果。

package cn.cxy.exec;

import java.util.Scanner;

public class TestNum {
    public static void main(String[] args) {
        //1.接收用户输入的要测试的数字
        System.out.println("请输入你要判断的数字：");
        double input = new Scanner(System.in).nextDouble();
        //2.调用求绝对值的方法并拿到方法执行后的结果（返回值）
        double result = getAbsNum(input);
        //3.打印求出的结果
        System.out.println(input+"的绝对值是："+result);
    }

    private static double getAbsNum(double input) {
        if(input >=0){//如果是非负数
            return input;//返回本身的值
        }else{//如果是负数
            return -input;//则值取反
        }
    }

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

练习题：求指定两个数的最大公约数和最小公倍数

package cn.cxy.exec;

import java.util.Scanner;

public class NumTest {
   public static void main(String[] args) {
      System.out.println("输入两个整数：");
      int a = new Scanner(System.in).nextInt();
      int b = new Scanner(System.in).nextInt();

      int d = zdgys(a,b);//调用求最大公约数的方法
      long x = zxgbs(a,b);//调用求最小公倍数的方法
      System.out.println("最大公约数："+d);
      System.out.println("最小公倍数："+x);
   }

   private static int zdgys(int a, int b) {
      int min = a<b ? a : b;
      for(int i=min; i>=1; i--) {
         //i能把a和b同时整除
         if(a%i==0 && b%i==0) {
            return i;
         }
      }
      //这句代码根本不会执行，
      //让编译可以通过
      return 0;
   }

   private static long zxgbs(int a, int b) {
      int max = a>b? a : b;
      for(long i=max; ;i+=max) {
         //i能同时被a和b整除
         if(i%a==0 && i%b==0) {
            return i;
         }
      }
   }

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

练习题：银行收入计算
某银行推出了整存整取定期储蓄业务，其存期分为一年、两年、三年、五年，到期凭存单支取本息。存款年利率表如下：
​ 存期 年利率（%）
​ 一年 2.25
​ 两年 2.7
​ 三年 3.25
​ 五年 3.6
请存入一定金额（1000起存），存一定年限（四选一），计算到期后得到的本息总额。
提示：
​ 存入金额和存入年限均由键盘录入
​ 本息计算方式：本金+本金×年利率×年限

import java.util.Scanner;
public class BankDemo {
    public static void main(String[] args) {
        //1.提示并接收用户输入的存款金额
        System.out.println("请输入存款金额：");
        int money = new Scanner(System.in).nextInt();
        //2.提示并接收用户输入的存款年限
        System.out.println("请输入存款年限：");
        int year = new Scanner(System.in).nextInt();
        //3.定义变量用来保存本金和利息之和
        double outMoney = 0;
        //4.根据利率和年限计算本息和
        if (year == 1) {
            outMoney = money + money * 2.25 / 100 * 1;
        } else if (year == 2) {
            outMoney = money + money * 2.7 / 100 * 2;
        } else if (year == 3) {
            outMoney = money + money * 3.25 / 100 * 3;
        } else if (year == 5) {
            outMoney = money + money * 3.6 / 100 * 5;
        } else {
            System.out.println("输入的年限有误");
        }
        //5.打印输出
        System.out.println("存款" + year + "年后的本息是：" + outMoney);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

练习题：求税后工资问题
2019年1月1日起，国家推出新的个人所得税政策，起征点上调值5000元。也就是说税前工资扣除三险一金（三险一金数额假设是税前工资的10%）后如果不足5000元，则不交税。如果大于5000元，那么大于5000元的部分按梯度交税，具体梯度比例如下：
​ 0 ~ 3000元的部分，交税3%
​ 3000 ~ 12000元的部分，交税10%
​ 12000 ~ 25000的部分 ， 交税20%
​ 25000 ~ 35000的部分，交税25%
​ 35000 ~ 55000的部分，交税30%
​ 55000 ~ 80000的部分，交税35%
​ 超过80000的部分，交税45%
比如：小蓝入职一家企业后，税前工资是18000，则他每月该交个税的部分是18000-1800-5000=11200元，个税缴纳数额是3000×3%+8200×10%=910元。税后工资15290元。
请完成一个个税计算程序，在用户输入税前工资后，计算出他对应的纳税数额，以及税后工资为多少？

import java.util.Scanner;
public class Demo5 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的税前工资：");
        //2.键盘录入税前工资
        int money = sc.nextInt();
        //3.计算应纳税部分的工资
        double before = money - (money*0.1) - 5000;
        //4.定义个税变量
        double shui = 0;
        //5.按照梯度范围计算个税数值
        if(before > 0 && before <=3000){
            shui = before * 0.03;
        }else if(before > 3000 && before <=12000){
            shui = 3000*0.03 + (before-3000) * 0.1;
        }else if(before > 12000 && before <=25000){
            shui = 3000*0.03 + 9000*0.1 +  (before-12000)*0.2;
        }else if(before > 25000 && before <=35000){
            shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + (before-25000)*0.25;
        }else if(before > 35000 && before <=55000){
            shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + (before-35000)*0.3;
        }else if(before > 55000 && before <=80000){
            shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + 20000*0.3 + (before-55000)*0.35;
        }else if(before > 80000){
            shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + 20000*0.3 + 25000*0.35 + (before-80000)*0.45;
        }
        //6.计算税后工资
        double after = money - (money*0.1) - shui;
        //7.打印个税和税后工资
        System.out.println("个人所得税" + shui + "元");
        System.out.println("税后工资" + after + "元");
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

练习题: 手机选号:根据用户输入的手机号来确认用户实际支付的价格
如果尾数为8，需支付办卡费50元
如果尾数为4，需支付办卡费用0元
如果是其他尾号,需支付办卡费用20元

package cn.cxy.exec;

import java.util.Scanner;

public class PayCard {
    public static void main(String[] args) {
        //1.提示并接收用户输入的手机号
        System.out.println("请输入您预选的手机号：");
        String tel = new Scanner(System.in).nextLine();//注意String类型数据一般用nextLine()

        //2.调用getPrice()方法，来计算价格,注意需要把手机号tel作为参数传入方法中
        getPrice(tel);
    }

    //3.创建getPrice()
    public static void getPrice(String tel) {
        //3.1 手机号tel的长度，必须是11位的正确手机号--提前校验,提高程序健壮性
        if(tel.length() != 11) {
            System.out.println("号码格式错误");
            return;//结束方法，返回到调用位置再继续执行
        }

        /*比如我们拿到的手机号是tel="2313123123",想要拿到尾数,也就是最后一个字符
         * 需要用到 char c = tel.charAt(10)
         * 注意:由于下标也是从0开始,所以取第11个字符，它的下标位置是10
         */
        //3.2获取手机号的尾数
        char c = tel.charAt(10);

        //3.2定义用来保存最终结果的变量price,初始值为0
        int price = 0;

        //3.3根据c字符的值，来为price重新赋值
        switch(c) {
            case '8': price=50; break;//尾数为8支付50
            case '4': price=0; break;//尾数为4免费
            default: price=20;//其他情况需支付20
        }
        //3.4显示结果
        System.out.println("您实际应支付的价格为："+price);
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

练习题: 获取邮箱名字
接收用户输入的邮箱名，获取邮箱的名字
比如：cxy@163.com,输出cxy

package cn.cxy.exec;

import java.util.Scanner;

public class GetEmailName {
	public static void main(String[] args) {
		System.out.println("输入email:");
		String e = new Scanner(System.in).nextLine();
		//email地址e，传递到该方法，
		//并得到方法返回的名字，保存到变量n
		String n = getName(e);
		System.out.println(n);
	}

	static String getName(String email) {
		/*
		 * "sdfwerw@rewerwe.com"
		 *         |
		 *         index
		 *
		 * 1. 定位 "@" 的下标位置 index
		 * 2. 截取 [0, index)，直接返回
		 * email.indexOf("@")
		 *        查找指定子串的位置
		 *        找不到，得到特殊值 -1
		 * email.substring(0, index)
		 *        截取 [0, index)
		 */
		//找@的位置
		int index = email.indexOf("@");
		if(index == -1) {//找不到
			return "邮箱格式错误";
		}
		//截取，直接返回截取的结果
		return email.substring(0, index);
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

练习题 : 分别通过for循环/While循环/do-While循环写一个死循环

package cn.cxy.exec;

public class DeadCycle {
    public static void main(String[] args) {
        //for循环的死循环
//        for (int i = 1; ; i++){
//            System.out.println("欢迎学习泡泡的分享,继续加油哦~");
//        }
        //while循环的死循环
//        while(true){
//            System.out.println("都到这里啦?奥利给~");
//        }
        //do-while循环的死循环
        do{
            System.out.println("相信我们可以的~");
        }while(true);
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

练习题: 鸡兔同笼问题(穷举法)

已知:鸡兔共35只,共94只脚,那么鸡和兔各几只?

package cn.cxy.exec;
//穷举法
//鸡    兔
//0     35
//1     34
//2     33
//3     32
//...
//23    12
//...
//35    0
public class SameCage {
    public static void main(String[] args) {
        //循环变量j,控制小鸡的个数: 0到35递增
        //循环变量t,控制兔子的个数: 35到0递减
        for(int j=0,t=35; j<=35; j++,t--) {//如果有多个小条件,用逗号隔开
            //保证脚的数量是94
            if(j*2 + t*4 == 94) {
                System.out.println("鸡："+j+"， 兔："+t);
            }
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

练习题:商品录入系统
通过java基础的相关知识，设计并完成一个简单的商品录入系统，可以实现：菜单显示、商品信息展示、商品信息录入、商品信息查询、退出的功能

package cn.cxy.exec;

import java.util.Scanner;

public class Product {
   //成员变量
   static String[] names = {"iPhoneXS","华为 Mate 20 pro","小米X","vivo NEX","oppo Find"};
   static double[] price = {8999,5399,2399,4399,3999};
   static int[] numbers =  {50,20,80,120,90};

   public static void main(String[] args) {
      /*
       * ----------------------
       * 1. 商品列表
       * 2. 商品录入
       * 3. 商品查询
       * 4. 统计信息
       * 5. 退出
       * ----------------------
       * 选择：> 1
       * ....
       */

      //死循环显示菜单
      outer:
      while(true) {
         //显示菜单，并获得选择的值
         int c = menu();
         //判断c的值
         switch(c) {
         case 1: f1(); break;
         case 2: f2(); break;
         case 3: f3(); break;
         case 4: f4(); break;
         case 5: break outer;
         }
      }
   }

   private static int menu() {
      System.out.println("----------------------");
      System.out.println("1. 商品列表");
      System.out.println("2. 商品录入");
      System.out.println("3. 商品查询");
      System.out.println("4. 统计信息");
      System.out.println("5. 退出");
      System.out.println("----------------------");
      System.out.print("选择：> ");
      return new Scanner(System.in).nextInt();
   }

   private static void f1() {
      /*
         names
         ["A", "B", "C"]
         price
         [2,    8,    3]
         numbers
         [200,  300,  180]
           0     1    2
         1. 名称：xx，价格：xx，数量：xx
       */
      for(int i=0;i<names.length;i++) {
         String n = names[i];
         double p = price[i];
         int b = numbers[i];
         System.out.println(
          (i+1)+". 名称："+n+"，价格："+p+"，数量："+b);
      }
   }

   private static void f2() {
      /*
         names
         ["A", "B", "C"]
         price
         [2,    8,    3]
         numbers
         [200,  300,  180]
          0     1    2
      */
      //遍历数组
      for (int i = 0; i < names.length; i++) {
         System.out.println("录入第"+(i+1)+"件商品：");
         System.out.print("名称：");
         String n = new Scanner(System.in).nextLine();
         System.out.print("价格：");
         double p = new Scanner(System.in).nextDouble();
         System.out.print("数量：");
         int b = new Scanner(System.in).nextInt();
         names[i] = n;
         price[i] = p;
         numbers[i] = b;
      }
      //重新显示商品列表
      f1();
   }

   private static void f3() {
      /*
         names
         ["A", "B", "C"]
         price
         [2,    8,    3]
         numbers
         [200,  300,  180]
          0     1    2
        字符串，比价是否相等，要用equals()方法
        a = "aaa"
        b = "aaa"
        a.equals(b)
       */
      System.out.print("输入查询的商品名：");
      String n = new Scanner(System.in).nextLine();
      //遍历数组
      for (int i = 0; i < names.length; i++) {
         // n 和 names[i] 相等
         if(n.equals(names[i])) {
            String name = names[i];
            double p = price[i];
            int b = numbers[i];
            System.out.println(
             (i+1)+". 名称："+name+"，价格："+p+"，数量："+b);
            return;
         }
      }
      //循环结束，所有商品都比较完，没有找到
      System.out.println("找不到商品");
   }

   private static void f4() {
      /*
         names
         ["A", "B", "C"]
         price
         [2,    8,    3]
         numbers
         [200,  300,  180]
              0     1     2
       */
      //商品总价，单价均价，最高单价，最高总价
      double spzj = 0;//商品总价
      double djzj = 0;//单价总价
      double zgdj = 0;//最高单价
      double zgzj = 0;//最高总价
      //遍历数组
      for (int i = 0; i < names.length; i++) {
         spzj += price[i] * numbers[i];
         djzj += price[i];
         //数组中，找到更大的值
         if(price[i] > zgdj) {
            zgdj = price[i];//更大值存到这个变量
         }
         if(price[i]*numbers[i] > zgzj) {
            zgzj = price[i]*numbers[i];
         }
      }
      System.out.println("商品总价："+spzj);
      System.out.println("单价均价："+(djzj/names.length));
      System.out.println("最高单价："+zgdj);
      System.out.println("最高总价："+zgzj);
   }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164

练习题:求数字阶乘(for循环版)
需求:接收用户输入的数字,计算该数字的阶乘结果
已知:负数不可以有阶乘,0的阶乘结果是1,
5 ! = 5 x 4 x 3 x 2 x 1

package cn.cxy.exec;

import java.util.Scanner;

public class Factorial {
    public static void main(String[] args) {
        System.out.print("输入整数，求阶乘：");
        int n = new Scanner(System.in).nextInt();
        //调用f()方法，把n的值传递到f()方法，求阶乘
        f(n);
    }

    public static void f(int n) {
        if(n<0) {
            System.out.println("负数不可以求阶乘");
            return;//方法结束，返回到调用位置继续执行
        }
        if(n == 0) {
            System.out.println("0的阶乘是1");
            return;
        }
        /*
         * r = 5
         * i
         * 4, r=r*i
         * 3, r=r*i
         * 2, r=r*i
         * 1, r=r*i
         */
        long r = n;
        for(int i=n-1; i>=1; i--) {
            r *= i;
        }
        System.out.println(n+"的阶乘："+r);
    }
}
/**其实我们还可以通过递归思想解决这个问题,感兴趣的可以研究一下~*/


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

练习题:多次生成随机数,并打印第一次出现大于0.999 时的次数与生成的随机数

package cn.cxy.exec;

public class ForBreak {
    public static void main(String[] args) {
        // Math.random()可以产生[0,1)的随机浮点数
        // >0.999
        //写一个死循环, i变量用来计次
        for(int i=1; ;i++) {
            double d = Math.random();
            if(d>0.999) {
                System.out.println("第"+i+"次产生了目标值,值为:"+d);
                break;
            }
        }
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

练习题:打印100以内除了尾数为3,5,7的所有数

package cn.cxy.exec;

public class ForContinue {
    public static void main(String[] args) {
        for(int i=1;i<=100;i++) {
            int y = i%10;//100以内的数,通过取余求出尾数
            if(y==3 || y==5 || y==7) {
                continue;//如果尾数为3 5 7 ,则跳过后面的打印,进行下一轮循环
            }
            System.out.println(i);
        }
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

练习题:求质数:接收用户输入的数字,判断是否为质数
质数的概念:一个大于1的自然数,除了1和它自身外,不能被其他自然数整除的数叫做质数,也称为素数
规定:1既不是质数,也不是合数

package cn.cxy.exec;

import java.util.Scanner;

public class PrimeNumber {
    public static void main(String[] args) {
        System.out.print("请输入要判断的自然数：");
        int n = new Scanner(System.in).nextInt();
        //调用getPrimeNumber()方法，判断n是否为质数
        getPrimeNumber(n);
    }
    public static void getPrimeNumber(int n) {
        if(n<2) {//此范围内的数均不为质数
            System.out.println(n+"不是质数");
            return;//结束程序
        }
        if(n == 2) {
            System.out.println("2是质数");
            return;
        }
        //在 2到 1+n开方范围(数学理论)，找能把n整除的值(这个值也称作因子)
        //如果找到可以把n整除的第三个数，那n就不是质数,反之,n为质数
        double max = 1+ Math.sqrt(n);//max保存的是查找因子的范围

        //依次遍历范围内的所有数,验证是否存在n的因子
        for(int i=2; i<max; i++) {
            //判断n能不能被i整除,如果有,说明不是质数
            if(n%i == 0) {
                System.out.println(n+"不是质数");
                return;
            }
        }
        //如果判断了范围内的所有值，没有能整除的,则说明n是质数
        System.out.println(n+"是质数");
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

练习题:接收用户输入的数字,判断在此范围内质数的个数

package cn.cxy.exec;

import java.util.Scanner;

public class CountPrimeNumber {
    public static void main(String[] args) {
        System.out.println("输入整数n，求n内质数的数量");
        int n = new Scanner(System.in).nextInt();

        count(n);
    }

    public static void count(int n) {
        if(n<2) {
            System.out.println("没有质数");
            return;
        }
        if(n==2) {
            System.out.println("有1个质数");
            return;
        }
        //定义计数变量
        int count = 1;//已知有一个质数
        outer:   //从3到n寻找质数
        for(int i=3; i<=n ;i++) {
            //判断i是否是质数
            double max = 1+ Math.sqrt(i);
            for(int j=2; j<max; j++) {//在2到<max，找能把i整除的数
                if(i%j == 0) {//i被j整除，i不是质数
                    //跳到i++，继续判断下一个i值
                    continue outer;//跳到外部outer的位置
                }
            }
            //内层j循环结束，i是质数
            count++;
        }
        System.out.println(n+"内质数的数量："+count);
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

练习题:生成一个顺序数组,将这个数组的元素打乱顺序后输出

package cn.cxy.exec;

import java.util.Arrays;
import java.util.Random;

public class ShuffleArray {
    public static void main(String[] args) {
        //调用f()方法，从方法获取一个int[]数组
        int[] a = f();
        //遍历打印数组数据
        for(int i=0; i<a.length; i++) {
            System.out.println(a[i]);
        }
        System.out.println("\n\n----------------");

        //把a数组，传递到 shuffle() 方法打乱顺序
        shuffle(a);
        //打印乱序后的数组
        System.out.println(Arrays.toString(a));
    }

    public static int[] f() {
        //新建int[]数组，长度5
        //再把它的内存地址存到变量 a
        int[] a = new int[5];
        //遍历访问5个位置，填入1,2,3,4,5
        for(int i=0; i<a.length; i++) {
            a[i] = i+1;
        }
        //返回数组，把数组返回到调用位置
        //本质是把数组地址返回去
        return a;
    }

    public static void shuffle(int[] a) {
        /*
         *        j
         * [4, 2, 3, 1, 5]
         *     i
         *
         * *) i循环遍历数组
         * *) 随机定位下标j与i交换
         */
        for (int i = 0; i < a.length; i++) {
            //随机下标j，范围：[0, a.length)
            int j = new Random().nextInt(a.length);
            int t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

练习题:打印全三角形
需求:接收用户输入的行数,打印对应的全三角形,如图所示:

在这里插入图片描述

在这里插入图片描述

package cn.cxy.exec;

import java.util.Scanner;

public class PrintTraingle {
	public static void main(String[] args) {
		//1.提示并接收用户输入的行数:
		System.out.println("请输入您要打印星星的行数:");
		int n = new Scanner(System.in).nextInt();

		//2.开始打印图形
		//2.1外层循环控制打印的行数 i的取值范围:[1,n],一共n行
		for(int i=1;i<=n;i++){
			//2.2内层循环1
			//控制每行打印空格的个数 j的取值范围:[0,n-i),即1 2 3...
			for(int j=0;j<n-i;j++){
				System.out.print(" ");
			}
			//2.3内层循环2
			//控制每行打印星星的个数 k的取值范围:[1,2*i-1],即1 3 5 ...
			for(int k=1;k<=2*i-1;k++){
				System.out.print("*");
			}
			//2.4打印完本行所有内容后添加换行
			System.out.println();
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

练习题：模拟双色球生成案例
需求：体彩中有一项是双色球，要求在1-33号共33个红色球里选出6个，1-16号共16个蓝色球中选出一个作为中奖号码，请实现这个需求

package cn.cxy.exec;

import java.util.Arrays;
import java.util.Random;

public class ColorBall {
	public static void main(String[] args) {
		//准备两个号码数组
		int[] r = zbsz(33);//[1,2,3,4,5....33]
		int[] b = zbsz(16);//[1,2,3...16]
		System.out.println(Arrays.toString(r));
		System.out.println(Arrays.toString(b));
		//选择红球
		int[] red = selectRed(r);
		//选择蓝球
		int blue = selectBlue(b);
		System.out.println("红球："+Arrays.toString(red));
		System.out.println("蓝球："+blue);
	}
	private static int[] zbsz(int n) {//准备数组的方法
		//新建n个长度的int[]数组，存到a
		int[] a = new int[n];
		//遍历a数组，填入1到n
		for (int i = 0; i < a.length; i++) {
			a[i] = i+1;
		}
		//返回数组
		return a;
	}
	private static int[] selectRed(int[] r) {//选择红球
		/*
		 *                                           j
		 * r [10, 5, 1, 4, 2, 6, 7, 8, 9, 3, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33]
		 *                       i
		 *       
		 *         [i, r.length)
		 *      i+ [0, r.length-i)
		 */
		//i循环从0到<6
		for (int i = 0; i < 6; i++) {
			//j随机定位
			int j =
					i+ new Random().nextInt(r.length-i);
			int t = r[i];
			r[i] = r[j];
			r[j] = t;
		}
		//截取前6个位置，生成一个新数组返回
		return Arrays.copyOf(r, 6);
	}
	private static int selectBlue(int[] b) {//选择蓝球
		return b[new Random().nextInt(16)];
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

练习题:求任意自然数各位数之和
接收用户输入的任意自然数,累计所有位数数字之和
需求:接收用户输入的行数,

package cn.cxy.exec;

import java.util.Scanner;

public class SumNum {
	public static void main(String[] args) {
		//1.提示并接收用户要计算的自然数:
		System.out.println("请输出您要求和的自然数:");
		int n = new Scanner(System.in).nextInt();
		//2.定义一个变量用来保存最终求和的结果
		int sum=0;
		//3.循环获取每一位上的数
		while(n!=0){
			//4.求当前的个位数,并将个位数累加
			sum = sum + (n%10);
			//5.去掉刚刚累加过的最后一位数,得到新的整数
			//比如刚刚的十位就变成了现在的个位
			n=n/10;
		}
		//6.打印最终的结果:
		System.out.println(sum);
	}

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

练习题:求任意数组中所有元素的最大值

package cn.cxy.exec;

public class GetArrayMaxNum {
		public static void main(String[] args) {
			//1.定义一个数组
			int[] arr={90,1562,43,2,44,8,6666};
			//2.选取数组中的第一个元素开始比较
			int max=arr[0];
			//3.依次遍历数组中的每个元素
			for(int i=1;i<arr.length;i++){//i指的是下标,我们通过下标来操作数组中的元素
				//4.判断当前元素与目前最大值的大小
				if(arr[i]>max){
					//5.如果当前数组元素大于max,就讲此元素的值赋值给max
					max=arr[i];
				}
			}
			//6.打印最终的结果
			System.out.println(max);
		}
	}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

练习题:求1000以内的完数
完数:如果一个数等于其所有因子之和,我们就称这个数为"完数",比如6的因子为1,2,3 6 = 1 + 2 + 3,那么6就是一个完数

package cn.cxy.exec;
/**获取1000以内的完数*/
public class GetNum {
	public static void main(String[] args) {
		//1.循环遍历1000以内的所有数
		for(int i=1;i<=1000;i++){
			//2.定义一个变量来保存求和的结果
			int sum = 0;
			//3.求i的因子
			for(int j=1;j<=i/2;j++){
				//4.判断是否能被整除
				if(i % j == 0){
					//5.如果能整除,就是因子,因子需要累加
					sum+=j;
				}
			}
			//6.如果因子累加之和为本轮判断的数,则当前数是完数,输出
			if(sum==i){
				System.out.println(i);

			}
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

练习题： 随机数组的归并问题
需求：生成两个任意的随机数组，并将这两个数组按照数字大小按顺序归并到一个新数组中

package cn.cxy.exec;

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

public class  MergingArrays {
	   public static void main(String[] args) {
	      int[] a = suiJi();
	      int[] b = suiJi();
	      Arrays.sort(a);
	      Arrays.sort(b);
	      System.out.println(Arrays.toString(a));
	      System.out.println(Arrays.toString(b));
	      int[] c = heBing(a, b);
	      System.out.println(Arrays.toString(c));
	   }

	   private static int[] suiJi() {
	      int n = 5+ new Random().nextInt(6);
	      int[] a = new int[n];
	      for (int i = 0; i < a.length; i++) {
	         a[i] = new Random().nextInt(100);
	      }
	      return a;
	   }

	   private static int[] heBing(int[] a, int[] b) {
	      /*
	       * a[1,1,2,3,4]
	       *              j
	       * b[1,2,4,5,6,8,9]
	       *         k
	       *
	       * c[                     ]
	       *               i
	       */
	      //新建数组
	      int[] c = new int[a.length+b.length];
	      //对新数组遍历
	      for(int i=0,j=0,k=0;i<c.length;i++) {
	         if(j>=a.length) {//j越界，b数组数据一个一个放入新数组
	            //c[i] = b[k];
	            //k++;
	            //continue;
	            System.arraycopy(b,k,c,i,b.length-k);
	            break;
	         } else if(k>=b.length) {//k越界,a数组数据一个个放入新数组
	            //c[i] = a[j];
	            //j++;
	            //continue;
	            System.arraycopy(a,j,c,i,a.length-j);
	            break;
	         }
	         //j和k，较小值放入i位置，并递增
	         if(a[j]<=b[k]) {
	            c[i] = a[j];
	            j++;
	         } else {
	            c[i] = b[k];
	            k++;
	         }
	      }    
	      return c;
	   }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67

练习题：遍历二维数组打油诗

package cn.cxy.exec;

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

public class  TestArray {
	  public static void main(String[] args) {
	      char[][] a = {
	          //i
	         /*0*/{'道','路','千','万','条'},
	         /*1*/{'安','全','第','一','条'},
	         /*2*/{'行','车','不','规','范'},
	         /*3*/{'亲','人','两','行','泪'}
	             //0    1    2    3    4    j
	      };
	      /* j是外层循环，递增
	       *    i是内层循环，递减
	       * 亲行安道
	       * 人车全路
	       * 两不第千
	       */
	      for(int j=0;j<a[0].length;j++) {
	         for(int i=a.length-1; i>=0; i--) {
	            System.out.print(a[i][j]);
	         }
	         System.out.println();
	      }
	   }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

练习题:求猴子大王
15个猴子围成一圈选大王,依次1-7循环报数,报到7的猴子被淘汰,直到最后一只猴子称为大王,问:哪只猴子会成为大王?

package cn.cxy.exec;
/**猴子选大王*/
public class MonkeyKing {
	public static void main(String[] args) {
		//1.定义长度为15的数组保存猴子,boolean类型是为了判断猴子是否存活
		boolean[] b=new boolean[15];

		//2.依次遍历每一只猴子
		//true---未淘汰  false---已淘汰
		for(int i=0;i<b.length;i++){
			b[i]=true;//先把所有猴子设置成存活
		}
		//3.定义变量保存猴子报的数
		int num=0;
		//4.定义变量保存剩余的猴子数
		int monkeyLeft=15;
		//5.定义数组下标
		int index=0;
		//6.循环,直到只剩最后一只猴子(猴子王)
		while(monkeyLeft>1){//判断条件
			//7.检测猴子是否已淘汰
			if(b[index]){
				//8.报数
				num++;
				//9.判断报数是否为7
				if(num==7){
					b[index]=false;//为7淘汰
					monkeyLeft--;//猴子数减一
					num=0;//报数归零
				}

			}

			//10.下标移动
			index++;
			//11.围成一圈---最后一个置为0
			if(index==15){
				index=0;
			}
		}

		//遍历数组,找到最后活着的那个猴子王
		for(int i=0;i<b.length;i++){
			if(b[i]){
				System.out.println(i+1);
			}
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

练习题:斐波那契问题
已知:斐波那契数列的前几个数分别为0,1,1,2,3,5…从第三项开始,每一项都等于前两项的和.请接收用户输入的整数n,求出此数列的前n项.

package cn.cxy.exec;

import java.util.Scanner;

/**斐波那契数列*/
public class Faibonacci {
	public static void main(String[] args) {
		System.out.println("请输入您要测试的数:");
		int n = new Scanner(System.in).nextInt();
		//判断n是否是不正常的范围
		if(n<1){
			System.out.println("输入数据有误！！！");
		}
		//n==1
		if(n==1){
			System.out.println(0);
		}
		//n==2
		if(n==2){
			System.out.println(0+"\t"+1);	
		}
		//n==3
		if(n==3){
			System.out.println(0+"\t"+1+"\t"+1);	
		}
		//拼接前n项
		if(n>3){
			System.out.print(0+"\t"+1+"\t"+1+"\t");	
		}
		//循环输出后面的数据
		int f1=1;
		int f2=1;
		int next=0;
		for(int i=4;i<=n;i++){
			next=f1+f2;
			f1=f2;
			f2=next;
			System.out.print(next+"\t");
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

练习题:古典问题：生兔兔问题
有一对兔子，从出生后第3个月起都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月兔子的对数为多少？
程序分析：前两个月兔子的对数为1
从第三个月开始，兔子的对数变成了 2 3 5 8 13 21 …

package cn.cxy.exec;

import java.util.Scanner;

public class GetRabbitNum {
	public static void main(String[] args) {
		System.out.println("请输入要判断的月数：");
		int month = new Scanner(System.in).nextInt();
		System.out.println("第"+month+"月兔子的对数为："+getSum(month));
	}

	public static int getSum(int month) {
		//如果是前两个月，还是1对兔子
		if(month == 1 || month == 2) {
			return 1;
		}else {
			//从第三个开始，兔子按照2 3 5 8 13 21变化
			return getSum(month-1)+getSum(month-2);
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

练习题:打印水仙花数
水仙花数：是指一个三位数，其各位数字立方和等于该数字本身
例如：153就是一个水仙花数，因为153 = 1³ + 5³ + 3³

package cn.cxy.exec;

public class GetNum {
	public static void main(String[] args) {
		//1.遍历所有的三位数
		for (int i = 100; i < 1000; i++) {
			//2.调用自定义方法判断是不是水仙花数
			if(isAim(i)) {
				//3.如果是水仙花数，就打印
				System.out.println(i);
			}
		}
	}

	//4.自定义判断水仙花数的方法
	public static boolean isAim(int a) {
		int x = a/100;
		int y = a/10%10;
		int z = a%10;
		if(a == x*x*x+y*y*y+z*z*z) {
			return true;
		}
		return false;
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

练习题：面向对象 封装百分制分数
需求：封装百分制分数，和它对应的五档分制分数

分数类：

package cn.cxy.exec;

public class Score {
	//成员变量
	int score;
	char level;
	//构造方法
	public Score(int score) {
		this.score = score;
		//计算五档分数，保存到成员变量level
		this.level = setLevel(score);
	}

	private char setLevel(int s) {
		char r = 0;
		switch(s/10) {
		case 10:case 9:
			r = 'A';break;
		case 8:case 7:
			r = 'B';break;
		case 6:
			r = 'C';break;
		case 5:case 4:case 3:case 2:
			r = 'D';break;
		case 1:case 0:
			r = 'E';break;
		}
		return r;

	}

	public String toString() {
		return score+", "+level;
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

测试类：

package cn.cxy.exec;

public class TestScore {
public static void main(String[] args) {
/*
A [90,100]
B [70,90)
C [60,70)
D [20,60)
E [0,20)
*/
Score s = new Score(54);
System.out.println(s.toString());
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

练习题:面向对象 打印图形
需求：设计一个可以随机打印形状的代码

形状类【父类】：

package cn.cxy.exec;

public class Shape {
	public void draw() {
		//无意义代码
		//在子类中要重写draw()方法
		System.out.println("图形形状");
	}
	public void clear() {
		System.out.println("\n\n\n");
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

圆形类【子类】：

package cn.cxy.exec;

public class Circle extends Shape {
	@Override
	public void draw() {
		System.out.println("打印一个圆形 O");
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

方形类【子类】：

package cn.cxy.exec;

public class Square extends Shape {
	@Override
	public void draw() {
		System.out.println("打印一个方形 口");
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

直线类【子类】：

package cn.cxy.exec;

public class Line extends Shape {
	@Override
	public void draw() {
		System.out.println("打印一条直线 ————");
	}

	public void length() {
		System.out.println("一米多。。。");
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

测试类：随机生成图形

package cn.cxy.exec;

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

public class TestShape {
	public static void main(String[] args) {
		System.out.println("按回车继续");
		while(true) {
			int r = new Random().nextInt(4);
			switch(r) {
			case 0: f(new Shape()); break;
			case 1: f(new Line()); break;
			case 2: f(new Square()); break;
			case 3: f(new Circle()); break;
			}
		}
	}

	/*
	 * Shape
	 *   |- Line
	 *   |- Square
	 *   |- Circle
	 */
	static void f(Shape s) {
		System.out.println("----------------");
		new Scanner(System.in).nextLine();
		s.draw();
		//向上转型后，只能调用父类定义的通用成员
		//子类特有成员不能调用
		//s.length();
		//s对象的真实类型是 Line 类型
		if(s instanceof Line) {
			//向下转型成Line类型，才能调用它特有的方法
			Line line = (Line) s;
			line.length();
		}
		new Scanner(System.in).nextLine();
		s.clear();
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

练习题:面向对象 设计士兵类
需求：设计士兵与武器AK47类，并完成前进、进攻、发射子弹、装载子弹的功能

士兵类：

package cn.cxy.exec;
/*
 * 封装：
 *     士兵相关的属性数据、逻辑运算方法，
 *     封装成一个士兵“类”组件
 */
import java.util.Random;
public class Soldier {
	//成员变量，属性变量
	int id; //默认值0
	int blood = 100;
	AK47 a;//默认 null 值

	//成员方法
	public void go() {
		//this是一个特殊引用
		//引用“当前对象”的地址
		//当前对象：谁调用就是谁
		//可以省略，缺省存在
		System.out.println(this.id+"号士兵前进");
	}

	public void attack() {
		if(blood == 0) {
			System.out.println("这是"+id+"号士兵的尸体");
			return;//方法结束
		}
		System.out.println(id+"号士兵进攻");
		if(a != null) {
			a.fire();//调用枪发射子弹
		}
		//模拟进攻掉血
		//随机的减血量
		int d = new Random().nextInt(10);
		blood -= d;    
		if(blood < 0) {//不允许负数血量
			blood = 0;
		}
		System.out.println("血量："+blood);
		//血量是0
		if(blood == 0) {
			System.out.println(id+"号士兵阵亡");
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

武器类：

package cn.cxy.exec;
import java.util.Random;
/*
 * 封装：
 *     AK47武器相关的属性数据、运算代码，
 *     封装成一个“类”组件
 */
public class AK47 {
	int bullets = 100;
	public void fire() {
		if(bullets == 0) {
			System.out.println("没有子弹");
			return;
		}
		//随机产生发射子弹数量
		int r = new Random().nextInt(10);
		//要发射的数量，比现有子弹多
		if(r > bullets) {
			r = bullets;//有多少发多少
		}
		bullets -= r;
		for(int i=0;i<r;i++) {
			System.out.print("突");
		}
		System.out.println("~");
		if(bullets == 0) {
			System.out.println("弹夹空了");
		}
	}

	public void load() {
		bullets = 100;
		System.out.println("弹夹已装满");
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

测试类1：

package cn.cxy.exec;

public class Test1 {
	public static void main(String[] args) {
		//新建 Soldier 士兵对象
		//内存地址，保存到变量s1
		Soldier s1 = new Soldier();
		Soldier s2 = new Soldier();
		//用s1引用第一个士兵对象
		//为它的id赋值
		s1.id = 9527;
		s2.id = 9528;
		//用s1找到第一个士兵对象
		//让第一个士兵执行go()方法代码
		s1.go();
		s2.go();
		//新建 AK47 对象，保存到s1.a
		s1.a = new AK47();
		s2.a = new AK47();
		s2.attack();
		s2.attack();
		s2.attack();
		s2.attack();
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

测试类2：

package cn.cxy.exec;

import java.util.Scanner;

public class Test2 {
	public static void main(String[] args) {
		//新建AK47对象，地址存到变量a
		AK47 a = new AK47();
		System.out.println("按回车射击，输入load装载子弹");
		while(true) {
			String s = new Scanner(System.in).nextLine();
			if(s.equals("load")) {
				a.load();
				continue;
			}
			a.fire();
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

练习题:面向对象 设计宠物类
需求：设计宠物类，用户可以自由选择养猫还是养狗，可以给宠物起名字，还可以实现喂食互动的功能，宠物需要有饱食度和快乐度

宠物类【父类】：

package cn.cxy.exec;
public class Pet {
	String name;
	int full;
	int happy;
	public Pet(String name) {
		this(name, 50, 50);
	}
	public Pet(String name,int full,int happy) { 
		this.name = name;
		this.full = full;
		this.happy = happy;
	}
	public void feed() {//宠物的喂食方法
		if(full == 100) {
			System.out.println(name+"已经吃饱了");
			return;
		}
		System.out.println("给"+name+"喂食");
		full += 10;
		System.out.println("饱食度："+full);
	}
	public void play() {//宠物的互动玩耍方法
		if(full == 0) {
			System.out.println(name+"已经饿得玩不动了");
			return;
		}
		System.out.println("陪"+name+"玩耍");
		happy += 10;
		full -= 10;
		System.out.println("快乐度："+happy);
		System.out.println("饱食度："+full);
	}
	public void punish() {//宠物的惩罚方法
		//子类不同的代码，改成调方法
		System.out.println(
				"打"+name+"的pp，"+name+"哭叫："+cry());
		happy -= 10;
		System.out.println("快乐度："+happy);
	}
	public String cry() {//小动物被打哭了
		//无意义代码
		//cry()方法需要在子类中重写，返回具体哭叫声
		return "此处有哭叫声";
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

小猫类【子类】：

package cn.cxy.exec;
public class Cat extends Pet{
	public Cat(String name, int full, int happy) {
		super(name, full, happy);
	}
	public Cat(String name) {
		super(name);
	}
	@Override
	public String cry() {
		return "喵~";
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

小狗类【子类】：

package cn.cxy.exec;
public class Dog extends Pet {
	public Dog(String name, int full, int happy) {
		super(name, full, happy);
	}
	public Dog(String name) {
		super(name);
	}
	@Override
	public String cry() {
		return "汪~";
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

测试类：

package cn.cxy.exec;

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

public class TestPet {
	public static void main(String[] args) {
		System.out.println("1. 狗");
		System.out.println("2. 猫");
		System.out.print("选择：> ");
		int c = new Scanner(System.in).nextInt();
		System.out.print("给宠物起个名字：");
		String n = new Scanner(System.in).nextLine();
		//定义猫狗变量
		Dog dog = null;
		Cat cat = null;
		if(c == 1) {
			dog = new Dog(n);
			play(dog);
		} else {
			cat = new Cat(n);
			play(cat);
		}
	}
	private static void play(Dog dog) {
		System.out.println("按回车执行");
		while(true) {
			new Scanner(System.in).nextLine();
			int r = new Random().nextInt(6);
			switch(r) {
			case 0: dog.feed(); break;
			case 1: dog.play(); break;
			default: dog.punish(); break;
			}
		}
	}
	private static void play(Cat cat) {
		System.out.println("按回车执行");
		while(true) {
			new Scanner(System.in).nextLine();
			int r = new Random().nextInt(6);
			switch(r) {
			case 0: cat.feed(); break;
			case 1: cat.play(); break;
			default: cat.punish(); break;
			}
		}
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

将对象（使用类创建的对象）存入到数组里面并将对象的内容打印出来

package com.cy;

import java.util.Arrays;

public  class TestChong {
    public static void main(String[] args) {

        Aa aa = new Aa("aaa");
        Aa[] aas = new Aa[3];
        aas[0] = aa;
        System.out.println(Arrays.toString(aas));
    }
}
 class    Aa{

    public Aa(String str){
        System.out.println(str);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/693850
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号