Java编程练习题：Demo17-Demo32

目录

Demo17. 编写程序，提示用户输入以英镑为单位的体重，以及以英寸为单位的身高，然后显示BMI

Demo18. 判断输入的年份是不是闰年。

Demo19. 假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢

Demo20. (代数：解一元二次方程)可以使用下面的公式求一元二次方程ax²+bx+c=0的两个根

Demo21. (代数：求解2×2线性方程)可以使用编程练习题1.13中给出的Cramer规则解线性方程组

Demo22. 编写程序，找到将来的日期

Demo23. (回文数字)编写一个程序，提示用户输人一个三位的整数，然后确定它是否回文数字

Demo24. (游戏:剪刀、石头、布)编写可以玩流行的剪刀-石头-布游戏的程序

Demo25. (科学：某天是星期几) 编写程序，提示用户输入年、月和该月的哪一天，然后显示它是一周中的星期几

Demo26. (几何:点是否在圆内?）编写程序，提示用户输入一个点(x，y)，然后检查这个点是否在以原点(0，0)为圆心、半径为10的圆内

Demo27. (几何:点是否在矩形内?）编写程序，提示用户输人点(x，y)，然后检测该点是否在以原点(0,0)为中心、宽为10、高为5的矩形中

Demo28. (几何:点是否在三角形内?）编写程序，提示用户输入一个点的x坐标和y坐标，然后判定这个点是否在该三角形内

Demo30. (几何：两个圆）编写程序，提示用户输人两个圆的中心坐标和各自的半径值，然后决定第二个圆是在第一个圆内，还是和第一个圆重叠

Demo31. (使用操作符&&、||和^)编写一个程序，提示用户输人一个整数值， 然后判定它是否能被5和6整除，是否能被5或6整除， 以及是否能被5或6整除但是不能同时被它们整除。

Demo32. 编写一个程序，随机产生一个0到100之间且包含0和100的整数

---

Demo17. 编写程序，提示用户输入以英镑为单位的体重，以及以英寸为单位的身高，然后显示BMI

       身体质量指数（BMI)是关于体重指标的健康测量。可以通过以千克为单位的体重除以以米为单位的身高的平方，得到BMI的值。针对20岁及以上年龄的人群，他们的BMI值的说明如表所示：

注意:一磅是0.45359237千克，而一英寸是0.0254米。

import java.util.Scanner;

/*
    编写程序，提示用户输入以英镑为单位的体重，以及以英寸为单位的身高，然后显示BMI
    身体质量指数（BMI)是关于体重指标的健康测量。
    可以通过以千克为单位的体重除以以米为单位的身高的平方，得到BMI的值。
    注意:一磅是0.45359237千克，而一英寸是0.0254米。

    计算公式：BMI =体重 / 身高^2
    BMI ＜ 18.5:过轻
    18.5≤ BMI ＜24:正常
    24 ≤ BMI ＜27:过重
    27 ≤ BMI ＜ 30:轻度肥胖
    30 ≤ BMI < 35:中度肥胖
    BMI ≥ 35:重度肥胖
 */
public class Demo17 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入你的体重(磅)、身高(英寸)：");
        double weight = scan.nextFloat();
        double height = scan.nextFloat();
        judgeBMI(weight, height);
    }

    public static void judgeBMI(double weight, double height) {
        // 计算公式：BMI =体重 / 身高^2
        double bMI = weight * 0.45359237 / Math.pow((height * 0.0254), 2);
        if (bMI < 18.5) {
            System.out.println("偏瘦");
        }else if (bMI < 25.0) {
            System.out.println("正常");
        }else if (bMI < 30.0) {
            System.out.println("超重");
        }else {
            System.out.println("过胖");
        }
    }
}

结果：

Demo18. 判断输入的年份是不是闰年。

要点提示:如果某年可以被4整除而不能被100整除，或者可以被400整除，那么这一年就是闰年。

import java.util.Scanner;

/*
判断输入的年份是不是闰年。
要点提示:如果某年可以被4整除而不能被100整除，或者可以被400整除，那么这一年就是闰年。
 */
public class Demo18 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入年份：");
        int year = scan.nextInt();
        if (judgeYear(year)){
            System.out.println(year + "是闰年");
        }else {
            System.out.println(year + "是平年");
        }
    }

    public static boolean judgeYear(int year) {
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
            return true;
        }
        return false;
    }
}

