Java经典面试题解析（1-80题）

时间 2020-05-19

标签 java 经典面试解析栏目 Java 繁體版

原文原文链接

前言

前几天，在茫茫的互联网海洋中寻寻觅觅，我收藏了800道Java基础经典面试题，有小伙伴私聊我要答案。因此感受没有答案的面试题是没有灵魂的，因而今天先整理基础篇的前80道答案出来~html

全部的Java面试题已经上传github，答案也上传了一部分~java

github.com/whx123/Java…git

公众号：捡田螺的小男孩程序员

Java 基础

1. equals与==的区别

若是是基本类型，==表示判断它们值是否相等；
若是是引用对象，==表示判断两个对象指向的内存地址是否相同。

equalsgithub

若是是字符串，表示判断字符串内容是否相同；
若是是object对象的方法，比较的也是引用的内存地址值；
若是本身的类重写equals方法，能够自定义两个对象是否相等。

2. final, finally, finalize 的区别

final 用于修饰属性,方法和类, 分别表示属性不能被从新赋值, 方法不可被覆盖, 类不可被继承.
finally 是异常处理语句结构的一部分，通常以ty-catch-finally出现，finally代码块表示老是被执行.
finalize 是Object类的一个方法，该方法通常由垃圾回收器来调用，当咱们调用System.gc() 方法的时候，由垃圾回收器调用finalize()方法，回收垃圾，JVM并不保证此方法总被调用.

3. 重载和重写的区别

重写必须继承，重载不用。
重载表示同一个类中能够有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不一样）
重写表示子类中的方法与父类中的某个方法的名称和参数彻底相同啦，经过子类实例对象调用这个方法时，将调用子类中的定义方法，这至关于把父类中定义的那个彻底相同的方法给覆盖了，这是面向对象编程的多态性的一种表现。
重写的方法修饰符大于等于父类的方法，即访问权限只能比父类的更大，不能更小，而重载和修饰符无关。
重写覆盖的方法中，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，由于不能坑爹啊哈哈~

4. 两个对象的hashCode()相同，则 equals()是否也必定为 true？

两个对象equals相等，则它们的hashcode必须相等，若是两个对象的hashCode()相同，则equals()不必定为true。面试

hashCode 的常规协定：sql

在 Java 应用程序执行期间，在对同一对象屡次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另外一次执行，该整数无需保持一致。
两个对象的equals()相等，那么对这两个对象中的每一个对象调用 hashCode 方法都必须生成相同的整数结果。
两个对象的equals()不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不要求必定生成不一样的整数结果。可是，为不相等的对象生成不一样整数结果能够提升哈希表的性能。

5. 抽象类和接口有什么区别

抽象类要被子类继承，接口要被子类实现。
抽象类能够有构造方法，接口中不能有构造方法。
抽象类中能够有普通成员变量，接口中没有普通成员变量，它的变量只能是公共的静态的常量
一个类能够实现多个接口，可是只能继承一个父类，这个父类能够是抽象类。
接口只能作方法声明，抽象类中能够做方法声明，也能够作方法实现。
抽象级别（从高到低）：接口>抽象类>实现类。
抽象类主要是用来抽象类别，接口主要是用来抽象方法功能。
抽象类的关键字是abstract，接口的关键字是interface

6. BIO、NIO、AIO 有什么区别？

这个答案来自互联网哈，我的以为是最好理解的~编程

BIO：线程发起 IO 请求，无论内核是否准备好 IO 操做，从发起请求起，线程一直阻塞，直到操做完成。

NIO：线程发起 IO 请求，当即返回；内核在作好 IO 操做的准备以后，经过调用注册的回调函数通知线程作 IO 操做，线程开始阻塞，直到操做完成。

AIO：线程发起 IO 请求，当即返回；内存作好 IO 操做的准备以后，作 IO 操做，直到操做完成或者失败，经过调用注册的回调函数通知线程作 IO 操做完成或者失败。

BIO 是一个链接一个线程。,NIO 是一个请求一个线程。,AIO 是一个有效请求一个线程。设计模式

BIO：同步并阻塞，服务器实现模式为一个链接一个线程，即客户端有链接请求时服务器端就须要启动一个线程进行处理，若是这个链接不作任何事情会形成没必要要的线程开销，固然能够经过线程池机制改善。

NIO：同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的链接请求都会注册到多路复用器上，多路复用器轮询到链接有I/O请求时才启动一个线程进行处理。

AIO：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的 IO 请求都是由 OS 先完成了再通知服务器应用去启动线程进行处理。

