• 运算符

    1 指出下面程序的运行输出结果

    1.         int a, b, c;
    2.         a = b = c = 100;
    3.         System.out.println("a="+a+",b="+b+",c="+c);

    参考答案

    上述代码的输出结果为：

    1. a=100,b=100,c=100

    上述代码中，从右向左，首先，将c赋值为100；然后将c的值赋值给了b，同样b的值也为100；最后，又将b的值赋给了a，a的值也为100。

    2 指出下面程序的运行输出结果

     
    1. System.out.println(5+6+""+5+6);

    参考答案

    上述代码的输出结果为：

     
    1. 1156

    “+”有两种运算规则，一种是两端为数字则为数学加法运算，另外一种是实现字符串的连接，也可以实现字符串与其他数据类型的“相连”。上述代码中，字符串之前的运算按照加法运算，字符串之后的运算按照字符串相连。

    3 输出两个int数中的最大值

    用户从控制台接收两个整数，通过程序找出两个数中的最大值。控制台的交互效果如图-1所示。

    图- 1

    参考答案

    实现此案例需要按照如下步骤进行。

    步骤一：定义类及 main方法

    首先定义一个名为 MaxOfTwo的类，并在类中添加 main方法。代码如下所示：

     
    1. public class MaxOfTwo {
    2.     public static void main(String[] args) {
    4.     }
    5. }

    步骤二：读取控制台的输入

    在main方法中，实例化Scanner类，并调用Scanner类的nextInt 方法接收用户从控制台输入的两个整数，使用完毕后将scanner对象关闭。代码如下所示：

     
    1. import java.util.Scanner;
    3. public class MaxOfTwo {
    4.     public static void main(String[] args) {
    5.         System.out.println("请依次输入两个整数：a，b（以空格隔开）");
    6.         Scanner scanner = new Scanner(System.in);
    7.         int a = scanner.nextInt();
    8.         int b = scanner.nextInt();
    9. scanner.close();
    10.     }
    11. }

    步骤三：计算最大值

    使用三目运算符比较a，b两个整数的大小并输出结果。代码如下所示：

     
    1. import java.util.Scanner;
    3. public class MaxOfTwo {
    4.     public static void main(String[] args) {
    5.         System.out.println("请依次输入两个整数：a，b（以空格隔开）");
    6.         Scanner scanner = new Scanner(System.in);
    7.         int a = scanner.nextInt();
    8.         int b = scanner.nextInt();
    9. scanner.close();
    10.         int result=a>b?a:b;
    11.         System.out.println("最大值为"+result);
    12.     }
    13. }

    本案例的完整代码如下所示：

    1. import java.util.Scanner;
    3. public class MaxOfTwo {
    4.     public static void main(String[] args) {
    5.         System.out.println("请依次输入两个整数：a，b（以空格隔开）");
    6.         Scanner scanner = new Scanner(System.in);
    7.         int a = scanner.nextInt();
    8.         int b = scanner.nextInt();
    9. scanner.close();
    10.         int result=a>b?a:b;
    11.         System.out.println("最大值为"+result);
    12.     }
    13. }

    4 编写三个数值的排序程序

    使用程序为用户所录入的 3 个数值进行升序排列，并将排序后的结果输出到控制台。程序交互过程如图－3所示：

    图- 3

    参考答案

    此案例需要接收用户从控制台录入的三个整数，并使用if语句对三个数值进行大小判断。

    首先，比较a和b的大小。如果a大于b，则将a和b的值进行交换；然后再比较 a 和 c 的值，如果 a 的值大于 c，则继续交换；此时，a 中存储的则是三个数值中的最小值；

    继续比较，将 b 和 c 中的数值进行比较，如果 b 的值 大于c，则进行交换。此时，c 中存储的则是三个数值中的最大值，排序完毕。最后将a、b、c 中的数值输出到控制台。

    实现此案例需要按照如下步骤进行。

    步骤一：定义类及 main 方法

    首先定义一个名为 SortOfThree的类，并在类中定义Java 应用程序的入口方法main ，代码如下所示：

    1. public class SortOfThree {
    2.     public static void main(String[] args) {
    3.     }
    4. }

    步骤二：读取控制台的输入

    在main方法中，实例化Scanner类，并调用Scanner类的nextInt方法接收用户从控制台输入的三个数值，使用完毕后将scanner对象关闭。代码如下所示：

     
    1. import java.util.Scanner;
    2. public class SortOfThree {
    3.     public static void main(String[] args) {
    4.         Scanner scanner = new Scanner(System.in);
    5.         System.out.println("请依次输入三个整数：a，b，c（以空格隔开）");
    6.         int a = scanner.nextInt();
    7.         int b = scanner.nextInt();
    8.         int c = scanner.nextInt();
    9.         scanner.close();
    10. System.out.println("您输入的是：");
    11.         System.out.println("a=" + a + ", b=" + b + ", c=" + c);
    12.     }
    13. }

    步骤三：找到三个数值中的最小值

    定义临时变量temp，并比较a和b的大小，如果a 大于 b，则将 a 和 b 中的数值进行交换；再比较 a 和 c 的大小，如果a 大于 c，则将 a 和 c 中的数值进行交换。

    此轮比较后，a 中存储的是三个数值中的最小值。代码如下所示：

     
    1. import java.util.Scanner;
    2. public class SortOfThree {
    3.     public static void main(String[] args) {
    4.         Scanner scanner = new Scanner(System.in);
    5.         System.out.println("请依次输入三个整数：a，b，c（以空格隔开）");
    6.         int a = scanner.nextInt();
    7.         int b = scanner.nextInt();
    8.         int c = scanner.nextInt();
    9.         scanner.close();
    10.         System.out.println("您输入的是：");
    11.         System.out.println("a=" + a + ", b=" + b + ", c=" + c);
    12.         int temp = 0;
    13.         if (a > b) {
    14.             temp = a;
    15.             a = b;
    16.             b = temp;
    17.         }
    18.         if (a > c) {
    19.             temp = a;
    20.             a = c;
    21.             c = temp;
    22.         }
    23.     }
    24. }

    步骤四：找到三个数值中的最大值

    继续比较 b 和 c 的大小，如果b 大于 c ，则将 b 和 c 中的数值进行交换。此轮比较后，c 中存储的数值则为三个数值中的最大值，排序结束。然后将结果输出到控制台。代码如下所示：

     
    1. import java.util.Scanner;
    2. public class SortOfThree {
    3.     public static void main(String[] args) {
    4.         Scanner scanner = new Scanner(System.in);
    5.         System.out.println("请依次输入三个整数：a，b，c（以空格隔开）");
    6.         int a = scanner.nextInt();
    7.         int b = scanner.nextInt();
    8.         int c = scanner.nextInt();
    9.         scanner.close();
    10.         System.out.println("您输入的是：");
    11.         System.out.println("a=" + a + ", b=" + b + ", c=" + c);
    12.         int temp = 0;
    13.         if (a > b) {
    14.             temp = a;
    15.             a = b;
    16.             b = temp;
    17.         }
    18.         if (a > c) {
    19.             temp = a;
    20.             a = c;
    21.             c = temp;
    22.         }
    23.         if (b > c) {
    24.             temp = b;
    25.             b = c;
    26.             c = temp;
    27.         }
    28.         System.out.println("升序排列后，结果为：");
    29.         System.out.println("a=" + a + ", b=" + b + ", c=" + c);
    30.     }
    31. }

    本案例的完整代码如下所示：

    代码

    5 编写程序判断某一个年份是否为闰年（使用if-else）

    本案例需要使用交互的方式判断某年是否为闰年：用户从控制台输入需要判断的年份值，由程序使用if-else判断该年是否为闰年，并将判断结果输出到控制台。程序交互过程如图－4所示：

    图- 4

    参考答案

    实现此案例需要按照如下步骤进行。

    步骤一：定义类及 main方法

    首先定义一个名为 LeapYear的类，并在类中添加 main方法。代码如下所示：

    1. public class LeapYear {
    2.     public static void main(String[] args) {
    3.     }
    4. }

    步骤二：读取控制台的输入

    在main方法中，实例化Scanner类，并调用Scanner类的nextInt 方法接收用户从控制台输入的年份数值，使用完毕后将scanner对象关闭。代码如下所示：

     
    1. import java.util.Scanner;
    2. public class LeapYear {
    3.     public static void main(String[] args) {
    4.         Scanner scanner = new Scanner(System.in);
    5.         System.out.println("请输入年份（例如：2012）");
    6.         int year = scanner.nextInt();
    7.         scanner.close();
    8.     }
    9. }

    步骤三：闰年判断

    某年份只需要满足下列两个条件之一，即可认定是闰年：

    • 年份可以被 4 整除且不能被 100 整除；
    • 年份可以被400 整除。

    在此，使用if-else来判断某一年是否为闰年。代码如下所示：

     
    1. import java.util.Scanner;
    2. public class LeapYear {
    3.     public static void main(String[] args) {
    4.         Scanner scanner = new Scanner(System.in);
    5.         System.out.println("请输入年份（例如：2012）");
    6.         int year = scanner.nextInt();
    7.         scanner.close();
    8.         if((year % 4 == 0 && year % 100 != 0) || year % 400==0 ){
    9.             System.out.println("是闰年");
    10.         }else{
    11.             System.out.println("不是闰年");
    12.         }
    13.     }
    14. }

    本案例的完整代码如下所示：

    代码

    6 编写个人所得税计算程序

    个人所得税是国家对本国公民、居住在本国境内的个人的所得和境外个人来源于本国的所得征收的一种所得税。目前，北京地区的个人所得税的计算公式为：应纳税额＝（工资薪金所得－扣除数）×适用税率－速算扣除数。其中，扣除数为3500元，适用税率以及速算扣除数如下表所示。

    表－1 个人所得税缴纳标准

    上表中的全月应纳税所得额=工资薪金所得－扣除数。

    本案例要求计算个人所得税的缴纳额度：用户从控制台输入税前工资的金额，程序计算所需要交纳的个人所得税的金额，并将计算结果输出到控制台。

    程序的交互过程如图-5所示：

    图- 5

    参考答案

    首先，程序从控制台接收税前的工资金额，然后根据表－1中的规则进行计算。

    需要使用 if－else if语句来实现表－1所示的计算规则，其计算过程如图－6所示。

    图- 6

    图－6中，T表示true，F表示false，taxIncome表示全月应纳税所得额，tax表示应交纳的个人所得税的税额。

    实现此案例需要按照如下步骤进行。

    步骤一：定义类及 main 方法

    首先定义一个名为 IncomeTax的类，并在类中定义Java 应用程序的入口方法main ，代码如下所示：

    1. public class IncomeTax {
    2.     public static void main(String[] args) {
    3.     }
    4. }

    步骤二：读取控制台的输入

    在main方法中，实例化Scanner类，并调用Scanner类的nextDouble 方法接收用户从控制台输入的税前工资金额，使用完毕后将scanner对象关闭。代码如下所示：

     
    1. import java.util.Scanner;
    2. public class IncomeTax {
    3.     public static void main(String[] args) {
    4.         Scanner scanner = new Scanner(System.in);
    5.         System.out.println("请输入你的工资的税前金额（￥）：");
    6.         double salary = scanner.nextDouble();
    7.         scanner.close();
    8.     }
    9. }

    步骤三：计算个人所得税

    根据个人所得税计算公式，使用if-else if语句计算出个税并输出。代码如下：

     
    1. import java.util.Scanner;
    2. public class IncomeTax {
    3.     public static void main(String[] args) {
    4.         Scanner scanner = new Scanner(System.in);
    5.         System.out.println("请输入你的工资的税前金额（￥）：");
    6.         double salary = scanner.nextDouble();
    7.         scanner.close();
    8.         double tax = 0.0;
    9.         double taxIncome = salary - 3500;
    10.         if (taxIncome <= 0) {
    11.             tax = 0.0;
    12.         } else if (taxIncome <= 1500) {
    13.             tax = taxIncome * 0.03;
    14.         } else if (taxIncome <= 4500) {
    15.             tax = taxIncome * 0.10 - 105;
    16.         } else if (taxIncome <= 9000) {
    17.             tax = taxIncome * 0.20 - 555;
    18.         } else if (taxIncome <= 35000) {
    19.             tax = taxIncome * 0.25 - 1005;
    20.         } else if (taxIncome <= 55000) {
    21.             tax = taxIncome * 0.30 - 2755;
    22.         } else if (taxIncome <= 80000) {
    23.             tax = taxIncome * 0.35 - 5505;
    24.         } else {
    25.             tax = taxIncome * 0.45 - 13505;
    26.         }
    27.         System.out.println("你应该缴纳的个人所得税是：￥" + tax);
    28.     }
    29. }

    本案例的完整代码如下所示：

    代码

    7 输入年份和月份，输出该月的天数（使用switch-case）

    一年有 12 个月，而每个月的天数是不一样的。其中，有7个月为 31 天，称为大月，分别为1、3、5、7、8、10、12月；有 4个月为 30 天，称为小月，分别为4、6、9、11月；还有二月比较特殊，平年的二月只有28天，而闰年的二月有 29 天。

    本案例需要使用交互的方式计算某年某月的天数：由用户在控制台输入年份和月份值，程序计算该年该月的天数，并将结果输出在控制台。程序交互情况如图－7所示：

    图- 7

    参考答案

    首先，此案例需要从控制台接收用户录入的年份和月份数值；然后，根据月份判断该月是大月还是小月；再根据年份判断是否为闰年。各项判断完毕后，计算得出该年该月的天数，并将结果输出到控制台。

    实现此案例需要按照如下步骤进行。

    步骤一：定义类及 main方法

    首先定义一个名为 DayOfMonth的类，并在类中添加 main方法。代码如下所示：

     
    1. public class DayOfMonth {
    2.     public static void main(String[] args) {
    3.     }
    4. }

    步骤二：读取控制台的输入

    在main方法中，实例化Scanner类，并调用Scanner类的nextInt方法接收用户从控制台输入的年份和月份数值，使用完毕后将scanner对象关闭。代码如下所示：

     
    1. import java.util.Scanner;
    2. public class DayOfMonth {
    3.     public static void main(String[] args) {
    4.         Scanner scanner = new Scanner(System.in);
    5.         System.out.println("请输入年份（例如：2012）");
    6.         int year = scanner.nextInt();
    7.         System.out.println("请输入月份（例如：１）");
    8.         int month = scanner.nextInt();
    9.         scanner.close();
    10.     }
    11. }

    步骤三：使用switch-case判断各个月份的天数

    使用switch-case,根据规则判断用户所录入的月份的天数。代码如下所示：

     
    1. import java.util.Scanner;
    3. public class DayOfMonth {
    4.     public static void main(String[] args) {
    5.         Scanner scanner = new Scanner(System.in);
    6.         System.out.println("请输入年份（例如：2012）");
    7.         int year = scanner.nextInt();
    8.         System.out.println("请输入月份（例如：１）");
    9.         int month = scanner.nextInt();
    10.         scanner.close();
    11.         // 某月的天数
    12.         int days = 0;
    13.         switch (month) {
    14.         case 2:
    15.             // 判断是否为闰年，闰年29天，非闰年28天
    16.             if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
    17.                 days = 29;
    18.             } else {
    19.                 days = 28;
    20.             }
    21.             break;
    22.         // 4，6，9，11为小月
    23.         case 4:
    24.         case 6:
    25.         case 9:
    26.         case 11:
    27.             days = 30;
    28.             break;
    29.         // 其余为大月
    30.         default:
    31.             days = 31;
    32.         }
    33.         System.out.println(year + "年" + month + "月有" + days + "天");
    34.     }
    35. }

    在上述代码中，“case 2：”表示为2月，2月为平月。在该case块中，使用if-else语句判断当前年是否为闰年。当为闰年的时候2月为29天，否则，2月为28天。“case 4：”、“case 6：”、“case 9：”以及“case 11”分别表示为4月、6月、9月和11月，这些月为小月，天数为30天。另外，剩余的其它月份为大月，天数为31天，使用default分支中实现即可。

    本案例的完整代码如下所示：

    代码

    8 输出三个int数中的最大值（提高题，选做）

    用户从控制台接收三个整数，通过程序找出三个数中的最大值。控制台的交互效果如图-2所示。

    图- 2

    参考答案

    实现此案例需要按照如下步骤进行。

    步骤一：定义类及 main方法

    首先定义一个名为 MaxOfThree的类，并在类中添加 main方法。代码如下所示：

     
    1. public class MaxOfThree {
    2.     public static void main(String[] args) {
    4.     }
    5. }

    步骤二：读取控制台的输入

    在main方法中，实例化Scanner类，并调用Scanner类的nextInt方法接收用户从控制台输入的三个整数，使用完毕后将scanner对象关闭。代码如下所示：

     
    1. import java.util.Scanner;
    3. public class MaxOfThree {
    4.     public static void main(String[] args) {
    5.         System.out.println("请依次输入三个整数：a,b,c（以空格隔开）");
    6.         Scanner scanner = new Scanner(System.in);
    7.         int a = scanner.nextInt();
    8.         int b = scanner.nextInt();
    9.         int c = scanner.nextInt();
    10.         scanner.close();        
    11.     }
    12. }

    步骤三：计算最大值

    使用三目运算符的嵌套，比较a、b、c三个整数的大小并输出结果。代码如下所示：

     
    1. import java.util.Scanner;
    3. public class MaxOfThree {
    4.     public static void main(String[] args) {
    5.         System.out.println("请依次输入三个整数：a,b,c（以空格隔开）");
    6.         Scanner scanner = new Scanner(System.in);
    7.         int a = scanner.nextInt();
    8.         int b = scanner.nextInt();
    9.         int c = scanner.nextInt();
    10.         scanner.close();
    11.         int result=(a>b?a:b)<c?c:(a>b?a:b);
    12.         System.out.println("最大值为"+result);
    13.     }
    14. }

    本案例的完整代码如下所示：

    1. import java.util.Scanner;
    3. public class MaxOfThree {
    4.     public static void main(String[] args) {
    5.         System.out.println("请依次输入三个整数：a,b,c（以空格隔开）");
    6.         Scanner scanner = new Scanner(System.in);
    7.         int a = scanner.nextInt();
    8.         int b = scanner.nextInt();
    9.         int c = scanner.nextInt();
    10.         scanner.close();
    11.         int result=(a>b?a:b)<c?c:(a>b?a:b);
    12.         System.out.println("最大值为"+result);
    13.     }
    14. }
  • 相关阅读:
    财务报表分析（张新民教授）-第五章 企业报表战略分析（1）：资源配置战略（续）
    财务报表分析（张新民教授）-第五章 企业报表战略分析（1）：资源配置战略
    财务报表分析（张新民教授）-第四章 企业经营活动与财务报表的关系
    以商品为生25：交易商品价差
    以商品为生22：页岩油与水力压裂的优缺点
    以商品为生17：石油价格历史——自1974年以来的高点和低点
    以商品为生15：商品交易中的Backwardation和Contango
    以商品为生14：大宗商品投资者的大豆交易指南
    以商品为生11：来自USDA的月度WASDE报告
    AJAX 跨域请求
  • 原文地址：https://www.cnblogs.com/xyk1987/p/8329306.html
Copyright © 2020-2023  润新知