Java笔试07

在Java中，接口（interface）最初被设计为只能包含抽象方法和常量。从Java 8开始，接口可以包含默认方法（default methods）和静态方法（static methods），这些方法提供了实现代码。但是，除了默认方法和静态方法之外，接口中的其他方法仍然是抽象的，不能包含实现代码。

在Java中，静态变量（static variables）和实例变量（instance variables）的存储位置是不同的。

• 实例变量的值是存储在堆（Heap）中的对象内存空间里。每个对象都有自己的实例变量副本。
• 静态变量的值是存储在方法区（Method Area）中的，这是所有对象共享的内存区域。静态变量不属于任何一个对象实例，而是属于类本身。

在Java中，finalize() 方法是 java.lang.Object 类的一个保护方法，它在对象被垃圾收集器回收前调用。这个方法被设计为在对象生命周期的末端执行清理操作，比如释放资源。然而，依赖 finalize() 方法来释放资源并不是一个好的实践，因为：

1. 不确定性：对象的 finalize() 方法执行时机是不确定的，它可能永远不会被调用，因为垃圾收集器可能决定不调用它。
2. 性能问题：依赖 finalize() 方法可能会导致性能问题，因为它延迟了对象的回收。
3. 不保证执行：在不同的垃圾收集器实现中，finalize() 方法可能根本不会被执行。

在Java 8及以后的版本中，接口可以包含实现代码。具体来说，接口可以包含：

1. 默认方法（default methods）：这些方法提供了方法的实现，所有实现该接口的类都会继承这个方法的实现。默认方法是使用 default 关键字声明的。
2. 静态方法（static methods）：这些方法也是带有实现的，它们可以在接口中直接调用，不需要由实现接口的类来实现。

在Java中，抽象类（abstract class）不一定非要包含抽象方法。抽象类可以包含抽象方法，也可以包含具体实现的方法。抽象类的主要目的是作为其他类的基类，提供一个通用的模板，其中可以包含一些通用的属性和方法。

抽象方法是一种没有实现体的方法，它使用关键字 abstract 声明，并且必须在抽象类中。如果一个类包含至少一个抽象方法，那么这个类也必须被声明为抽象类。

然而，一个抽象类可以没有抽象方法，但它仍然被声明为抽象类，这通常是为了强制要求子类实现某些方法。

在Java中，数组是用来存储固定大小的单一类型元素的集合。这意味着一个数组的所有元素必须是相同的数据类型。

实例变量（Instance Variables）

实例变量是定义在类中，但在任何方法或构造函数之外的变量，它们不属于任何特定的对象实例。每个对象实例都有自己的实例变量副本。

类变量（Class Variables，也称为静态变量）

类变量是使用 static 关键字声明的变量，它们属于类本身，而不是类的任何特定实例。整个类只有一个类变量的副本，所有实例共享这个变量。
 

 

1. 实例变量：实例变量是定义在类中，但在方法之外的变量，它们不是用 static 关键字声明的。实例变量可以被子类继承，并且子类可以有自己的实例变量，这些变量可以有不同的名称和类型。
2. 类变量：类变量是定义在类中，并且用 static 关键字声明的变量。类变量实际上是属于类的，而不是类的某个特定实例的。虽然子类可以访问父类的静态变量，但这些静态变量并不是被子类继承的。子类不能覆盖父类的静态变量，因为静态变量属于类本身，而不是对象实例。

在Java中，数组（Array）并不是一个基本数据类型。Java的基本数据类型包括：byte、short、int、long、float、double、char 和 boolean。数组是一种复合数据类型，它可以用来存储多个相同类型的元素。数组在Java中是一种对象，每个数组都是 Object 类的实例，并且继承自 java.lang.Object 类。

Java虚拟机（JVM）为每个线程分配了不同的内存区域，其中包括：