7. String，Stringbuffer，StringBuilder的区别

String：数组

String类是一个不可变的类，一旦建立就不能够修改。
String是final类，不能被继承
String实现了equals()方法和hashCode()方法

StringBuffer：

继承自AbstractStringBuilder，是可变类。
StringBuffer是线程安全的
能够经过append方法动态构造数据。

StringBuilder：

继承自AbstractStringBuilder，是可变类。
StringBuilder是非线性安全的。
执行效率比StringBuffer高。

8. JAVA中的几种基本数据类型是什么，各自占用多少字节呢

基本类型	位数	字节
int	32	4
short	16	2
long	64	8
byte	8	1
char	16	2
float	32	4
double	64	8
boolean	？	？

对于boolean，官方文档未明肯定义，它依赖于 JVM 厂商的具体实现。逻辑上理解是占用 1位，可是实际中会考虑计算机高效存储因素

感兴趣的小伙伴，能够去看官网

9. Comparator与Comparable有什么区别？

在牛客网看到这道题的答案，以为写的最好~

连接：www.nowcoder.com/questionTer… 来源：牛客网

Comparable & Comparator 都是用来实现集合中元素的比较、排序的，只是 Comparable 是在集合内部定义的方法实现的排序，Comparator 是在集合外部实现的排序，因此，如想实现排序，就须要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。

Comparator位于包java.util下，而Comparable位于包 java.lang下。

Comparable 是一个对象自己就已经支持自比较所须要实现的接口（如 String、Integer 本身就能够完成比较大小操做，已经实现了Comparable接口）自定义的类要在加入list容器中后可以排序，能够实现Comparable接口，在用Collections类的sort方法排序时，若是不指定Comparator，那么就以天然顺序排序，这里的天然顺序就是实现Comparable接口设定的排序方式。

而 Comparator 是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能知足你的要求时，你能够写一个比较器来完成两个对象之间大小的比较。

能够说一个是自已完成比较，一个是外部程序实现比较的差异而已。用 Comparator 是策略模式（strategy design pattern），就是不改变对象自身，而用一个策略对象（strategy object）来改变它的行为。好比：你想对整数采用绝对值大小来排序，Integer 是不符合要求的，你不须要去修改 Integer 类（实际上你也不能这么作）去改变它的排序行为，只要使用一个实现了 Comparator 接口的对象来实现控制它的排序就好了。

10. String类能被继承吗，为何。

首先，String是一个final修饰的类，final修饰的类不能够被继承。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
复制代码

String类为何不能被继承呢？

有两个缘由：

效率性，String 类做为最经常使用的类之一，禁止被继承和重写，能够提升效率。
安全性，String 类中有不少调用底层的本地方法，调用了操做系统的 API，若是方法能够重写，可能被植入恶意代码，破坏程序。

11. 说说Java中多态的实现原理

多态机制包括静态多态（编译时多态）和动态多态（运行时多态）
静态多态好比说重载，动态多态通常指在运行时才能肯定调用哪一个方法。
咱们一般所说的多态通常指运行时多态，也就是编译时不肯定究竟调用哪一个具体方法，一直等到运行时才能肯定。
多态实现方式：子类继承父类（extends）和类实现接口（implements）
多态核心之处就在于对父类方法的改写或对接口方法的实现，以取得在运行时不一样的执行效果。
Java 里对象方法的调用是依靠类信息里的方法表实现的，对象方法引用调用和接口方法引用调用的大体思想是同样的。当调用对象的某个方法时，JVM查找该对象类的方法表以肯定该方法的直接引用地址，有了地址后才真正调用该方法。

举个例子吧，假设有个Fruit父类，一个taste味道方法，两个子类Apple和Pear，以下：

abstract class Fruit {
    abstract String taste() ;
}

class Apple extends Fruit {
    @Override
    String taste() {
        return "酸酸的";
    }
}

class Pear extends Fruit {
    @Override
    String taste() {
        return "甜甜的";
    }
}
public class Test {
    public static void main(String[] args) {
        Fruit f = new Apple();
        System.out.println(f.taste());
    }
}
复制代码

程序运行，当调用对象Fruit f的方法taste时，JVM查找Fruit对象类的方法表以肯定taste方法的直接引用地址，到底来自Apple仍是Pear，肯定后才真正调用对应子类的taste方法，

12. Java泛型和类型擦除

这个面试题，能够看我这篇文章哈~

Java程序员必备基础：泛型解析

13. int和Integer 有什么区别，还有Integer缓存的实现

这里考察3个知识点吧：

