南邮-Java期末考试复习要点

Java期末考试复习要点，虽然已经过去很久了，但是整理出来总归还是好的吧。

第二章

2-3 short 和 char 的取值范围有何不同

short 为有符号数，取值范围是2^-15 ~ 2¹⁵-1，char 为无符号类型，取值范围是 \u0000～\uFFFF（即0～65535）。

2-8 分析基本数据类型与引用数据类型的主要特点，说明这两种变量的差别

基本数据类型有：整数类型 byte、short、int、long，浮点数类型 float、double，字符类型 char，布尔类型 boolean；引用数据类型包括数组（array）、类（class）和接口（interface）。
基本数据类型是存储于栈中，引用数据类型存储于堆中。
基本数据类型按值传递，引用数据类型传递的是引用，多个相同引用会指向同一片内存空间。

2-16怎样将数值类型的数据转换成字符串？采用下列语句是否可行

int i = 10;
String str = (String)i;

使用 String 类中的 public static String format(String format, Object… args) 方法。

2-18怎样比较两个字符？怎样比较两个字符串？有几种比较字符串的方法？

char 字符是基本数据类型，可以使用 == 和 != 运算符比较是否相等，也可使用 >、>=、<、<= 运算符比较大小。
String 字符串是类，提供 equals(obj) 方法判断是否相等，返回 boolean 类型。提供 compareTo(cobj) 比较大小，返回 int 类型，当返回0时，表示两者相等；当返回正数时，表示当前对象大；当返回负数时，表示当前对象小，说明详见教材第4章Comparable 接口。

思考题

Java代码：

public class DoubleTest {
   
    public static void main (String[] args){
   
        System.out.println(0.3 - 0.1);
    }
}

结果为0.19999999999999998

C代码：

#include <stdio.h>

int main() {
   
    double a = 0.3;
    double b = 0.1;
    printf("a-b=%f\n", a - b);
    return 0;
}

Gcc编译运行结果为：a-b=0.200000

为什么相同的浮点数（0.3和0.1），计算的结果不一致？
提示：尝试改变 printf 函数的输出精度。
参考答案：
对于 double 类型数据，在计算机内部存储的时候，java 和 c 都是一致的（IEEE 754标准）。只不过 c 中的 printf 函数对输出进行了截断，默认精度为6位，所以产生四舍五入，为0.200000。

第三章

第一题：阅读下述代码

public class SuperClass1 {
   
       public SuperClass1() {
   
        System.out.println("SuperClass1");
    }
}

public class SuperClass2Extends1 extends SuperClass1 {
   

    public SuperClass2Extends1() {
   
        System.out.println("SuperClass2Extends1");
    }
}

public class ChildClassExtends2 extends SuperClass2Extends1 {
   

    public ChildClassExtends2() {
   
        System.out.println("ChildClassExtends2");
    }

    public static void main(String[] args) {
   
        new ChildClassExtends2();
    }
}

运行 main 函数，请问最终输出是什么？
提示：Java 是单继承，但会形成一个完整的继承树。
参考答案：会先执行父类的构造方法然后执行子类的构造方法
SuperClass1
SuperClass2Extends1
ChildClassExtends2

第二题：理解抽象类设计和多态

设计一个抽象类，代码如下：

public abstract class NonPerfectAbstractClass {
   
    public abstract void printData();
}

设计一个子类，继承上述抽象类，代码如下：

public class NonPerfectChildCLass extends NonPerfectAbstractClass {
   
    private int data;

    public void setData(int data) {
   
        this.data = data;
    }

    public void printData() {
   
        System.out.println(this.data);
    }

    public static void main(String[] args) {
   
        NonPerfectAbstractClass npac = new NonPerfectChildCLass();//多态
        npac.setData(5);
        npac.printData();
    }
}

在子类的 main 方法中，利用多态特征，父类定义的变量 npac 指向了一个子类的实例。但我们试图用 npac. 访问 setData 方法是失败的，无法调用。请问：
（1）为什么变量 npac 不能调用 setData 方法？
参考答案：NonPerfectAbstractClass npac，npac 的数据类型是 NonPerfectAbstractClass。编译器在检查程序时，会查看NonPerfectAbstractClass 中的方法定义，发现没有 setData，所以报错。
提示：从编译器角度思考