1. 程序计数器（Program Counter）：每个线程都有自己的程序计数器，用于存储下一条指令的地址。
2. 虚拟机栈（VM Stacks）：每个线程都有自己的虚拟机栈，用于存储局部变量和方法调用信息。
3. 本地方法栈（Native Method Stacks）：用于支持本地方法的执行，每个线程也有自己的本地方法栈。
4. 堆（Heap）：这是所有线程共享的内存区域，用于存储对象实例。
5. 方法区（Method Area）：也称为永久代（PermGen），在Java 8之前，这是所有线程共享的内存区域，用于存储类信息、常量、静态变量等。从Java 8开始，方法区被元空间（Metaspace）所取代，元空间是本地内存，也由所有线程共享。

在Java中，finalize() 方法是对象被垃圾收集器回收前的一个回调方法，用于执行清理工作。这个方法是 java.lang.Object 类的一个保护方法，所有Java对象都继承了这个方法。然而，依赖 finalize() 方法来手动释放对象占用的资源并不是一个可靠的做法，原因如下：

1. 不可预测性：finalize() 方法的调用时机是不可预测的，因为Java规范并不保证垃圾收集器一定会调用这个方法。
2. 性能问题：依赖 finalize() 方法可能会导致性能问题，因为它延迟了对象的回收。
3. 不保证执行：在不同的垃圾收集器实现中，finalize() 方法可能根本不会被执行。

因此，正确的做法是显式地释放资源，例如通过使用 try-with-resources 语句来自动关闭资源，或者在需要时手动调用资源释放方法，而不是依赖 finalize() 方法。从Java 9开始，finalize() 方法已经被标记为过时（deprecated），并且在未来版本中可能会被移除。

在Java中，Object 类确实提供了 clone() 方法，该方法用于创建对象的副本。clone() 方法是一个受保护的方法，这意味着它只能在同一个包中的类或者子类中被访问。这个方法是 Cloneable 接口的一部分，该接口用于标记一个类的对象是“可克隆的”。

当一个类实现了 Cloneable 接口并重写了 Object 类的 clone() 方法时，就可以创建该对象的副本。默认情况下，clone() 方法执行的是浅拷贝，即复制对象的引用，而不是对象本身。如果需要创建对象的深拷贝（复制对象及其所有成员变量），则需要在 clone() 方法中实现相应的逻辑。

在Java中，System.gc() 方法是用来提示JVM进行垃圾回收的，但它并不保证立即或完全执行垃圾回收。这个方法是非确定性的，JVM的垃圾回收器可以忽略这个请求。

垃圾回收器的运行是由JVM控制的，它会根据当前的内存使用情况和垃圾回收策略来决定何时进行垃圾回收。因此，System.gc() 方法不能强制进行垃圾回收，它只是一个建议。

在实际编程中，通常不建议使用 System.gc() 方法，因为它可能会干扰JVM的垃圾回收策略，导致性能问题。正确的做法是让JVM自己决定何时进行垃圾回收，以优化程序性能。

在Java中，== 运算符用于比较两个对象的引用是否相等，即它们是否指向内存中的同一个位置。它并不比较对象的内容。

 

在Java中，要实现对象的序列化，该对象的类需要实现java.io.Serializable接口。

java.util.Date：java.util.Date类实现了Serializable接口，这意味着Date对象可以被序列化和反序列化。

java.lang.String：虽然String类没有直接实现Serializable接口，但它是内置的Java类，并且是可序列化的。实际上，所有的Java基本数据类型及其对应的包装类，以及一些基本的Java类（如String、Integer等）都默认是可序列化的。

java.io.File：java.io.File类没有实现Serializable接口，因此它不能被序列化。

java.awt.Point：java.awt.Point类实现了Serializable接口，表示坐标空间中的位置点，可以进行序列化和反序列化。

abstract：用于声明一个类或方法。抽象类可以被继承，抽象方法可以被重写。

在Java中，流处理（stream processing）是指使用流式处理数据集合的方式，这通常与Java 8引入的Stream API有关。

map()方法：该方法用于将流中的每个元素映射到另一个元素上，返回一个新的流。

filter()方法：该方法用于对流中的元素进行过滤，返回一个包含所有符合给定谓词的元素的新流。