int 是基本数据类型，interger 是 int 的封装类
int 默认值为 0 ，而interger 默认值为 null， Interger使用须要判空处理
Integer的缓存机制：为了节省内存和提升性能，Integer类在内部经过使用相同的对象引用实现缓存和重用，Integer类默认在-128 ~ 127 之间，能够经过 -XX:AutoBoxCacheMax进行修改，且这种机制仅在自动装箱的时候有用，在使用构造器建立Integer对象时无用。

看个Integer的缓存的例子，加深一下印象哈：

Integer a = 10;
Integer b = 10;

Integer c = 129;
Integer d = 129;
System.out.println(a == b);
System.out.println(c == d);
输出结果：
true
false
复制代码

14. 说说反射的用途及实现原理，Java获取反射的三种方法

这道面试题，看我这篇文章哈：谈谈Java反射：从入门到实践，再到原理

Java获取反射的三种方法：

第一种，使用 Class.forName 静态方法。
第二种，使用类的.class 方法
第三种，使用实例对象的 getClass() 方法。

15. 面向对象的特征

面向对象的三大特征：

封装
继承
多态

16. &和&&的区别

按位与, a&b 表示把a和b都转换成二进制数，再进行与的运算；
&和&&都是逻辑运算符号，&&又叫短路运算符
逻辑与，a&& b ，a&b 都表示当且仅当两个操做数均为 true时，其结果才为 true，不然为false。
逻辑与跟短路与的差异是很是巨大的，虽然两者都要求运算符左右两端的布尔值都是true，整个表达式的值才是true。可是，&&之因此称为短路运算，是由于若是&&左边的表达式的值是false，右边的表达式会被直接短路掉，不会进行运算。

17. Java中IO流分为几种?

Java中的流分为两种：一种是字节流，另外一种是字符流。
IO流分别由四个抽象类来表示（两输入两输出）:InputStream，OutputStream，Reader，Writer。

18. 讲讲类的实例化顺序，好比父类静态数据，构造函数，子类静态数据，构造函数。

直接看个例子吧：

public class Parent {
    {
        System.out.println("父类非静态代码块");
    }
    static {
        System.out.println("父类静态块");
    }
    public Parent() {
        System.out.println("父类构造器");
    }
}
public class Son extends Parent {
    public Son() {
        System.out.println("子类构造器");
    }
    static {
        System.out.println("子类静态代码块");
    }
    {
        System.out.println("子类非静态代码块");
    }
}
public class Test {
    public static void main(String[] args) {
        Son son = new Son();
    }
}
复制代码

运行结果：

父类静态块
子类静态代码块
父类非静态代码块
父类构造器
子类非静态代码块
子类构造器
复制代码

因此，类实例化顺序为： 父类静态代码块/静态域->子类静态代码块/静态域 -> 父类非静态代码块 -> 父类构造器 -> 子类非静态代码块 -> 子类构造器

19. Java建立对象有几种方式

Java建立对象有5种方式

用new语句建立对象。
使用反射，使用Class.newInstance()建立对象/调用类对象的构造方法——Constructor
调用对象的clone()方法。
运用反序列化手段，调用java.io.ObjectInputStream对象的readObject()方法.
使用Unsafe

20. 如何将GB2312编码的字符串转换为ISO-8859-1编码的字符串呢？

public class Test {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String str = "捡田螺的小男孩";
        String strIso = new String(str.getBytes("GB2312"), "ISO-8859-1");
        System.out.println(strIso);
    }
}
复制代码

21. 守护线程是什么？用什么方法实现守护线程

守护线程是运行在后台的一种特殊进程。
它独立于控制终端而且周期性地执行某种任务或等待处理某些发生的事件。
在 Java 中垃圾回收线程就是特殊的守护线程。

22. notify()和 notifyAll()有什么区别？

notify是唤醒一个处于该对象wait的线程，而notifyAll是唤醒全部处于该对象wait的线程。
可是唤醒不等于就能执行了，须要获得锁对象才能有权利继续执行，而锁只有一把，因此多个线程被唤醒时须要争取该锁。

23. Java语言是如何处理异常的，关键字throws、throw、try、catch、finally怎么使用？

这道面试题，能够看我这篇文章哈：Java程序员必备：异常的十个关键知识点

24. 谈谈Java的异常层次结构

从前从前，有位老人，他的名字叫Throwable，他生了两个儿子，大儿子叫Error,二儿子叫Exception。

Error

表示编译时或者系统错误，如虚拟机相关的错误，OutOfMemoryError等，error是没法处理的。

