这里的Java面试问题和答案涉及Java面试的不同类型的问题，以使面试官可以测试你在Java和面向对象编程方面的技能。

我们将包含有关面向对象编程及其特征的Java面试问题，有关Java及其功能的一般问题，Java中的集合，垃圾收集器，异常处理，Java小程序，Swing，JDBC，远程方法调用（RMI） ，Servlet和JSP。

第一部分 面向对象编程

什么是Java

Java是一种并行的，基于类的和面向对象的计算机编程语言。 面向对象软件开发的优势如下所示：

代码的模块化开发，这样易于维护和修改。代码的可重用性。提高了代码的可靠性和灵活性。增加了对代码的理解。面向对象编程OOP的概念

面向对象编程OOP包括：

抽象化封装多态性继承预定义类型必须是对象用户定义的类型必须是对象必须通过向对象发送消息来执行操作说出Java的某些功能

使得Java很流行的一些重要功能如下：

面向对象平台无关高性能多线程可移植性安全Java是100%面向对象的吗

不是100％。 Java不能满足所有OOP条件（预定义类型必须是对象），因为中间有不是对象的原始类型，包括boolean, byte, char, int, float, double, long, short不是对象。

什么是抽象

抽象是将想法与特定实例分离开来的过程，因此，开发类时要根据其自身的功能而不是其实现细节。 Java支持暴露出接口的抽象类的创建和存在，但不包括所有方法的实际的实现。 抽象技术旨在将类的实现细节与其行为分开。

下面介绍了抽象类Person。 它具有抽象方法getName。

public abstract class Person  {      public abstract String getName(); }

Employee类扩展了Abstract类Person。 方法getName返回雇员的name属性。

public class Employee extends Person   {      private String name;         public Employee(String name)    {      this.name = name;    }      public String getName()    {       return this.name;    }      public static void main (String args[])      {          Employee employee = new Employee("John Wilson");                 System.out.println("Employee's Name "+ employee.getName());                  Person person = new Employee("Thomas Smith");                 System.out.println("Employee-Person's Name "+ person.getName());                      }  } 

封装使对象能够隐藏其内部特征和行为。 每个对象提供许多方法，其他对象可以访问这些方法并更改其内部数据。 在Java中，有三种访问修饰符：public，private和protected。 每个修饰符对其他类提供了不同的访问权限。 下面列出了使用封装的一些优点：

隐藏每个对象的属性可以保护每个对象的内部状态。可以独立更改或扩展对象的行为，所以它增加了代码的可用性和可维护性。它通过防止对象以我们不希望的方式相互调用来提高模块化。

例子中Student类展示了对Id和Name的封装。

public class Student{          private int id;    private String name;    public void setId(int id) {        this.id = id;    }    public void setName(String name) {        this.name = name;    }    public int getId() {        return this.id;    }    public String getName() {        return this.name;    }    public static void main(String args[]) {        Student student = new Student();        student.setId(1034);        student.setName("David Smith");        System.out.println("Student id " + student.getId());        System.out.println("Student name " + student.getName());    }}  

抽象和封装是互补的概念。 一方面，抽象集中于对象的行为。 另一方面，封装着重于对象行为的实现。 封装通常是通过隐藏有关对象内部状态的信息来实现的，因此可以看作是用于提供抽象的策略。

什么是多态？

多态是编程语言为不同的底层数据类型提供相同接口的能力。 多态类型是一种类型，其操作也可以应用于其他类型的值。

可以在下面的示例中查看Vehicle接口的方法为increaseVelocity。 Truck, Train和Aeroplane实现了Vehicle接口，并且该方法将速度增加到与车辆类型相关的速度。

多态有哪些类型？

Java中有两种类型的多态：

编译时多态（静态绑定）–方法重载运行时多态（动态绑定）–方法覆盖

我们可以通过方法重载和方法覆盖来执行多态。

编译时多态的特点

类的方法具有相同的名称。 每种方法都有不同数量的参数。 它可以具有不同类型和顺序的参数。方法重载是要增加方法的行为。 它可以扩展到方法的行为。重载的方法将没有相同的签名。在这种情况下，不需要继承。

运行时多态的特点

子类具有名称与超类方法相同的方法。 它具有超类方法的参数数量，参数类型和返回类型。方法覆盖是修改方法的行为。重写的方法将具有完全相同的签名。继承是必需的。

方法重载的代码

