[双体系练习]Java基础练习题1

因为练习是word，本文我只是写了里面的部分内容，如果想查阅完整内容或者获取word以及PDF，请
关注微信公众号 乖乖狼科技
发送口令 akcd

T1

1. 静态代码块中不能？ · 【D 】
   A. 初始化静态变量 B. 调用静态方法
   C. new对象 D. 直接调用类中实例方法（实例方法是非静态方法，非静态的无法直接调用）

注意：在静态代码块中创建的对象实例会在类加载时就创建，并且这些实例在整个应用程序生命周期中都会占用内存。
为了进行性能优化，可以采用的方法：

1. 按需创建对象
   尽量避免在静态代码块中创建不必要的对象。如果对象只需要在某些特定条件下才需要，可以在需要的时候再创建。
2. 使用局部变量
   如果对象只在静态代码块中使用，可以将其声明为局部变量，这样对象在静态代码块执行完毕后就会被垃圾回收器回收。
3. 使用懒加载（Lazy Initialization）
   对于单例模式或其他需要延迟初始化的情况，可以使用懒加载技术，确保对象只在首次需要时创建。
4. 使用静态内部类
   静态内部类可以延迟初始化对象，同时保持单例模式的线程安全性。
5. 使用枚举实现单例
   枚举是一种线程安全且简单的方式来实现单例模式，同时避免了反射攻击的风险。
6. 内存管理
   确保对象在不再需要时能够被垃圾回收器回收。避免对象引用泄露，特别是在长时间运行的应用程序中。

T2

5.给定表达式：3*0.1 == 0.3，运算结果为？ 【 B 】
A. true B. false C.编译错误 D. null

给定表达式 3 * 0.1 == 0.3 的运算结果通常是 false，因为浮点数的精度问题会导致 3 * 0.1 的结果不是精确的 0.3。

具体来说，3 * 0.1 的结果可能是 0.30000000000000004，而不是 0.3。因此，直接用 == 进行比较会返回 false。

你可以通过以下代码来验证这一点：

public class FloatPrecisionTest {

    public static void main(String[] args) {
        double result = 3 * 0.1;
        System.out.println("Result: " + result);
        
        boolean isEqual = (result == 0.3);
        System.out.println("Is the result equal to 0.3? " + isEqual);
    }
}

运行这段代码，你可能会看到类似以下的输出：

Result: 0.30000000000000004
Is the result equal to 0.3? false

因此，正确答案是：

B. false

如果你需要进行非常精确的计算，特别是涉及到金融或科学计算等领域，可以考虑使用 BigDecimal 类。BigDecimal 提供了高精度的算术运算，避免了浮点数的精度问题。

以下是使用 BigDecimal 进行精确计算的一个示例：

import java.math.BigDecimal;

public class PrecisionCalculation {

    public static void main(String[] args) {
        // 创建 BigDecimal 对象
        BigDecimal a = new BigDecimal("3");
        BigDecimal b = new BigDecimal("0.1");

        // 执行乘法运算
        BigDecimal result = a.multiply(b);

        // 输出结果
        System.out.println("Result: " + result);

        // 比较结果是否等于 0.3
        BigDecimal target = new BigDecimal("0.3");
        boolean isEqual = result.compareTo(target) == 0;
        System.out.println("Is the result equal to 0.3? " + isEqual);
    }
}

解释：

1. 创建 BigDecimal 对象：使用字符串构造函数 new BigDecimal("3") 和 new BigDecimal("0.1") 来创建 BigDecimal 对象。这样可以避免从浮点数转换时引入的精度问题。
2. 执行乘法运算：使用 multiply 方法进行乘法运算。
3. 输出结果：打印计算结果。
4. 比较结果：使用 compareTo 方法进行精确比较。compareTo 方法返回 0 表示两个 BigDecimal 对象相等。

运行这段代码，你会看到如下输出：

Result: 0.3
Is the result equal to 0.3? true

注意事项：

• 构造函数：使用字符串构造函数 new BigDecimal("0.1") 而不是 new BigDecimal(0.1)，因为后者会将浮点数 0.1 转换为 BigDecimal，这仍然会引入精度问题。
• 算术运算：BigDecimal 提供了多种算术运算方法，如 add、subtract、multiply 和 divide。需要注意的是，divide 方法可能会抛出 ArithmeticException，如果除不尽的话，可以指定舍入模式，例如 divide(BigDecimal divisor, int scale, RoundingMode roundingMode)。