Exception

代码异常，Java程序员关心的基类型一般是Exception。它能被程序自己能够处理，这也是它跟Error的区别。

它能够分为RuntimeException（运行时异常）和CheckedException（可检查的异常）。

常见的RuntimeException异常：

- NullPointerException 空指针异常
- ArithmeticException 出现异常的运算条件时，抛出此异常
- IndexOutOfBoundsException 数组索引越界异常
- ClassNotFoundException 找不到类异常
- IllegalArgumentException(非法参数异常)
复制代码

常见的 Checked Exception 异常：

- IOException (操做输入流和输出流时可能出现的异常)
- ClassCastException(类型转换异常类)
复制代码

Checked Exception就是编译器要求你必须处置的异常。
与之相反的是，Unchecked Exceptions，它指编译器不要求强制处置的异常，它包括Error和RuntimeException 以及他们的子类。

25. 静态内部类与非静态内部类有什么区别

这道面试题，能够看我这篇文章哈：Java程序员必备基础：内部类解析

静态内部类能够有静态成员(方法，属性)，而非静态内部类则不能有静态成员(方法，属性)。
静态内部类只可以访问外部类的静态成员和静态方法,而非静态内部类则能够访问外部类的全部成员(方法，属性)。
实例化静态内部类与非静态内部类的方式不一样
调用内部静态类的方法或静态变量,能够经过类名直接调用

26. String s与new String与有什么区别

String str ="whx";
String newStr =new String ("whx");
复制代码

String str ="whx"

先在常量池中查找有没有"whx" 这个对象,若是有，就让str指向那个"whx".若是没有，在常量池中新建一个“whx”对象，并让str指向在常量池中新建的对象"whx"。

String newStr =new String ("whx");

是在堆中创建的对象"whx" ,在栈中建立堆中"whx" 对象的内存地址。

如图所示：

网上这篇文章讲的挺好的： String和New String()的区别

27. 反射中，Class.forName和ClassLoader的区别

Class.forName和ClassLoader均可以对类进行加载。它们区别在哪里呢？ ClassLoader负责加载 Java 类的字节代码到 Java 虚拟机中。Class.forName实际上是调用了ClassLoader，以下：

这里面，forName0的第二个参数为true，表示对加载的类进行初始化化。其实还能够调用 Class<?> forName(String name, boolean initialize, ClassLoader loader)方法实现同样的功能，它的源码以下：

因此，Class.forName和ClassLoader的区别，就是在类加载的时候，class.forName有参数控制是否对类进行初始化。

28. JDK动态代理与cglib实现的区别

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，经过修改其字节码生成子类来处理。
JDK动态代理只能对实现了接口的类生成代理，而不能针对类
cglib是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法。由于是继承，因此该类或方法最好不要声明成final

网上这篇文章写得不错，描述Java动态代理的几种实现方式，分别说出相应的优缺点

29. error和exception的区别，CheckedException，RuntimeException的区别。

Error: 表示编译时或者系统错误，如虚拟机相关的错误，OutOfMemoryError等，error是没法处理的。

Exception: 代码异常，Java程序员关心的基类型一般是Exception。它能被程序自己能够处理，这也是它跟Error的区别。

它能够分为RuntimeException（运行时异常）和CheckedException（可检查的异常）。常见的RuntimeException异常：

- NullPointerException 空指针异常
- ArithmeticException 出现异常的运算条件时，抛出此异常
- IndexOutOfBoundsException 数组索引越界异常
- ClassNotFoundException 找不到类异常
- IllegalArgumentException(非法参数异常)
复制代码

常见的 Checked Exception 异常：

- IOException (操做输入流和输出流时可能出现的异常)
- ClassCastException(类型转换异常类)
复制代码

有兴趣能够看我以前写得这篇文章： Java程序员必备：异常的十个关键知识点

30. 深拷贝和浅拷贝区别

浅拷贝

复制了对象的引用地址，两个对象指向同一个内存地址，因此修改其中任意的值，另外一个值都会随之变化。

深拷贝

将对象及值复制过来，两个对象修改其中任意的值另外一个值不会改变

31. JDK 和 JRE 有什么区别？

JDK：Java Development Kit 的简称，Java 开发工具包，提供了 Java 的开发环境和运行环境。
JRE：Java Runtime Environment 的简称，Java 运行环境，为 Java 的运行提供了所需环境。

32. String 类的经常使用方法都有那些呢？

indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的 byte 类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

33. 谈谈自定义注解的场景及实现