public class Calculator {    public int subtract(int a, int b) {        return a - b;    }    public double subtract(double a, double b) {        return a - b;    }    public static void main(String args[]) {        Calculator calculator = new Calculator();        System.out.println("Difference of 150 and 12 is " + calculator.subtract(150, 12));        System.out.println("Difference of 15.5 and 15.4 is " + calculator.subtract(15.50, 15.40));    }}

方法重写的实例

public class Shape {      public void getArea() {        System.out.println("Shape Area");    }  } 

Rectangle类重写getArea方法，并且该方法的实现特定于Rectangle。 覆盖注解用于向编译器指示该方法被覆盖。 使用注解可以提高代码的可读性。

public class Rectangle extends Shape {    @Override    public void getArea() {        System.out.println("Rectangle Area");    }    public static void main(String args[]) {        Shape shape = new Shape();        shape.getArea();        Rectangle rectangle = new Rectangle();        rectangle.getArea();    }}

继承为对象提供了获取另一个类（称为基类）的字段和方法的能力。 继承增强了代码的可重用性，并且可以用于对现有的类增加新的功能，而无需对其进行修改。

什么是组合（composition）

一个类可能是由其他类组合起来的，看下面这个例子。

public class Car {    private Tire[] tires;    private Door[] doors;    private Steering steering;    private Window[] windows;}class Tire {}class Door {}class Steering {}class Window {}

聚集是典型的整体/部分关系。 但实例不能具有循环聚合关系。

public class Person {    private Address address; } class Address {  private String city;     private String state;     private String country;     private String line1;     private String line2; }

Java基础

什么是JVM？

Java虚拟机（JVM）是可以执行Java字节码的进程虚拟机。 每个Java源文件都被编译为字节码文件，该文件由JVM执行。

Java为什么称为平台独立的编程语言？

Java旨在构建可以在任何平台上运行的应用程序，而不必由程序员针对每个单独的平台进行重写或重新编译。 Java虚拟机让这个特性成为可能，由虚拟机兼容不同平台带来的差异性。

JDK和JRE有什么区别？

Java运行时环境（JRE=Java Runtime Environment）是执行Java程序的Java虚拟机（JVM）。 它还包括用于执行applet的浏览器插件。

Java开发工具包（JDK=Java Development Kit）是用于开发Java的功能齐全的软件开发工具包，包括JRE，编译器和工具（例如JavaDoc和Java Debugger），以便用户开发，编译和执行Java应用程序。

static关键字是什么意思？

static关键字表示可以访问成员变量或方法，而无需实例化其所属的类。

可以在Java中覆盖私有方法还是静态方法？

用户无法覆盖Java中的静态方法，因为方法覆盖基于运行时的动态绑定，而静态方法则在编译时静态绑定。

静态方法未与类的任何实例关联，因此该概念不适用。

可以在静态上下文中访问非静态变量吗？

Java中的静态变量属于其类，并且其所有实例的值都相同。 当JVM加载类时，将初始化静态变量。

如果您的代码尝试在没有任何实例的情况下访问非静态变量，则编译器会报警，因为尚未创建这些变量并且它们未与任何实例关联。

Java支持那些原始数据类型

八种原始数据类型

byteshortintlongfloatdoublebooleanchar什么是自动装箱和拆箱？

自动装箱是Java编译器在原始类型及其对应的对象包装器类之间进行的自动转换。

例如，编译器将int转换为Integer，将double转换为Double，依此类推。 如果转换是相反方向，则此操作称为拆箱。

什么是Java中的函数覆盖和重载？

当同一类中的两个或多个方法具有完全相同的名称，但参数不同时，就会发生Java中的方法重载。

方法覆盖是指子类重新定义与父类相同的方法。 重写的方法必须具有相同的名称，参数列表和返回类型。

覆盖方法在访问描述符上，只能和父类一样或者更宽松。

什么是构造函数？

创建新对象时会调用构造函数。 每个类都有一个构造函数。

如果程序员不为类提供构造函数，则Java编译器（Javac）为该类创建默认构造函数。

什么是构造函数重载？

构造函数重载类似于Java中的方法重载。 可以为单个类创建不同的构造函数。

每个构造函数必须具有自己的唯一参数列表。

什么是拷贝构造函数？

最后，Java确实支持像C ++这样的副本构造函数，

但是不同之处在于，需要自己去实现拷贝构造函数。

Java是否支持多重继承？

不，Java不支持多重继承。 每个类只能在一个类上扩展，但可以实现多个接口。

接口和抽象类之间有什么区别？

Java提供并支持抽象类和接口的创建。两种实现都有一些共同的特征，但是它们在以下特征上有所不同：

