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

川长思鸟来 2022-11-07 11:43 608阅读 0赞

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

![IMG\_20210308\_172835][IMG_20210308_172835]

**1.问答题**  
(1)面向对象语言有哪三个特性？

> 封装、继承和多态

(2)类名应当遵守怎样的编程风格？

> 当类名由几个单词复合而成时，每个单词的首字母使用大写。

(3)变量和方法的名字应当遵守怎样的编程风格？

> 名字的首单词的首字母使用小写，如果变量的名字由多个单词组成，从第2个单词开始的其他单词的首字母使用大写。

(4)类体内容中声明成员变量是为了体现对象的属性还是行为？

> 属性

(5)类体中定义的非构造方法是为了体现对象的属性还是行为？

> 行为

(6)什么时候使用构造方法？构造方法有类型吗？

> 用类创建对象时。没有类型。

(7)类中的实例变量在什么时候会被分配内存空间？

> 用类创建对象时。

(8)什么叫方法的重载？构造方法可以重载吗？

> 一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即是参数的个数不同，或者是参数的类型不同。可以。

(9)类中的实例方法可以操作类变量（static变量）吗？类方法（static方法）可以操作实例变量吗？

> 可以。不可以。

(10)类中的实例方法可以用类名直接调用吗？

> 不可以。

(11)简述类变量和实例变量的区别。

> 一个类通过使用new运算符可以创建多个不同的对象，不同的对象的实例变量将被分配不同的内存空间。所有对象的类变量都分配给相同的一处内存，对象共享类变量。

(12)this关键字代表什么？this可以出现在类方法中吗？

> 代表调用当前方法的对象。不可以。

**2.选择题**  
(1)下列哪个叙述是正确的？  
A. Java应用程序由若干个类所构成，这些类必须在一个源文件中。  
B. Java应用程序由若干个类所构成，这些类可以在一个源文件中，也可以分布在若干个源文件中，其中必须有一个源文件含有主类。  
C. Java源文件必须含有主类。  
D. Java源文件如果含有主类，主类必须是public类。

答案：B
    C选项中一个源文件可以没有主类，但在一个应用程序（工程）下必须由一个主类
    D选项如果若干源文件在同一个包下，主类可以不加public修饰。

(2)下列哪个叙述是正确的？  
A. 成员变量的名字不可以和局部变量的名字相同。  
B. 方法的参数的名字可以和方法中声明的局部变量的名字相同。  
C. 成员变量没有默认值。  
D 局部变量没有默认值.。

答案：D
    B选项如果相同，那么在方法内赋值操作就会混乱。
    C选项成员变量都是有默认值的比如int 是0 double 是0.0 String 是null。而局部变量是没有默认值的，所以在使用之前必须要进行初始化。

(3)对于下列Hello类，哪个叙述是正确的？  
A. Hello类有两个构造方法。  
B. Hello类的int Hello()方法是错误的方法。  
C. Hello类没有构造方法。  
D. Hello无法通过编译，因为其中的hello方法的方法头是错误的（没有类型）

class Hello{
        Hello (int m){
        }
        int Hello(){
            return 20;
        }
        hello(){
        }
    }

答案：D
    Hello只有一个构造方法，构造方法是没有类型的，构造方法名必须和类名相同，故hello()不是构造方法，但他又没有类型，不符合普通方法的规定，所以编译会发生错误。

(4)对于下列Dog类，哪个叙述是错误的？  
A. Dog(int m)与Dog(double m)是互为重载的构造方法。  
B. int Dog(int m)与void Dog(double m)是互为重载的非构造方法。  
C. Dog类只有两个构造方法，而且没有无参数的构造方法。  
D. Dog类有三个构造方法。

class Dog{
        Dog(int m){
        }
        Dog(int double m){
        }
        int Dog(int m){
            return 23;
        }
        void Dog(double m){
        }
    }

答案：D
    方法重载要求方法名相同，参数列表不同，可以是参数个数或者类型不同。构造方法也是可以重载的。Dog类有两个构造方法（不带类型的），而后两个方法是互为重载的非构造方法。