结果：

Demo19. 假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢

1）如果用户的输入数匹配彩票的实际顺序，奖金为10 000美元。

2）如果用户输入的所有数字匹配彩票的所有数字，奖金为3000美元。

3）如果用户输入的一个数字匹配彩票的一个数字，奖金为1000美元。

import java.util.Scanner;

public class Demo19 {
    /*
    假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，
    提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢
    1）如果用户的输入数匹配彩票的实际顺序，奖金为10 000美元。
    2）如果用户输入的所有数字匹配彩票的所有数字，奖金为3000美元。
    3）如果用户输入的一个数字匹配彩票的一个数字，奖金为1000美元。
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的彩票号码(如：10)：");
        int num = scanner.nextInt();
        judgePrize(num);
    }

    public static void judgePrize(int num) {
        int winNum = (int)(Math.random() * 90 + 10);
        if (num == winNum) {
            System.out.println("恭喜你中奖了，奖金为10 000美元！" + "你的号码：" + num + "，本期中奖号：" + winNum);
        }else if (num / 10 == winNum % 10 && num % 10 == winNum / 10) {
            System.out.println("恭喜你，奖金为3000美元！" + "你的号码：" + num + "，本期中奖号：" + winNum);
        }else if (num / 10 == winNum / 10 || num % 10 == winNum % 10 || num / 10 == winNum % 10 || num % 10 == winNum / 10) {
            System.out.println("恭喜你，奖金为1000美元！" + "你的号码：" + num + "，本期中奖号：" + winNum);
        }else {
            System.out.println("很遗憾，未中奖！" + "你的号码：" + num + "，本期中奖号：" + winNum);
        }
    }
}

结果：

Demo20. (代数：解一元二次方程)可以使用下面的公式求一元二次方程ax²+bx+c=0的两个根

                和

       b²-4ac称作一元二次方程的判别式。如果它是正值，那么一元二次方程就有两个实数根。如果它为0，方程式就只有一个根。如果它是负值，方程式无实根。
       编写程序，提示用户输人a、b和c的值，并且显示基于判别式的结果。如果这个判别式为正，显示两个根。如果判别式为0，显示一个根。否则，显示“The equation has no real roots”(该方程式无实数根)。

import java.util.Scanner;

public class Demo20 {
    /*
     (代数：解一元二次方程)可以使用下面的公式求一元二次方程ax²+bx+c=0的两个根
     b²-4ac称作一元二次方程的判别式。如果它是正值，那么一元二次方程就有两个实数根。
     如果它为0，方程式就只有一个根。如果它是负值，方程式无实根。

     编写程序，提示用户输人a、b和c的值，并且显示基于判别式的结果。
     如果这个判别式为正，显示两个根。如果判别式为0，显示一个根。
     否则，显示“The equation has no real roots”(该方程式无实数根)。
     */

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入一个一元二次方程(ax²+bx+c=0)：");
        double a = scan.nextDouble();
        double b = scan.nextDouble();
        double c = scan.nextDouble();
        solveEquations(a, b, c);
    }

    public static void solveEquations(double a, double b, double c) {
        double condition = Math.pow(b, 2) - 4 * a * c;
        if(condition > 0) {
            double x1 = (-b + Math.pow(condition, 0.5)) / (a * 2);
            double x2 = (-b - Math.pow(condition, 0.5)) / (2 * a);
            System.out.println("第一个根：" + x1 + ",第二个根：" + x2);
        } else if (condition == 0) {
            double x1 = (-b + Math.pow(condition, 0.5)) / (2 * a);
            System.out.println("方程的根：" + x1);
        } else {
            System.out.println("The equation has no real roots");
        }
    }
}

结果：

