Java分支结构

OraOla

于 2023-11-12 16:13:20 发布

阅读量117

点赞数 1

文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/gyh3222719788/article/details/134361594

版权

一、求三个数中最大者

本关任务：求三个数中最大者。

import java.util.Scanner;

public class ApplicationTest {
    /**
     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
     */
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        //声明整型变量 a ， b ，c 获取控制台的输入。
        int a = input.nextInt();
        int b = input.nextInt();
        int c = input.nextInt();
        //声明整型变量 max ， 用来存储最大值。
        /********** Begin **********/
        //第一步，将变量 a 的值赋值给变量 max ，假设变量 a 的值为最大值。

        //第二步，使用 if 语句比较变量 b 与变量 max 的大小，如果值大于 max ，则将值赋值给 max。

		//第三步，使用 if 语句比较变量 c 与变量 max 的大小，如果值大于 max ，则将值赋值给 max。
        int max1 = Math.max(a,b);
        int max2 = Math.max(b,c);
        int max = Math.max(max1, max2);
        /********** End **********/
        System.out.println("最大值为：" + max);
    }
}

二、按序输出三个数

本关任务：给定三个数，将三个数从小到大排序后，再输出这三个数。

import java.util.Scanner;

/**
 * 任务：按升序（从小到大）输出三个数
*/
public class ApplicationTest {

    /**
     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 声明整型变量 x ， y ，z 获取控制台的输入
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        int z = scanner.nextInt();
        // 声明整型变量 temp ，用于变量值的临时存储
        int sum = x+y+z;
        /********** Begin **********/		
        // 使用 if 语句判断 x、y、z 的大小 ，并将三个数中的最小值赋值给 x，最大值赋值给 z。
        int min1 = Math.min(x, y);
        int min2 = Math.min(x, z);
        int max1 = Math.max(x, y);
        int max2 = Math.max(x, z);
        
        x = Math.min(min1,min2);
        z = Math.max(max1,max2);
        y = sum - x - z;
        
      
       
        /********** End **********/
        System.out.println("从小到大排列:" + x + " " + y + " " + z);
    }

}

三、偶数判断

本关任务：输入两个整数，判断其是否同为偶数。

import java.util.Scanner;
/**
 * 任务：输入两个整数，判断其是否同为偶数。
 */
public class ApplicationTest {
    /**
     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 声明整型变量 x ， y 获取控制台的输入
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        int a = 0;
        int b = 0;
        /********** Begin **********/
        // 第一步，使用 if 语句，分别判断变量 x 和 y 是否是偶数，并且用逻辑运算符连接两个判断结果
        if(x % 2 == 0) {
        	a = 1;
        }
        if(y % 2 == 0) {
        	b = 1;
        }
        
        // 第二步，如果同为偶数，则打印输出“两个数同为偶数！”
        if(a == 1 && b == 1) 
        	System.out.println("两个数同为偶数！");
        

        
        // 第三步，如果不同为偶数，则打印输出“两个数至少有一个数为奇数！”
        else 
        	System.out.println("两个数至少有一个数为奇数！");
        /********** End **********/
    }
}

四、判断回文数

本关任务：判断一个给定的 5 位整数是否是一个回文数。

import java.util.Scanner;
/**
 * 任务：判断一个给定的 5 位数是否是一个回文数Application
 */
public class ApplicationTest {
    /**
     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 声明 int 类型的变量 num ，用来获取控制台输入
        int num = scanner.nextInt();
        /********** Begin **********/
        // 第一步：获取个位数的数值
        int a = num % 10;
        // 第二步：获取十位数的数值
        int b = num /10%10;
        // 第三步：取百位数的数值
        int c = num / 100%10;
        // 第四步：获取千位数的数值
        int d = num / 1000%10;
        // 第五步：获取万位数的数值
        int e = num / 10000;
        // 第六步：将获取的个位数值乘以 10000 

        // 第七步：将获取的十位数值乘以 1000 

        // 第八步：将获取的百位数值乘以 100 

        // 第九步：将获取的千位数值乘以 10 

