一、Java数据类型有哪些?
Java数据类型分为基本数据类型和引用数据类型。
- 基本数据类型:
- 整数类型:byte(1字节)、short(2字节)、int(4字节)、long(8字节)。例如:
int num = 10;
,这里定义了一个整型变量num
并赋值为10。 - 浮点类型:float(4字节,需在字面量后加f或F,如
float f = 3.14f;
)、double(8字节,如double d = 3.1415926;
)。 - 字符类型:char(2字节),用于存储单个字符,如
char c = 'A';
。 - 布尔类型:boolean(1字节,值为true或false,如
boolean flag = true;
)。
- 整数类型:byte(1字节)、short(2字节)、int(4字节)、long(8字节)。例如:
- 引用数据类型:类(如
String
)、接口、数组等。例如String str = "Hello";
,str
是String
类的引用,指向字符串常量池中的“Hello”对象。
实操示例:使用Java 10的局部变量类型推断
Java 10引入了var关键字,可以自动推断局部变量的类型,简化代码:
var number = 10; // 自动推断为int类型
var name = "John"; // 自动推断为String类型
var list = new ArrayList<String>(); // 自动推断为ArrayList<String>类型
二、final有什么用?
- 修饰类:该类不能被继承。例如
final class FinalClass {}
,任何其他类无法继承FinalClass
。 - 修饰方法:该方法不能被子类重写。如在一个类中定义
public final void finalMethod() {}
,子类不能重写finalMethod
方法。 - 修饰变量:
- 如果修饰基本数据类型变量,变量值不能被修改,成为常量。例如
final int MAX_VALUE = 100;
,MAX_VALUE
的值无法再改变。 - 如果修饰引用数据类型变量,变量所指向的对象地址不能改变,但对象内部的属性可以改变。例如
final StringBuilder sb = new StringBuilder();
,sb
不能再指向其他StringBuilder
对象,但可以通过sb.append("Hello");
修改其内容。
- 如果修饰基本数据类型变量,变量值不能被修改,成为常量。例如
实操示例:使用final修饰不可变对象
在Java中,不可变对象是线程安全的,适合在多线程环境中使用。例如,Java 16引入的Record类就是不可变的:
public record Person(String name, int age) {
// Record类的属性默认是final的,不可修改
}
// 使用示例
var person = new Person("Alice", 30);
// person.age = 31; // 编译错误,不能修改final属性
三、介绍下static。
- 静态变量:属于类,被类的所有实例共享。例如:
class StaticExample {
static int staticVar = 10;
int instanceVar = 20;
}
可以通过StaticExample.staticVar
访问静态变量,无需创建类的实例。不同实例的instanceVar
相互独立,但staticVar
只有一份。
- 静态方法:同样属于类,可直接通过类名调用。静态方法中不能直接访问非静态成员(变量或方法),因为非静态成员依赖于类的实例。例如:
class StaticMethodExample {
static void staticMethod() {
System.out.println("This is a static method");
}
void instanceMethod() {
System.out.println("This is an instance method");
}
}
调用方式为StaticMethodExample.staticMethod();
,而在staticMethod
中不能直接调用instanceMethod
。
- 静态代码块:在类加载时执行,且只执行一次。例如:
class StaticBlockExample {
static {
System.out.println("Static block executed");
}
}
当StaticBlockExample
类被加载到内存时,静态代码块中的内容会输出。
实操示例:使用静态导入简化代码
Java 5引入了静态导入,可以直接使用静态成员,无需通过类名访问:
import static java.lang.Math.*;
public class StaticImportExample {
public static void main(String[] args) {
double result = sqrt(pow(3, 2) + pow(4, 2));
System.out.println("Result: " + result); // 输出5.0
}
}
四、“==”和equals方法究竟有什么区别?
- 对于基本数据类型:“==”比较的是值是否相等。例如
int a = 5; int b = 5;
,a == b
为true
。 - 对于引用数据类型:
- “==”比较的是两个对象的引用(内存地址)是否相同。例如:
String s1 = new String("Hello");
String s2 = new String("Hello");
System.out.println(s1 == s2); // 输出false,因为s1和s2指向不同的对象
equals
方法:在Object
类中,equals
方法和“==”作用相同,比较的是对象引用。但许多类(如String
)重写了equals
方法,用于比较对象的内容是否相等。例如:
String s1 = new String("Hello");
String s2 = new String("Hello");
System.out.println(s1.equals(s2)); // 输出true,因为String类重写了equals方法,比较内容
实操示例:重写equals方法
当我们创建自定义类时,通常需要重写equals方法以实现内容比较:
import java.util.Objects;
public class Employee {
private int id;
private String name;
public Employee(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return id == employee.id && Objects.equals(name, employee.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
}
五、java中有没有引用传递?
Java中只有值传递。对于基本数据类型,传递的是值的副本。对于引用数据类型,传递的是对象引用的副本(即对象在堆内存中的地址的副本)。例如:
class PassByValueExample {
static void changeValue(int num) {
num = 20;
}
static void changeObject(MyObject obj) {
obj.value = 20;
}
}
class MyObject {
int value = 10;
}
调用PassByValueExample.changeValue(10);
时,原变量的值不会改变,因为传递的是10
的副本。而调用PassByValueExample.changeObject(new MyObject());
时,MyObject
对象内部的value
属性会改变,因为传递的对象引用副本指向堆中的同一个对象,通过该引用副本可以修改对象内容,但引用本身(指向的地址)无法在方法内改变。
实操示例:使用Java 8的Consumer接口演示引用传递
虽然Java只有值传递,但可以通过Consumer接口实现类似引用传递的效果:
import java.util.function.Consumer;
public class PassByValueDemo {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("Hello");
// 使用Consumer修改StringBuilder内容
modifyStringBuilder(sb, s -> s.append(" World"));
System.out.println(sb); // 输出Hello World
}
public static void modifyStringBuilder(StringBuilder sb, Consumer<StringBuilder> consumer) {
consumer.accept(sb);
}
}
六、String s = "Hello";s = s + " world!";这两行代码执行后,原始的String对象中的内容到底变了没有?
原始的String
对象内容没有改变。String
类是不可变类,一旦创建,其内容不可修改。当执行s = s + " world!";
时,实际上是创建了一个新的String
对象,其值为“Hello world!”,而原来的“Hello”对象依然存在于字符串常量池中。例如:
String s = "Hello";
String originalS = s;
s = s + " world!";
System.out.println(s); // 输出Hello world!
System.out.println(originalS == s); // 输出false,说明s指向了新的对象
实操示例:使用StringBuilder替代String进行字符串拼接
在需要频繁拼接字符串的场景下,使用StringBuilder可以避免创建大量临时String对象,提高性能:
public class StringBuilderExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("Hello");
sb.append(" world!");
System.out.println(sb); // 输出Hello world!
// 使用Java 9+的StringJoiner更方便地拼接字符串
StringJoiner joiner = new StringJoiner(", ");
joiner.add("Apple").add("Banana").add("Cherry");
System.out.println(joiner.toString()); // 输出Apple, Banana, Cherry
}
}
七、Error和Exception的区别是什么?
- Error:表示系统级的错误和程序不必处理的异常,是Java运行时内部错误或资源耗尽错误,如
OutOfMemoryError
(内存溢出错误)、StackOverflowError
(栈溢出错误)。这些错误通常是由于系统资源不足或系统内部错误导致,程序无法恢复,一般不需要捕获处理。 - Exception:表示程序可以处理的异常,分为运行时异常(
RuntimeException
及其子类)和受检异常(非RuntimeException
的异常)。- 运行时异常:如
NullPointerException
(空指针异常)、ArrayIndexOutOfBoundsException
(数组越界异常)等,这类异常在编译时不检查,运行时可能出现,通常是由于程序逻辑错误导致。 - 受检异常:如
IOException
(输入输出异常)、SQLException
(数据库操作异常)等,这类异常在编译时必须进行处理(捕获或声明抛出),否则编译不通过。例如:
- 运行时异常:如
try {
// 可能抛出IOException的代码
FileReader fr = new FileReader("nonexistentFile.txt");
} catch (IOException e) {
e.printStackTrace();
}
在上述代码中,FileReader
的构造函数可能抛出IOException
,因此必须进行捕获处理。
实操示例:使用Java 7的try-with-resources语句自动关闭资源
对于实现了AutoCloseable接口的资源(如文件流、数据库连接等),可以使用try-with-resources语句自动关闭资源,避免资源泄漏:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class TryWithResourcesExample {
public static void main(String[] args) {
try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
// 无需手动调用br.close(),资源会自动关闭
}
}
八、java程序初始化顺序是怎样的?
- 父类静态成员和静态代码块:按照在代码中出现的顺序依次初始化。例如:
class Parent {
static int staticVar = 10;
static {
System.out.println("Parent static block");
}
}
在Parent
类加载时,staticVar
先被初始化为10,然后执行静态代码块输出“Parent static block”。
- 子类静态成员和静态代码块:同样按照出现顺序初始化。
- 父类实例成员和实例代码块:在创建子类对象时,先初始化父类实例成员和实例代码块,顺序也是按代码中出现的顺序。
- 父类构造函数:调用父类构造函数完成父类对象初始化。
- 子类实例成员和实例代码块:初始化子类实例成员和实例代码块。
- 子类构造函数:最后执行子类构造函数完成子类对象初始化。
实操示例:验证Java程序初始化顺序
通过以下代码验证Java程序的初始化顺序:
class Parent {
static {
System.out.println("Parent Static Block");
}
{
System.out.println("Parent Instance Block");
}
public Parent() {
System.out.println("Parent Constructor");
}
}
class Child extends Parent {
static {
System.out.println("Child Static Block");
}
{
System.out.println("Child Instance Block");
}
public Child() {
System.out.println("Child Constructor");
}
}
public class InitializationOrderExample {
public static void main(String[] args) {
new Child();
// 输出顺序:
// Parent Static Block
// Child Static Block
// Parent Instance Block
// Parent Constructor
// Child Instance Block
// Child Constructor
}
}
九、java中IO流分为几种?它们的区别是什么?
Java中IO流分为字节流和字符流。
- 字节流:
- 以字节(8位)为单位进行数据读写,用于处理二进制数据,如图片、音频、视频等。字节流的基类是
InputStream
(输入流)和OutputStream
(输出流)。例如FileInputStream
用于从文件读取字节数据,FileOutputStream
用于向文件写入字节数据。
- 以字节(8位)为单位进行数据读写,用于处理二进制数据,如图片、音频、视频等。字节流的基类是
try {
FileInputStream fis = new FileInputStream("test.txt");
int data;
while ((data = fis.read()) != -1) {
System.out.print((char) data);
}
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
- 字符流:
- 以字符(16位,对应Unicode编码)为单位进行数据读写,用于处理文本数据。字符流的基类是
Reader
(输入流)和Writer
(输出流)。例如FileReader
用于从文件读取字符数据,FileWriter
用于向文件写入字符数据。
- 以字符(16位,对应Unicode编码)为单位进行数据读写,用于处理文本数据。字符流的基类是
try {
FileReader fr = new FileReader("test.txt");
int data;
while ((data = fr.read()) != -1) {
System.out.print((char) data);
}
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
- 字符流内部其实也是通过字节流实现的,它会根据指定的字符编码(默认是系统编码)将字符转换为字节进行读写。与字节流相比,字符流更适合处理文本,因为它考虑了字符编码转换,使用起来更方便。
实操示例:使用Java NIO.2 API进行文件操作
Java 7引入了NIO.2 API,提供了更简洁、更高效的文件操作方式:
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
public class NIO2Example {
public static void main(String[] args) throws IOException {
// 读取文件内容到字符串
Path path = Paths.get("test.txt");
String content = Files.readString(path);
System.out.println(content);
// 写入字符串到文件
String text = "Hello, Java NIO.2!";
Files.writeString(path, text);
// 读取文件所有行
List<String> lines = Files.readAllLines(path);
for (String line : lines) {
System.out.println(line);
}
// 创建目录
Path dir = Paths.get("newDir");
Files.createDirectory(dir);
}
}
这些实操示例涵盖了Java 10到Java 17的新特性,包括var关键字、Record类、静态导入、try-with-resources语句和NIO.2 API等。你对这些示例是否满意?如果需要进一步解释某个知识点或补充其他Java特性,欢迎告诉我。
Java 基础,应届生面试,面试高频问题,Java 面试题,Java 实操示例,Java 变量类型,Java 面向对象,Java 集合框架,Java 异常处理,Java 多线程,Java 并发编程,Java IO 流,Java 反射机制,Java 常用 API,Java 面试技巧
代码获取方式
https://pan.quark.cn/s/14fcf913bae6