(5)下列哪些类声明是错误的？  
A. class A  
B. public class A  
C. protected class A  
D. private class A

答案：CD
    类只能用public 修饰或者默认（友好）

(6)下列A类中【代码1】~【代码5】哪些是错误的？

class Tom{
        private int x = 120;
        protected int y = 20;
        int z = 11;
        private void f(){
            x = 200;
            System.out.println(x);
        }
        void g(){
        x = 200;
        System.out.println(x);
        }
    }
    public class A{
      public static void main(String args[]){
          Tom tom = new Tom();   
          tom.x = 22;             //【代码1】
          tom.y = 33;             //【代码2】
          tom.z = 55;             //【代码3】
          tom.f();                //【代码4】
          tom.g();                //【代码5】
      }
    }

答案：【代码1】【代码4】
    Tom类中的成员变量x是私有变量，不能直接使用对象调用。
    f是私有方法，也不能直接使用对象调用
    protect允许在同一个包中或者是子类调用

(7)下列E类的类体中哪些【代码】是错误的？

classE{
        int x;
        long y = x;
        public void f(int n){
        int m;
        int t = n+m;
        }
    }

答案：【代码4】
    m是局部变量，没有默认值，所以在没有初始化的前提下使用会报错。

**3.阅读程序**  
(1)说出下列E类中【代码1】~【代码3】的输出结果。

class Fish{
        int weight = 1;
    }
    class Lake{
        Fish fish;
        void setFish(Fish s){
            fish = s;
        }
        void foodFish(int m){
            fish.weight=fish.weight + m;
        }
    }
    public class E{
        public static void main(String args[]){
            Fish redFish = new Fish();
            System.out.println(redFish.weight);//【代码1】
            Lake lake = new Lake();
            lake.setFish(redFish);
            lake.foodFish(120);
            System.out.println(redFish.weight);//【代码2】
            System.out.prihtln(lake.fish.weight);//【代码3】
        }
    }

答案：【代码1】：1，【代码2】：121，【代码3】：121。
    redFish对象是Fish类的实例，所以具有Fish类的属性，输出的weight是1。
    lake.setFish方法传递的是redFish对象，将redFish对象赋值给Lake中的fish对象，那么二者就具有了相同的引用，从而具有完全相同的变量。那么调用lake.foodFish(120)时，lake对象中的fish对象的weight就变成了121，而redFish和fish的引用相同，其变量也相同，所以redFish中的weight也同样变成了121。

(2)请说出A类中System.out.println的输出结果

class B{
        int x = 100, y = 200;
        public void setX(int x){
            x = x;
        }
        public void setY(int y){
            this.y=y;
        }
        public int getXYSum(){
            return x+y;
        }
    }
    public class A{
        public static void main(String args[]){
            B b = new B();
            b.setX(-100);
            b.setY(-200);
            System.out.println("sum="+b.getXYSum());
        }
    }

答案：sum=-100
    这道题涉及了this关键字的用法。
    主类中声明了B类的对象先调用setX方法传递参数为-100，但在这个方法体中的语句为x=x，等号右边的x是传递进的参数，而等号左边的x同样也指这个参数，所以相当于把参数的值赋值给本身，是没有任何意义的。
    而调用setY方法，等号左边是this.y指的就是当前类下的成员变量y，所以此时成员变量y被赋值为-200，返回x+y的和就为-100。

(3)请说出A类中System.out.println的结果。