        // 第十步：将获取的万位数值乘以 1 

        // 第十一步：将第六、七、八、九、十步转换后的数值相加

        // 第十二步：判断变量 num 是否等于第十一步的数值，如果等于，则在控制台输出“回文数”；反之，则输出“不是回文数”
        if(a == e && b == d)
        	System.out.println("回文数");
        else
        	System.out.println("不是回文数");
         /********** End **********/
    }
}

五、成绩判断

本关任务：判断学生的成绩是否合格（成绩分数不低于 60 ）。

import java.util.Scanner;
/**
 * 任务：判断学生的成绩是否合格（成绩分数不低于 60 ）
 */
public class ApplicationTest {
    /**
     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
     */
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        // 声明 double 类型变量 score  获取控制台输入的学生成绩
        double score = input.nextDouble();
		// 声明 int 类型变量 temp 用来保存学生成绩是否合格的结果（1 或者 0）
		int temp;
        /********** Begin **********/
        // 使用三元表达式，判断变量 score 是否小于 60 ，如果小于 60 ，则将数值 0 赋值给变量 temp；
		//反之，则将数值 1 赋值给变量 temp
		temp = score<60 ? 0 : 1;
        
        /********** End **********/
		String result = temp == 1 ? "合格":"不合格";
        System.out.println("该学生成绩判定为：" +result );
    }
}

六、字符类型判断

本关任务：输入单个字符，判断该字符的类型（判断输入字符是大写字母、小写字母、数字还是其他字符）。

提示：需要将字符强转为int类型，得到字符的ASCII码，然后根据ASCII码所处的区间，判断字符类型（如果ASCII码位于区间65-90，则字符为大写字母），ASCII码字符对照表如下表所示。

import java.util.Scanner;

/**
 * 任务：输入单个字符，判断该字符的类型（判断输入字符是大写字母、小写字母、数字还是其他字符）。Application
 */
public class ApplicationTest {

    /**
     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码。
     */
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        // 声明 char 类型的变量 a 用来获取控制台输入
        char a = input.next().charAt(0);

        /********** Begin **********/
        // 第一步：将 char 类型的变量 a 强制转换成 int 类型
        int A = (int) a;
        // 第二步：判断强制转换成 int 类型的变量是否大于等于 65，同时小于等于 90 ，如果满足条件，则在控制台输出"该字符是大写字母"
        if(65 <= A && A <= 90)
        	System.out.println("该字符是大写字母");
        
        
        // 第三步：判断强制转换成 int 类型的变量是否大于等于 97，同时小于等于 122 ，如果满足条件，则在控制台输出"该字符是小写字母"
        else if(97 <= A && A <= 122)
        	System.out.println("该字符是小写字母");
        
        // 第四步：判断强制转换成 int 类型的变量是否大于等于 48，同时小于等于 57 ，如果满足条件，则在控制台输出"该字符是数字"
        else if(48 <= A && A <= 57)
        	System.out.println("该字符是数字");
        
        // 第五步：如果以上条件都不满足，则在控制台输出"该字符是其他字符"
        else
        	System.out.println("该字符是其他字符");
        
        /********** End **********/

    }
}

七、月份天数计算

本关任务：根据给定的年份和月份，获取该月份的天数。

提示：在求二月份的天数时，需要判断年份是否是闰年。闰年的条件是，年份是否能够被 400 整除，或者年份能够被 4 整除但是不能被 100 整除。

import java.util.Scanner;

/**
 * 任务：根据给定的年份和月份，获取该月份的天数。
 */
public class ApplicationTest {

    /**
     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码。
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();
        int month = scanner.nextInt();
        int day = 0;
        /********** Begin **********/
        // 第一步：判断变量 month 是否为 1、3、5、7、8、10、12 内的月份，
        // 如果是，则将数值 31 赋值给变量 day
        if(month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
			day = 31;

        // 第二步：判断变量 month 是否为 4、6、9、11 内的月份，
        // 如果是，则将数值 30 赋值给 day
        else if(month == 4 || month == 6 || month == 9 || month == 11)
        	day = 30;

        // 第三步：如果以上条件都不满足，则进入最后一种情况
        else {

        // 第四步：判断是否是闰年，是闰年，则将数值 29 赋值给 day；
        //反之，则将数值 28 赋值给 day
        	if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
        		day = 29;
        	else
        		day = 28;
        }
        /********** End **********/
        System.out.print(year + "年" + month + "月有" + day + "天");
    }
}

