Java2实用教程第五版+第三章习题答案

分手后的思念是犯贱 2022-11-07 01:56 399阅读 0赞

> 这是《Java2实用教程第五版》的试题答案，需要的同学评论关注加点赞
> 
> 有问题可以在评论区提出

![IMG\_20210308\_172835][IMG_20210308_172835]

**1.问答题**  
(1) 关系运算符的运算结果是怎样的数据类型？

> boolean类型（true或者false）

(2)if语句中的条件表达式的值是否可以是int型？

> 不可以，只能是boolean类型

(3)while语句中的条件表达式的值是什么类型？

> boolean类型

(4)switch语句中必须由dafault选项吗？

> 不是必须的，但为了增强代码的鲁棒性，建议添加default选项

(5)在while语句的循环体中，执行break语句的效果是什么？

> 结束while语句的执行

(6)可以用for语句代替while语句的作用吗？

> 可以

增强型for循环介绍
    增强型for循环，又叫foreach循环，最多的应用在于循环遍历数组元素
    
    int [] arr = {1,2,3,4,5};
    for(int n:arr)   //定义了一个局部变量n按顺序获取数组arr中每一个元素
      System.out.println(n);

**2.选择题**  
(1).下列哪个叙述是正确的？  
A. 5.0/2+10的结果是double型数据  
B. (int)5.8+1.0的结果是int型数据  
C. ‘苹’+’果’的结果是char型数据  
D.(short)10+’a’的结果是short型数据

> 答案：A
> 
> B选项将5.8转化为整型后又加了一个double型1.0，所以结果仍为double型
> 
> C选项字符和int可以相互转换，两个字符相加就是对应的unicode相加，但是相加后unicode的值大于了char的范围（0-65535），所以不能用char字符接收，需要用int数据接收
> 
> D选项char的精度要比short高，所以一个short加上一个char结果为char

(2).用下列哪个代码替换程序标注的【代码】会导致编译错误？  
A. m–>0  
B. m++>0  
c. m=0  
D. m>100&&true

public class E {
        public static void main(String args[]) {
            int m=10,n=0;
            while([代码]){
                n++;
            }
        }
    }

> 答案：C
> 
> while循环条件应该是boolean类型，而C是赋值语句，所以会编译错误，要注意=是赋值，==才是等于。

(3).假设有“int x=1;”，以下哪个代码导致“可能损失精度，找到int需要char”这样的编译错误？  
A. short t = 12+’a’;  
B. char c = ‘a’+1;  
C. char m = ‘a’+x;  
D. byte n = ‘a’+1;

> 答案：C
> 
> 精度从“低”到“高”的排列的顺序是：  
> byte->short->char->int->long->float->double  
> Java在计算算术表达式的值时，使用下列运算精度规则：  
> （1）如果表达式中有double，则按double进行运算。  
> （2）如果表达式中最高精度是float，则按float进行运算  
> （3）如果表达式中最高精度是long，则按long进行运算  
> （4）如果表达式中最高精度低于int，则按int进行计算
> 
> Java允许把不超出byte、short、char的取值范围的算术表达式的值赋给byte、short、char。  
> a的ASCII码值是97，所以A选项97+12可以赋值给short
> 
> 这道题关键在于B和C的区别，有人会说x不是等于1吗，那么’a’+x不就是’a’+1吗，为什么c是错的？  
> 原因在于char c=’a’+1中’a’是字符型常量，1是数字常量。在编译器编译的时候，会自动合并，不会做类型转换。在编译阶段就完成。
> 
> char m=’a’+x中’a’是字符型常量，但x是变量，在编译阶段无法合并，只能在运行时编译，运行时发现x是整型，’a’+x自动转换成整型，无法直接赋值给char型。需要进行强转。(char)(‘a’+x)

**3.阅读程序题**  
(1)下列程序的输出结果是什么？

public class E {
        public static void main(String args[]) {
            char x='你',y='e',z='吃';
            if(x>'A'){
                y='苹';
                z='果';
            }
            else
                y='酸';
            z='甜';
            System.out.println(x+","+y+","+z);
        }
    }

> 答案为：你,苹,甜
> 
> ‘你’的字符编号大于’A’所以执行if中语句，而注意到else没有加大括号，所以z=’甜’;必定会执行。

(2)下列程序的输出结果是什么？

public class E {
        public static void main(String args[]) {
            char c = '\0';
            for (int i = 1; i <= 4; i++) {
                switch (i) {
                case 1:
                    c = 'J';
                    System.out.print(c);
                case 2:
                    c = 'e';
                    System.out.print(c);
                    break;
                case 3:
                    c = 'p';
                    System.out.print(c);
                default:
                    System.out.print("好");
                }
            }
        }
    }

> 答案为：Jeep好好
> 
> 如果switch中的一个case后面没有加break,那么程序会一直执行，直到遇到break或者swich结束。所以第一次循环输出J和e，第二次输出e，第三次输出p和好，第四次输出好。

