java差生的逆袭之路（期中选择题）

有以下类定义：

abstract class Animal{//这里是一个抽象类Animal，有一个抽象方法say

abstract void say();

}

public class Cat extends Animal{//这里是一个Cat类继承了抽象类Animal的方法

public Cat(){//Cat类里面弄一个Cat方法，这两个名称可以相同是因为这两个在不同的作用域上，类在包中，可以被包里面其他的类引用，方法在类中，只能被主函数引用，一个类中的方法不能有一样的，否则就不知道是调用的哪一个方法

System.out.printf("I am a cat");//在这个例子中，程序中定义了一个名为 Cat 的类，并创建了一个 Cat 类的对象。这个对象是通过调用 Cat 类的无参构造函数创建的，该构造函数会在创建对象时输出 "I am a cat" 字符串。因此，程序输出 "I am a cat"，证明成功创建了 Cat 对象。

}

public static void main(String[] args) {

Cat cat=new Cat();//

这句代码可以分解为三个部分：

1. Cat 是一个类名，代表一个类类型；

2. cat 是一个变量名，代表一个对象引用；

3. new Cat() 是一个表达式，代表创建一个 Cat 类型的对象，并返回该对象的引用。

因此，这句代码的含义是：创建一个 Cat 类型的对象，将该对象的引用赋值给变量 cat。

}

}

运行后 【 正确答案: B】

A I am a cat

B Animal能编译，Cat不能编译

C Animal不能编译，Cat能编译

D 编译能通过，但是没有输出结果有这样一段程序

实例化是指通过类创建一个对象

在Java中，实例化一个对象通常需要以下步骤：

①定义类：定义一个类，用于描述对象的属性和行为。

②创建对象：使用 new 关键字创建一个类的对象。例如，Cat cat = new Cat(); 就是创建了一个 Cat 类的对象。

③初始化对象：使用构造函数为对象初始化属性和状态。例如，Cat 类中的构造函数 public Cat() { System.out.printf("I am a cat"); } 就是在创建对象时初始化了该对象的状态。

类是对象的抽象。

类是一种数据类型，它描述了具有相同特征和行为的一组对象。它是对象的模板或蓝图，定义了对象的属性和方法。可以把类看作是对象的抽象，是创建对象的一种方式。

对象是类的实例，它是具有一组特定属性和行为的数据实体。在程序运行时，我们可以通过创建对象来使用该类中定义的属性和方法。可以把对象看作是类的具体实现，它是类的实例化结果。

2.

方法重载（Overloading），指的是在同一个类中定义名称相同的方法，但是这些方法的参数列表不同，这样可以根据不同的参数列表来区分不同的方法。例如，下面的代码定义了两个同名的 say() 方法，但是它们的参数列表不同：

public class Cat {
    public void say() {
        System.out.println("Meow");
    }

    public void say(String message) {
        System.out.println(message);
    }
}

这样定义是合法的，因为这两个方法的参数列表不同，编译器可以根据参数列表的不同来区分它们。第一个 say() 方法没有参数，第二个 say() 方法有一个 String 类型的参数 message。

3.

Animal 是一个抽象类，其中定义了一个抽象方法 say()，而 Cat 继承自 Animal，但是没有实现 say() 方法，因此 Cat 也必须成为抽象类。

修改 Cat 类，使其成为抽象类或者实现 say() 方法，就可以使程序能够编译通过并输出正确的结果。例如，下面的代码将 Cat 类声明为抽象类：

abstract class Cat extends Animal {
    public Cat() {
        System.out.println("I am a cat");
    }
}

或者实现 say() 方法：

public class Cat extends Animal {
    public Cat() {
        System.out.println("I am a cat");
    }

    void say() {
        System.out.println("Meow");
    }
}

A 封装B 继承C 覆盖D 重载等概念

A. 封装（Encapsulation）：封装是一种将数据和方法包装在一个单元中，对外部隐藏数据和方法实现细节的机制。通过封装，可以提高程序的安全性和可维护性，同时也可以提高代码的复用性和可读性。