八、百分制成绩转换GPA成绩

本关任务：给出一个 GPA 成绩，输出与之对应的百分制成绩区间。

GPA 标准为:

优秀(A): 100-90分;
良好(B): 80-89分;
中等(C): 70-79分;
及格(D): 60-69分;
不及格(E): 60分以下。

import java.util.Scanner;

/**
 * 任务：给出一个 GPA 成绩，输出与之对应的百分制成绩区间。
 */
public class ApplicationTest {



	/**
     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 声明 char 类型的变量 score 用来获取控制台输入的成绩
        char score = scanner.next().charAt(0);
        /********** Begin **********/

        /**
         * 使用 switch 构建 A 、B、C、D、E 五条分支
         *      分支 A ，控制台输出 “百分制分数段为90分以上”
         *      分支 B ，控制台输出 “百分制分数段为80-89分”
         *      分支 C ，控制台输出 “百分制分数段为70-79分”
         *      分支 D ，控制台输出 “百分制分数段为60-69分”
         *      分支 E ，控制台输出 “百分制分数段为60分以下”
         */
        switch(score) {
        case 'A':
        	System.out.println("百分制分数段为90分以上");
        	break;
        case 'B':
        	System.out.println("百分制分数段为80-89分");
        	break;
        case 'C':
        	System.out.println("百分制分数段为70-79分");
        	break;
        case 'D':
        	System.out.println("百分制分数段为60-69分");
        	break;
        case 'E':
        	System.out.println("百分制分数段为60分以下");
        	break;
        }


    
        /********** End **********/
    }
}

九、嵌套

本关任务：给定一个整数 a，判断其是否是自然数同时又是偶数。

import java.util.Scanner;

/**
 * 任务：给定一个整数 a，判断其是否是自然数同时又是偶数。
 */
public class ApplicationTest {

    /**
     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 声明 int 类型的变量 a 用来获取控制台输入
        int a = scanner.nextInt();
        /********** Begin **********/
        // 第一步：判断变量 a 是否大于等于 0 ,如果符合条件，则进入第二步；反之，则在控制台输出"该数不是自然数"
        if(a <= 0)
        	System.out.println("该数不是自然数");
        // 第二步：判断变量 a 取模 2 是否为 0 ，如果为 0 ，则在控制台输出 "该数既是自然数又是偶数"；反之，则输出"该数为自然数，但不是偶数"
        else if(a % 2 == 0)
        	System.out.println("该数既是自然数又是偶数");
        	else
        		System.out.println("该数为自然数，但不是偶数");
      

        /********** End **********/
    }
}

十、一元二次方程求解

本关任务：变量a、b、c分别为方程ax^2+bx+c=0中a、b、c的值，求解该一元二次方程的值，将该值四舍五入后保留两位小数后输出。

import java.util.Scanner;

/**
 * 任务：求解该方程的值。
 * 类名为：Equation
 */

public class Equation {
    public static void main(String[] args) {
    	
    	Scanner reader = new Scanner(System.in);        
    	double a = reader.nextDouble();
    	double b = reader.nextDouble();
    	double c = reader.nextDouble();

        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
        /********** Begin **********/
    	
        // 第一步：判断方程有几个根
    	double d = b * b - 4 * a * c;
    	
    	// 第二步：如果方程有两个根，计算这两个值，将其按照题目所给的格式输出
    	if(d > 0) {
    		double x1 = (-b+Math.sqrt(d))/(2*a);
    		double x2 = (-b-Math.sqrt(d))/(2*a);
    		System.out.println("该方程有两个根");
    		System.out.printf("x1 = %.2f，x2 = %.2f",x1,x2);
    	}
    	// 第三步：如果方程只有一个跟，计算出该值，将其按照题目所给的格式输出	
    		else if(d == 0) {
    			double x = -b/(2*a);
    			System.out.println("该方程只有一个根");
    			System.out.printf("x = %.2f",x);
    		}
		// 第四步：若方程无解，将其按照题目所给的格式输出
    			else {
    				System.out.println("该方程无解");
    			}
    		

        /********** End **********/
    	
    	
   	
    
    }
}

