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

因为练习是word，本文我只是写了里面的部分内容，如果想查阅完整内容或者获取word以及PDF，请

关注微信公众号乖乖狼科技

发送口令 akcd

T1

静态代码块中不能？ · 【D 】

A. 初始化静态变量 B. 调用静态方法

C. new对象 D. 直接调用类中实例方法（实例方法是非静态方法，非静态的无法直接调用）

注意：在静态代码块中创建的对象实例会在类加载时就创建，并且这些实例在整个应用程序生命周期中都会占用内存。

为了进行性能优化，可以采用的方法：

按需创建对象

尽量避免在静态代码块中创建不必要的对象。如果对象只需要在某些特定条件下才需要，可以在需要的时候再创建。
使用局部变量

如果对象只在静态代码块中使用，可以将其声明为局部变量，这样对象在静态代码块执行完毕后就会被垃圾回收器回收。
使用懒加载（Lazy Initialization）

对于单例模式或其他需要延迟初始化的情况，可以使用懒加载技术，确保对象只在首次需要时创建。
使用静态内部类

静态内部类可以延迟初始化对象，同时保持单例模式的线程安全性。
使用枚举实现单例

枚举是一种线程安全且简单的方式来实现单例模式，同时避免了反射攻击的风险。
内存管理

确保对象在不再需要时能够被垃圾回收器回收。避免对象引用泄露，特别是在长时间运行的应用程序中。

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);

    }

}

解释：

创建 BigDecimal 对象：使用字符串构造函数 new BigDecimal("3") 和 new BigDecimal("0.1") 来创建 BigDecimal 对象。这样可以避免从浮点数转换时引入的精度问题。
执行乘法运算：使用 multiply 方法进行乘法运算。
输出结果：打印计算结果。
比较结果：使用 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

    }

}