通过使用 BigDecimal，你可以确保计算的高精度和准确性。

T3

6.参考如下类的代码，执行A b = new B();时输出结果是？ 【 B 】

class A {
 public void A(){
  System.out.print("A");
 }
}
public class B extends A {
 public B(){
 System.out.print("B");
 }
}

A. B B.B C.AB D.编译错误

T4

T5

9.下列关于constructor构造方法的说法正确的是？ 【 C 】
A. class中的constructor不可省略
B. 一个class 只能定义一个constructor
C. constructor在一个对象被new时执行
D. constructor名称可以随便定义

关于构造方法（constructor）的说法，正确的选项是：

C. constructor在一个对象被new时执行

解释：

• A. class中的constructor不可省略

  • 错误。如果一个类没有显式定义任何构造方法，Java 编译器会自动提供一个默认的无参构造方法。因此，构造方法是可以省略的。

• B. 一个class只能定义一个constructor

  • 错误。一个类可以定义多个构造方法，只要这些构造方法的参数列表不同（即重载构造方法）。

• C. constructor在一个对象被new时执行

  • 正确。构造方法是在使用 new 关键字创建对象时被调用的，用于初始化新创建的对象。

• D. constructor名称可以随便定义

  • 错误。构造方法的名称必须与类名完全相同，并且没有返回类型（包括 void）。

示例代码：

public class MyClass {
    // 构造方法
    public MyClass() {
        System.out.println("Default constructor");
    }

    // 重载构造方法
    public MyClass(int value) {
        System.out.println("Constructor with int parameter: " + value);
    }

    public static void main(String[] args) {
        // 调用默认构造方法
        MyClass obj1 = new MyClass();
        
        // 调用带参数的构造方法
        MyClass obj2 = new MyClass(10);
    }
}

总结：

正确的答案是：

C. constructor在一个对象被new时执行

T6

13.定义数组错误的是？ 【 B 】
A.int[] a = new int[]{1}; //匿名数组初始化(静态初始化)
B.int a = new int[1];
C.int[] a = new int[1]; // 动态初始化
D.int[] a = {1}; // 静态初始化的省略式子

数据类型[] 变量名称 = new 数据类型[长度]; // 动态初始化
数据类型[] 变量名称 = new 数据类型[]{}; // 静态初始化
数据类型[] 变量名称 = {值1，值2，值3}; // 静态初始化的省略式子

关于子类与父类之间的方法重载（overloading）和方法覆盖（overriding），正确的说法是：

A. 子类既可以重载父类的方法，又可以覆盖父类的方法

解释：

• A. 子类既可以重载父类的方法，又可以覆盖父类的方法

  • 正确。子类可以重载（overload）父类的方法，这意味着可以在子类中定义具有不同参数列表的方法。同时，子类也可以覆盖（override）父类的方法，这意味着可以在子类中重新定义具有相同签名（方法名和参数列表）的方法。

• B. 子类只能重载父类的方法，而不能覆盖（错误的）

  • 错误。子类不仅可以重载父类的方法，还可以覆盖父类的方法。

• C. 子类不能定义和父类同名同形参的方法，否则，系统将不知道调用哪个方法（错误的）

  • 错误。子类可以定义和父类同名同形参的方法，这正是方法覆盖（overriding）的概念。在这种情况下，调用哪个方法取决于对象的实际类型，而不是引用类型。

• D. 子类只能覆盖父类的方法，而不能重载（错误的）

  • 错误。子类既可以覆盖父类的方法，也可以重载父类的方法。

示例代码：

class Parent {
    public void method1() {
        System.out.println("Parent method1");
    }

    public void method2(int a) {
        System.out.println("Parent method2 with int parameter: " + a);
    }
}

class Child extends Parent {
    // 覆盖父类的方法
    @Override
    public void method1() {
        System.out.println("Child method1");
    }

    // 重载父类的方法
    public void method2(int a, String b) {
        System.out.println("Child method2 with int and String parameters: " + a + ", " + b);
    }

    // 新增方法
    public void method3() {
        System.out.println("Child method3");
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();

        child.method1();  // 输出: Child method1
        child.method2(10);  // 输出: Parent method2 with int parameter: 10
        child.method2(10, "hello");  // 输出: Child method2 with int and String parameters: 10, hello
        child.method3();  // 输出: Child method3
    }
}