十一、物流运费计算

货物的运输费用与距离和重量有关，距离 S 越远，每公里的运费越低。总运输费用 Exp 的计算公式为：Exp=P×W×S×(1-d) ，公式中 P 为每公里每吨货物的基本运费、W 为货物重量（T）、S 为运输距离（km）、d 为折扣。折扣率与距离有关，标准如下：

0 < S < 250 km (d = 0)
250 ≤ S < 500 km (d = 2%)
500 ≤ S < 1000 km (d = 5%)
1000 km ≤ S (d = 8%)

本关任务：变量 p 为每公里每吨货物的基本运费，变量 w 为货物重量，s 为运输距离，d 为折扣，根据上述总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。

import java.util.Scanner;

/**
 * 任务：变量 p 为每公里每吨货物的基本运费，
 * 变量 w 为货物重量，s 为运输距离，d 为折扣，
 * 根据题目中的总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
 * 类名为：Logistics
 */

public class Logistics {
    public static void main(String[] args) {
    	
    	Scanner reader = new Scanner(System.in);        
    	double p = reader.nextDouble();     // 表示每公里每吨货物的基本运费
    	double w = reader.nextDouble();     // 表示货物重量
    	double s = reader.nextDouble();     // 运输距离
    	double d = 0.0;// 折扣
        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
        /********** Begin **********/
    	
        // 第一步：判断该运输距离的折扣为多少 如果0 < s < 250，则折扣为0，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
    	
    		
    	// 第二步：如果250 ≤ S < 500，则折扣为0.02，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。

        // 第三步：如果500 ≤ S < 1000，则折扣为0.05，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。

			
		// 第四步：如果1000 ≤ S，则折扣为0.08，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
    	if (s < 250) {
            d = 0;
        } else if (s < 500) {
            d = 0.02;
          } 	else if (s < 1000) {
            		d = 0.05;
        		} 	else {
        			d = 0.08;
        			}
    	double totalCost = p * w * s * (1 - d);
    	System.out.printf("%.2f",totalCost);
    	    	
        /********** End **********/

    }
}

十二、根据年月日计算星期

本关任务：根据输入的年月日，确定这一天是星期几。

提示：根据基姆拉尔森日期公式，已知年月日，可以快速的求出这一天是星期几。

基姆拉尔森日期公式如下所示:

iweek=(d+2∗m+3∗(m+1)/5+y+y/4−y/100+y/400) mod 7

import java.util.Scanner;

/**
 * 任务：根据输入的年月日，确定这一天是星期几。
 */
public class ApplicationTest {

    /**
     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
     */
    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);

        // 声明 int 类型的变量 y 用来获取控制台输入的年
        int y = scanner.nextInt();
        // 声明 int 类型的变量 m 用来获取控制台输入的月
        int m = scanner.nextInt();
        // 声明 int 类型的变量 d 用来获取控制台输入的日
        int d = scanner.nextInt();

        /********** Begin **********/
        // 第一步：判断变量 m 的值是否是 1 或者 2。如果是，则变量 m 在原来的基础上加12，同时变量 y 在原来的基础上减1
        if(m == 1 || m == 2) {
        	m+=12;
        	y-=1;
        }

        // 第二步：使用基姆拉尔森日期公式，计算星期几
        int iweek = (d + 2 * m + 3 * (m + 1) / 5 + y + y / 4 - y /100 + y / 400) % 7; 

        // 第三步：使用多路分支判断星期几。如果是星期一，则在控制台输出"星期一"；如果是星期二，则在控制台输出"星期二"....以此类推，如果是星期日，就是在控制台输出"星期日"
        switch(iweek){
        	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;
        }
        /********** End **********/
    }
}