Demo21. (代数：求解2×2线性方程)可以使用编程练习题1.13中给出的Cramer规则解线性方程组

               
编写程序，提示用户输入a，b ，c，d，e和f，然后显示结果。如果ad-bc为0，报告消息“The equation  has no solution”(方程式无解)。

习题1.13详见：Demo07Java基础语法编程题（Demo01-Demo8）_不会敲代码的HZ的博客-CSDN博客

测试用例 ： 

import java.util.Scanner;

public class Demo21 {
    /*
    编写程序，提示用户输入a，b ，c，d，e和f，然后显示结果。
    如果ad-bc为0，报告消息“The equation has no solution”(方程式无解)。
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入一个二元二次方程(ax+by=e,cx+dy=f)：的a,b,c,d,e,f的值：");
        double a = scan.nextDouble();
        double b = scan.nextDouble();
        double c = scan.nextDouble();
        double d = scan.nextDouble();
        double e = scan.nextDouble();
        double f = scan.nextDouble();
        solveEquations(a, b, c, d, e, f);
    }

    public static void solveEquations(double a, double b, double c, double d, double e, double f) {
        // (ax+by=e,cx+dy=f)
        // x = (ed - bf) / (ad - bc); y = (af - ec) / (ad - bc);
        if (a * d - b * c == 0) {
            System.out.println("方程式无解");
        }else {
            double x = (e * d - b * f) / (a * d - b * c);
            double y = (a * f - e * c) / (a * d - b * c);
            System.out.println("x = " + x + "y = " + y);
        }
    }
}

结果：

Demo22. 编写程序，找到将来的日期

       编写一个程序，提示用户输入代表今天日期的数字(周日为0，周一为1,……,周六为6)。同时，提示用户输人一个今天之后的天数，作为代表将来某天的数字，然后显示这天是星期几。下面是一个运行示例:

import java.util.Scanner;

public class Demo22 {
    /*
    编写一个程序，提示用户输入代表今天日期的数字(周日为0，周一为1,……,周六为6)。
    同时，提示用户输人一个今天之后的天数，作为代表将来某天的数字，然后显示这天是星期几
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入今天日期的数字(周日为0，周一为1,……,周六为6)：");
        int day = scan.nextInt();
        System.out.println("请输入今天今天之后的天数：");
        int nextDay = scan.nextInt();
        judgeWeek(day, nextDay);
    }

    public static void judgeWeek(int day, int nextDay) {
        if (day < 0 || day > 6) {
            System.out.println("您输入的日期有误！");
        } else {
            int week = (day + nextDay) % 7;
            // System.out.println(week);
            switch (week){
                case 0:
                    System.out.println("星期日");
                    break;
                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;
            }
        }
    }
}

结果：

Demo23. (回文数字)编写一个程序，提示用户输人一个三位的整数，然后确定它是否回文数字

当从左到右，以及从右到左都是一样的话，这个数字称为回文数。下面是程序的一个运行示例:

import java.util.Scanner;

public class Demo23 {
    /*
    (回文数字)编写一个程序，提示用户输人一个三位的整数，然后确定它是否回文数字
    当从左到右，以及从右到左都是一样的话，这个数字称为回文数。
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入一个三位的整数：");
        int a = scan.nextInt();
        loopNum(a);
    }

    public static void loopNum(int a){
        int bai = a / 100;
        int ge = a % 100 % 10;
        if (bai == ge) {
            System.out.println(a + "是回文数");
        }else{
            System.out.println(a + "不是回文数");
        }
    }
}

结果：

Demo24. (游戏:剪刀、石头、布)编写可以玩流行的剪刀-石头-布游戏的程序

(剪刀可以剪布，石头可以砸剪刀，而布可以包石头。)程序提示用户随机产生一个数，这个数为0、1或者2，分别表示石头、剪刀和布。程序提示用户输人值0、1或者2，然后显示一条消息，表明用户和计算机谁赢了游戏，谁输了游戏，或是打成平手。下面是运行示例:

public class Demo24 {
    /*
    (游戏:剪刀、石头、布)编写可以玩流行的剪刀-石头-布游戏的程序
    (剪刀可以剪布，石头可以砸剪刀，而布可以包石头。)
    程序随机产生一个数，这个数为0、1或者2，分别表示石头、剪刀和布。
    程序提示用户输人值0、1或者2，
    然后显示一条消息，表明用户和计算机谁赢了游戏，谁输了游戏，或是打成平手。
     */
    public static void main(String[] args) {
        int play1 = (int) (Math.random() * 3); // 随机一个[0, 3)的整数；
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入0、1或者2，分别表示石头、剪刀和布：");
        int play2 = scan.nextInt();
        guessHand(play1, play2);
    }