以前我这边有这么一个业务场景，用Redis控制接口调用频率，有使用过自定义注解。
经过 AOP（动态代理机制）给方法添加切面，经过反射来获取方法包含的注解，若是包含自定义关键字注解，就经过Redis进行校验拦截请求。

有关于注解，建议你们看一下java编程思想的注解篇章哈~

34. 说说你熟悉的设计模式有哪些？

设计模式分为三大类：

建立型模式：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式（5种）
结构型模式：适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式。（7种）
行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。（11种）

最好平时积累一下，单例模式（7种实现方式），工厂模式，模板方法设计模式，策略模式，装饰者模式、代理模式这几种怎么写吧~

我的以为，能够看看Hollis大神相关设计模式的文章哈，写得特别好！设计模式（二）——单例模式

35. 抽象工厂和工厂方法模式的区别？

能够看一下这篇文章介绍：抽象工厂模式-与-工厂方法模式区别

36. 什么是值传递和引用传递？

值传递是对基本型变量而言的,传递的是该变量的一个副本，改变副本不影响原变量.
引用传递通常是对于对象型变量而言的,传递的是该对象地址的一个副本, 并非原对象自己。因此对引用对象进行操做会同时改变原对象.

37. 能够在static环境中访问非static变量吗？

static变量在Java中是属于类的，它在全部的实例中的值是同样的。当类被Java虚拟机载入的时候，会对static变量进行初始化。由于静态的成员属于类，随着类的加载而加载到静态方法区内存，当类加载时，此时不必定有实例建立，没有实例，就不能够访问非静态的成员。类的加载先于实例的建立，所以静态环境中，不能够访问非静态！

38. Java支持多继承么,为何？

不支持多继承，缘由:

安全性的考虑，若是子类继承的多个父类里面有相同的方法或者属性，子类将不知道具体要继承哪一个。
Java提供了接口和内部类以达到实现多继承功能，弥补单继承的缺陷。

39. 用最有效率的方法计算2乘以8？

2 << 3
复制代码

将一个数左移n位，就至关于这个数乘以了2的n次方。
那么，一个数乘以8只要将其左移3位便可。
而cpu直接支持位移运算，且效率最高。

40. 构造器是否可被重写？

构造器是不能被继承的，由于每一个类的类名都不相同，而构造器名称与类名相同，因此谈不上继承。又因为构造器不能被继承，因此相应的就不能被重写了。

41. char型变量中能不能存贮一个中文汉字，为何？

在Java中，char类型占2个字节，并且Java默认采用Unicode编码，一个Unicode码是16位，因此一个Unicode码占两个字节，Java中不管汉子仍是英文字母都是用Unicode编码来表示的。因此，在Java中，char类型变量能够存储一个中文汉字。

char ch = '啦';
System.out.println("char:" + ch);
复制代码

42. 如何实现对象克隆？

实现 Cloneable 接口，重写 clone() 方法。
Object 的 clone() 方法是浅拷贝，即若是类中属性有自定义引用类型，只拷贝引用，不拷贝引用指向的对象。
对象的属性的Class 也实现 Cloneable 接口，在克隆对象时也手动克隆属性，完成深拷贝
结合序列化(JDK java.io.Serializable 接口、JSON格式、XML格式等)，完成深拷贝

43. object中定义了哪些方法？

getClass(); 获取类结构信息
hashCode() 获取哈希码
equals(Object) 默认比较对象的地址值是否相等，子类能够重写比较规则
clone() 用于对象克隆
toString() 把对象转变成字符串
notify() 多线程中唤醒功能
notifyAll() 多线程中唤醒全部等待线程的功能
wait() 让持有对象锁的线程进入等待
wait(long timeout) 让持有对象锁的线程进入等待，设置超时毫秒数时间
wait(long timeout, int nanos) 让持有对象锁的线程进入等待，设置超时纳秒数时间
finalize() 垃圾回收前执行的方法

44. hashCode的做用是什么？

hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中肯定对象的存储地址的；

若是两个对象相同，就是适用于equals(java.lang.Object) 方法，那么这两个对象的hashCode必定要相同；

若是对象的equals方法被重写，那么对象的hashCode也尽可能重写，而且产生hashCode使用的对象，必定要和equals方法中使用的一致，不然就会违反上面提到的第2点；

两个对象的hashCode相同，并不必定表示两个对象就相同，也就是不必定适用于equals(java.lang.Object) 方法，只可以说明这两个对象在散列存储结构中.

这篇文章讲得挺详细的：Java中hashCode的做用

45. for-each与常规for循环的效率对比