十三、判断素数

本关任务：判断给定的任意一个大于 1 的正整数是否是素数。素数的定义：在大于 1 的自然数中，除了 1 和它本身以外不再有其他因数的自然数。

/*
任务：判断给定的任意一个大于 1 的正整数是否是素数。
素数的定义：在大于 1 的自然数中，除了 1 和它本身以外不再有其他因数的自然数。
思路：接收给定的正整数n，从2到n对该数取余，如果存在余数为零，那么该数不为素数，否则就是素数
      
如果不是：请输出“x不是一个素数”。
如果是：请输出“x是一个素数”。

*/
import java.util.Scanner;

public class  BreakTest {
    public static void main(String[] args) {
       
        // 请在Begin-End间编写代码
        /********** Begin **********/
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int temp = 0;
        for(int i = 2;i < n;i++){
        	if(i == n)
        		continue;
        	else if(n % i ==0) {
        		temp = 1;
        		break;
        	}
        }
        if(temp == 0)
        	System.out.printf("%d是一个素数",n);
        else
        	System.out.printf("%d不是一个素数",n);
       
        
        /********** End **********/

    }
}

十四、continue

本关任务：给定一个正整数 n，统计比 n 小的正奇数的个数。

输出格式：n前面共有xx个奇数。

/*
任务：使用Scanner对象接收给定的一个整数，统计小于该整数的正奇数个数。
输出格式：5前面共有2个奇数。
*/
import java.util.Scanner;

public class  ContinueTest {
    public static void main(String[] args) {
        
        // 定义变量count，用于统计奇数个数，并赋初值为0。
        int count = 0;
        // 创建Scanner对象
        Scanner sc = new Scanner(System.in);
        // 获取输入值
        int n = sc.nextInt();
        // 请在Begin-End间编写代码
        /********** Begin **********/
        // 第一步：编写for循环从1到n之间循环取数
        for(int i = 1;i < n;i++) {
        // 第二步：判断是否为偶数，如果是，跳出本次循环，如果不是，对奇数个数变量值加1
        	if(i % 2 != 0) {
        		count +=1;
        	}
        }
        // 第三步：循环结束，输出总的奇数个数
        System.out.printf("%d前面共有%d个奇数。",n,count);
        /********** End **********/

    }}

十五、矩阵加

本关任务：给定两个矩阵，求它们的和。


public class Transpose {
    public static void main(String[] args) {
        // 请在Begin-End间编写代码
        /********** Begin **********/
        // 定义二维数组并初始化
    	int[][] array1 = {{5,6,7},{15,65,43},{32,43,22},{11,88,6},{4,98,66}};
    	int[][] array2 = {{94,65,31},{0,71,98},{66,88,100},{32,7,1},{16,2,34}};
        // 打印求和后的新数组
    	int[][] array = new int[5][3];
    	for(int i = 0;i < 5;i++) {
    		for(int j = 0;j < 3;j++) {
    			array[i][j] = array1[i][j]+array2[i][j];
    		}
    	}
    	for(int i = 0;i < 5;i++) {
    		for(int j = 0;j < 3;j++) {
    			System.out.printf("%d ",array[i][j]);
    		}
    		System.out.println();
    	}
        /********** End **********/

        }
}

十六、矩阵转置

本关任务：对给定的矩阵做转置操作。

public class Transpose{
    public static void main(String[] args) {
        // 请在Begin-End间编写代码
        /********** Begin **********/
        // 定义二维数组并初始化
    	int[][] array = {{5,6,7},{15,65,43},{32,43,22},{11,88,6},{4,98,66}};
        // 定义转置后的新数组
    	int[][] Array = new int[3][5];
        // 转置数组
    	for(int i = 0;i < 3;i++) {
    		for(int j = 0;j < 5;j++) {
    			Array[i][j] = array[j][i];
    		}
    	}
        // 打印新数组
    	for(int i = 0;i < 3;i++) {
    		for(int j = 0;j < 5;j++) {
    			System.out.print(Array[i][j]+" ");
    		}
    		System.out.println();
    	}
        /********** End **********/
     }
}

