一手真实java面试题：2023年各大公司java面试真题汇总--持续更新

**Java 面试题汇总 (持续更新)**作为一名 Java 开发者，面试是每个人的必经之路。以下是一些常见的 Java 面试题，涵盖了基础知识、设计模式、多线程、集合框架等方面。

### 基础知识####1. Java 的基本数据类型有哪些？

Java 有八种基本数据类型：

* 整型：byte、short、int、long* 浮点型：float、double* 布尔型：boolean* 字符型：char

javapublic class BasicDataType {
 public static void main(String[] args) {
 // 基本数据类型示例 byte b =10;
 short s =20;
 int i =30;
 long l =40L;
 float f =50.5f;
 double d =60.6;
 boolean bl = true;
 char c = 'A';

 System.out.println("byte: " + b);
 System.out.println("short: " + s);
 System.out.println("int: " + i);
 System.out.println("long: " + l);
 System.out.println("float: " + f);
 System.out.println("double: " + d);
 System.out.println("boolean: " + bl);
 System.out.println("char: " + c);
 }
}

####2. Java 中的变量和属性有哪些区别？

Java 中的变量和属性都是用于存储数据的，但它们有不同的作用域和访问方式。

* 变量是局部变量，仅在方法内有效。
* 属性是成员变量或实例变量，属于类或对象本身。

javapublic class VariableAndProperty {
 private int property; // 属性 public void method() { // 方法 int variable =10; // 变量 System.out.println("variable: " + variable);
 System.out.println("property: " + property); // 访问属性 }

 public static void main(String[] args) {
 VariableAndProperty var = new VariableAndProperty();
 var.method(); // 调用方法 }
}

####3. Java 中的继承和多态性有哪些特点？

Java 支持继承和多态性，允许子类继承父类的属性和方法，并在必要时重写或覆盖它们。

* 继承：子类继承父类的属性和方法。
* 多态性：子类可以重写或覆盖父类的方法。

javapublic class InheritanceAndPolymorphism {
 public static void main(String[] args) {
 Animal animal = new Dog(); // 多态性示例 animal.sound();
 }
}

class Animal { // 父类 public void sound() {
 System.out.println("动物叫");
 }
}

class Dog extends Animal { // 子类 @Override public void sound() {
 System.out.println("狗叫");
 }
}

### 设计模式####1. Java 中的单例模式有哪些特点？

Java 的单例模式是一种设计模式，确保在整个应用程序中只有一个实例。

* 单例模式：只创建一个实例。
* 线程安全：使用双重检查锁定机制或 volatile 关键字实现线程安全。

javapublic class Singleton {
 private static volatile Singleton instance; // 单例实例 public static Singleton getInstance() { // 获取单例实例 if (instance == null) {
 synchronized (Singleton.class) {
 if (instance == null) {
 instance = new Singleton();
 }
 }
 }
 return instance;
 }

 private Singleton() {} // 私有构造函数}

####2. Java 中的工厂模式有哪些特点？

Java 的工厂模式是一种设计模式，用于创建对象而不直接暴露具体类。

* 工厂模式：通过工厂方法创建对象。
* 多态性：允许在运行时根据需要创建不同类型的对象。

javapublic class Factory {
 public static Animal createAnimal(String type) { // 工厂方法 if (type.equals("dog")) {
 return new Dog();
 } else if (type.equals("cat")) {
 return new Cat();
 }
 return null;
 }
}

class Animal {} // 父类class Dog extends Animal {} // 子类class Cat extends Animal {} // 子类

####3. Java 中的观察者模式有哪些特点？

Java 的观察者模式是一种设计模式，允许对象在状态变化时通知其他对象。

* 观察者模式：定义一个一对多的关系。
* 多态性：允许在运行时根据需要注册或移除观察者。

javapublic class Observer {
 public static void main(String[] args) {
 Subject subject = new Subject();
 subject.addObserver(new DogObserver());
 subject.addObserver(new CatObserver());

 subject.setState("dog");
 subject.setState("cat");
 }
}

class Subject { // 被观察者 private List observers; // 观察者列表 public void addObserver(Observer observer) {
 observers.add(observer);
 }

 public void setState(String state) {
 for (Observer observer : observers) {
 observer.update(state);
 }
 }
}

interface Observer { // 观察者接口 void update(String state);
}

class DogObserver implements Observer { // 观察者实现 @Override public void update(String state) {
 System.out.println("dog:" + state);
 }
}

class CatObserver implements Observer { // 观察者实现 @Override public void update(String state) {
 System.out.println("cat:" + state);
 }
}

### 多线程####1. Java 中的线程有哪些特点？

Java 支持多线程，允许在同一时间执行多个任务。

* 线程：一个独立的执行单元。
* 并发性：多个线程可以同时执行。

javapublic class ThreadExample {
 public static void main(String[] args) {
 Thread thread = new Thread(new Runnable() { // 创建线程 @Override public void run() {
 System.out.println("线程正在运行");
 }
 });

 thread.start(); // 启动线程 }
}

####2. Java 中的同步有哪些特点？

Java 支持同步机制，允许在多线程环境下保护共享资源。

* 同步：通过锁定或等待来保护共享资源。
* 线程安全：使用 synchronized 关键字实现线程安全。

javapublic class SynchronizedExample {
 public static void main(String[] args) {
 Object lock = new Object(); // 锁对象 Thread thread1 = new Thread(new Runnable() { // 线程1 @Override public void run() {
 synchronized (lock) {
 System.out.println("线程1 正在运行");
 }
 }
 });

 Thread thread2 = new Thread(new Runnable() { // 线程2 @Override public void run() {
 synchronized (lock) {
 System.out.println("线程2 正在运行");
 }
 }
 });

 thread1.start(); // 启动线程1 thread2.start(); // 启动线程2 }
}

####3. Java 中的线程池有哪些特点？

Java 支持线程池机制，允许重复使用已创建的线程。

* 线程池：一个线程集合。
* 重用性：线程池可以重用已创建的线程。

javapublic class ThreadPoolExample {
 public static void main(String[] args) {
 ExecutorService executor = Executors.newFixedThreadPool(5); // 创建线程池 for (int i =0; i < 10; i++) { // 执行任务 final int index = i;
 executor.execute(new Runnable() {

 @Override public void run() {
 System.out.println("线程 " + index + " 正在运行");
 }
 });
 }

 executor.shutdown(); // 关闭线程池 }
}

### 集合框架####1. Java 中的集合有哪些特点？

Java 支持各种类型的集合，允许存储和操作元素。

* 集合：一个元素集合。
* 多态性：支持多种类型的集合。

javapublic class CollectionExample {
 public static void main(String[] args) {
 List list = new ArrayList<>(); // 创建列表 list.add("A"); // 添加元素 list.add("B");
 list.add("C");

 System.out.println(list); // 输出列表内容 }
}

####2. Java 中的集合