[本文参考原文地址]http://bjbsair.com/2020-03-09/it/1875.html
毋庸置疑，Java是获得丰厚薪资的主要编程选择之一。毕竟，基于类的通用，面向对象的编程语言是世界上使用最广泛的编程语言之一。
Java面试问题
具有许多强大的功能，编程语言不仅是经验丰富的专家的首选，而且是编程领域的新手所追求的。因此，这里有一些重要的Java面试问题，可以帮助您完成Java工作，或者至少可以提高您的学习水平。
问题：什么是Java？
答： Java是一种最初由James Gosling设计并由Oracle Corporation进一步开发的面向对象的高级通用编程语言。它是世界上最受欢迎的编程语言之一。
问题：构造函数是什么意思？
答：构造函数是一种与其所属类具有相同名称的方法。一旦创建了新对象，就会调用与该类相对应的构造函数。 尽管用户可以显式创建一个构造函数，但是一旦创建一个类，它就会自己创建。这被称为默认构造函数。构造函数可以重载。
注意：如果显式创建的构造函数具有参数，则必须创建另一个没有参数的构造函数。
问：Java有什么功能？
答：以下是Java编程语言的各种功能：
- 高性能–使用JIT（即时）编译器可以提高Java的性能。JIT编译器将Java字节码转换为机器语言代码，然后由JVM执行
- 多线程–线程是执行流程。JVM创建一个称为主线程的线程。Java允许通过扩展线程类或实现Runnable接口来创建多个线程
- OOPS概念– Java遵循各种OOPS概念，即抽象，封装，继承，面向对象和多态性
- 平台独立性 –Java利用Java虚拟机或JVM，使单个Java程序无需修改即可在多个平台上运行
问题：Java如何实现高性能？
答：在即时编译中，所需的代码在运行时执行。通常，它涉及将字节码转换为机器代码，然后直接执行它。为了实现高性能，Java可以利用即时编译。 JIT编译器默认在Java中处于启用状态，并在调用方法后立即被激活。然后，它将Java方法的字节码编译为本地机器代码。此后，JVM直接调用已编译的代码，而不是对其进行解释。这可以提高性能。
问题：Java IDE对您有什么了解？
答：Java IDE是允许Java开发人员轻松编写和调试Java程序的软件。它基本上是各种编程工具的集合，可通过单个界面访问，并具有一些有用的功能，例如代码完成和语法突出显示。 Codenvy，Eclipse和NetBeans是一些最受欢迎的Java IDE。
问题：请解释Java中的局部变量和实例变量。
答：只能在声明它们的方法或代码块中访问的变量称为局部变量。另一方面，实例变量可被类中的所有方法访问。 虽然局部变量在方法或代码块内部声明，而实例变量在类内部但方法外部声明。 即使未分配，实例变量的值也可以为null，0、0.0或false。需要分配值的局部变量不是这种情况，否则分配值将产生错误。 调用方法时会自动创建局部变量，并在方法退出后立即销毁。要创建实例变量，必须使用new关键字。
问题：什么是对象？
答：Java类的实例称为对象。Java对象的两个重要属性是行为和状态。JVM遇到new关键字后，即会创建一个对象。(https://stackoverflow.com/questions/18219339/trouble-understanding-object-state-behavior-and-identity)
问题：您能解释一下OOPS概念吗？
答：以下是各种OOPS概念：
- 抽象–表示基本功能，而无需给出背景细节。该技术用于为某些特定应用创建新的合适数据类型
- 聚合–所有对象都有各自的生命周期，但存在所有权。子对象除父对象外，不能属于其他对象
- 关联–两个对象之间的关系，其中每个对象都有其独立的生命周期。没有所有权
- 类–一组相似的实体
- 组合–也称为死亡关系，它是聚集的一种特殊形式。子对象没有生命周期。这样，如果删除了关联的父对象，它们会自动被删除
- 封装–指将数据和代码包装到单个实体中。允许类的变量只能由父类访问，而不能由其他类访问
- 继承–当对象获取其他对象的属性时，称为继承。这导致所涉及的班级之间形成亲子关系。提供组织和结构化软件的强大而自然的机制
- 对象–表示类的实例。任何类都可以具有多个实例。一个对象包含数据以及将对数据进行操作的方法
- 多态性–指 方法，对象或变量采取几种形式的能力
问题：请解释Java中的方法重写？
答：Java中的方法重写允许子类提供其父类或父类已经提供的方法的特定实现。如果子类方法和超类方法具有：
- 同名
- 同样的论点
- 相同的返回类型
问题：重载是什么意思？
回答：重载是两种或多种不同方法（方法重载）或运算符（运算符重载）具有相同表示形式时的现象。 例如，+运算符将两个整数值相加，但将两个字符串连接在一起。同样，名为Add的重载函数可用于两个目的
- 加两个整数
- 连接两个字符串
与方法重写不同，方法重载要求两个重载的方法具有相同的名称但参数不同。重载的函数可以具有或可以不具有不同的返回类型。
问题：请解释一下String，String Builder和String Buffer之间的区别。
答：字符串变量存储在常量字符串池中。随着字符串引用的更改，无法删除旧值。例如，如果字符串存储了值“ Old”，则添加新值“ New”不会删除旧值。但是，它仍处于休眠状态。 在字符串缓冲区中，值存储在堆栈中。通过更改字符串引用，新值将替换旧值。 字符串缓冲区是同步的（因此是线程安全的），并且比字符串生成器（它也是一个字符串缓冲区但未同步）提供的性能要慢。因此，在String Builder中，性能比String Buffer快。
问题：Java中设置了什么？另外，在Java Collections中解释其类型。
答：在Java中，Set是唯一对象的集合。它使用equals()方法确定两个对象是否相同。Java集合中各种类型的Set是：
- 哈希集–使用对象的哈希码添加值的无序和未排序集。当集合的顺序不重要时使用
- 链接哈希集–这是哈希集的有序版本，维护所有元素的双链表。在强制执行迭代顺序时使用。插入顺序与将元素添加到集合中的方式相同。
- 树集–Java中两个排序的集合之一，它使用Read-Black树结构并确保元素以升序出现。
问题：请比较notify()和notifyAll()方法。
答：notify()方法用于发送信号以唤醒等待池中的单个线程。相反，notifyAll()方法用于发送信号以唤醒等待池中的所有线程。
问题：什么时候Runnable接口优先于线程类，反之亦然？
答：在Java中，只能扩展一个类。因此，仅当不需要扩展其他类时才扩展线程类。如果一个类需要扩展除线程类之外的其他类，那么我们需要使用Runnable接口。
问：请解释Java中的各种类型的垃圾收集器吗？
答：Java编程语言具有四种类型的垃圾收集器：
- 串行垃圾收集器–仅使用单个线程进行垃圾收集，串行垃圾收集器通过保存所有应用程序线程来工作。它是专为单线程环境而设计的。因为串行垃圾收集器在执行垃圾收集时会冻结所有应用程序线程，所以它最仅适用于命令行程序。为了使用串行垃圾收集器，需要打开-XX：+ UseSerialGC JVM参数。
- 并行垃圾收集器–也称为吞吐量收集器，并行垃圾收集器是JVM的默认垃圾收集器。它使用多个线程进行垃圾回收，就像串行垃圾回收器在垃圾回收期间冻结所有应用程序线程一样。
- CMS垃圾收集器–并发标记扫描的缩写，CMS垃圾收集器使用多个线程扫描堆内存以将实例标记为驱逐，然后清除标记的实例。CMS垃圾收集器拥有所有应用程序线程时，只有两种情况：
- 在终身生成空间中标记参考对象时
- 如果在执行垃圾收集时堆内存发生了一些变化，则 CMS垃圾收集器将通过使用更多的CPU来确保与并行垃圾收集器相比更好的应用程序吞吐量。为了使用CMS垃圾收集器，需要打开XX：+ USeParNewGC JVM参数。
- G1垃圾收集器–用于大型堆内存区域，G1垃圾收集器的工作原理是将堆内存分成多个区域，然后在其中并行执行垃圾收集。与CMS垃圾收集器在STW情况下压缩内存不同，G1垃圾收集器在回收内存后立即压缩可用堆空间。同样，G1垃圾收集器会优先处理垃圾最多的区域。使用G1垃圾收集器需要打开–XX：+ UseG1GC JVM参数。(https://stackoverflow.com/questions/16695874/why-does-the-jvm-full-gc-need-to-stop-the-world)
问题：如何区分HashMap和HashTable？
答：Java中的HashMap是基于Map的集合类，用于存储键和值对。它表示为HashMap
问题：Java中的集合是什么意思？Java中Collections的组成是什么？
答：Java中的一组对象称为集合。Java.util包包含日期和时间功能，国际化，旧版收集类等，以及用于收集的各种类和接口。或者，可以将集合视为设计用于存储对象和操纵对象存储在其中的设计的框架。您可以使用集合对对象执行以下操作：
- 删除中
- 插入
- 操纵
- 正在搜寻
- 排序
以下是集合框架的各个组成部分：
- 类–数组列表，链接列表，列表和向量
- 接口–集合，列表，地图，队列，集合，排序的地图和排序的集合
- 图– HashMap，HashTable，LinkedHashMap和TreeMap
- 队列–优先队列
- 集–哈希集，链接哈希集和树集
问题：请在Java中解释Map及其类型。
答：Java Map是一个将键映射到值的对象。它不能包含重复的键，并且每个键只能映射到一个值。为了确定两个键是相同还是不同，Map使用equals()方法。Java中有4种类型的Map，如下所述：
- HashMap-它是无序且未排序的地图，因此，当不强调顺序时，它是一个不错的选择。HashMap允许一个null键和多个null值，并且不维护任何插入顺序。
- HashTable–不允许为空并且具有同步的方法。由于它允许线程安全，因此性能很慢。
- LinkedHashMap –比HashMap慢，但保持插入顺序并具有更快的迭代速度。
- TreeMap–排序的Map，它支持使用构造函数构造排序顺序。
问题：Java中的优先级队列是什么意思？
答：优先级队列与常规队列一样，是一种抽象数据类型，不同之处在于优先级队列与它所包含的每个元素相关联。在优先级队列中，高优先级的元素在低优先级的元素之前得到服务。优先队列中的元素根据比较器或自然排序。优先级队列中元素的顺序代表它们的相对优先级。
问题：抽象类与接口有何不同？
答：在Java中，抽象类和接口之间存在一些区别，总结如下：
- 组成部分–抽象类包含实例变量，而接口只能包含常量。
- 构造函数和实例化–接口既没有构造函数也不能实例化，则抽象类可以具有默认的构造函数，该实例在实例化具体子类时就被调用。
- 方法的实现–实现接口的所有类都需要为其包含的所有方法提供实现。但是，扩展抽象类的类不需要实现包含在其中的所有方法。在具体的子类中只需实现抽象方法。
- 方法类型–任何抽象类都具有抽象方法和非抽象方法。另一方面，接口只有一个抽象方法。
问题：您能解释一下Java中的各种异常吗？另外，请告诉我们有关处理它们的不同方法。
答：Java提供了两种类型的异常：
- 检查异常–扩展Throwable类的类（运行时异常和错误除外）称为检查异常。此类异常由编译器在编译期间检查。这些类型的异常必须具有适当的try / catch块，或者必须使用throws关键字声明。ClassNotFoundException是一个检查的异常。
- 未检查的异常–编译期间，编译器不会检查此类异常。这样，编译器无需处理未经检查的异常。算术异常和ArrayIndexOutOfBounds异常是未经检查的异常。
Java中的异常以两种方式处理：
class ExceptionCheck{
public static void main(String[] args){
add();
}
public void add() throws Exception{
addition();
}
}
class ExceptionCheck{
public static void main (String[] args) {
add();
}
public void add(){
try{
addition();
}catch(Exception e){
e.printStacktrace();
}
}
}
问题：您可以绘制Java异常层次结构吗？
答：
问题：final关键字在Java中扮演什么角色？它对变量，方法和类有什么影响？
答：Java中的final关键字是一个非访问修饰符，仅适用于类，方法或变量。根据使用环境的不同，它有不同的用途。
- 使用class：
当一个类被声明为最终类时，则禁止其被子类化，即，没有任何类可以扩展最终类。
- 使用方法：
带有final关键字的任何方法都不能被子类覆盖。
- 用带有变量：
紧跟着final关键字的变量不能在程序执行期间更改其持有的值。因此，它的行为就像一个常量。
问题：如何在Java中创建线程？举个例子。
答：为了在Java中创建线程，有两种选择：
- 扩展线程类 –线程在java.lang.Thread类中可用。为了创建线程，您需要扩展线程类并覆盖run方法。例如，
public class Addition extends Thread {
public void run() {
}
}
使用线程类的缺点是无法扩展任何其他类。但是，可以在类中重载run()方法
-
实现可运行接口–在Java中创建线程的另一种方法是通过实现可运行接口。为此，有必要提供
public class Addition implements Runnable { public void run() { } }
问题：为什么我们使用yield()方法？
答：yield()方法属于线程类。它将当前正在运行的线程转移到可运行状态，并允许其他线程执行。换句话说，它为优先级相同的线程提供了运行的机会。因为yield()是静态方法，所以它不会释放任何锁。
问：您能解释一下Java中的线程生命周期吗？
答：线程生命周期具有以下状态，并遵循以下顺序：
- 创建–在线程生命周期的第一个状态下，将创建线程实例，并且尚未调用start（）方法。该线程现在被认为是活动的。
- 可运行-调用start()方法之后但调用run()方法之前，线程处于可运行状态。线程也可以从等待或睡眠状态返回到可运行状态。
- 正在运行–调用run()方法后，线程进入运行状态。这是线程开始执行的时间。
- 不可运行–尽管线程处于活动状态，但无法运行。通常，一段时间后它将返回到可运行状态。
- 终止– run()方法完成执行后，线程进入终止状态。现在还不活着。
问题：看看下面的两个代码片段：
一
class Adder {
Static int add(int a, int b)
{
return a+b;
}
Static double add( double a, double b)
{
return a+b;
}
public static void main(String args[])
{
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(12.3,12.6));
}}
二
class Car {
void run(){
System.out.println(“bjbsair.com”);
}
Class Audi extends Car{
void run()
{
System.out.prinltn(“Audi is running at bjbsair.com”);
}
public static void main( String args[])
{
Car b=new Audi();
b.run();
}
}
两者之间的重要区别是什么？
答案：代码段i。是代码片段ii中方法重载的示例。演示方法重载。
问题：您对Java的同步有什么了解？它最大的缺点是什么？
答：如果多个线程尝试访问单个代码块，那么产生不准确结果的机会就会增加。为防止这种情况，请使用同步。使用sync关键字使线程需要键才能访问同步的代码。简而言之，同步一次只允许一个线程访问一个代码块。每个Java对象都有一个锁，每个锁只有一个键。线程只有在可以获取对象锁定的键的情况下，才能访问同步方法。以下示例演示了同步：
public class ExampleThread implements Runnable {
public static void main (String[] args){
Thread t = new Thread();
t.start();
}
public void run(){
synchronized(object){
{
}
}
注意：建议避免对所有方法实施同步。这是因为当只有一个线程能够访问同步的代码时，下一个线程需要等待。因此，它导致程序性能降低。
问题：是否可以在单个try块下写入多个catch块？
回答：是的，可以在一个try块下写入多个catch块。但是，该方法需要从特定到一般。下面的示例演示了相同的内容：
public class Example {
public static void main(String args[]) {
try {
int a[]= new int[10];
a[10]= 10/0;
}
catch(ArithmeticException e)
{
System.out.println("Arithmetic exception in first catch block");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Array index out of bounds in second catch block");
}
catch(Exception e)
{
System.out.println("Any exception in third catch block");
}
}
问题：您能否分辨出execute()，executeQuery()和executeUpdate()之间的区别？
答：
- execute()–用于执行SQL查询。如果结果是ResultSet（如运行Select查询），则返回TRUE；如果结果不是ResultSet（如运行Insert或Update查询），则返回FALSE。
- executeQuery()–用于执行Select查询。它返回ResultSet，即使没有匹配查询的记录，也不为null。执行选择查询时必须使用executeQuery()方法，以便在有人尝试执行Insert或Update语句时，抛出带有“ executeQuery方法无法用于更新”的消息的java.sql.SQLException。
- executeUpdate()–用于执行Delete / Insert / Update语句或不返回任何内容的DDL语句。输出取决于语句是数据操作语言（DML）语句还是数据定义语言（DDL）语句而有所不同。输出为整数，等于前一种情况的总行数，后一种情况为0。
注意：execute()方法仅在不确定语句类型的情况下才需要使用。在所有其他情况下，请使用executeQuery()或executeUpdate()方法。
问题：提供一个Hibernate体系结构示例：
答：
问题：您能否通过代码示例演示如何在JSP中删除cookie？
回答：以下代码演示了如何在JSP中删除cookie：
Cookie mycook = new Cookie("bjbsair.com","value1");
response.addCookie(mycook1);
Cookie killmycook = new Cookie("bjbsair.com","value1");
killmycook.set MaxAge ( 0 );
killmycook.set Path ("/");
killmycook.addCookie ( killmycook 1 );
问题：编写合适的代码示例来演示final，final和finalize的用法。
答：final关键字用于限制类，方法和变量。不能继承final类，不能覆盖final方法，并且final变量变为常量，即其值无法更改。
class FinalVarExample {
public static void main( String args[])
{
final int a=10;
a=50; /* Will result in an error as the value can’t be changed now*/
}
最终：无论是否处理异常，都将执行finally块内的任何代码。
class FinallyExample {
public static void main(String args[]){
try {
int x=100;
}
catch(Exception e) {
System.out.println(e);
}
finally {
System.out.println("finally login to bjbsair.com");}
}
}
}
Finalize ：finalize方法在对象被垃圾回收之前执行清理。
class FinalizeExample {
public void finalize() {
System.out.println("bjbsair.com is called");
}
public static void main(String args[])
{
FinalizeExample f1=new FinalizeExample();
FinalizeExample f2=new FinalizeExample();
f1= NULL;
f2=NULL;
System.gc();
}
}
问题：throw关键字与throws关键字有何不同？
答：throws关键字允许声明异常，而throw关键字用于显式抛出异常。受检查的异常不能仅通过throw传播，而throw允许这样做而无需任何其他操作。throws关键字后跟一个类，而throw关键字后跟一个实例。方法中使用throw关键字，但方法签名中使用throws关键字。此外，不可能抛出多个异常，但是可以声明多个异常。
问题：如何区分进程和线程？
答：进程和线程之间有几个基本区别，如下所述：
- 定义–进程是程序的执行实例，而线程是进程的子集。
- 更改–对父流程所做的更改不会影响子流程。但是，主线程的更改可能导致同一进程的其他线程的行为发生更改。
- 通信–进程需要进程间通信才能与同级进程进行通信，而线程却能够直接与属于同一进程的其他线程进行通信。
- 控制–进程由操作系统控制，并且只能控制子进程。相反，线程是由程序员控制的，并且能够对它们所属的同一进程的线程进行控制。
- 依赖关系–进程是独立的实体，而线程是依赖的实体
- 内存–线程在共享内存空间中运行，但进程在单独的内存空间中运行。
问题：能否在Array和ArrayList之间进行比较？
答：数组必须在声明时给出大小，而数组列表不一定需要大小，因为它会动态更改大小。为了将对象放入数组，需要指定索引。但是，对于数组列表，没有这样的要求。参数化数组列表时，不参数化数组。
问题：请解释一下Abstract类和Abstract方法是什么意思？
答：Java中的抽象类是无法实例化的类。这样的类通常用于为子类提供基础，以便扩展以及实现抽象方法以及覆盖或使用抽象类中定义的已实现方法。为了创建抽象类，需要在其后跟随abstract关键字。任何抽象类都可以具有抽象方法和非抽象方法。Java中仅具有声明而没有实现的方法被称为抽象方法。同样，抽象方法名称后跟abstract关键字。任何扩展抽象类的具体子类都必须提供抽象方法的实现。
问：您对Java接口有什么了解？
答：Java接口是仅包含方法声明而不包含方法实现的模板。这是一种在Java中实现多重继承的解决方法。一些值得记住的有关Java接口的要点是：
- 实现接口的类必须为接口中声明的所有方法提供实现
- 接口中的所有方法在内部都是公共抽象void
- 接口中的所有变量都是内部公共的static final
- 类不扩展但实现接口
问题：什么是join()方法？举个例子。
答：我们使用join()方法将一个线程与当前正在运行的线程的末端连接起来。它是一种非静态方法，并且具有重载版本。考虑下面的示例：
public static void main (String[] args) {
Thread t = new Thread();
t.start();
t.join();
}
主线程在上述示例中开始执行。一旦执行到达代码t.start()，线程t就会启动其自己的堆栈以执行。JVM在主线程和那里的线程之间切换。一旦执行达到t.join()，则线程t单独执行并被允许完成其任务。之后，主线程恢复执行。
问题：如何在Java中使线程停止？
答：Java中有三种方法可以停止执行线程：
- 阻塞–此方法用于将线程置于阻塞状态。满足阻塞条件后，将立即恢复执行。例如，ServerSocket.accept()是一种阻塞方法，它侦听传入的套接字连接，并且仅在建立连接时才恢复被阻塞的线程。
- 睡眠–此方法用于将线程的执行延迟一段时间。使用sleep()方法的线程被称为进入睡眠状态。唤醒后即进入睡眠状态，即进入可运行状态。在sleep()方法的花括号内提到了线程需要进入睡眠状态的时间。这是一种静态方法。
- 等待中-尽管可以在任何Java对象上调用它，但是wait()方法只能从同步块中调用。
问题：Volatile变量在Java中起什么作用？
答：易失性变量中存储的值不是从线程的高速缓存存储器中读取的，而是从主存储器中读取的。易失变量主要在同步期间使用。
问题：请比较Java中的序列化与反序列化。
答：序列化是将Java对象转换为字节流的过程。反序列化与序列化的过程恰好相反，在序列化过程中，从字节流中检索Java对象。通过将Java对象写入ObjectOutputStream来序列化Java对象，并通过从ObjectInputStream读取Java对象来反序列化Java对象。
问题：您对Java中的OutOfMemoryError了解什么？
答：通常，当JVM由于内存不足而无法分配对象时，将引发OutOfMemoryError异常。在这种情况下，垃圾收集器无法回收任何内存。 导致OutOfMemoryError异常的原因可能有多种，其中最著名的是：
- 保持物体太长时间
- 尝试同时处理太多数据
- 使用第三方库来缓存字符串
- 部署后使用不执行内存清理的应用程序服务器
- 当无法满足本机分配时
这就完成了Java面试的主要问题清单。您如何看待我们编制的清单？将您的评论放在下面的专用窗口中，让我们知道。另外，请查看这些最佳Java教程，以进一步完善Java技能。
问题：关于集合的排序和排序是什么？
回答：
1.顺序
这意味着值以特定顺序存储在集合中，但顺序与值无关。例如。列表
2.排序
这意味着集合的顺序取决于元素的值。
例如。SortedSet
问题：解释Java中处理关键字的各种异常吗？
回答：
Java中有两个关键的异常处理关键字，其后是第三个关键字final，它们在处理异常后可能会或可能不会使用。
try:
如果代码段有机会出现异常或错误，则将其放置在try块中。引发异常时，将由catch块对其进行处理和捕获。
try块必须在其后具有catch（）或final（）或两个块。
catch：
在try块中引发异常时，将在块中对其进行处理。
final:
不管异常如何，都执行该块。可以将其放置在try {}或catch {}块之后。
问题：解释异常传播
答：如果未捕获，则堆栈顶部的方法将引发异常。它移至下一个方法，并继续这样直到被捕获。
例：
public class Sum()
{
public static void main(String args[])
{
addition()
}
public void addition()
{
add();
}
}
上面的代码栈是：
add()
addition()
main()
如果未捕获到add（）方法中发生的异常，则它将移至方法add（）。然后将其移至main（）方法，该处的执行流程停止。这称为异常传播。
问题：在Java中解释public static void main（String args []）
答：执行Java程序从公共静态void main（String args []）开始，也称为main（）方法。
- public：它是一个访问修饰符，定义了类或方法的可访问性。程序中的任何类都可以访问定义为public的main（）方法。
- static：关键字指示变量，或方法为类方法。将方法main（）设为静态，以便无需创建类的实例即可对其进行访问。当main（）方法不是静态的时，编译器会抛出一个错误，因为JVM在创建任何对象之前调用了main（），并且只能通过该类直接调用静态方法。
- void：方法的返回类型。无效定义该方法不返回任何类型的值。
- main ：JVM在开始执行任何程序时（仅具有特定签名）搜索此方法。
- 字符串args []：传递给main方法的参数。
问题：Java是与平台无关的语言。为什么？
答： Java编程语言不依赖任何特定的硬件或软件，因为它是由编译器编译然后转换为字节码的。字节码与平台无关，可以在多个系统上运行。唯一的要求是Java需要一个运行时环境，即JRE，它是用于开发Java应用程序的一组工具。
问题：Java中的包装器类是什么？
答：包装器类负责将Java原语转换为引用类型（对象）。一个类专用于每种原始数据类型。它们被称为包装器类，因为它们将原始数据类型包装到该类的对象中。它存在于java.lang包中。下表显示了不同的原始类型，包装器类。
| 简单类型 | 包装类 |
| boolean | Boolean |
| char | Character |
| double | Double |
| float | Float |
| int | Integer |
| long | Long |
问题：解释装箱，拆箱，自动装箱和自动拆箱的概念。
回答：
- 装箱：将原始值放入对象内的概念称为装箱。
- 拆箱：从对象获取原始值。
- 自动装箱：将值直接分配给整数对象。
- 自动拆箱：将原始值直接放入整数对象。
问题：解释类型转换
答：将一种数据类型的变量分配给另一种数据类型的变量的概念。布尔数据类型是不可能的。
它有两种类型：
- 隐含的
- 明确的
问题：解释不同类型的类型转换。
答：不同类型的类型转换是：
- 隐式：将值从较小的数据类型存储到较大的数据类型。它由编译器自动完成。
- 显式：将较大数据类型的值存储到较小数据类型中。这导致信息丢失：
- 截断
- 超出范围
让我们看一下代码示例，以进一步了解这一点：
int i = 10;
long l = i;
long l = 10,000;
int i = (int) l;
float f = 3.14f
int i = (int) f;
i=3;
long l = 123456789;
byte b = (byte) l;
问题：扩展名为.java的空文件名是否为有效文件名？
答：是的，Java只允许通过.java保存我们的java文件。它由javac .java编译，并由java类名运行。
让我们举一个简单的例子：
public class Any()
{
public static void main(String args[])
{
System.out.println("Hello bjbsair.com!");
}
}
编译：javac.java
运行：java Any
问题：在Java中定义Singleton类。如何使一个class成为Singleton？
答： Singleton类仅允许创建该类的一个实例。
可以通过以下步骤使一个类成为单例：
用该类创建该类的静态实例。
通过不允许用户通过定义私有构造函数来使用默认构造函数创建实例。
-
创建一个静态方法以返回A实例的对象。
public class Singleton { public static void main(String args[]) { Single obj1 = Single.getInstance(); /* both would point to one and same instance of the class */ Single obj2 = Single.getInstance(); } } class Single { static Single obj = new Single(); /* step a*/ private Single() /* step b*/ { } public static Single getInstance() { return obj; /* step c*/ } }
问题：如果将公共静态无效空间替换为静态公共无效空间，程序仍将运行吗？
答：是的，程序的编译和运行不会出现任何错误，因为说明符的顺序无关紧要。
问题：Java中的软件包是什么？在Java中说明Packages的一些优点？
答：包是Java将各种类和/或接口组合在一起的方式。对象的功能决定了如何对其进行分组。打包程序充当类的“容器”。
下面列出了Packages的优点：
- 其他程序的类可以重用。
- 两个相同的类可以存在于两个不同的包中。
- 包可以隐藏类，从而拒绝访问仅供内部使用的某些程序和类。
- 他们还将设计与编码分开。
问题：区分==和equals()吗？
回答
| Equals() | == |
|---|---|
| 是一个字符串类 | 是操作符 |
| 比较的是内容 | 比较的是地址 |
class Operator { public static void main(String[]args) { /* integer-type*/ System.out.println(10 == 20); /* char-type*/ System.out.println('a' == 'b'); /* char and double type*/ System.out.println('a' == 97.0); /* boolean type*/ System.out.println(true == true); }} |
public class Equals{ public static void main(String[] args) { String s1 = new String("HELLO"); String s2 = new String("HELLO"); System.out.println(s1 == s2); System.out.println(s1.equals(s2)); }} |
问题：我们为什么不在Java中使用指针？
答：指针被认为是不安全的，并增加了程序的复杂性，添加
指针的概念可能是矛盾的。而且，JVM负责隐式内存分配；因此，为避免用户直接访问内存，在Java中不建议使用指针。
问题：区分中断和继续
答
| break | continue |
| 与循环和开关语句一起使用 | 与仅循环语句一起使用。 |
| 它终止循环或开关块。 | 它不会终止，但会跳到下一个迭代。 |
问题：区分this()和super()
答：
| this() | super() |
| 表示该类的当前实例。 | 表示父/基类的当前实例。 |
| 它用于调用同一类的默认构造函数 | 它用于调用父/基类的默认构造函数。 |
| 访问当前类的方法 | 访问基类的方法 |
| 点当前类的实例 | 指向超类实例。 |
| 必须是该块的第一行 | 它必须是该块的第一行。 |
问题：Java中的字符串池是什么？
答：堆内存中存储的字符串集合是指字符串池。每当创建新对象时，都会检查它是否已存在于字符串池中。如果已经存在，则将相同的引用返回到变量，否则在字符串池中创建新对象，并返回相应的引用。
问题：解释Java中的访问修饰符。
答：访问修饰符是Java中的预定义关键字，用于限制对另一个类中的类，方法，构造函数和数据成员的访问。
Java支持四个访问修饰符：
- 默认
- 私有(private)
- 受保护的(protected)
- 公开(public)
| 编辑 | 默认 | 私有 | 受保护的 | 公开 |
| 同类 | 是 | 是 | 是 | 是 |
| 相同的包子类 | 是 | 没有 | 是 | 是 |
| 同一包非子类 | 是 | 没有 | 是 | 是 |
| 不同的包子类 | 没有 | 没有 | 是 | 是 |
| 不同的包非子类 | 没有 | 没有 | 没有 | 是 |
问题：什么是多重继承？Java是否支持多重继承？如果没有，如何实现？
答：如果子类或子类有两个父类，这意味着它从两个基类继承属性，则它是多重继承。Java没有多重继承，以防万一父类具有相同的方法名称，那么在运行时它就变得模棱两可，并且编译器无法决定从子类执行哪个方法。
Java编码面试问题
问题：不使用内置函数进行字符串反转的程序
答：
public class Reversal
{
public static void main(String args[])
{
String input = "bjbsair.com";
System.out.println("Given String -> " + "bjbsair.com");
char charArray[] = input.toCharArray();
System.out.println("Reversed String -> ");
for(int i = charArray.length-1;i>=0; i--)
{
System.out.print(charArray[i]);
}
System.out.println();
}
}
问题：从数组中删除重复项的程序
答：
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
class RemoveDuplicates
{
public static void main(String args[])
{
/*create ArrayList with duplicate elements*/
ArrayList duplicate = new ArrayList();
duplicate.add(5);
duplicate.add(7);
duplicate.add(1);
duplicate.add(4);
duplicate.add(1);
duplicate.add(7);
System.out.println("bjbsair.com: "+ duplicate);
Set withoutDuplicates = new LinkedHashSet(duplicate);
duplicate.clear();
duplicate.addAll(withoutDuplicates);
System.out.println("Array without duplicates: "+ duplicate);
}
}
问题：将数字取反的程序
import java.util.Scanner;
public class NumberReversal
{
public static void main(String args[])
{
System.out.println("Please enter the number to be reversed");
Scanner sc = new Scanner (System.in);
int number = sc.nextInt();
int reverse = reverse(number);
System.out.println("Reverse of number: " + number + " is " + reverse(number));
}
public static int reverse(int number){
int reverse = 0;
int remainder = 0;
do{
remainder = number%10;
reverse = reverse*10 + remainder;
number = number/10;
}while(number > 0);
return reverse;
}
}
问题：二进制搜索程序
答：
import java.util.Scanner;
import java.util.Arrays;
public class Binary {
public static void main(String[] args) {
System.out.println("Enter total number of elements : ");
Scanner s = new Scanner (System.in);
int length = s.nextInt();
int[] input = new int[length];
System.out.printf("Enter %d integers", length);
for (int i = 0; i < length; i++) {
input[i] = s.nextInt();
}
/* binary search requires the input array to be sorted so we must sort the array first*/
Arrays.sort(input);
System.out.print("the sorted array is: ");
for(int i= 0; i<= length-1;i++)
{
System.out.println(input[i] + " ,");
}
System.out.println("Please enter number to be searched in sorted array");
int key = s.nextInt();
int index = BSearch(input, key);
if (index == -1) {
System.out.printf("Sorry, %d is not found in array %n", key);
} else {
System.out.printf("%d is found in array at index %d %n", key,
index);
}
}
public static int BSearch(int[] input, int number) {
int low = 0;
int high = input.length - 1;
while (high >= low) {
int middle = (low + high) / 2;
if (input[middle] == number) {
return middle;
} else if (input[middle] < number) {
low = middle + 1;
} else if (input[middle] > number) {
high = middle - 1;
}
}
return -1;
}
}
问题：检查数字是否为质数的程序。
import java.util.Scanner;
public class Prime
{
public static void main(String args[])
{
System.out.println("Enter the number to check: ");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
boolean isPrime = false;
if(num!=0)
{
isPrime = checkPrime(num);
}else
{
System.out.println("Enter valid number");
}
if(isPrime == false)
{
System.out.println(" NOT PRIME!!");
}
else
{
System.out.println("PRIME!!");
}
}
public static boolean checkPrime(int number)
{
int sqrt = (int) Math.sqrt(number) + 1;
for(int i = 2; i答：
import java.util.Scanner;
public class Fibo
{
public static void main(String args[])
{
System.out.println("Enter the number upto which Fibonacci series should be printed ");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
System.out.println("Fibonacci Series upto %d is" + num);
for(int i=1; i<=num; i++)
{
System.out.print(fib(i) + " ");
}
}
public static int fib(int n)
{
if(n ==1 || n==2)
{
return 1;
}
return fib(n-1) + fib(n-2);
}
}
问题：打印斐波那契数列的程序
答：
import java.util.Scanner;
public class PalinDrome
{
public static void main(String args[])
{
System.out.println("Enter the string to check");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
boolean isPalindrome;
isPalindrome = checkPalindrome(str);
if(str.equals(" "))
{
System.out.println("Enter valid string");
}
else
{
if(isPalindrome)
{
System.out.println("PALINDROME!!");
}
else
{
System.out.println("NOT A PALINDROME!!");
}
}
}
public static boolean checkPalindrome(String input)
{
int str_length = input.length();
int i=0, j= str_length-1;
while(i问题：程序检查给定的字符串是否是回文。
答：
public class Pattern
{
public static void main(String args[])
{
for(int i=5; i>=0; i--)
{
System.out.println();
for(int j=i; j<5;j++)
{
System.out.print(" * ");
}
}
System.out.println();
}
}
问题：图案印刷
*
* *
* * *
* * * *
* * * * *
答：
import java.util.Scanner;
public class Swap
{
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
System.out.println("Enter a number: ");
int a = s.nextInt();
System.out.println("Enter second number: ");
int b = s.nextInt();
System.out.println("Value of a and b before swapping: " + "a = " +a + " b = " + b);
swap(a,b);
}
public static void swap(int a , int b)
{
int swap_variable;
swap_variable = a;
a = b;
b = swap_variable;
System.out.println("Value of a and b after swapping: " + "a = " +a + " b = " + b);
}
}
问题：交换两个数字的程序
答：
import java.util.Scanner;
public class Swap
{
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
System.out.println("Enter a number: ");
int a = s.nextInt();
System.out.println("Enter second number: ");
int b = s.nextInt();
System.out.println("Value of a and b before swapping: " + "a = " +a + " b = " + b);
swap(a,b);
}
public static void swap(int a , int b)
{
int swap_variable;
swap_variable = a;
a = b;
b = swap_variable;
System.out.println("Value of a and b after swapping: " + "a = " +a + " b = " + b);
}
}
问题：程序检查给定的号码是否为阿姆斯特朗号码。
import java.util.Scanner;
public class Armstrong
{
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
System.out.println("Enter a number: ");
int number = s.nextInt();
int a=number, sum = 0, num=0;
while(a%10 !=0)
{
num = a%10;
sum = sum + (num*num*num);
a = a/10;
}
if(sum == number)
{
System.out.println("Armstrong Number!");
}
else
{
System.out.println("Not an Armstrong Number!");
}
}
}