十七、文件名与邮箱验证

本关任务：分别判断 Java 文件名与邮箱格式是否正确。其中：合法的文件名应该以 .java 结尾（如 Test.java 正确，Test.txt 不正确）；合法的邮箱名中至少要包含 @ , 并要求 @ 在 . 之前(如 9876543@qq.com 正确，987654qq.com 不正确)。

import java.util.Scanner;

public class StrTest {
	public static void main(String[] args) {
// 请在Begin-End间编写代码
		/********** Begin **********/
// 第一步：接收输入的两个字符串，第一个是文件名，第二个是邮箱地址
		Scanner input = new Scanner(System.in);
		String str1 = input.next();
		String str2 = input.next();
// 第二步：判断文件名是否正确
		if(str1.startsWith(".java") == false && str1.endsWith(".java") == true)
			System.out.println("Java文件名正确");
		else if(str1.startsWith(".java") == true ||str1.endsWith(".java") == false)
			System.out.println("Java文件名无效");
// 第三步：判断邮箱地址是否正确
		if(str2.endsWith(".com") == true && str2.contains("@") == true && str1.contains(".") == true && str2.indexOf("@") < str2.indexOf("."))
			System.out.println("邮箱名正确");
		else
			System.out.println("邮箱名无效");
		/********** End **********/

	}
}

十八、花名册

本关任务:接收给定的两行字符串，分别代表两份不同的花名册，请你输出两份花名册的长度各是多少，以及它们是否相同。

import java.util.Scanner;

public class StrTest {
	public static void main(String[] args) {
		// 请在Begin-End间编写代码
		/********** Begin **********/
		// 第一步：接收输入的两份花名册
		Scanner input = new Scanner(System.in);
		String str1 = input.nextLine();
		String str2 = input.nextLine();
		// 第二步：输出第一份花名册的长度（字符串长度）
		int len1 = str1.length();
		int len2 = str2.length();
		// 第三步：输出第二份花名册的长度（字符串长度）
		System.out.println(len1);
		System.out.println(len2);
		// 第四步：判断两个花名册是否相同，若相同，请输出相同，若不同，请输出不相同
		if (str1.equals(str2)) {
            System.out.println("相同");
        } else {
            System.out.println("不相同");
        }
		
		/********** End **********/
	}
}

十九、坐标系中两点距离计算

本关任务：已知两个点 A、B 以及坐标分别为(2,3) 、(8,-5) ，求 A 和 B 两点之间的距离。

/**
 * 任务：已知两个点 A、B 以及坐标分别为(2,3) 、(8,-5) ，求 A 和 B 两点之间的距离。
 * 类名为：Distance
 */

public class Distance {

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码

/********** Begin **********/

    /**
     * 定义一个静态方法，该方法计算坐标两点的距离，携带四个参数，分别为x1、y1、x2、y2的值
     * 将距离结果返回，返回类型为double
     */

    // 定义主方法
	public static void main(String[] agrs) {

    // 通过类名.方法名的方式调用计算两点间距离的方法，分别将A、B的x1、y1、x2、y2的值传入该方法中
		
		int x1 = 2;
		int y1 = 3;
		int x2 = 8;
		int y2 = -5;
    // 不换行输出，输出格式: A、B两点的距离为xx
		double d = Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
		System.out.printf("A、B两点的距离为%f",d);
	}

/********** End **********/

}

二十、模拟手机功能

本关任务：实现手机的基本功能。

手机具有属性：品牌（brand）、型号（type）、价格（price）、操作系统（os）和内存（memory）；

具有功能：查看手机信息（about()）、打电话（call(int number)）、玩游戏（play()）。

/**
 * 任务：实现手机的基本功能。
 * 类名为：Phone
 */