B. 继承（Inheritance）：继承是一种通过创建新的类来扩展或修改现有类的机制。通过继承，可以实现代码的复用和扩展，同时也可以实现代码的分层和组织。

C. 覆盖（Override）：覆盖是指在子类中重新定义父类中已有的方法的机制。通过覆盖，可以实现对父类方法的修改和扩展，同时也可以实现多态性的功能。

D. 重载（Overload）：重载是指在一个类中定义多个同名但参数列表不同的方法的机制。通过重载，可以实现方法的多态性和灵活性，同时也可以提高代码的复用性。重载方法必须拥有不同的参数类型、个数或顺序，否则会编译错误。

1. 类（Class）：类是 Java 程序的基本组成单元，用于封装数据和方法。类定义了对象的属性和行为，它是对象的模板和蓝图。

2. 对象（Object）：对象是类的一个实例，表示具体的一个事物。对象具有自己的状态和行为，可以调用类定义的方法来实现特定的功能。

3. 方法（Method）：方法是类中定义的一段代码，用于实现某个特定的功能。方法可以接受参数，也可以返回值，是类的行为之一。

4. 属性（Property）：属性是类或对象的特性，用于存储数据或状态。属性也称为字段（Field），是类的状态之一。

5. 继承（Inheritance）：继承是一种面向对象编程的机制，用于实现代码的复用和扩展。通过继承，一个类可以继承另一个类的属性和方法，从而扩展自己的功能。

6. 抽象类（Abstract Class）：抽象类是一种不能被实例化的类。抽象类中定义了抽象方法，用于规范子类的行为。子类必须实现抽象方法，才能被实例化。

7. 接口（Interface）：接口是一种特殊的抽象类，它只定义了方法的签名，没有实现。接口用于规范类的行为，一个类可以实现多个接口，从而实现多重继承。

8. 多态（Polymorphism）：多态是一种面向对象编程的特性，通过多态，一个对象可以表现出多种不同的行为。多态可以通过方法重载、方法重写、接口和抽象类等方式实现。

9. 封装（Encapsulation）：封装是一种面向对象编程的特性，用于隐藏对象的实现细节，只暴露必要的接口。封装可以保护对象的状态，提高代码的可维护性和可复用性。

10. 构造方法（Constructor）：构造方法是一种特殊的方法，用于创建类的对象并初始化对象的属性。构造方法与类同名，没有返回值，可以重载。当一个对象被创建时，会自动调用它的构造方法。

11. 静态方法（Static Method）：静态方法是一种属于类的方法，不需要实例化对象就可以调用。静态方法可以通过类名来调用，也可以通过对象引用来调用，但是推荐使用类名来调用。

12. 静态属性（Static Property）：静态属性是一种属于类的属性，不需要实例化对象就可以访问。静态属性可以通过类名来访问，也可以通过对象引用来访问，但是推荐使用类名来访问。

13. final 关键字：final 关键字用于修饰类、方法和变量，表示它们是不可变的。final 类不能被继承，final 方法不能被重写，final 变量不能被修改。

14. super 关键字：super 关键字用于调用父类的构造方法、属性和方法。在子类中，可以使用 super 关键字来调用父类的构造方法，通过 super. 属性名来访问父类的属性，通过 super. 方法名来调用父类的方法。

15. this 关键字：this 关键字用于引用当前对象，可以用于访问对象的属性和方法。在方法内部，可以使用 this 关键字来访问当前对象的属性和方法，也可以用于调用其他构造方法。

16. instanceof 运算符：instanceof 运算符用于判断一个对象是否是某个类或其子类的实例。它返回一个布尔值，如果对象是某个类或其子类的实例，则返回 true，否则返回 false。

17. 包（Package）：包是 Java 程序的一种组织方式，用于将类组织在一起，避免命名冲突。包可以包含多个类，可以嵌套多个子包，可以用于访问控制和类的导入。

18. 访问修饰符（Access Modifier）：访问修饰符用于控制类、方法和属性的访问范围。Java 中有四种访问修饰符：public、protected、default 和 private。它们分别表示公开的、受保护的、默认的和私有的访问级别。