(3)下列程序的输出结果是什么？

public class E {
        public static void main(String args[]) {
            int x=1,y=6;
            while(y-->0){
                x--;
            }
            System.out.println("x="+x+",y="+y);
        }
    }

> 答案为：x=-5,y=-1
> 
> 这道题重点是while判断条件是y–>0，自减在后，所以先判断y的大小是否大于0，再自减。即使循环不满足条件，但是只要进行了判断操作就一定会自减。
> 
> 可以算出y从6减少到1都是满足循环条件的，所以循环执行了6次，x减了6次，结果是-5，此时y的值为0；再次判断循环条件，发现不满足条件，退出循环，而y还要自减，结果为-1。

**4.编程题**

(1)求1!+2!+···+10!

public class chapter1 {
        public static void main(String[] args) {
            int sum = 0;
            for (int i = 1; i <= 10; i++) {
                int a = 1;
                for (int j = 1; j<= i; j++) {
                    a *= j; //a=a*j;
                }
                sum += a; //sum=sum+a;
            }
            System.out.println("1!+2!+...+10!= " + sum);
        }
    }

![image-20210310175018726][]

(2)求100以内的全部素数

public class chapter1 {
        public static void main(String[] args) {
            int i,j;
            System.out.println("100以内的全部素数: ");
            for (i = 2; i <= 100; i++) {
                for (j = 2; j <= i / 2; j++) {
                    if (i % j == 0){
                        break;
                    }
                }
                if (j > i / 2) {
                    System.out.print(" " + i);
                }
            }
            System.out.println();
        }
    }

![image-20210310175509401][]

(3)分别用do-while和for循环计算1+1/2!+1/3!+1/4!+···的前20项和

public class chapter1 {
        public static void main(String[] args) {
            int i = 1, j = 1;
            double sum = 0;
            do {
                i *= j;
                sum += 1.0 / i;
                j ++;
            }while (j <= 20);
            System.out.println("do-while循环");
            System.out.println("1 + 1/2! + 1/3! + 1/4! + ···+的前20项和 = " + sum);
            System.out.println();
        }
    }

public class chapter1 {
        public static void main(String[] args) {
            double sum = 0;
            int i = 1;
            for (int j = 1; j <= 20; j++) {
                i *= j;
                sum += 1.0 / i;
            }
            System.out.println("for循环");
            System.out.println("1 + 1/2! + 1/3! + 1/4! + ···+的前20项和 = " + sum);
            System.out.println();
        }
    }

![image-20210310180020409][]

(4)一个数如果恰好等于它的因子之和，这个数就称为完数，求1000之内所以的完数

public class PerfectNumbers {
        public static void main(String[] args) {
            int i, j,sum;//i表示要判断的数，j表示因子，sum表示因子之和
            System.out.print("1000之内的所有完数:");
            /*判断i能否被j整除，能的话j即为因子  因子不包括自身*/
            for (i = 2; i <= 1000; i++) {
                sum = 1;
                for (j = 2; j <= i / 2; j++) {
                    if (i % j == 0) {
                        sum += j;
                    }
                }
                if (sum == i) {
                    System.out.print(" " + i);
                }
            }
            System.out.println();
        }
    }

![image-20210310180319540][]

(5)使用for循环语句计算8+88+888+···前10项之和

public class Factorial {
        public static void main(String[] args) {
          long t = 8;
          long sum = 8;
          for (int i = 1; i < 10; i++) {
              t = t * 10 + 8;
              sum += t;
          }
          System.out.println("8+88+888+···前10项之和= " + sum);
          System.out.println();
        }
    }

![image-20210310180525684][]

(6)输出满足1+2+3+···+n<8888的最大正整数n

public class Example {
        public static void main(String[] args) {
            int sum = 0;
            int i = 1;
            while ((sum + i)< 8888)  {
                sum += i;
                i++;
            }
            System.out.println("满足1+2+3+···+n<8888的最大正整数n = " + (i - 1));
            System.out.println();
        }
    }

![image-20210310180646013][]

[IMG_20210308_172835]: /images/20221023/2269cfb3cb754305afa4d8814bbf06e7.png
[image-20210310175018726]: /images/20221023/e4672504ba4a4ea39476e4c424ac9cf6.png
[image-20210310175509401]: /images/20221023/0a2c2ca99bae445ab3abce2d036b065a.png
[image-20210310180020409]: /images/20221023/f1dcccd4a06b40e8b107d545ff4903a7.png
[image-20210310180319540]: /images/20221023/e6e7f4b5ef904b47a21508ae2807dcc6.png
[image-20210310180525684]: /images/20221023/e98e3580e3aa4c44861025b22173bc1d.png
[image-20210310180646013]: /images/20221023/fbba2e44a424433ca47db62c6a98a819.png