面试必背 - Java篇（四）

31、String s = new String(“xyz”);创建了几个字符串对象？

创建了两个字符串对象。

String s1 = new String("xyz"); // 创建一个字符串对象s1，值为"xyz"
String s2 = "xyz"; // 创建一个字符串对象s2，值为"xyz"

在上面的代码中，我们创建了两个字符串对象。第一个对象是通过调用 String 类的构造函数来创建的，它包含一个字符串字面量"xyz"。第二个对象是一个字符串常量池中的字符串对象，它包含相同的字符串字面量"xyz"。虽然这两个对象都包含相同的字符串值，但它们是不同的对象，因此它们具有不同的内存地址。

32、接口是否可继承（extends）接口？抽象类是否可实现（implements）接口？抽象类是否可继承具体类（concrete class）？

接口可以继承其他接口，抽象类可以实现接口，抽象类也可以继承具体类。

下面是一个示例代码：

// 定义一个接口
interface Animal {void eat();
}// 定义一个接口继承自Animal接口
interface Mammal extends Animal {void sleep();
}// 定义一个抽象类实现Animal接口
abstract class Bird implements Animal {@Overridepublic void eat() {System.out.println("I can eat");}
}// 定义一个抽象类继承自Bird抽象类
abstract class Penguin extends Bird {@Overridepublic void sleep() {System.out.println("I can sleep");}
}// 定义一个具体类
class Dog extends Mammal {@Overridepublic void eat() {System.out.println("I can eat too");}@Overridepublic void sleep() {System.out.println("I can't sleep");}
}public class Main {public static void main(String[] args) {Dog dog = new Dog();dog.eat(); // 输出：I can eat toodog.sleep(); // 输出：I can't sleep}
}

在上面的代码中，我们定义了一个接口Animal，它有一个方法eat()。然后我们定义了一个接口Mammal，它继承自Animal接口，并添加了一个新的方法sleep()。接着我们定义了一个抽象类Bird，它实现了Animal接口，并重写了eat()方法。然后我们定义了一个抽象类Penguin，它继承自Bird抽象类，并重写了sleep()方法。最后我们定义了一个具体类Dog，它继承自Mammal接口，并重写了eat()和sleep()方法。在Main类的main方法中，我们创建了一个Dog对象，并调用了它的eat()和sleep()方法。

33、一个”.java”源文件中是否可以包含多个类（不是内部类）？有什么限制？

一个“.java”源文件中可以包含多个类，但是只能有一个public类，并且该public类的名称必须与文件名相同。其他类可以是public、protected或默认访问权限的类。

下面是一个示例代码：

// 文件名：MainClass.java
public class MainClass {public static void main(String[] args) {System.out.println("Hello, World!");AnotherClass anotherClass = new AnotherClass();anotherClass.printMessage();}
}// 文件名：AnotherClass.java
public class AnotherClass {public void printMessage() {System.out.println("This is another class.");}
}

在上面的代码中，我们定义了两个类：MainClass和AnotherClass。它们都位于同一个源文件中，但是只有MainClass是public类，因此它是源文件中唯一的public类。在MainClass中，我们创建了一个AnotherClass对象，并调用了它的printMessage()方法。这个AnotherClass类是public类的嵌套类，它位于MainClass的内部。

34、Anonymous Inner Class(匿名内部类)是否可以继承其它类？是否可以实现接口？

匿名内部类不能继承其他类，但可以实现接口。

下面是一个示例代码：

// 定义一个接口
interface MyInterface {void doSomething();
}public class Test {public static void main(String[] args) {// 使用匿名内部类实现接口MyInterface myInterface = new MyInterface() {@Overridepublic void doSomething() {System.out.println("Doing something...");}};myInterface.doSomething(); // 输出：Doing something...}
}

在上面的代码中，我们定义了一个接口MyInterface，它有一个方法doSomething()。然后我们在Test类的main方法中使用匿名内部类来实现了这个接口。匿名内部类没有名称，因此我们使用花括号来创建一个匿名内部类的对象，并重写了接口中的doSomething()方法。最后我们调用了myInterface对象的doSomething()方法，输出了一条消息。

35、内部类可以引用它的包含类（外部类）的成员吗？有没有什么限制？

内部类可以引用它的包含类（外部类）的成员，包括私有成员。

下面是一个示例代码：

public class OuterClass {private int outerField = 10;class InnerClass {void printOuterField() {System.out.println("Outer field: " + outerField);}}
}

在上面的代码中，我们定义了一个名为OuterClass的外部类，它有一个私有成员outerField。然后我们在OuterClass中定义了一个名为InnerClass的内部类，它有一个方法printOuterField()，用于打印outerField的值。在InnerClass中，我们可以直接访问outerField，因为它是OuterClass的一个成员。

需要注意的是，如果内部类需要访问外部类的私有成员，应该使用getter和setter方法来获取和设置这些成员的值。这是因为Java不支持直接访问私有成员。

36、Java 中的final关键字有哪些用法？

Java 中的 final 关键字可以用于以下几种情况：

1. 修饰类

当一个类被 final 修饰时，表示该类不能被继承。例如：

final class MyClass {// ...
}

2. 修饰方法

当一个方法被 final 修饰时，表示该方法不能被子类重写（覆盖）。例如：

class MyClass {final void myMethod() {// ...}
}

3. 修饰变量

当一个变量被 final 修饰时，表示该变量的值只能被赋值一次，并且必须在声明时或者构造函数中进行初始化。例如：

class MyClass {final int myVariable = 10; // 在声明时进行初始化
}

4. 修饰参数

当一个方法的参数被 final 修饰时，表示该参数在方法内部不能被修改。例如：

void myMethod(final int myParameter) {// myParameter = newValue; // 编译错误
}

5. 修饰引用类型变量

当一个引用类型变量被 final 修饰时，表示该引用指向的对象不能被修改，但引用本身可以被修改。例如：

class MyClass {final List<String> myList = new ArrayList<>();
}

37、数据类型之间的转换

Java 中的数据类型之间可以通过以下方式进行转换：

1. 自动类型转换

Java 会自动将低精度数据类型转换为高精度数据类型，例如将 int 类型的值转换为 double 类型的值。

int i = 10;
double d = i; // 自动类型转换，将 int 类型的值 i 转换为 double 类型的值 d

2. 强制类型转换

使用强制类型转换可以将高精度数据类型转换为低精度数据类型，例如将 double 类型的值转换为 int 类型的值。

double d = 3.14;
int i = (int) d; // 强制类型转换，将 double 类型的值 d 转换为 int 类型的值 i

需要注意的是，强制类型转换可能会导致精度丢失，因为 Java 会将 double 类型的值截断为 int 类型的值。

3. 字符串与基本数据类型的相互转换

可以使用 Integer.parseInt() 和 Double.parseDouble() 方法将字符串转换为基本数据类型，也可以使用 String.valueOf() 方法将基本数据类型转换为字符串。

String str = "123";
int i = Integer.parseInt(str); // 将字符串 str 转换为 int 类型的值 istr = "3.14";
double d = Double.parseDouble(str); // 将字符串 str 转换为 double 类型的值 di = 123;
str = String.valueOf(i); // 将 int 类型的值 i 转换为字符串 str

4. 数组之间的转换

可以使用 Arrays.asList() 方法将数组转换为 List 集合，也可以使用 Arrays.stream() 方法将数组转换为 Stream 流。

int[] arr = {1, 2, 3};
List<Integer> list = Arrays.asList(arr); // 将数组 arr 转换为 List 集合 listint[] arr2 = {4, 5, 6};
Stream<Integer> stream = Arrays.stream(arr2); // 将数组 arr2 转换为 Stream 流 stream

38、如何实现字符串的反转及替换？

字符串的反转可以使用 StringBuilder 类的 reverse() 方法实现，替换可以使用 String 类的 replace() 方法实现。

下面是一个示例代码：

public class StringReverseAndReplace {public static void main(String[] args) {String str = "Hello, World!";// 反转字符串StringBuilder sb = new StringBuilder(str);String reversedStr = sb.reverse().toString();System.out.println("反转后的字符串：" + reversedStr);// 替换字符串中的字符String replacedStr = str.replace('o', '0');System.out.println("替换后的字符串：" + replacedStr);}
}

在上面的代码中，我们首先定义了一个字符串 str，然后使用 StringBuilder 类的 reverse() 方法将其反转，并将结果存储在变量 reversedStr 中。接着，我们使用 String 类的 replace() 方法将字符串中的字符 ‘o’ 替换为 ‘0’，并将结果存储在变量 replacedStr 中。最后，我们分别输出了反转后的字符串和替换后的字符串。

39、怎样将GB2312编码的字符串转换为ISO-8859-1编码的字符串？

可以使用Java中的String类的构造函数来实现GB2312编码的字符串转换为ISO-8859-1编码的字符串。

下面是一个示例代码：

public class EncodingConversion {public static void main(String[] args) {// 定义一个GB2312编码的字符串String gb2312Str = "中文字符";try {// 将GB2312编码的字符串转换为ISO-8859-1编码的字符串String iso88591Str = new String(gb2312Str.getBytes("GB2312"), "ISO-8859-1");System.out.println("转换后的字符串：" + iso88591Str);} catch (UnsupportedEncodingException e) {e.printStackTrace();}}
}

在上面的代码中，我们首先定义了一个GB2312编码的字符串 gb2312Str。然后，我们使用该字符串的 getBytes() 方法将其转换为字节数组，并指定编码为 GB2312。接着，我们使用 String 类的构造函数将该字节数组转换为ISO-8859-1编码的字符串，并将结果存储在变量 iso88591Str 中。最后，我们输出了转换后的字符串。需要注意的是，在使用 String 类的构造函数时，需要捕获 UnsupportedEncodingException 异常。

40、日期和时间，并打印昨天的当前时刻。

在Java中，日期和时间可以通过java.util.Date类和java.time.LocalDateTime类来处理。

1. java.util.Date类：这个类表示特定的瞬间，精确到毫秒。它有一个构造函数可以接受年、月、日、时、分、秒等参数。

import java.util.Date;public class Main {public static void main(String[] args) {// 创建一个Date对象，表示当前时间Date date = new Date();System.out.println("当前时间的Date对象：" + date);}
}

2. java.time.LocalDateTime类：这个类表示日期和时间，没有时区的概念。它有一个静态方法now()可以获取当前的日期和时间。

import java.time.LocalDateTime;public class Main {public static void main(String[] args) {// 获取当前的日期和时间LocalDateTime now = LocalDateTime.now();System.out.println("当前的日期和时间：" + now);}
}

如果你需要对日期和时间进行更复杂的操作，比如加减天数、小时、分钟等，可以使用java.time包中的其他类，如LocalDate、LocalTime、Period等。

要打印昨天的当前时刻，可以使用Java的java.time包中的LocalDateTime类。以下是一个示例代码：

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;public class Main {public static void main(String[] args) {// 获取昨天的日期LocalDateTime yesterday = LocalDateTime.now().minusDays(1);// 获取昨天的当前时刻LocalDateTime yesterdayCurrentTime = LocalDateTime.of(yesterday, LocalDateTime.MIN.toLocalTime());// 格式化输出DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");System.out.println("昨天的当前时刻：" + yesterdayCurrentTime.format(formatter));}
}

这段代码首先获取昨天的日期，然后根据昨天的日期和最小时间（00:00:00）创建一个LocalDateTime对象，表示昨天的当前时刻。最后，使用DateTimeFormatter将结果格式化为字符串并输出。

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！