    public static void guessHand(int play1, int play2) {
        if (play2 < 0 || play2 > 2) {
            System.out.println("你出的有误！");
        } else {
            // (剪刀可以剪布，石头可以砸剪刀，而布可以包石头。)
            // 0 石头，1 剪刀，2 布
            if (play1 == play2) {
                System.out.println("打成平手");
            } else if (play1 == 0 && play2 == 1) {
                System.out.println("恭喜你赢了！战胜了电脑");
            } else if (play1 == 0 && play2 == 2){
                System.out.println("很遗憾你输了！电脑赢了");
            } else if (play1 == 1 && play2 == 0){
                System.out.println("很遗憾你输了！电脑赢了");
            } else if (play1 == 1 && play2 == 2){
                System.out.println("恭喜你赢了！战胜了电脑");
            } else if (play1 == 2 && play2 == 0){
                System.out.println("恭喜你赢了！战胜了电脑");
            } else if (play1 == 2 && play2 == 1){
                System.out.println("很遗憾你输了！电脑赢了");
            }
        }
    }
}

结果：

Demo25. (科学：某天是星期几) 编写程序，提示用户输入年、月和该月的哪一天，然后显示它是一周中的星期几

泽勒一致性是由克里斯汀·泽勒开发的用于计算某天是星期几的算法。

import java.util.Scanner;