（2）如何调用 setData 方法呢？
参考答案：强制类型转化，代码如下

NonPerfectChildCLass npcc = (NonPerfectChildCLass)npac;
npcc.setData(3);

（3）但强制类型转化又暴露了子类，多态失去了真正的含义。如何解决？
参考答案：对父类重新定义，父类应该包含所有应该出现的方法，如将 setData 也定义为虚方法。子类只需要实现这些方法，而不需要重新增加新的方法。

第三题：类设计（有一定难度，请仔细思考）

1、用户要求设计一个算术运算类 BasicIntOpera，支持 int 类型数据的加法和减法操作，并返回 int 类型的计算结果。

要求：变量为 private。通过 setData 方法对数据赋值。加法和减法为 public 类型成员方法，这两个方法不带参数，无返回值。通过 getResult 方法获得计算结果。
参考答案：

2、用户要求设计子类 IntOpera，继承 BasicIntOpera，额外支持 int 类型数据的乘法和除法运算，运算结果为 int 类型。

3、用户不再满足仅对 int 类型的数据进行加减乘除运算，还需要对 double 类型数据进行四则运算，计算结果同样为 int 类型。

为了程序的可扩展性，请设计抽象类 AbstractOpera，表示算术运算。AbstractOpera 中包括加减乘除4个抽象成员方法以及抽象的 setData 和 getResult 方法。其中，setData 方法的参数固定为 double 类型，getResult 方法返回值类型固定为 int。再针对 int、double 这两种情形，重新设计两个子类继承 AbstractOpera，分别实现对应的抽象成员方法。
提示：setData 方法的参数固定为 double 类型，getResult 方法返回值类型固定为 int，会涉及类型转化。

package cn.edu.njupt.iot.lesson3;

public abstract class AbstractOpera {
   
    public abstract void setData(double para1, double para2);
    public abstract int getResult();
    public abstract void add();
    public abstract void sub();
    public abstract void multiply();
    public abstract void divided();

}

package cn.edu.njupt.iot.lesson3;
public class IntOpera extends AbstractOpera
    private int opera1;
    private int opera2;
    private int result;
    IntOpera() {
   
    } 
    public void setData(double para1, double para2) {
   
        this.opera1 = (int)para1;
        this.opera2 = (int)para2;
    }
    public int getResult() {
   
        return result;
    }
    public void add() {
   
        result = opera1 + opera2;
    }
    public void sub() {
   
        result = opera1 - opera2;
    }
    public void multiply() {
   
        result = opera1 * opera2;
    }
    public void divided() {
   
        result = (int)(opera1 / opera2);
    }
}


public class IntOpera extends AbstractOpera {
   
    private int opera1;
    private int opera2;
    private int result;
    IntOpera(){
   
    }
    public void setData(double para1, double para2) {
   
        this.opera1 = (int)para1;
        this.opera2 = (int)para2;
    }
    public int getResult() {
   
        return result;
    }
    public void add() {
   
        result = opera1 + opera2;
    }
    public void sub() {
   
        result = opera1 - opera2;
    }
    public void multiply() {
   
        result = opera1 * opera2;
    }
    public void divided() {
   
        result = (int)(opera1 / opera2);
    }
}


package cn.edu.njupt.iot.lesson3;
public class DoubOpera extends AbstractOpera{
   
    private double opera1;
    private double opera2;
    private double result;
    DoubOpera() {
   
    }
    public void setData(double para1, double para2) {
   
        this.opera1 = para1;
        this.opera2 = para2;
    }
    public int getResult() {
   
        return (int) result;
    }
    public void add() {
   
        result = opera1 + opera2;
    }
    public void sub() {
   
        result = opera1 - opera2;
    }
    public void multiply() {
   
        result = opera1 * opera2;
    }
    public void divided() {
   
        result = opera1 / opera2;