public class Phone {
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
    // 定义五个变量，分别表示品牌、型号、价格、操作系统和内存
	String brand;
	String number;
	double price;
	String system;
	String memory;
    // 无参构造
	public Phone() {
	}
    // 有参构造
	public Phone(String brand, String number, double price, String system, String memory) {
		this.brand = brand;
		this.number = number;
		this.price = price;
		this.system = system;
		this.memory = memory;
	}
    /**
     * 定义一个方法，该方法实现查询手机信息的方法，无返回值
     * 输出格式：品牌：xx
     *           型号：xx
     *           操作系统：xx
     *           价格：xx
     *           内存：xx
     * 中间用换行符隔开
     */
	void inquire() {
		System.out.println("品牌："+brand);
		System.out.println("型号："+number);
		System.out.println("操作系统："+system);
		System.out.println("价格："+price);
		System.out.println("内存："+memory);
	}
    /**
     * 定义一个方法，该方法实现打电话的功能，无返回值，
     * 携带一个int型参数，其中1,2,3分别表示爸爸、妈妈、姐姐的号，
     * 输出格式  如果参数为1，换行输出：正在给爸爸打电话
     * 如果出现其它情况，换行输出：你所拨打的电话为空号
     */
	void callup(int i) {
		if(i == 1) {
			System.out.println("正在给爸爸打电话");
		}
		else if(i == 2) {
			System.out.println("正在给妈妈打电话");
		}
		else if(i == 3) {
			System.out.println("正在给姐姐打电话");
		}
		else {
			System.out.println("你所拨打的电话为空号");
		}
	}
    /**
     * 定义一个方法，该方法实现听音乐的功能，无返回值
     * 携带一个参数，其表示为歌曲名
     * 不换行输出格式：正在播放xx
     */
	void musics(String music) {
		System.out.println("正在播放"+music);
	}
    // 定义主方法
	public static void main(String[] args) {
		// 通过无参构造创建手机对象
		Phone phone = new Phone();
	    // 设置手机品牌为小米，型号为小米9，操作系统为Android 9，价格为2599，运行内存为8
	    phone = new Phone("小米","小米9",2599,"Android 9","8");
		// 查询手机信息
	    phone.inquire();
	    // 给妈妈拨打电话
	    phone.callup(2);
	    // 播放浮夸这首歌
	    phone.musics("浮夸");
	}
    
/********** End **********/

}

二十一、分支结构之多重if

本小节需要你实现一个星级成绩评定系统，效果如下：

package step3;

import java.util.Scanner;

public class HelloStep3 {
	public static void main(String[] args) {
		System.out.println("星级成绩评定系统");
		System.out.println("请输入成绩：");
		Scanner sc = new Scanner(System.in);
		int score = sc.nextInt();
		/****** start ******/
		if(score < 60) {
			System.out.println("无星成绩");
		}else if(score < 70) {
			System.out.println("**俩星成绩");
		}else if(score < 80) {
			System.out.println("***三星成绩");
		}else if(score < 90) {
			System.out.println("****四星成绩");
		}else{
			System.out.println("*****五星成绩");
		}
		
		/****** end ******/
	}
}

二十二、分支结构之Switch

本关需要你使用Switch完成一个能根据用户输入的月份，给出对应的季节的小程序。效果图如下：

package step4;

import java.util.Scanner;

public class HelloSwitch {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入月份：");
		int month = sc.nextInt();		//获取输入的月份
        //通过输入的月份来判断当前季节并输出
		/*****start*****/
		switch (month) {
		case 1:
			System.out.println("1月是冬天");
			break;
		case 2:
			System.out.println("2月是冬天");
			break;
		case 3:
			System.out.println("3月是春天");
			break;
		case 4:
			System.out.println("4月是春天");
			break;
		case 5:
			System.out.println("5月是春天");
			break;
		case 6:
			System.out.println("6月是夏天");
			break;
		case 7:
			System.out.println("7月是夏天");
			break;
		case 8:
			System.out.println("8月是夏天");
			break;
		case 9:
			System.out.println("9月是秋天");
			break;
		case 10:
			System.out.println("10月是秋天");
			break;
		case 11:
			System.out.println("11月是秋天");
			break;
		case 12:
			System.out.println("12月是冬天");
			break;
		default:
			break;
		}
	
		
		/*****end*****/
		
	}
}