19. 异常（Exception）：异常是指程序在运行过程中遇到的错误或异常情况。Java 中提供了异常处理机制，可以通过 try-catch-finally 语句块来捕获和处理异常，保证程序的健壮性和可靠性。

20. 泛型（Generics）：泛型是一种参数化类型的机制，用于在编译时检查类型的安全性和提高代码的可读性和可复用性。通过泛型，可以定义不同类型的集合类和算法，避免了强制类型转换和类型不安全的问题。

在java中，下列（ ）语句不能通过编译．B 【 正确答案: D】

A String s =”john”+”was”+”here”

B String s =”john”+3

C int a =3+5

D float f =5+5.5

在 Java 中，如果一个算术表达式中包含不同类型的操作数，编译器会自动进行类型转换，将所有操作数转换成同一种类型后再进行运算。然而，如果其中一个操作数的类型是浮点型，那么另一个操作数就会被自动转换成浮点型。

因此，选项 D 中的 5 会被转换成 5.0，但是 5.5 仍然是浮点型，所以整个算术表达式的类型就是浮点型。然而，浮点型不能直接赋值给 float 类型，因为 float 是一种单精度浮点数类型，需要在数字后面加上 f 或 F 来表示。

因此，选项 D 会导致编译错误。

当你需要在 Java 中将一个浮点数值赋给一个 float 类型的变量时，可以使用以下示例的语法：

float f = 5.5f;

在 Java 中，浮点数字面量默认被解释为 double 类型。为了将浮点数值赋给 float 变量，你需要在数字后面显式地添加 f 或 F 后缀，将其转换为 float 类型。在上面的示例中，f 后缀表示 5.5 应该被解释为 float 类型。

在 Java 中，有两种浮点类型：float 和 double。double 是默认的浮点类型，比 float 拥有更高的精度和范围。然而，float 占用更少的内存，对于某些应用程序可能已经足够。

当你将一个浮点数字面量赋给一个 float 变量时，你需要在数字面量后面添加 f 或 F 后缀。如果你省略了后缀，编译器会将数字面量解释为 double 类型，如果你尝试将其赋给 float 变量而没有显式转换，就会出现编译错误。

以下是一些在 Java 中有效的 float 赋值示例：

float f1 = 1.23f;   // 将浮点数字面量添加 f 后缀
float f2 = 3.14F;   // F 后缀等同于 f
float f3 = (float) 2.71828;   // 显式转换为 float 类型

注意，最后一个示例使用了显式转换将 double 数字面量转换为 float 变量。这是必要的，因为 double 数字面量比 float 变量宽，如果直接赋值可能会导致精度损失。

通常情况下，除非你有使用 float 的特定需求（例如在大型浮点数值数组中节省内存），否则最好使用 double 进行大多数浮点计算。此外，当比较浮点数值相等性时，应该小心，因为浮点算术的有限精度可能会导致意外的结果。

下列哪些语句关于内存回收的说明是正确的? 【 正确答案: B】

A 程序员必须创建一个线程来释放内存

B 内存回收程序负责释放无用内存

C 内存回收程序允许程序员直接释放内存

D 内存回收程序可以在指定的时间释放内存对象

B 内存回收程序负责释放无用内存是正确的。内存回收程序（Garbage Collector）是一种自动化的机制，用于释放无用的内存对象，程序员不需要手动创建线程或释放内存。内存回收程序会在程序运行过程中监测对象的引用情况，当发现某个对象没有任何引用时，就会将其标记为垃圾对象，并在适当的时候将其释放。内存回收程序具有自动化、透明化和高效性的特点，可以提高程序的稳定性和可靠性。选项 A、C、D 都是错误的。

如下哪个是Java中的标识符 【 正确答案: A】

A fieldname

B super

C 3number

D #number

正确答案是 A，即选项 A 中的 fieldname 是 Java 中的标识符。

在 Java 中，标识符是用来标识变量、方法、类、接口、包等元素的名称。标识符必须遵守一定的命名规则，否则会导致编译错误。

Java 标识符的命名规则如下：

• 必须以字母、下划线（_）或美元符号（$）开头，不能以数字开头。