reduce()方法：该方法用于通过某个连接动作将所有元素汇总成一个汇总结果。

在Java中，反射（reflection）是一种在运行时检查或修改类和对象的行为的功能。

Class对象：每个类在Java中都有一个Class对象，它包含了类的相关信息，如名称、字段、方法等。通过这个对象，可以使用反射来访问类的结构和内容。

newInstance()方法：Class类的newInstance()方法用于创建类的新实例。这个方法是在Java早期版本中使用的，但在Java 9中已被弃用。现在通常使用Constructor类的newInstance()方法来创建实例。

getDeclaredFields()方法：这个方法是Class类的一部分，它返回一个包含类中声明的所有字段（包括私有字段）的Field对象数组。

Class.forName()方法：这是一个静态方法，用于根据给定的类名获取Class对象。这个方法通常用于加载并初始化类。

泛型在Java中可以用于类（包括接口），方法是通过在类名或方法名后跟一个尖括号<>来指定类型参数。

Java泛型在编译时会被处理，编译器会检查泛型的类型信息，但在运行时，所有的泛型类型信息都会被擦除，即泛型类型参数不会被保留，这有助于保持向后兼容性和减少运行时的开销。

泛型允许在编译时检查类型安全，从而避免了在运行时进行强制类型转换可能引发的ClassCastException。

Java泛型可以同时使用多个类型参数，例如public class Box<T, K> {...}。

synchronized关键字用于在Java中实现方法或代码块的同步，确保同一时间只有一个线程可以执行该段代码，从而保证操作的原子性。

volatile关键字确保一个变量的修改对所有线程都是可见的，即当一个线程修改了这个变量的值时，新值对其他线程来说是立即可见的。

Lock接口提供了比synchronized关键字更灵活的线程同步机制，例如尝试锁定（tryLock）、定时锁定（tryLock with timeout）、可中断的锁定（lockInterruptibly）等。

ReentrantReadWriteLock是一种读写锁，它允许多个线程同时读取一个资源，但在写入资源时则需要独占访问。

FileInputStream和FileOutputStream确实是基于字节的流，用于从文件中读取字节数据或将字节数据写入文件。

BufferedReader通常比Scanner更快，因为它是为了高效读取文本数据而优化的。然而，BufferedReader不支持正则表达式。Scanner类提供了正则表达式支持，但速度较慢，因为它提供了更多的解析功能。

RandomAccessFile允许在文件中任意位置进行读写操作。它提供了文件定位的方法，如seek()，以及读写数据的方法。

FileChannel是一个提供文件I/O操作的通道，它可以用于高效的文件传输，并且支持内存映射文件I/O操作，这可以提高大文件处理的性能。

生成随机数

Math.random()方法返回一个0.0到1.0之间的随机浮点数。

Random类的nextInt()方法返回一个随机整数。Random类是Java中用于生成随机数的常用类。

SecureRandom类提供加密安全的随机数生成器，适用于需要高安全性的随机数生成场景。

ThreadLocalRandom是Java 7引入的，用于生成与当前线程局部的随机数，适用于并发程序中，以减少竞争和提高性能。

可以使用java.util.concurrent包中的Executors类来创建不同类型的线程池

Executors.newFixedThreadPool()：这个方法用于创建一个固定大小的线程池。每次执行任务时，如果没有可用的线程，它会将任务排队。

Executors.newSingleThreadExecutor()：这个方法用于创建一个只有一个线程的线程池，即单线程执行器，保证所有任务按顺序执行。

Executors.newCachedThreadPool()：这个方法用于创建一个可根据需要创建新线程的线程池，对于短生命周期的异步任务非常合适。

Executors.newScheduledThreadPool()：这个方法用于创建一个用于延迟执行或定期执行任务的线程池。

ReentrantLock是Java并发包java.util.concurrent.locks中提供的一个可重入锁，它提供了比synchronized关键字更灵活的锁定机制。