关于这个问题,《Effective Java》给咱们作的解答：

for-each可以让代码更加清晰，而且减小了出错的机会。下面的惯用代码适用于集合与数组类型：
for (Element e : elements) {
     doSomething(e); 
}
复制代码
使用for-each循环与常规的for循环相比，并不存在性能损失，即便对数组进行迭代也是如此。实际上，在有些场合下它还能带来微小的性能提高，由于它只计算一次数组索引的上限。

46. 写出几种单例模式实现，懒汉模式和饿汉模式区别

7种：

第一种（懒汉，线程不安全）
第二种（懒汉，线程安全）
第三种（饿汉）
第四种（饿汉，变种）
第五种（静态内部类）
第六种（枚举）：
第七种（双重校验锁）

能够看这篇文章：单例模式的七种写法

47. 请列出 5 个运行时异常。

- NullPointerException 空指针异常
- ArithmeticException 出现异常的运算条件时，抛出此异常
- IndexOutOfBoundsException 数组索引越界异常
- ClassNotFoundException 找不到类异常
- IllegalArgumentException(非法参数异常)
复制代码

48. 2个不相等的对象有可能具备相同的 hashcode吗？

有可能哈~

hashCode 的常规协定：

在 Java 应用程序执行期间，在对同一对象屡次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另外一次执行，该整数无需保持一致。
两个对象的equals()相等，那么对这两个对象中的每一个对象调用 hashCode 方法都必须生成相同的整数结果。
两个对象的equals()不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不要求必定生成不一样的整数结果。可是，为不相等的对象生成不一样整数结果能够提升哈希表的性能。

49. 访问修饰符public,private,protected,以及default的区别？

50. 谈谈final在java中的做用？

final 修饰的类叫最终类，该类不能被继承。
final 修饰的方法不能被重写。
final 修饰的变量叫常量，常量必须初始化，初始化以后值就不能被修改。

51. java中的Math.round(-1.5) 等于多少呢？

JDK 中的 java.lang.Math 类:

round() ：返回四舍五入，负 .5 小数返回较大整数，如 -1.5 返回 -1。
ceil() ：返回小数所在两整数间的较大值，如 -1.5 返回 -1.0。
floor() ：返回小数所在两整数间的较小值，如 -1.5 返回 -2.0。

52. String属于基础的数据类型吗？

String 不属于基础类型，基础类型有 8 种：byte、boolean、char、short、int、float、long、double，而 String 属于对象。

53. 如何将字符串反转呢？

使用 StringBuilder 或 StringBuffer 的 reverse 方法，本质都调用了它们的父类 AbstractStringBuilder 的 reverse 方法实现。（JDK1.8）
使用chatAt函数，倒过来输出；

54. 描述动态代理的几种实现方式，它们分别有什么优缺点

JDK动态代理
CGLIB动态代理
JDK原声动态代理时java原声支持的、不须要任何外部依赖、可是它只能基于接口进行代理
CGLIB经过继承的方式进行代理、不管目标对象没有没实现接口均可以代理，可是没法处理final的状况

55. 在本身的代码中，若是建立一个java.lang.String类，这个类是否能够被类加载器加载？为何。

不能够。由于JDK处于安全性的考虑，基于双亲委派模型，优先加载JDK的String类，若是java.lang.String已经加载，便不会再次被加载。

56. 谈谈你对java.lang.Object对象中hashCode和equals方法的理解。在什么场景下须要从新实现这两个方法。

在咱们的业务系统中判断对象时有时候须要的不是一种严格意义上的相等，而是一种业务上的对象相等。在这种状况下，原生的equals方法就不能知足咱们的需求了，因此这个时候咱们须要重写equals方法，来知足咱们的业务系统上的需求。

那么为何在重写equals方法的时候须要重写hashCode方法呢？若是只重写了equals方法而没有重写hashCode方法的话，则会违反约定的第二条：相等的对象必须具备相等的散列码.因此hashCode和equals方法都须要重写

能够看网上这篇文章哈：java为何要重写hashCode和equals方法

57. 在jdk1.5中，引入了泛型，泛型的存在是用来解决什么问题。

Java 泛型（generics）是 JDK 5 中引入的一个新特性，其本质是参数化类型，解决不肯定具体对象类型的问题。
复制代码

这个面试题，能够看我这篇文章哈~Java程序员必备基础：泛型解析

58. 什么是序列化，怎么序列化，反序列呢？

序列化：把Java对象转换为字节序列的过程
反序列：把字节序列恢复为Java对象的过程

能够看我这篇文章哈~ Java程序员必备：序列化全方位解析