接口中的所有方法都是隐式抽象的。而抽象类可能同时包含抽象方法和非抽象方法。一个类可以实现许多接口，但只能扩展一个抽象类。为了使类实现接口，它必须实现其所有声明的方法。但是，一个类可能没有实现抽象类的所有已声明方法。但是，在这种情况下，子类也必须声明为抽象类。抽象类可以实现接口，甚至不提供接口方法的实现。在Java接口中声明的变量默认为final。抽象类可能包含非最终变量。默认情况下，Java接口的成员是public。抽象类的成员可以是私有的，受保护的或公共的。接口绝对是抽象的，无法实例化。如果抽象类包含main方法，它也不能实例化，但可以被调用。什么是按引用传递和按值传递？

通过值传递对象时，这意味着传递的是对象的副本。 因此，即使对该对象进行了更改，它也不会影响原始值。 通过引用传递对象时，传递的是该对象的引用。 因此，外部方法所做的任何更改也都会反映在所有地方。

volatile变量的目的是什么？

volatile变量值可以通过不同的线程进行修改。 他们将永远没有机会阻止并持有锁。 只要访问变量，就会发生同步。 使用volatile可能比使用锁快，但在某些情况下将不起作用。 Java 5中扩展了volatile有效的情况范围； 特别是，双重检查锁定现在可以正常工作了。

Transient 变量的作用是什么?

Transient变量的类序列化时，这种字段不被序列化。

Java中有哪些不同的访问修饰符？

访问修饰符有四种类型：

publiic-可从应用程序中的任何地方访问

protected–可在包中访问，以及子类中访问

包私有（默认）–只能在包内访问

private–仅可在声明该类的同一个类中访问

什么是包装类

包装类将8种原始类型，包装成对象。

什么是单例，我们如何制作单例？

在单例中：

确保仅存在单例类的一个实例提供对该实例的全局访问

要创建单例类：

将该类的所有构造函数声明为私有提供一个静态方法，该方法返回对该实例的引用

关于单例的写法，参看另一篇双重检查加锁单例的缺陷和其他的单例写法

进程和线程之间有什么区别？

进程是程序的执行，而线程是进程内的单个执行序列。 一个进程可以包含多个线程。 线程有时称为轻量级进程。

其中

进程与程序的执行有关。 进程由多个线程组成。

进程之间使用进程间通信（IPC）进行通信。 进程的线程之间可以相互通信。

流程可以控制子进程。 进程的线程可以控制其他线程。

父进程中的任何修改都不会更改子进程，而主线程中的任何修改都可能影响该进程其他线程的行为。

进程在单独的内存空间中执行。 线程在共享内存空间中执行。

操作系统控制进程。 软件开发人员可以控制线程的使用。

进程彼此独立。 线程彼此依赖。

解释创建线程的不同方法。 您想要哪一个，为什么？

可以使用三种方法来创建线程：

可以扩展Thread类，重写run方法。可以实现Runnable接口。应用程序可以使用Executor框架来创建线程池。

首选Runnable接口，因为它不需要对象来继承Thread类。 如果您的应用程序设计需要多重继承，则只有接口可以为您提供帮助。 此外，线程池非常有效，可以非常容易地实现和使用。

从High-level解释可用线程的状态。

在执行期间，线程可以处于以下状态之一：

NEW：线程准备就绪，可以运行，但不一定立即开始运行。RUNNABLE：Java虚拟机（JVM）正在积极执行线程的代码。BLOCKED：线程处于阻塞状态，在等待监视器锁定时。WAITING：线程等待另一个线程执行特定操作。TIMED_WAITING：线程等待另一个线程执行特定操作，直到指定的等待时间。TERMINATED：线程已完成执行。同步的方法和块之间有什么区别？

在Java编程中，每个对象都有一个锁。 线程可以使用synchronized关键字获取对象的锁。 可以在方法级别（粗粒度锁定）或代码块级别（细粒度锁定）中应用synchronized关键字。

监视器内部如何发生线程同步？

JVM将锁与监视器结合使用。 监视器基本上是监视一系列同步代码并确保一次仅一个线程执行同步代码段的监视者。 每个监视器都与一个对象引用关联。 在线程获得锁之前，不允许其执行代码。

什么是死锁？

在继续进行之前，两个线程正在互相等待对方完成。 结果是两个线程都无限等待。

如何确保N个线程可以无死锁地访问N个资源？

在使用N个线程时避免死锁的一种非常简单的方法是在锁上施加一个顺序，并强制每个线程遵循该顺序。 因此，如果所有线程以相同顺序锁定和解锁互斥锁，则不会出现死锁。

未完待续，持续更新

原文：