• 可以包含字母、数字、下划线和美元符号。

• 标识符的长度没有限制。

• 标识符是区分大小写的。

在选项 A 中，fieldname 以字母开头，只包含字母，符合 Java 标识符的命名规则，因此是 Java 中的标识符。

在选项 B 中，super 是 Java 中的关键字，不能用作标识符。

在选项 C 中，3number 以数字开头，不符合 Java 标识符的命名规则，因此不是 Java 中的标识符。

在选项 D 中，#number 以井号（#）开头，不符合 Java 标识符的命名规则，因此不是 Java 中的标识符。

需要注意的是，标识符是区分大小写的，因此 count 和 Count 是不同的标识符。此外，Java 中有一些关键字是不能用作标识符的，如 public、private、class、static 等。

如果一个类的声明中没有使用extends关键字，这个类被系统默认为是 主类 【 正确答案: Object】的子类。

在 Java 中，所有类都继承自 Object 类，即使在类的声明中没有显式地指定父类，编译器也会将其视为继承自 Object 类。因此，即使在类的声明中没有使用 extends 关键字，该类仍然可以使用 Object 类中的方法和属性。

下面是一个没有显式指定父类的类的示例：

public class MyClass {
    // 类的成员变量和方法
}

在这个示例中，类 MyClass 没有使用 extends 关键字指定父类，因此默认继承自 Object 类。可以通过 getClass() 方法获取该类的运行时类型，发现其父类确实是 Object 类：

MyClass myObj = new MyClass();
System.out.println(myObj.getClass().getSuperclass());  // 输出 "class java.lang.Object"

因此，可以说一个没有指定父类的类被系统默认为是 Object 类的子类。

在 Java 中，getClass() 方法是定义在 Object 类中的方法，因此所有的 Java 对象都可以调用 getClass() 方法来获取自己的运行时类型。

即使在一个类的代码中没有显式地定义 getClass() 方法，该类的实例仍然可以调用该方法，因为它是从 Object 类继承而来的。

下面是一个示例代码，展示了如何使用 getClass() 方法获取对象的运行时类型：

public class MyClass {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        System.out.println(obj.getClass().getName());  // 输出 "MyClass"
    }
}

在这个示例中，MyClass 类没有显式地定义 getClass() 方法，但是在 main() 方法中，可以通过 obj.getClass() 来获取 obj 的运行时类型，并通过 getName() 方法获取其名称。

需要注意的是，如果一个类重写了 getClass() 方法，那么该类的实例调用该方法时将返回重写后的实现，而不是从 Object 类继承而来的默认实现。

表达式5.3+(int)(8.5+4.6)/3%4的值是 5.3 【 正确答案: 5.3】。

根据 Java 运算符优先级的规则，表达式 5.3 + (int)(8.5 + 4.6) / 3 % 4 的计算顺序如下：

21. 将 (8.5 + 4.6) 算出结果 13.1，强制转换为 int 类型得到 13。

22. 13 / 3 等于 4，余数为 1。

23. 4 % 4 等于 0。

24. 5.3 + 0 等于 5.3。

因此，表达式的最终值为 5.3，与题目给出的答案一致。注意，在计算整数除法时，Java 会向下取整，因此 13 / 3 的结果为 4 而不是 5。

在JAVA中下面哪一行代码不出现编译警告或错误【D】

A float f=1.3 ;

B char c="a";

C byte b=258;

D int i=10;

在 Java 中，每个数据类型都有一个范围，如果将超出范围的值赋给变量，编译器会发出警告或错误。根据这个规则，选项 A、B 和 D 都会出现编译警告或错误。

选项 C 的赋值语句 byte b = 258; 也会出现编译警告或错误，因为 byte 类型的取值范围是从 -128 到 127，不能容纳 258 这个数值。

因此，以上选项中都会出现编译警告或错误，没有符合题目要求的选项。如果要消除警告或错误，可以将代码修改为：

// 选项 A：使用 float 类型的字面量
float f = 1.3f;

// 选项 B：使用 char 类型的字面量
char c = 'a';