59. java8的新特性。

Lambda 表达式：Lambda容许把函数做为一个方法的参数
Stream API ：新添加的Stream API（java.util.stream）把真正的函数式编程风格引入到Java中
方法引用：方法引用提供了很是有用的语法，能够直接引用已有Java类或对象（实例）的方法或构造器。
默认方法：默认方法就是一个在接口里面有了一个实现的方法。
Optional 类：Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。
Date Time API ：增强对日期与时间的处理。

60. 匿名内部类是什么？如何访问在其外面定义的变量呢？

匿名内部类就是没有名字的内部类，平常开发中使用的比较多。

public class Outer {

    private void test(final int i) {
        new Service() {
            public void method() {
                for (int j = 0; j < i; j++) {
                    System.out.println("匿名内部类" );
                }
            }
        }.method();
    }
 }
 //匿名内部类必须继承或实现一个已有的接口 
 interface Service{
    void method();
}

复制代码

匿名内部类还有如下特色：

没有名字
匿名内部类必须继承一个抽象类或者实现一个接口。
匿名内部类不能定义任何静态成员和静态方法。
当所在的方法的形参须要被匿名内部类使用时，必须声明为 final。
匿名内部类不能是抽象的，它必需要实现继承的类或者实现的接口的全部抽象方法。
匿名内部类不能访问外部类方法中的局部变量，除非该变量被声明为final类型

能够看我这篇文章哈~Java程序员必备基础：内部类解析

61. break和continue有什么区别？

break可使流程跳出switch语句体，也能够在循环结构终止本层循环体，从而提早结束本层循环。
continue的做用是跳过本次循环体中余下还没有执行的语句，当即进行下一次的循环条件断定，能够理解为仅结束本次循环

62. String s = "Hello";s = s + " world!";这两行代码执行后，原始的 String 对象中的内容是否会改变？

没有。由于 String 被设计成不可变(immutable)类，因此它的全部对象都是不可变对象。

63. String s="a"+"b"+"c"+"d";建立了几个对象？

1个而已啦。

Java 编译器对字符串常量直接相加的表达式进行优化，不等到运行期去进行加法运算，在编译时就去掉了加号，直接将其编译成一个这些常量相连的结果。因此 "a"+"b"+"c"+"d" 至关于直接定义一个 "abcd" 的字符串。

64. try-catch-finally-return执行顺序

try-catch-finally-return 执行描述:

若是不发生异常，不会执行catch部分。
无论有没有发生异常，finally都会执行到。
即便try和catch中有return时，finally仍然会执行
finally是在return后面的表达式运算完后再执行的。（此时并无返回运算后的值，而是先把要返回的值保存起来，若finally中无return，则无论finally中的代码怎么样，返回的值都不会改变，仍然是以前保存的值），该状况下函数返回值是在finally执行前肯定的)
finally部分就不要return了，要否则，就回不去try或者catch的return了。

看一个例子

public static void main(String[] args) throws IOException {
        System.out.println("result：" + test());
    }

    private static int test() {
        int temp = 1;
        try {
            System.out.println("start execute try,temp is:"+temp);
            return ++temp;
        } catch (Exception e) {
            System.out.println("start execute catch temp is: "+temp);
            return ++temp;
        } finally {
            System.out.println("start execute finally,temp is:" + temp);
            ++temp;
        }
    }
复制代码

运行结果：

start execute try,temp is:1
start execute finally,temp is:2
result:2
复制代码

分析：

先执行try部分，输出日志，执行++temp表达式，temp变为2,这个值被保存起来。
由于没有发生异常，因此catch代码块跳过。
执行finally代码块，输出日志，执行++temp表达式.
返回try部分保存的值2.

65. Java 7新的 try-with-resources语句，平时有使用吗

try-with-resources，是Java7提供的一个新功能，它用于自动资源管理。

资源是指在程序用完了以后必需要关闭的对象。
try-with-resources保证了每一个声明了的资源在语句结束的时候会被关闭
什么样的对象才能当作资源使用呢？只要实现了java.lang.AutoCloseable接口或者java.io.Closeable接口的对象，都OK。

在try-with-resources出现以前

try{
    //open resources like File, Database connection, Sockets etc
} catch (FileNotFoundException e) {
    // Exception handling like FileNotFoundException, IOException etc
}finally{
    // close resources
}
复制代码

Java7，try-with-resources出现以后，使用资源实现

try(// open resources here){
    // use resources
} catch (FileNotFoundException e) {
    // exception handling
}
// resources are closed as soon as try-catch block is executed.
复制代码

