面向对象的特征是什么？
抽象(Encapsulation)：包装的目的是确保变量的安全。用户不必关心具体的实现细节，而只能通过外部接口访问成员 如果不包装，可以直接检查和修改类中的实例变量，可能会对整个代码产生不良影响 因此，成员变量一般在编写类别中私有化，外部类需要相同getter和setter检查和设置变量的方法。
继承(Inherit)：事实上，继承也是为了提高代码的再利用性和可扩展性。在定义不同类别时，有一些相同的属性。为了方便使用，这些共同属性可以抽象成父类。在定义其他子类时，可以继承父类，减少代码的重复定义。子类可以使用父类中的非私有成员。
继承需要注意：
父类不知道他有什么子类，但子类必须清楚他有什么父类
如果子类想在父类功能的基础上增加新的功能，可以使用super实现
不能作为继承的子类：
存取控制
使用final一般来说，添加修的方法被重写，通常是添加final修饰符
只有private构造方法
子类参数的数量和类型应与父类完全一致，返回类型应兼容
子类方法的存取权只能改为较低，不能高于父类方法的存取权 (里氏代换原则)
包装：包装是将对象的属性私有化，隐藏内部实现细节，并提供一些外部访问属性的方法。该程序易于使用，提高了重用性和安全性。
多态(Polymorphism)：是指在不同的情况下，相同的类实例方法有不同的表达形式。多态机制使具有不同内部结构的对象共享相同的外部接口。这意味着，虽然不同对象的具体操作不同，但它们（这些操作）可以以相同的方式通过公共类调用。
多态三点：
1.多态是方法多态，不是属性多态(多态与属性无关)
2.多态存在有三个必要条件:继承、方法重写、父类引用子类对象。
3.父类引用指向子类对象后，用父类引用调用子类重写法，此时出现多态。
多态性分为编译时的多态性和操作时的多态性。方法重载（overload）在编译过程中实现多态性(也称为前绑定)，方法重写（override）在运行过程中实现多态性(也称后绑定)。
重载（Overload）和重写（Override）区别。重载的方法可以根据返回类型来区分吗？
该方法的重载和重写是实现多态性的方法。区别在于前者在编译过程中实现多态性，后者在运行过程中实现多态性。
重载（overload）：发生在同一类别中，不同的参数列表（不同的参数类型、不同的数量和不同的顺序）与方法返回值和访问修改符无关，即重载方法不能根据返回类型进行区分
重写（override）：在父子类中，方法名和参数列表必须相同，返回值小于等于父，异常抛出小于等于父，访问修改符大于等于父（里氏替换原则）；如果父亲方法访问修改符private子类不是重写。
五大基本原则
单一职责原则SRP(Single Responsibility Principle)
这意味着一个类的功能应该是单一的，而不是包罗万象的。就像一个人一样，不能分配太多的工作，否则虽然整天都很忙，但效率并不高。
开放封闭原则OCP(Open－Close Principle)
一个模块在扩展性方面应该是开放的，在变化方面应该是封闭的。例如：网络模块，最初只有服务端功能，现在添加客户端功能，所以应该在不修改服务端功能代码的前提下，可以增加客户端功能的实现代码，这需要在设计开始时，服务端和客户端分开，公共部分抽象。
里式替换原则LSP(the Liskov Substitution Principle LSP)
子类应该可以在父类可以出现的任何地方出现的任何地方。例如，如果公司举办年度聚会，所有员工都可以参加抽奖，那么老员工、新员工、总部员工和外籍员工都应该能够参加抽奖，否则公司将不和谐。
依靠倒置原则DIP(the Dependency Inversion Principle DIP)
依赖抽象，上层依赖下层。假设B是低于A的模块，但B需要使用A的功能，此时，BA中的具体类别不应直接使用：而应由B定义抽象接口，并由A实现，B只使用这个抽象接口：这样就达到了依赖倒置的目的，B反过来，A依赖于B定义的抽象接口也消除了对A的依赖。很难避免依赖下层模块通过上层模块。如果B也直接依赖A，则可能 造成循环依赖。编译A模块时需要直接包含B模块的一个常见问题是cpp在编译B时，文件也应直接包含在A中cpp文件。
接口分离原理ISP(the Interface Segregation Principle ISP)
模块应通过抽象接口隔离，而不是通过特定的类强耦合
访问修饰符 public,private,protected,还有不写(默认)的区别？
不写访问修改符的成员默认认为default，默认相当于同一同一包中的其他类别(public)，其他类别不是同一个包相当于私有(private)
成员变量与局部变量的区别
类中的位置
成员变量：中外方法
局部变量：方法定义或方法声明
内存中的位置
成员变量：堆放
局部变量：在栈中
不同的生命周期
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用而消失
不同的初始化值
成员变量：默认值
局部变量：无默认值，必须定义、赋值，才能使用
静态变量与实例变量的区别
静态变量是被子 static 修饰符修饰的变量，又称类变量，属于类，不属于类的任何对象。无论一个类创建多少对象，静态变量都存在于内存中，只有一个副本；实例变量必须依赖于某个实例，需要先创建对象，然后通过对象访问。静态变量可以让多个对象共享内存。在 Java 在开发过程中，通常会有大量的静态成员在上下文和工具。
是否可以从静态开始（static）内部发出非静态（non-static）方法的调用 不，静态方法只能访问静态成员，因为非静态方法的调用需要先创建对象，所以调用静态方法时对象可能不会初始化。
==, equals 与 hashCode 区别与联系
== ：操作符生成的是一个boolean因此，它计算了操作数值之间的关系
如果操作数的类型是基本数据类型，则关系操作符判断左右操作数的值是否相等
如果操作数的类型是引用数据类型，则关系操作符判断左右操作数的内存地址是否相同。换句话说，如果此时返回true,操作符必须是同一对象。
equals ：Object 的 实例法，比较两个对象content是否相同
内部实现分为三个步骤：
先 比较引用是否相同(是否为同一对象)，
再 判断类型是否一致(是否相同)，
最后 比较内容是否一致
Java 所有内置类别 equals 实现方法的步骤是这样的，尤其是 Integer，Double 等包装类别。
对象内容的比较是设计equals()真正的目的，Java语言对equals()要求如下法时必须遵循以下要求:
类推：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回也应该返回true” ；
一致性:如果x.equals(y)返回是“true只要x和y内容一直不变，不管你重复x.equals(y)返回多少次都是true” ；
对称：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回也应该返回true”。
在任何情况下，x.equals(null)【应用关系比较一致 ==】，永远回来false”；x.equals(和x不同类型的对象)永远回来false”
hashCode : Object 的 native方法 , 获取对象的哈希值，于确定该对象在哈希表中的索引位置，它实际上是一个int型整数
equals 与 hashCode :
二者均是Object类里的方法。由于Object类是所有类的基类，所以一切类里都可以重写这两个方法。
原则 1 ：如果 x.equals(y) 返回 “true”，那么 x 和 y 的 hashCode() 必须相等 ；
原则 2 ：如果 x.equals(y) 返回 “false”，那么 x 和 y 的 hashCode() 有可能相等，也有可能不等 ；
原则 3 ：如果 x 和 y 的 hashCode() 不相等，那么 x.equals(y) 一定返回 “false” ；
原则 4 ：一般来讲，equals 这个方法是给用户调用的，而 hashcode 方法一般用户不会去调用 ；
原则 5 ：当一个对象类型作为集合对象的元素时，那么这个对象应该拥有自己的equals()和hashCode()设计，而且要遵守前面所说的几个原则
值传递和引用传递
值传递：在调用方法时将实际参数复制一份到方法中，在方法中对参数进行修改并不会影响到实际参数。引用传递：在调用方法时将实际参数的地址直接传递到方法中，在方法中对参数进行修改会影响到实际参数。
如何理解Java中只有值传递没有引用传递
按值调用(call by value)表示方法接收的是调用者提供的值，而按引用调用（call by reference)表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。
Java对对象采用的不是引用调用，实际上，对象引用是按值传递的。
一个方法不能修改一个基本数据类型的参数（即数值型或布尔型）
一个方法可以改变一个对象参数的状态。
一个方法不能让对象参数引用一个新的对象。
当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数
被传递到方法中时，参数的值就是对该对象的引用。对象的属性可以在被调用过
程中被改变，但对象的引用是永远不会改变的。C++和 C#中可以通过传引用或
传输出参数来改变传入的参数的值。
实现对象克隆
1.实现 Cloneable 接口并重写 Object 类中的 clone()方法；
2.实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下。
注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用 Object 类的 clone 方法克隆对象。
JAVA 复制
将一个对象的引用复制给另外一个对象，一共有三种方式。第一种方式是直接赋值，第二种方式
是浅拷贝，第三种是深拷贝。所以大家知道了哈，这三种概念实际上都是为了拷贝对象。
直接赋值复制
直接赋值。在 Java 中，A a1 = a2，我们需要理解的是这实际上复制的是引用，也就是
说 a1 和 a2 指向的是同一个对象。因此，当 a1 变化的时候，a2 里面的成员变量也会跟
着变化。
浅复制（复制引用但不复制引用的对象）
创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，
那么对该字段执行复制；如果该字段是引用类型的话，则复制引用但不复制引用的对象。
因此，原始对象及其副本引用同一个对象
class Resume implements Cloneable{
public Object clone() {
try {
return (Resume)super.clone();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}深复制（复制对象和其应用对象）
深拷贝不仅复制对象本身，而且复制对象包含的引用指向的所有对象。
class Student implements Cloneable {
String name;
int age;
Professor p;
Student(String name, int age, Professor p) {
this.name = name;
this.age = age;
this.p = p;
}
public Object clone() {
Student o = null;
try {
o = (Student) super.clone();
} catch (CloneNotSupportedException e) {
System.out.println(e.toString());
}
o.p = (Professor) p.clone();
return o;
} }序列化（深 clone 一中实现）
在 Java 语言里深复制一个对象，常常可以先使对象实现 Serializable 接口，然后把对
象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来，便可以重建对象。
JAVA 序列化(创建可复用的 Java 对象)
保存(持久化)对象及其状态到内存或者磁盘
Java 平台允许我们在内存中创建可复用的 Java 对象，但一般情况下，只有当 JVM 处于运行时，
这些对象才可能存在，即，这些对象的生命周期不会比 JVM 的生命周期更长。但在现实应用中，
就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。
Java 对象序列化就能够帮助我们实现该功能。
序列化对象以字节数组保持-静态成员不保存
使用 Java 对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装
成对象。必须注意地是，对象序列化保存的是对象的”状态”，即它的成员变量。由此可知，对
象序列化不会关注类中的静态变量。
序列化用户远程对象传输
除了在持久化对象时会用到对象序列化之外，当使用 RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化。Java序列化API为处理对象序列化提供了一个标准机制，该API简单易用。
Serializable 实现序列化
在 Java 中，只要一个类实现了 java.io.Serializable 接口，那么它就可以被序列化。
ObjectOutputStream 和 ObjectInputStream 对对象进行序列化及反序列化
通过 ObjectOutputStream 和 ObjectInputStream 对对象进行序列化及反序列化。
writeObject 和 readObject 自定义序列化策略
在类中增加 writeObject 和 readObject 方法可以实现自定义序列化策略。
序列化 ID
虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个
类的序列化 ID 是否一致（就是 private static final long serialVersionUID）
13/04/2018 Page 114 of 283
序列化并不保存静态变量
序列化子父类说明
要想将父类对象也序列化，就需要让父类也实现 Serializable 接口。
Transient 关键字阻止该变量被序列化到文件中
在变量声明前加上 Transient 关键字，可以阻止该变量被序列化到文件中，在被反序列
化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。
服务器端给客户端发送序列化对象数据，对象中有一些数据是敏感的，比如密码字符串
等，希望对该密码字段在序列化时，进行加密，而客户端如果拥有解密的密钥，只有在
客户端进行反序列化时，才可以对密码进行读取，这样可以一定程度保证序列化对象的
数据安全。
JAVA 泛型
泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本
质是参数化类型，也就是说所操作的数据类型被指定为一个参数。比如我们要写一个排序方法，
能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，我们就可以使用 Java 泛型。
泛型方法（<E>）
你可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数
类型，编译器适当地处理每一个方法调用。
// 泛型方法 printArray
public static < E > void printArray( E[] inputArray )
{
for ( E element : inputArray ){
System.out.printf( "%s ", element );
}
}<? extends T>表示该通配符所代表的类型是 T 类型的子类。<? super T>表示该通配符所代表的类型是 T 类型的父类。
泛型类 <T>
泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。和泛型方法一
样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，
也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，
这些类被称为参数化的类或参数化的类型。
public class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
13/04/2018 Page 113 of 283类型通配符<?>
类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是
List<String>,List<Integer> 等所有 List<具体类型实参>的父类。类型擦除
Java 中的泛型基本上都是在编译器这个层次来实现的。在生成的 Java 字节代码中是不包含泛
型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉。这个
过程就称为类型擦除。如在代码中定义的 List<Object>和 List<String>等类型，在编译之后
都会变成 List。JVM 看到的只是 List，而由泛型附加的类型信息对 JVM 来说是不可见的。
类型擦除的基本过程也比较简单，首先是找到用来替换类型参数的具体类。这个具体类一般
是 Object。如果指定了类型参数的上界的话，则使用这个上界。把代码中的类型参数都替换
成具体的类。
String 是最基本的数据类型吗?
不是。Java 中的基本数据类型只有 8 个：byte、short、int、long、float、
double、char、boolean；除了基本类型（primitive type）和枚举类型（enumeration type），剩下的都是引用类型（reference type）。
float f=3.4;是否正确?
不正确。3.4 是双精度数，将双精度型（double）赋值给浮点型（float）属
于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型
转换 float f =(float)3.4; 或者写成 float f =3.4F;
short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗?
对于 short s1 = 1; s1 = s1 + 1;由于 1 是 int 类型，因此 s1+1 运算结果也是 int 型，需要强制转换类型才能赋值给 short 型。而 short s1 = 1; s1+= 1;可以正确编译，因为 s1+= 1;相当于 s1 = (short)(s1 + 1);其中有隐含的强制类型转换。
Java 有没有 goto?
goto 是 Java 中的保留字，在目前版本的 Java 中没有使用。
int 和 Integer 有什么区别?
Java 是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入
不是对象的基本数据类型，但是为了能够将这些基本数据类型当成对象操作，J
ava 为每一个基本数据类型都引入了对应的包装类型（wrapper class），int
的包装类就是 Integer，从 JDK 1.5 开始引入了自动装箱/拆箱机制，使得二者
可以相互转换。
Java 为每个原始类型提供了包装类型：
原始类型: boolean，char，byte，short，int，long，float，double
包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double
如果不明就里很容易认为两个输出要么都是 true 要么都是 false。
首先需要注意的是 f1、f2、f3、f4 四个变量都是 Integer 对象，所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢？当我们给一个 Integer 对象赋一个 int 值的时候，会调用 Integer 类的静态方法 valueOf，如果看看 valueOf 的源代码就知道发生了什么。
IntegerCache 是 Integer 的内部类，其代码如下所示：
简单的说，如果字面量的值在-128 到 127 之间，那么不会 new 新的 Integer对象，而是直接引用常量池中的 Integer 对象，所以上面的面试题中 f1==f2 的结果是 true，而 f3==f4 的结果是 false。
&和&&的区别
&运算符有两种用法：(1)按位与；(2)逻辑与。&&运算符是短路与运算。
逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是 true 整个表达式的值才是 true。&&之所以称为短路运算是因为，如果&&左边的表达式的值是 false，右边的表达式会被直接短路掉，不会进行运算。
注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。
解释内存中的栈（stack）、堆(heap)和静态存储区的用法。
通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用内存中的栈空间；而通过 new 关键字和构造器创建的对象放在堆空间；程序中的字面量（literal）如直接书写的 100、“hello”和常量都是放在静态存储区中。栈空间操作最快但是也很小，通常大量的对象都是放在堆空间，整个内存包括硬盘上的虚拟内存都可以被当成堆空间来使用。
String str = new String(“hello”);
补充：较新版本的 Java 中使用了一项叫“逃逸分析“的技术，可以将一些局部
对象放在栈上以提升对象的操作性能。
Math.round(11.5) 等于多少? Math.round(-11.5)等于多少?
答：Math.round(11.5)的返回值是 12，Math.round(-11.5)的返回值是-11。四
舍五入的原理是在参数上加 0.5 然后进行下取整。
swtich 是否能作用在 byte 上，是否能作用在 long 上，是否能作用在 String 上?
早期的 JDK 中，switch（expr）中，expr 可以是 byte、short、char、int。
从 1.5 版开始，Java 中引入了枚举类型（enum），expr 也可以是枚举，从 JDK 1.7 版开始，还可以是字符串（String）；长整型（long）是不可以的。
用最有效率的方法计算 2 乘以 8?
2 << 3（左移 3 位相当于乘以 2 的 3 次方，右移 3 位相当于除以 2 的 3次方）。
补充：我们为编写的类重写 hashCode 方法时，可能会看到如下所示的代码，其实我们不太理解为什么要使用这样的乘法运算来产生哈希码（散列码），而且为什么这个数是个素数，为什么通常选择 31 这个数？前两个问题的答案你可以
选择 31 是因为可以用移位和减法运算来代替乘法，从而得到更好的性能。说到这里你可能已经想到了：31 * num <==> (num << 5) - num，左移 5 位相当于乘以 2 的 5 次方（32）再减去自身就相当于乘以 31。现在的 VM 都能自动完成这个优化。
数组有没有 length()方法?String 有没有 length()方法？
数组没有 length()方法，有 length 的属性。String 有 length()方法。JavaScript 中，获得字符串的长度是通过 length 属性得到的，这一点容易和 Java混淆。
在 Java 中，如何跳出当前的多重嵌套循环？
在最外层循环前加一个标记如 A，然后用 break A;可以跳出多重循环。
构造器（constructor）是否可被重写（override）?
构造器不能被继承，因此不能被重写，但可以被重载。
两个对象值相同(x.equals(y) == true)，但却可有不同的 hash code，这句话对不对？
不对，如果两个对象 x 和 y 满足 x.equals(y) == true，它们的哈希码（hash code）应当相同。Java 对于 eqauls 方法和 hashCode 方法是这样规定的：
(1)如果两个对象相同（equals 方法返回 true），那么它们的 hashCode 值一定
要相同；
(2)如果两个对象的 hashCode 相同，它们并不一定相同。
当然，你未必要按照要求去做，但是如果你违背了上述原则就会发现在使用容器时，相同的
对象可以出现在 Set 集合中，同时增加新元素的效率会大大下降（对于使用哈希
存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。
是否可以继承 String 类?
String 类是 final 类，不可以被继承。
补充：继承 String 本身就是一个错误的行为，对 String 类型最好的重用方式是关联（HAS-A）而不是继承（IS-A）。
StringBuffer、StringBuilder、String区别
线程安全
StringBuffer：线程安全，StringBuilder：线程不安全。
因为 StringBuffer 的所有公开方法都是 synchronized 修饰的，而 StringBuilder 并没有 synchronized 修饰。
StringBuffer 代码片段：
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}缓冲区
StringBuffer 代码片段：
private transient char[] toStringCache;
@Override
public synchronized String toString() {
if (toStringCache == null) {
toStringCache = Arrays.copyOfRange(value, 0, count);
}
return new String(toStringCache, true);
}StringBuilder 代码片段：
@Override
public String toString() {
// Create a copy, don't share the array
return new String(value, 0, count);
}可以看出，StringBuffer 每次获取 toString 都会直接使用缓存区的 toStringCache 值来构造一个字符串。
而 StringBuilder 则每次都需要复制一次字符数组，再构造一个字符串。
所以，缓存冲这也是对 StringBuffer 的一个优化吧，不过 StringBuffer 的这个toString 方法仍然是同步的。
性能
StringBuffer 是线程安全的，它的所有公开方法都是同步的，StringBuilder 是没有对方法加锁同步的，所以毫无疑问，StringBuilder 的性能要远大于 StringBuffer。
StringBuilder > StringBuffer > String
String最慢的原因：String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。
有没有哪种情况用+做字符串连接比调用 StringBuffer / StringBuilder 对象的 append 方法性能更好？
如果连接后得到的字符串在静态存储区中是早已存在的，那么用+做字符串连接是优于 StringBuffer / StringBuilder 的 append 方法的。
静态嵌套类(Static Nested Class)和内部类（Inner Class）的不同？
Static Nested Class 是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。
char 型变量中能不能存贮一个中文汉字?为什么?
char 类型可以存储一个中文汉字，因为 Java 中使用的编码是 Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个 char 类型占 2 个字节（16bit），所以放一个中文是没问题的。
抽象类（abstract class）和接口（interface）有什么异同?
抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。
接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。抽象类中的成员可以是 private、默认、protected、public 的，而接口中的成员全都是 public 的。
抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。
抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本地方法（native），是否可同时被 synchronized 修饰?
都不能。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者
是矛盾的。本地方法是由本地代码（如 C 代码）实现的方法，而抽象方法是没
有实现的，也是矛盾的。synchronized 和方法的实现细节有关，抽象方法不涉
及实现细节，因此也是相互矛盾的。
String s=new String(“xyz”);创建了几个字符串对象？
两个对象，一个是静态存储区的"xyz",一个是用 new 创建在堆上的对象。
接口是否可继承（extends）接口? 抽象类是否可实现（implements）接口? 抽象类是否可继承具体类（concrete class）
接口可以继承接口。
抽象类可以实现(implements)接口，抽象类可继承具体类，但前提是具体类必须有明确的构造函数。
一个“.java”源文件中是否可以包含多个类（不是内部类）？有什么限制？
可以，但一个源文件中最多只能有一个公开类（public class）而且文件名必须和公开类的类名完全保持一致。
Anonymous Inner Class(匿名内部类)是否可以继承其它类？是否可以实现接口？
可以继承其他类或实现其他接口，在 Swing 编程中常用此方式来实现事件
监听和回调。
内部类可以引用它的包含类（外部类）的成员吗？有没有什么限制？
一个内部类对象可以访问创建它的外部类对象的成员，包括私有成员。
Java 中的 final 关键字有哪些用法？
(1)修饰类：表示该类不能被继承；
(2)修饰方法：表示方法不能被重写；
(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。
指出下面程序的运行结果
执行结果：1a2b2b。
创建对象时构造器的调用顺序是：先初始化静态成员，然后调用父类构造器，再初始化非静态成员，最后调用自身构造器。
如何将字符串转换为基本数据类型？
调用基本数据类型对应的包装类中的方法 parseXXX(String)或 valueOf(String)即可返回相应基本类型；
如何将基本数据类型转换为字符串？
一种方法是将基本数据类型与空字符串（””）连接（+）即可获得其所对应的字符串；
另一种方法是调用 String 类中的 valueOf(…)方法返回相应字符串
如何实现字符串的反转及替换？
方法很多，可以自己写实现也可以使用 String 或 StringBuffer / StringBuilder 中的方法。有一道很常见的面试题是用递归实现字符串反转，代码如下所示：
怎样将 GB2312 编码的字符串转换为 ISO-8859-1 编码的字符串？
String s1 = "你好";
String s2 = newString(s1.getBytes("GB2312"), "ISO-8859-1");如何取得年月日、小时分钟秒
创建 java.util.Calendar 实例，调用其 get()方法传入不同的参数即可获得参数所对应的值
如何取得从 1970 年 1 月 1 日 0 时 0 分 0 秒到现在的毫秒数
如何取得某月的最后一天
如何格式化日期
利用 java.text.DataFormat 的子类（如 SimpleDateFormat 类）中的 forma t(Date)方法可将日期格式化。
打印昨天的当前时刻
比较一下 Java 和 JavaSciprt
JavaScript 与 Java 是两个公司开发的不同的两个产品。Java 是原 Sun公司推出的面向对象的程序设计语言，特别适合于互联网应用程序开发；而 JavaScript 是 Netscape 公司的产品，为了扩展 Netscape 浏览器的功能而开发的一种可以嵌入 Web 页面中运行的基于对象和事件驱动的解释性语言，它的前身是 LiveScript；而 Java 的前身是 Oak 语言。
下面对两种语言间的异同作如下比较：
1）基于对象和面向对象：Java 是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象；JavaScript 是种脚本语言，它可以用来制作与网络无关的，与用户交互作用的复杂软件。它是一种基于对象（Object-Based）和事件驱动（Event-Driven）的编程语言。因而它本身提供了非常丰富的内部对象供设计人员使用；
2）解释和编译：Java 的源代码在执行之前，必须经过编译；JavaScript 是一种解释性编程语言，其源代码不需经过编译，由浏览器解释执行；
3）强类型变量和类型弱变量：Java 采用强类型变量检查，即所有变量在编译之前必须作声明；JavaScript 中变量声明，采用其弱类型。即变量在使用前不需作声明，而是解释器在运行时检查其数据类型；
4）代码格式不一样。
上面列出的四点是原来所谓的标准答案中给出的。其实 Java 和 JavaScript 最重要的区别是一个是静态语言，一个是动态语言。目前的编程语言的发展趋势是函数式语言和动态语言。在 Java 中类（class）是一等公民，而 JavaScript 中函数（function）是一等公民。对于这种问题，在面试时还是用自己的语言回答会更加靠谱。
什么时候用 assert？
assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。一般来说，assertion 用于保证程序最基本、关键的正确性。assertion 检查通常在开发和测试时开启。为了提高性能，在软件发布后， assertion 检查通常是关闭的。在实现中，断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true；如果表达式计算为 false，那么系统会报告一个AssertionError断言用于调试目的：
assert(a > 0); // throws an AssertionError if a <= 0断言可以有两种形式：
assert Expression1;
assert Expression1 : Expression2 ;
Expression1 应该总是产生一个布尔值。
Expression2 可以是得出一个值的任意表达式；这个值用于生成显示更多调试信息的字符串消息。
断言在默认情况下是禁用的，要在编译时启用断言，需使用 source 1.4 标记：
javac -source 1.4 Test.java要在运行时启用断言，可使用-enableassertions 或者-ea 标记。
要在运行时选择禁用断言，可使用-da 或者-disableassertions 标记。
要在系统类中启用断言，可使用-esa 或者-dsa 标记。还可以在包的基础上启用或者禁用断言。可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。
Error 和 Exception 有什么区别?
Error 表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情况；Exception 表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况。
try{}里有一个 return 语句，那么紧跟在这个 try 后的 finally{}里的 code会不会被执行，什么时候被执行，在 return 前还是后?
会执行，在方法返回调用者前执行。Java 允许在 finally 中改变返回值的做法是不好的，因为如果存在 finally 代码块，try 中的 return 语句不会立马返回调用者，而是记录下返回值待 finally 代码块执行完毕之后再向调用者返回其值，然后如果在 finally 中修改了返回值，这会对程序造成很大的困扰，C#中就从语法上规定不能做这样的事。
Java 语言如何进行异常处理，关键字：throws、throw、try、catch、finally 分别如何使用？
Java 通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在 Java 中，每个异常都是一个对象，它是 Throwable 类或其子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。
Java 的异常处理是通过 5 个关键词来实现的：try、catch、throw、throws 和 finally。一般情况下是用 try 来执行一段程序，如果出现异常，系统会抛出（throw）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理；try 用来指定一块预防所有“异常”的程序；catch 子句紧跟在 try 块后面，用来指定你想要捕捉的“异常”的类型；throw 语句用来明确地抛出一个“异常”；throws 用来标明一个成员函数可能抛出的各种“异常”；finally 为确保一段代码不管发生什么“异常”都被执行一段代码；可以在一个成员函数调用的外面写一个 try 语句，在这个成员函数内部写另一个 try 语句保护其他代码。每当遇到一个 try 语句，“异常”的框架就放到栈上面，直到所有的try 语句都完成。如果下一级的 try 语句没有对某种“异常”进行处理，栈就会展开，直到遇到有处理这种“异常”的 try 语句。
运行时异常与受检异常有何异同？
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误，只要程序设计得没有问题通常就不会发生。受检异常跟程序运行的上下文环境有关，即使程序设计无误，仍然可能因使用的问题而引发。Java 编译器要求方法必须声明抛出可能发生的受检异常，但是并不要求必须声明抛出未被捕获的运行时异常。
列出一些你常见的运行时异常？
ArithmeticException（算术异常）
ClassCastException （类转换异常）
IllegalArgumentException （非法参数异常）
IndexOutOfBoundsException （下表越界异常）
NullPointerException （空指针异常）
SecurityException （安全异常）
final, finally, finalize 的区别?
final：修饰符（关键字）有三种用法：如果一个类被声明为 final，意味着它不能再派生出新的子类，即不能被继承，因此它和 abstract 是反义词。将变量声明为 final，可以保证它们在使用中不被改变，被声明为 final 的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改。被声明为 final 的方法也同样只能使用，不能在子类中被重写。
finally：通常放在 try…catch 的后面构造总是执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要 JVM 不关闭都能执行，可以将释放外部资源的代码写在 finally 块中。finalize：Object 类中定义的方法，Java 中允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的，通过重写 finalize() 方法可以整理系统资源或者执行其他清理工作。
什么是反射？
在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法
Java反射机制主要提供了以下功能：
在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的方法。
反射机制的优缺点
优点：
能够运行时动态获取类的实例，提高灵活性；
与动态编译结合Class.forName('com.mysql.jdbc.Driver.class');//加载MySQL的驱动类
缺点：
使用反射性能较低，需要解析字节码，将内存中的对象进行解析。
其解决方案是：通过setAccessible(true)关闭JDK的安全检查来提升反射速度；多次创建一个类的实例时，有缓存会快很多；ReflflectASM工具类，通过字节码生成的方式加快反射速度
Java反射API有几类？
反射 API 用来生成 JVM 中的类、接口或则对象的信息。
Class 类：反射的核心类，可以获取类的属性，方法等信息。
Field 类：Java.lang.reflec 包中的类，表示类的成员变量，可以用来获取和设置类之中的属性值。
Method 类：Java.lang.reflec 包中的类，表示类的方法，它可以用来获取类中的方法信息或者执行方法。
Constructor 类：Java.lang.reflec 包中的类，表示类的构造方法。
反射使用步骤(获取Class对象、调用对象方法)
获取想要操作的类的Class对象，他是反射的核心，通过Class对象我们可以任意调用类的方法。
调用 Class 类中的方法，既就是反射的使用阶段。
使用反射 API 来操作这些信息。
什么是 java 序列化？
简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。
什么情况下需要序列化
a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候；
动态代理是什么？
当想要给实现了某个接口的类中的方法，加一些额外的处理。比如说加日志，加事务等。可以给这个类创建一个代理，故名思议就是创建一个新的类，这个类不仅包含原来类方法的功能，而且还在原来的基础上添加了额外处理的新类。这个代理类并不是定义好的，是动态生成的。具有解耦意义，灵活，扩展性强。
动代理的应用
Spring的AOP
加事务
加权限
加日志
怎么实现动态代理？
首先必须定义一个接口，还要有一个InvocationHandler(将实现接口的类的对象传递给它)处理类。再有一个工具类Proxy(习惯性将其称为代理类，因为调用他的newInstance()可以产生代理对象,其实他只是一个产生代理对象的工具类）。利用到InvocationHandler，拼接代理类源码，将其编译生成代理类的二进制码，利用加载器加载，并将其实例化产生代理对象，最后返回。
JAVA IO
阻塞 IO 模型
最传统的一种 IO 模型，即在读写数据过程中会发生阻塞现象。当用户线程发出 IO 请求之后，内 核会去查看数据是否就绪，如果没有就绪就会等待数据就绪，而用户线程就会处于阻塞状态，用 户线程交出 CPU。当数据就绪之后，内核会将数据拷贝到用户线程，并返回结果给用户线程，用户线程才解除 block 状态。典型的阻塞 IO 模型的例子为：data = socket.read();如果数据没有就 绪，就会一直阻塞在 read 方法。
非阻塞 IO 模型
当用户线程发起一个 read 操作后，并不需要等待，而是马上就得到了一个结果。如果结果是一个 error 时，它就知道数据还没有准备好，于是它可以再次发送 read 操作。一旦内核中的数据准备 好了，并且又再次收到了用户线程的请求，那么它马上就将数据拷贝到了用户线程，然后返回。所以事实上，在非阻塞 IO 模型中，用户线程需要不断地询问内核数据是否就绪，也就说非阻塞 IO 不会交出 CPU，而会一直占用 CPU。典型的非阻塞 IO 模型一般如下：
while(true){
data = socket.read();
if(data!= error){
处理数据
break;
}
}但是对于非阻塞 IO 就有一个非常严重的问题，在 while 循环中需要不断地去询问内核数据是否就绪，这样会导致 CPU 占用率非常高，因此一般情况下很少使用 while 循环这种方式来读取数据。
多路复用 IO 模型
多路复用 IO 模型是目前使用得比较多的模型。Java NIO 实际上就是多路复用 IO。在多路复用 IO 模型中，会有一个线程不断去轮询多个 socket 的状态，只有当 socket 真正有读写事件时，才真 正调用实际的 IO 读写操作。因为在多路复用 IO 模型中，只需要使用一个线程就可以管理多个 socket，系统不需要建立新的进程或者线程，也不必维护这些线程和进程，并且只有在真正有 socket 读写事件进行时，才会使用 IO 资源，所以它大大减少了资源占用。
在 Java NIO 中，是通 过 selector.select()去查询每个通道是否有到达事件，如果没有事件，则一直阻塞在那里，因此这 种方式会导致用户线程的阻塞。多路复用 IO 模式，通过一个线程就可以管理多个 socket，只有当 socket 真正有读写事件发生才会占用资源来进行实际的读写操作。因此，多路复用 IO 比较适合连 接数比较多的情况。
另外多路复用 IO 为何比非阻塞 IO 模型的效率高是因为在非阻塞 IO 中，不断地询问 socket 状态 时通过用户线程去进行的，而在多路复用 IO 中，轮询每个 socket 状态是内核在进行的，这个效 率要比用户线程要高的多。不过要注意的是，多路复用 IO 模型是通过轮询的方式来检测是否有事件到达，并且对到达的事件 逐一进行响应。因此对于多路复用 IO 模型来说，一旦事件响应体很大，那么就会导致后续的事件 迟迟得不到处理，并且会影响新的事件轮询。
信号驱动 IO 模型
在信号驱动 IO 模型中，当用户线程发起一个 IO 请求操作，会给对应的 socket 注册一个信号函 数，然后用户线程会继续执行，当内核数据就绪时会发送一个信号给用户线程，用户线程接收到 信号之后，便在信号函数中调用 IO 读写操作来进行实际的 IO 请求操作。
异步 IO 模型
异步 IO 模型才是最理想的 IO 模型，在异步 IO 模型中，当用户线程发起 read 操作之后，立刻就 可以开始去做其它的事。而另一方面，从内核的角度，当它受到一个 asynchronous read 之后， 它会立刻返回，说明 read 请求已经成功发起了，因此不会对用户线程产生任何 block。然后，内 核会等待数据准备完成，然后将数据拷贝到用户线程，当这一切都完成之后，内核会给用户线程 发送一个信号，告诉它 read 操作完成了。也就说用户线程完全不需要实际的整个 IO 操作是如何 进行的，只需要先发起一个请求，当接收内核返回的成功信号时表示 IO 操作已经完成，可以直接去使用数据了。
也就说在异步 IO 模型中，IO 操作的两个阶段都不会阻塞用户线程，这两个阶段都是由内核自动完 成，然后发送一个信号告知用户线程操作已完成。用户线程中不需要再次调用 IO 函数进行具体的 读写。这点是和信号驱动模型有所不同的，
JAVA IO 包
JAVA NIO
NIO 主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector。
传统 IO 基于字节流和字 符流进行操作，而 NIO 基于 Channel 和 Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区 中，或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通道的事件（比如：连接打开， 数据到达）。因此，单个线程可以监听多个数据通道。
NIO 和传统 IO 之间第一个最大的区别是，IO 是面向流的，NIO 是面向缓冲区的。
NIO 的缓冲区
Java IO 面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何 地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓 存到一个缓冲区。NIO 的缓冲导向方法不同。数据读取到一个它稍后处理的缓冲区，需要时可在 缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所 有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。
NIO 的非阻塞
IO 的各种流是阻塞的。这意味着，当一个线程调用 read() 或 write()时，该线程被阻塞，直到有 一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。NIO 的非阻塞模式， 使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可 用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以 继续做其他的事情。
非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它 完全写入，这个线程同时可以去做别的事情。线程通常将非阻塞 IO 的空闲时间用于在其它通道上 执行 IO 操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。
Channel
首先说一下 Channel，国内大多翻译成“通道”。Channel 和 IO 中的 Stream(流)是差不多一个 等级的。只不过 Stream 是单向的，譬如：InputStream, OutputStream，而 Channel 是双向 的，既可以用来进行读操作，又可以用来进行写操作。
NIO 中的 Channel 的主要实现有：
FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel
这里看名字就可以猜出个所以然来：分别可以对应文件 IO、UDP 和 TCP（Server 和 Client）。下面演示的案例基本上就是围绕这 4 个类型的 Channel 进行陈述的。
Buffer
Buffer，故名思意，缓冲区，实际上是一个容器，是一个连续数组。Channel 提供从文件、 网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer。
上面的图描述了从一个客户端向服务端发送数据，然后服务端接收数据的过程。客户端发送数据时，必须先将数据存入 Buffer 中，然后将 Buffer 中的内容写入通道。服务端这边接收数据必 须通过 Channel 将数据读入到 Buffer 中，然后再从 Buffer 中取出数据来处理。
在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类，常用的 Buffer 的子类有：ByteBuffer、IntBuffer、 CharBuffer、 LongBuffer、 DoubleBuffer、FloatBuffer、 ShortBuffer
Selector
Selector 类是 NIO 的核心类，Selector 能够检测多个注册的通道上是否有事件发生，如果有事 件发生，便获取事件然后针对每个事件进行相应的响应处理。这样一来，只是用一个单线程就可 以管理多个通道，也就是管理多个连接。这样使得只有在连接真正有读写事件发生时，才会调用 函数来进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护 多个线程，并且避免了多线程之间的上下文切换导致的开销。
作者：夏目 链接：
blog.csdn.net/wuzhiwei549/article/details/121913337
推荐阅读 点击标题可跳转
春节后挣一波快钱！Top 19 接私活平台
1月崩3次！再牛逼的系统也挡不住明星的一次出轨
一款简单好用、且永久免费的内网穿透工具
你还在 Docker 中跑 MySQL？恭喜你，可以下岗了！
为了搞定面试，我把 Nginx 核心知识点扒了个底朝天
最新 955 不加班的公司名单（2022版）
PS：因为公众号平台更改了推送规则，如果不想错过内容，记得读完点一下，加个，这样每次新文章推送里。