// 选项 C：使用 byte 类型的合法值
byte b = 127;

// 选项 D：使用 int 类型的字面量
int i = 10;

在选项 A 中，需要在字面量后面添加 f 表示它是一个 float 类型的值。在选项 B 中，需要使用单引号将字符括起来，表示它是一个 char 类型的值。在选项 C 中，需要使用 byte 类型的合法值，例如最大值 127。在选项 D 中，使用 int 类型的字面量即可，不需要特别处理。

Java 中用于表示字符的字符常量必须使用单引号括起来，例如 'a'、'B'、'1' 等等。双引号用于表示字符串常量，也就是由多个字符组成的序列，例如 "hello"、"world" 等等。

需要注意的是，字符常量只能包含一个字符，如果需要表示 Unicode 字符，可以使用 Unicode 转义序列，例如 '\u0041' 表示大写字母 A。

下面是一些示例，展示了如何在 Java 中使用字符常量：

char c1 = 'a';        // 字符常量 'a'
char c2 = 'B';        // 字符常量 'B'
char c3 = '1';        // 字符常量 '1'
char c4 = '\u0041';   // Unicode 转义序列表示大写字母 A

需要注意的是，在字符常量的赋值语句中，等号左侧的变量类型必须是 char，不能是其他类型，例如 int、short 或 byte。如果需要将一个字符常量赋值给一个整型变量，需要进行强制类型转换，例如：

char c = 'a';
int i = (int) c;      // 将字符常量 'a' 转换为整数 97

下列代码的输出结果是()。class Parentf

void printMe0 !

System.out.print("parent ");

class Child extends Parent f