Java7使用资源demo

public class Java7TryResourceTest {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader(
                "C:/jaywei.txt"))) {
            System.out.println(br.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
复制代码

使用了try-with-resources的好处

代码更加优雅，行数更少。
资源自动管理，不用担忧内存泄漏问题。

66. 简述一下面向对象的”六原则一法则”。

单一职责原则:一个类只作它该作的事情。
开闭原则：软件实体应当对扩展开放，对修改关闭。
依赖倒转原则：面向接口编程。
接口隔离原则：接口要小而专，毫不能大而全。
合成聚合复用原则：优先使用聚合或合成关系复用代码。
迪米特法则：迪米特法则又叫最少知识原则，一个对象应当对其余对象有尽量少的了解。

67. switch是否能做用在byte 上，是否能做用在long 上，是否能做用在String上？

switch可做用于char byte short int
switch可做用于char byte short int对应的包装类
switch不可做用于long double float boolean，以及他们的包装类

68. 数组有没有length()方法？String有没有length()方法？

数组没有length()方法，而是length；
String有length()方法

69. 是否能够从一个静态（static）方法内部发出对非静态（non-static）方法的调用？

不能够。

非static方法是要与对象实例息息相关的，必须在建立一个对象后，才能够在该对象上进行非static方法调用，而static方法跟类相关的，不须要建立对象，能够由类直接调用。
当一个static方法被调用时，可能尚未建立任何实例对象，若是从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪一个对象上的呢？这个逻辑是不成立的
所以，一个static方法内部不能够发出对非static方法的调用。

70. String s = new String("jay");建立了几个字符串对象？

一个或两个

第一次调用 new String("jay"); 时，会在堆内存中建立一个字符串对象，同时在字符串常量池中建立一个对象 "jay"

第二次调用 new String("jay"); 时，只会在堆内存中建立一个字符串对象，指向以前在字符串常量池中建立的 "jay"

能够看老王这篇文章，很清晰~ 别再问我 new 字符串建立了几个对象了！我来证实给你看！

71. this和super关键字的做用

this：

对象内部指代自身的引用
解决成员变量和局部变量同名问题
能够调用成员变量，不能调用局部变量
能够调用成员方法
在普通方法中能够省略 this
在静态方法当中不容许出现 this 关键字

super：

调用父类的成员或者方法
调用父类的构造函数

72. 咱们能将int强制转换为 byte类型的变量吗？若是该值大于byte 类型的范围，将会出现什么现象？

能够，咱们能够作强制转换，可是在Java中，int是32位，byte是8位，若是强制作转化，int类型的高24位将会被丢弃。

public class Test {
    public static void main(String[] args)  {
        int a =129;
        byte b = (byte) a;
        System.out.println(b);
        int c =10;
        byte d = (byte) c;
        System.out.println(d);

    }
}
输出：
-127
10
复制代码

73. float f=3.4;正确吗？

不正确，精度不许确,应该用强制类型转换

74. 接口能否继承接口？抽象类是否可实现接口？抽象类是否可继承实体类？

均可以的

75. Reader和InputStream区别？

InputStream是表示字节输入流的全部类的超类
Reader是用于读取字符流的抽象类

76. 列举出JAVA中6个比较经常使用的包

java.lang;
java.util;
java.io;
java.sql;
java.awt;
java.net;

77. JDK 7有哪些新特性

Try-with-resource语句
NIO2 文件处理Files
switch能够支持字符串判断条件
泛型推导
多异常统一处理

78. 同步和异步有什么区别？

同步，能够理解为在执行完一个函数或方法以后，一直等待系统返回值或消息，这时程序是出于阻塞的，只有接收到返回的值或消息后才往下执行其余的命令。
异步，执行完函数或方法后，没必要阻塞性地等待返回值或消息，只须要向系统委托一个异步过程，那么当系统接收到返回值或消息时，系统会自动触发委托的异步过程，从而完成一个完整的流程。
同步，就是实时处理（如打电话）
异步，就是分时处理（如收发短信）

参考这篇文章~ 同步和异步的区别

79. 实际开发中，Java通常使用什么数据类型来表明价格？

java中使用BigDecimal来表示价格是比较好的。

能够看这篇文章，写得很是好老大说：谁要再用double定义商品金额，就本身收拾东西走

80. 64 位 JVM 中，int 的长度是多数？

int数据类型占4个字节 32位，跟JVM位数不要紧的

公众号

欢迎关注我我的公众号，交个朋友，一块儿学习哈~