StampedLock是Java 8中引入的一种锁，旨在提供比ReentrantLock更高效的读写锁。它使用乐观读锁和悲观写锁来减少锁竞争。

AtomicInteger不是锁，而是一个支持原子操作的整数类。它使用CAS（Compare-And-Swap）操作来保证操作的原子性，常用于实现无锁编程。

Semaphore是一种信号量，它用于控制对资源的访问，允许一定数量的线程同时访问资源。它是一种更通用的同步机制，可以用来实现锁的功能，但通常用于更复杂的控制流。

java.util.Date类是一个古老的类，用于表示特定的瞬间，精确到毫秒。

java.util.Calendar类是一个抽象类，提供了一个通用的日历系统，可以处理日期和时间的字段，如年、月、日、时、分、秒等。

java.time.LocalDateTime是一个相对较新的API，属于Java 8引入的新的日期和时间API，用于表示不带时区的日期-时间。

java.time.Instant也是Java 8引入的新API的一部分，用于表示一个时间点，通常表示为UTC时区的日期和时间。
 

Runnable是一个函数式接口，它有一个run()方法，通常用于创建线程任务。

Callable也是一个函数式接口，它有一个call()方法，与Runnable不同，Callable可以返回值和抛出异常。

Predicate是一个函数式接口，它属于java.util.function包，有一个test()方法，通常用于进行条件判断。

Consumer是一个函数式接口，它属于java.util.function包，有一个accept()方法，通常用于执行对单个参数的操作。

synchronized关键字可以用来修饰方法或代码块，确保同一时间只有一个线程可以执行该段代码，是Java中最基本的同步机制之一。

Lock接口是java.util.concurrent.locks包中的一个接口，提供了比synchronized关键字更灵活的锁定机制，如尝试锁定、定时锁定和可中断锁定等。

Semaphore类是java.util.concurrent包中的一个类，用于控制对资源的访问，它是一种计数信号量，可以用于实现线程间的同步。

Thread.sleep()方法用于让当前线程暂停执行指定的时间，但它本身并不是用于线程同步的方法。它不会释放任何锁，通常用于线程暂停，而不是用于控制线程间的同步。

@Override：这是Java的一个标准注解，用于表示一个方法声明打算重写父类中的另一个方法。

@Deprecated：这是Java的一个标准注解，用于标记某个程序元素（类、方法、字段等）已经过时。

@NotNull 和 @Nullable：这两个注解不是Java标准库的一部分，而是通常由开发者使用或第三方库提供，用于表示方法参数、返回值或字段不应该为null（@NotNull），或者可以为null（@Nullable）。

BufferedReader是一个包装其他读取类以提供缓冲字符数据的方法的类，它可以用来高效地读取文本文件。

FileReader是一个用于读取字符文件的便捷类，它继承自Reader类，提供了读取文本文件的方法。

Scanner类提供了丰富的方法用于扫描和解析文本，包括读取文本文件中的文本和各种数据。

FileInputStream是用于读取文件中的原始字节流的类，它不适合直接用于读取文本文件内容，因为它不处理字符编码。通常，你会使用FileInputStream来读取非文本文件，如图片或视频。

自动类型转换（Automatic Type Conversion）：也称为隐式类型转换，是指编译器自动将范围较小的数据类型转换为范围较大的数据类型，如从int到long。

强制类型转换（Casting）：也称为显式类型转换，是指程序员明确指定将一个数据类型转换为另一个数据类型，如(int) someLongValue。

解包装（Unboxing）：是将包装类类型转换为对应的基本数据类型，如intValue()方法将Integer对象转换为int类型。

包装（Boxing）：是将基本数据类型转换为对应的包装类类型，如Integer.valueOf()方法将int类型转换为Integer对象。

近日总结：没投，没面试，每天大脑昏昏的，我的身体......我的身体，哎，自从来了学校，失去了我的饭搭子，每一顿饭都变得不那么可口起来，每天都要哄着自己吃饭，哎，我需要一个下饭的饭搭子啊！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

晚饭就吃花甲吧～