public class Demo25 {
    /*
    (科学：某天是星期几) 编写程序，提示用户输入年、月和该月的哪一天，然后显示它是一周中的星期几
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = scan.nextInt();
        System.out.println("请输入月份(1-12)：");
        int m = scan.nextInt();
        System.out.println("请输入是这个月的第几天：");
        int q = scan.nextInt();
        int week = judgeWeek(year, m, q);
        System.out.println("这天是星期" + (week + 1));
    }

    public static int judgeWeek(int year, int m, int q) {
        if (m > 2) {
            m += 12;
            year -= 1;
        }
        int j = Math.abs(year / 100);
        int k = year % 100;
        int h = (q + ((26 * (m + 1)) / 10) + k + k / 4 + j / 4 + 5 * j) % 7;
        return h;
    }
}

结果：

Demo26. (几何:点是否在圆内?）编写程序，提示用户输入一个点(x，y)，然后检查这个点是否在以原点(0，0)为圆心、半径为10的圆内

例如:(4，5)是圆内的一点，而(9，9)是圆外的一点
提示:如果一个点到(0，0)的距离小于或等于10，那么该点就在圆内，计算距离的公式是，使用各种情况来测试你的程序。以下是两个运行示例。

import java.util.Scanner;

public class Demo26 {
    /*
    (几何:点是否在圆内?）编写程序，提示用户输入一个点(x，y)，
    然后检查这个点是否在以原点(0，0)为圆心、半径为10的圆内
    例如:(4，5)是圆内的一点，而(9，9)是圆外的一点
    提示:如果一个点到(0，0)的距离小于或等于10，那么该点就在圆内，计算距离的公式是
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入点x, y(例如 1 2 ==> (1, 2):");
        double x = scan.nextDouble();
        double y = scan.nextDouble();
        judgePoint(x, y);
    }

    public static void judgePoint(double x, double y) {
        double d = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
        if (d < 10) {
            System.out.println("(" + x + ", " + y + ")" + "这个点在圆内");
        } else if (d == 10){
            System.out.println("(" + x + ", " + y + ")" + "这个点在圆上");
        } else {
            System.out.println("(" + x + ", " + y + ")" + "这个点在圆外");
        }
    }
}

结果：

Demo27. (几何:点是否在矩形内?）编写程序，提示用户输人点(x，y)，然后检测该点是否在以原点(0,0)为中心、宽为10、高为5的矩形中

例如:(2,2)在矩形内，而(6,4)在矩形外。提示:如果一个点到点（0,0)的水平距离小于等于10/2且到点（0,0)的垂直距离小于等于5.0/2,该点就在矩形内，使用各种情况来测试你的程序。

import java.util.Scanner;

public class Demo27 {
    /*
    (几何:点是否在矩形内?）编写程序，提示用户输人点(x，y)，
    然后检测该点是否在以原点(0,0)为中心、宽为10、高为5的矩形中
    例如:(2,2)在矩形内，而(6,4)在矩形外。
    提示:如果一个点到点（0,0)的水平距离小于等于10/2
    且到点（0,0)的垂直距离小于等于5.0/2,该点就在矩形内，使用各种情况来测试你的程序。
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入点x, y(例如 1 2 ==> (1, 2):");
        double x = scan.nextDouble();
        double y = scan.nextDouble();
        judgePoint(x, y);
    }

    public static void judgePoint(double x, double y) {
        double level = x;
        double vertical = y;
        if (level <= 10.0 /2 && vertical <= 5.0 / 2) {
            System.out.println("(" + x + ", " + y + ")" + "这个点在矩形内");
        } else {
            System.out.println("(" + x + ", " + y + ")" + "这个点不在矩形内");
        }
    }
}

结果：

Demo28. (几何:点是否在三角形内?）编写程序，提示用户输入一个点的x坐标和y坐标，然后判定这个点是否在该三角形内

假设一个直角三角形放在一个平面上，如下图所示。直角点在（0,0)处，其他两个点分别在（200，0)和(0，100）处。下面是运行示例

解答思路：

定义一个求两点之间距离的函数，和一个求三角形面积的函数，如果点在三角形内，则三角形的面积应该等于点和三边构成的三个三角形之和，如果不等，则说明不在。

import java.util.Scanner;

public class Demo28 {
    /*
    (几何:点是否在三角形内?）编写程序，提示用户输入一个点的x坐标和y坐标，
    然后判定这个点是否在该三角形内
    假设一个直角三角形放在一个平面上，如下图所示。
    直角点在（0,0)处，其他两个点分别在（200，0)和(0，100）处。
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入点x, y(例如 1 2 ==> (1, 2)：");
        double x = scan.nextDouble();
        double y = scan.nextDouble();
        judgePoint(x, y);
    }

    public static void judgePoint(double x, double y) {
        if (x == 0) {
            if (y > 100 || y < 0) {
                System.out.println("(" + x + ", " + y + ")" + "不在三角形内！");
            }else if (y <= 100) {
                System.out.println("(" + x + ", " + y + ")" + "在三角形内！");
            }
        }else if (y == 0){
            if (x > 200 || x < 0){
                System.out.println("(" + x + ", " + y + ")" + "不在三角形内！");
            }else if (x <= 200) {
                System.out.println("(" + x + ", " + y + ")" + "在三角形内！");
            }
        }else if (x < 0 || y < 0) {
            System.out.println("(" + x + ", " + y + ")" + "不在三角形内！");
        }else {
            // 三角形的三边
            double a = 100;
            double b = 200;
            double c = calcDistance(0, 100, 200, 0);
            double area = helen(a, b, c);
            // 点道三角形三个顶点的距离
            double d1 = calcDistance(x, y, 0, 0);
            double d2 = calcDistance(x, y, 200, 0);
            double d3 = calcDistance(x, y, 0, 100);
            double area1 = helen(d1, d2, b);
            double area2 = helen(d1, d3, a);
            double area3 = helen(d2, d3, c);
            if (Math.round(area) == Math.round(area1 + area2 + area3)) {
                System.out.println("(" + x + ", " + y + ")" + "在三角形内！");
            } else {
                System.out.println("(" + x + ", " + y + ")" + "不在三角形内！");
            }
        }
    }

    public static double calcDistance(double x1, double y1, double x2, double y2) {
        double distance = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
        return distance;
    }

    public static double helen(double a, double b, double c) {
        double area = 0;
        if (a + b > c && a + c > b && b + c > a){
            double perimeter = a + b + c;
            double p = perimeter / 2;
            area = Math.pow((p * (p - a) * (p - b) * (p - c)), 0.5);
            // System.out.println("三角形的周长：" + perimeter + "，面积：" + area);
        }
        return area;
    }
}

结果：

Demo29. (几何:两个矩形）编写一个程序，提示用户输入两个矩形中点的x坐标和y坐标以及它们的宽度和高度，然后判定第二个矩形是在第一个矩形内，还是和第一个矩形重叠，如图所示。

import java.util.Scanner;

public class Demo29 {
    /*
    (几何:两个矩形）编写一个程序，提示用户输入两个矩形中点的x坐标和y坐标以及它们的宽度和高度，
    然后判定第二个矩形是在第一个矩形内，还是和第一个矩形重叠，如图所示。
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入矩形1中点的x坐标、y坐标、宽度、高度：");
        double x1 = scan.nextDouble(), y1 = scan.nextDouble();
        double weight1 = scan.nextDouble(), height1 = scan.nextDouble();
        System.out.print("请输入矩形2中点的x坐标、y坐标、宽度、高度：");
        double x2 = scan.nextDouble(), y2 = scan.nextDouble();
        double weight2 = scan.nextDouble(), height2 = scan.nextDouble();
        judgePoint(x1, y1, weight1, height1, x2, y2, weight2, height2);
    }

    public static void judgePoint(double x1, double y1, double weight1, double height1, double x2, double y2, double weight2, double height2) {
        double level = Math.abs(x2 - x1);
        double vertical = Math.abs(y2 - y1);
        if (weight1 >= weight2) {
            if (level + weight2 / 2 <= weight1 / 2 && vertical + height2 / 2 <= height1 / 2) {
                System.out.println("矩形2在矩形1这个在矩形内！");
            } else if (level - weight2 / 2 <= weight1 / 2 && vertical - height2 / 2 <= height1 / 2) {
                System.out.println("矩形2和矩形1重叠！");
            } else if (level - weight2 / 2 > weight1 / 2 && vertical - height2 / 2 > height1 / 2) {
                System.out.println("矩形2和矩形1互不重叠！");
            }
        }else if (weight2 >= weight1) {
            if (level + weight1 / 2 <= weight2 / 2 && vertical + height1 / 2 <= height2 / 2) {
                System.out.println("矩形2在矩形1这个在矩形内！");
            } else if (level - weight1 / 2 <= weight2 / 2 && vertical - height1 / 2 <= height2 / 2) {
                System.out.println("矩形2和矩形1重叠！");
            } else if (level - weight1 / 2 > weight2 / 2 && vertical - height1 / 2 > height2 / 2) {
                System.out.println("矩形2和矩形1互不重叠！");
            }
        }
    }
}

结果：

Demo30. (几何：两个圆）编写程序，提示用户输人两个圆的中心坐标和各自的半径值，然后决定第二个圆是在第一个圆内，还是和第一个圆重叠

提示:如果两个圆心的距离≤|r1-r2|，就认为circle2在circlel内;如果两个圆心的距离≤r1+r2,就认为circle2和 circle1重叠。

import java.util.Scanner;

public class Demo30 {
    /*

     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入矩形1中点的x坐标、y坐标、半径：");
        double x1 = scan.nextDouble(), y1 = scan.nextDouble();
        double r1 = scan.nextDouble();
        System.out.print("请输入矩形2中点的x坐标、y坐标、半径：");
        double x2 = scan.nextDouble(), y2 = scan.nextDouble();
        double r2 = scan.nextDouble();
        judgePoint(x1, y1, r1, x2, y2, r2);
    }

    public static void judgePoint(double x1, double y1, double r1, double x2, double y2, double r2) {
        double d = calcDistance(x1, y1, x2, y2);
        if (d <= Math.abs(r1 - r2)) {
            System.out.println("第二个圆在第一个圆内！");
        } else if (d <= r1 + r2) {
            System.out.println("两个圆重叠！");
        } else {
            System.out.println("两个圆互不干扰！");
        }
    }

    public static double calcDistance(double x1, double y1, double x2, double y2) {
        double distance = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
        return distance;
    }
}

结果：

Demo31. (使用操作符&&、||和^)编写一个程序，提示用户输人一个整数值， 然后判定它是否能被5和6整除，是否能被5或6整除， 以及是否能被5或6整除但是不能同时被它们整除。

import java.util.Scanner;

public class Demo31 {
    /*
    (使用操作符&&、||和^)编写一个程序，提示用户输人一个整数值，
    然后判定它是否能被5和6整除，是否能被5或6整除，
    以及是否能被5或6整除但是不能同时被它们整除。
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入一个整数：");
        int num = scan.nextInt();
        judgeNumber(num);
    }

    public static void judgeNumber(int num) {
        System.out.println(num + "可以被5和6整除吗？" + (num % 5 == 0 && num % 6 == 0));
        System.out.println(num + "可以被5或6整除吗？" + (num % 5 == 0 || num % 6 == 0));
        System.out.println(num + "可以被5或6整除，但不能同时整除吗？" + (num % 5 == 0 ^ num % 6 == 0));
    }
}

结果：

Demo32. 编写一个程序，随机产生一个0到100之间且包含0和100的整数

       要解决的问题是猜测计算机“脑子”里想的是什么数。程序提示用户连续输入一个数字，直到它和计算机随机产生的数字相匹配为止。对用户每次输入的数字，程序都要告诉用户该输入值是偏大了，还是偏小了，这样用户可以明智地进行下一轮的猜测。

public class Demo32 {
    /*
    编写一个程序，随机产生一个0到100之间且包含0和100的整数
    程序提示用户连续输入一个数字，直到它和计算机随机产生的数字相匹配为止。
    对用户每次输入的数字，程序都要告诉用户该输入值是偏大了，
    还是偏小了，这样用户可以明智地进行下一轮的猜测。
     */
    public static void main(String[] args) {
        guessNum();
    }