void printMe0 {System.out.print("child ");

void printall0 f

super.printMe0

this.printMe0:

printMe0;

public class Test this (

public static void main(String argsll) f

Child myC=new Child0:

myC.printall0:【A】

A parent child child

B parent child parent

C parent child

D 编译错误

根据题目描述，我们可以将代码整理一下，得到如下的代码片段：

class Parentf {
    void printMe0() {
        System.out.print("parent ");
    }
}

class Child extends Parentf {
    void printMe0() {
        System.out.print("child ");
    }
    
    void printall0() {
        super.printMe0();
        this.printMe0();
        printMe0();
    }
}

public class Test_this {
    public static void main(String argsll) {
        Child myC = new Child();
        myC.printall0();
    }
}

在 main 方法中，我们创建了一个 Child 对象 myC，然后调用了它的 printall0 方法。根据 printall0 方法的实现，它会依次调用 super.printMe0()、this.printMe0() 和 printMe0() 三个方法。

在 Child 类中，我们重写了 printMe0 方法，它的实现是打印字符串 "child "。因此，当调用 this.printMe0() 方法时，它会输出 "child "。

在 Parentf 类中，我们定义了一个名为 printMe0 的方法，它的实现是打印字符串 "parent "。因此，当调用 super.printMe0() 方法时，它会输出 "parent "。

最后，由于 printMe0() 方法在 Child 类中被重写了，因此调用 printMe0() 方法时，实际上是调用了重写后的方法，即打印字符串 "child "。

综上所述，程序的输出结果应该是 "parent child child"，因此选项 A 是正确的。

-

在创建 Child 对象 myC 的时候，并不会先输出 "child"。创建对象只是在内存中分配了一段空间，并没有执行对象方法中的语句。

只有当调用了对象的方法时，才会执行该方法中的语句。在这道题中，调用 myC.printall0() 方法时，才会执行其中的语句，包括输出 "child" 和 "parent"。

因此，程序的输出结果是 "parent child child"，而不是 "child parent child"。

Java语言中字符串“爱China”所占的内存空间是【D】

A6个字节

B 7个字节

C 10个字节

D 12个字节

答案是D 12个字节。Java中的字符串是使用Unicode编码的，每个字符占用两个字节，所以字符串“爱China”共占用6个字符，即12个字节的内存空间。

内存分配：

• boolean类型：1个字节

• byte类型：1个字节

• char类型：2个字节

• short类型：2个字节

• int类型：4个字节

• long类型：8个字节

• float类型：4个字节

• double类型：8个字节

axtra Q:

我不太懂这个循环条件中的第二层循环

for(char[] n : a)

{

for(char t : n)

在增强 for 循环中，第一层循环的语法结构是 for(char[] n : a)，其中 char[] 表示一维字符数组的类型，n 表示循环变量，即 a 数组中的每个一维字符数组。

所以，当程序执行到第一层循环体内部的第二层循环 for(char t : n) 时，变量 n 就代表了 a 数组中的一个一维字符数组，变量 t 则代表了这个一维字符数组中的每个字符。

需要注意的是，增强 for 循环只适用于对数组、集合等容器类型的数据结构进行遍历。如果需要在循环中修改数组元素的值，或者需要对数组进行排序、搜索等操作，就需要使用传统的 for 循环了。

常用的Math类方法的用法：

1. abs：返回参数的绝对值

int a = -5;
int b = Math.abs(a); // b的值为5

2. ceil：返回大于等于参数的最小整数

double a = 3.1415;
double b = Math.ceil(a); // b的值为4.0

3. floor：返回小于等于参数的最大整数

double a = 3.1415;
double b = Math.floor(a); // b的值为3.0

4. max：返回两个参数中的最大值

int a = 3;
int b = 5;
int c = Math.max(a, b); // c的值为5

5. min：返回两个参数中的最小值

int a = 3;
int b = 5;
int c = Math.min(a, b); // c的值为3

6. pow：计算一个数的幂次方

double a = 2.0;
double b = 3.0;
double c = Math.pow(a, b); // c的值为8.0

7. sqrt：计算一个数的平方根

double a = 16.0;
double b = Math.sqrt(a); // b的值为4.0

8. sin：计算一个角度的正弦值

double a = 30.0;
double b = Math.sin(Math.toRadians(a)); // b的值为0.5

9. cos：计算一个角度的余弦值

double a = 60.0;
double b = Math.cos(Math.toRadians(a)); // b的值为0.5

10. tan：计算一个角度的正切值

double a = 45.0;
double b = Math.tan(Math.toRadians(a)); // b的值为1.0

11. atan2：计算两个参数的反正切值//不太懂：其中，x 和 y 分别表示平面直角坐标系中的一个点的横坐标和纵坐标，返回值是该点的极角，也就是该点与原点之间连线与 x 轴正半轴之间的夹角。

atan2 方法的参数顺序是先传入纵坐标，再传入横坐标，这与常规的数学函数的参数顺序不同，需要注意使用。

double x = 1.0;
double y = 1.0;
double a = Math.atan2(y, x); // a的值为π/4，约等于0.7854

12. random：返回一个随机数，范围为[0.0,1.0)

double a = Math.random(); // a的值为[0.0,1.0)之间的一个随机数

这些方法都是静态方法，可以直接通过Math类名调用，需要注意的是，有些方法需要将角度转换为弧度，可以使用Math.toRadians方法进行转换。

//

但如果需要返回指定范围内的随机数，可以使用下面的方法：

生成 [0, n) 之间的随机整数：

int randomNum = (int) (Math.random() * n);

其中，n 是指定范围的上限值，生成的随机数范围是 [0, n)。

例如，如果需要生成 [0, 10) 之间的随机整数，可以使用下面的代码：

int randomNum = (int) (Math.random() * 10);

生成 [a, b) 之间的随机整数：

int randomNum = (int) (Math.random() * (b - a)) + a;

其中，a 和 b 分别是指定范围的下限值和上限值，生成的随机数范围是 [a, b)。

例如，如果需要生成 [5, 15) 之间的随机整数，可以使用下面的代码：

int randomNum = (int) (Math.random() * (15 - 5)) + 5;

需要注意的是，Math.random() 方法返回的是一个 double 类型的随机数，范围是 [0.0, 1.0)，可以通过乘以一个系数和加上一个偏移量来生成指定范围的随机数，需要根据具体需求进行调整。

c = String.valueOf(i).length();

求数字的位数！求自幂数的题目中用这个替代循环，然后我的程序就可以运行了。