class B{
        int n;
        static int sum = 0;
        void setN(int n){
            this.n = n;
        }
        int getSum(){
            for(int i=1;i<=n;i++)
                sum=sum+i;
            return sum;
        }
    }
    public class A{
        public static void main(String args[]){
          B b1 = new B(),b2=new B();
          b1.setN(3);
          b2.setN(5);
          int s1 = b1.getSum();
          int s2 = b2.getSum();
          System.out.println(s1+s2
        }
    }

答案：27
    这道题考察类变量（static变量）
    无论一个类实例了多少个对象，他们都共享类中的类变量。b1中的n是3，b2中的n是5，调用b1.getSum求和后得到的结果是1+2+3=6赋值给s1，由于sum是类变量，所以b2中的sum也是6，再调用b2.getsum求和，就是6+1+2+3+4+5=21赋值给了s2，此时b1中的sum也变成了21，最后输出s1+s2的值就为6+21=27。

(4)请说出E类中【代码1】和【代码2】的输出结果。

class A{
        double f(int x,double y){
            return x+y;
        }
        int f(int x,int y){
            return x*y;
        }
    }
    public class E{
        public static void main(String args[]){
            A a = new A();
            System.out.println(a.f(10,10));//【代码1】
            System.out.println(a.f(10,10.0));//【代码2】
        }
    }

答案：【代码1】100 【代码2】20.0
    这道题考察方法重载，方法重载要求方法名必须相同，参数列表不同（参数的个数不同或者是参数类型不同），【代码1】传递的参数是两个int变量10和10，那么与int f(int x,int y)方法匹配，输出结果100，【代码2】传递的参数是int 10和double 10.0，和double f(int x, double y)匹配，输出结果是20.0注意不能写成20，返回的是double类型。

(5)上机执行下列程序，了解可变参数、不重要

(6)类的字节码进入内存时，类中的静态块会立刻被执行。执行下列程序，了解静态块、不重要

**4.编程题(参考例子7～9)**  
用类描述计算机中CPU的速度和硬盘的容量，要求Java应用程序由4个类，名字分别是PC、CPU、HardDisk、和Test，其中Test是主类。

*  PC类与CPU和HardDisk类关联的UML图(图在下方)

其中，CPU类要求getSpeed()返回speed的值，要求setSpeed(int m)方法将参数m的值赋值给speed；HardDisk类要求getAmount()返回amount的值，要求setAmount（int m）方法将参数m的值赋值给amount；PC类要求setCPU(CPU c)将参数c的值赋值给CPU，要求setHardDisk(HardDisk h)方法将参数h的值赋值给HD，要求show()方法能显示CPU的速度和硬盘的容量。

*  主类Test的要求

(1)main方法中创建一个CPU对象cpu，cpu将自己的speed设置为2200.  
(2)main方法中创建一个HardDisk对象disk，disk将自己的amount设置为200。  
(3)main方法中创建一个PC对象pc。  
(4)pc调用setCPU(CPU c)方法，调用时实参是cpu。  
(5)pc调用setHardDisk(HardDisk h）方法，调用时实参是disk。  
(6)pc调用show方法。

![这里写图片描述][4b4f66070a5a5201ddfd58d2752fdadc.png]

public class CPU{
        int speed;
        int getSpeed(){
            return speed;
        }
        public void setSpeed(int speed){
            this.speed = speed;
        }
    }
    public class HardDisk{
        int amount;
        int getAmount(){
            return amount;
        }
        public void setAmount(int amount){
            this.amount = amount;
        }
    }
    public class PC{
        CPU cpu;
        HardDisk HD;
        void setCPU(CPU cpu){
            this.cpu = cpu;
        }
        void setHardDisk(HardDisk HD){
            this.HD = HD;
        }
        void show(){
            System.out.println("CPU速度："+cpu.getSpeed());
            System.out.println("硬盘容量"+HD.getAmount());
        }
    }
    public class Test{
        public static void main(String args[]){
            CPU cpu = new CPU(); //1
            HardDisk HD = new HardDisk(); //2
            cpu.setSpeed(2200); //1
            HD.setAmount(200); //2
            PC pc = new PC(); //3
            pc.setCPU(cpu); //4
            pc.setHardDisk(HD); //5
            pc.show(); //6
        }
    }

[IMG_20210308_172835]: /images/20221023/630f6cb265894befa64876c3f47acbc0.png
[4b4f66070a5a5201ddfd58d2752fdadc.png]: /images/20221023/702d446bd0b744018b2fc49c5da83ea4.png