    private static void guessNum() {
        Scanner scan = new Scanner(System.in);
        int randomNum = (int)(Math.random() * 101);
        System.out.println("请输入你猜的数字：");
        while (true) {
            int yourNum = scan.nextInt();
            if (yourNum == randomNum) {
                System.out.println("恭喜你，猜对了！");
                break;
            }else if (yourNum < randomNum) {
                System.out.println("猜错了，你猜的偏小啦，你应该往大了猜");
                continue;
            } else if (yourNum > randomNum) {
                System.out.println("猜错了，你猜的偏大啦，你应该往小了猜");
                continue;
            }
        }
    }
}

结果：

如果你的运气够好，几次可能就猜对了，但是如果运气查，可能得猜好多次，所以我们可以优化一下，加个计数，比如猜三次就结束。

private static void guessNum() {
        Scanner scan = new Scanner(System.in);
        int randomNum = (int)(Math.random() * 101);
        System.out.println("请输入你猜的数字：");
        int count = 1;
        while (true) {
            if (count <= 3) {
                int yourNum = scan.nextInt();
                if (yourNum == randomNum) {
                    System.out.println("恭喜你，第" + count + "次就猜对了！");
                    break;
                }else if (yourNum < randomNum) {
                    System.out.println("猜错了，你猜的偏小啦，你应该往大了猜（你还有" + (3 - count) + "次机会）"  );
                    count++;
                    continue;
                } else if (yourNum > randomNum) {
                    System.out.println("猜错了，你猜的偏大啦，你应该往小了猜（你还有" + (3 - count) + "次机会）"  );
                    count++;
                    continue;
                }
            }else {
                System.out.println("很遗憾，三次机会用完啦，没有猜中！ 正确数字是：" + randomNum);
                break;
            }
        }
    }