标签：mutable 运算 listener 本质 object类 这一 静态 替换 固定
看到一篇不错的java面试题的文章，自己整理一下，作为备用吧！
封装
最常见的是把属性私有化封装在一个类里面，只能通过方法去访问
继承
子类继承父类，从而继承了父类的方法和属性
抽象
比如一个英雄类，抽象出了name,hp这些属性，使得开发过程中更加易于理解
多态
多态分操作符的多态和类的多态。 类的多态指父类引用指向子类对象，并且有继承，有重写。
String是类类型，不是基本类型。
基本类型有八种: 整型 （4种）字符型 （1种）浮点型 （2种）布尔型（1种）
int 是基本类型32位长度的整数,而Integer 是类类型，是int的封装类
int和Integer之间可以通过自动装箱、自动拆箱互相转换
String是immutable的,其内容一旦创建好之后，就不可以发生改变。
StringBuffer 是可以变长的，内容也可以发生改变 改变的原理是StringBuffer内部采用了字符数组存放数据，在需要增加长度的时候，创建新的数组，并且把原来的数据复制到新的数组这样的办法来实现。
运行时异常 又叫做非可查异常，在编译过程中，不要求必须进行显示捕捉
一般异常又叫做可查异常，在编译过程中，必须进行处理，要么捕捉，要么通过throws 抛出去.是如何实现的。
ArrayList和Vector
两者都继承了抽象类AbstractList，但是Vector是线程安全的，而ArrayList是非线程安全的
ArrayList和LinkedList的区别
ArrayList 是数组结构，所以定位很快，但是插入和删除很慢 LinkedList 是双向链表结构，所以插入和删除很快，但是定位很慢
首先不要说成了一个是单数，一个是复数。。。
Collection是接口，是List和Set的父接口
Collections是工具类，提供了排序，混淆等等很多实用方法
& 有两个作用，分别是 位与 和 逻辑与,&& 就是逻辑与,作为逻辑与， & 和 && 分别表示长路与和短路与
长路与 两侧，都会被运算 短路与 只要第一个是false，第二个就不进行运算了
HashMap和Hashtable都实现了Map接口，都是键值对保存数据的方式
区别1：
HashMap可以存放 null Hashtable不能存放null
区别2：
HashMap不是线程安全的类 Hashtable是线程安全的类
final
final修饰类，方法，基本类型变量，引用的时候分别有不同的意思 修饰类 表示该类不能被继承 修饰方法 表示该方法不能被重写 修饰基本类型变量 表示该变量只能被赋值一次 修饰引用 表示该引用只有一次指向对象的机会
finally
finally 是用于异常处理的场面，无论是否有异常抛出，都会执行
finalize
finalize是Object的方法，所有类都继承了该方法。 当一个对象满足垃圾回收的条件，并且被回收的时候，其finalize()方法就会被调用
Overload是方法重载的意思，指的是在同一个类里面，方法名一样，但是参数不一样
Override是方法重写的意思，指的是子类继承了父类的某个方法后，重新又写了一遍
Overloaded的方法是否可以改变返回值的类型?
可以，重载其实本质上就是完全不同的方法，只是恰好取了相同的名字
Error和Exception都实现了Throwable接口
Error指的是JVM层面的错误，比如内存不足OutOfMemoryError
Exception 指的是代码逻辑的异常，比如下标越界OutOfIndexException
abstract class 抽象类和interface接口的区别
使用方式：
抽象类只能够通过继承被使用 接口必须通过实现被使用
实现方法：
抽象类不仅可以提供抽象方法，也可以提供实现方法 接口只能提供抽象方法，不能提供实现方法。 但是在JAVA8版本开始，接口可以提供实现方法了，前提是要在方法前加一个default修饰符
heap: 堆
stack: 栈 (在一些书籍里，会被翻译为堆栈，实际上指的就是单纯的这个栈)
存放的内容不一样：
heap: 是存放对象的 stack: 是存放基本类型(int, float, boolean 等等)、引用(对象地址)、方法调用
存取方式不一样：
heap: 是自动增加大小的，所以不需要指定大小，但是存取相对较慢 stack: 是固定大小的，并且是FILO 先入后出的顺序，并且存取速度比较快
GC是Garbage Collection的缩写，即垃圾回收 这里所谓的垃圾，指的是那些不再被使用的对象，JVM的垃圾回收机制使得开发人员从无聊、容易犯错的手动释放内存资源的过程中解放出来。 开发人员可以更加专注的进行业务功能的开发，而资源回收的工作交由更加专业的垃圾回收机制自动完成。
1 short s1 = 1; //这一句没有错误，编译器会自动把1这个整数处理为short. 2 s1 = s1 + 1; //右侧的表达式会返回一个Int类型的整数，再把这个int类型的整数赋给short类型的s1的时候，就会出现强制转换错误
1 Math.round 的意思是+0.5 取整数 2 所以 Math.round(11.5) 即 11.5+0.5 = 12 3 Math.round(-11.5) 即 -11.5+0.5 = -11
String s = new String("xyz");
首先构造方法 new String("xyz"); 中的"xyz" 这本身就是一个字符串对象 然后 new 关键字一定会创建一个对象 所以总共创建了两个String对象
有,goto是关键字，但是是保留字，并不具备功能性
接口是否可继承接口?
可以，比如List 就继承了接口Collection
抽象类是否可实现(implements)接口?
可以，比如 MouseAdapter鼠标监听适配器 是一个抽象类，并且实现了MouseListener接口
抽象类是否可继承实体类（concrete class）？
可以，所有抽象类，都继承了Object
List 和 Set 继承了Collection接口
但是Map和Collection之间没有继承关系，因为一个是键值对容器，一个是单值容器，无法兼容
abstract的method是否可同时是static,是否可同时是synchronized？
都不可以
数组获取长度的手段是 .length 属性
String获取长度的手段是 length()方法
集合获取长度的手段是 size()方法
文件获取长度的手段是 length()方法
以HashSet为例，判断重复的逻辑是：
首先看hashcode是否相同，如果不同，就是不重复的
如果hashcode一样，再比较equals，如果不同，就是不重复的，否则就是重复的。
子类不能继承父类的构造方法，所以就不存在重写父类的构造方法。 注： super() 表示子类调用父类的构造方法，这不能被叫做继承父类的构造方法
String是final修饰的，所以不能够被继承
switch 可以作用在 byte,short,int String,Enum(枚举) 上，但是不能作用在long上面
注：switch 作用在String上从JDK1.7开始支持，实质是编译时将字符串替换为了其对应的hash值
try里的return 和 finally里的return 都会执行，但是当前方法只会采纳finally中return的值
因为hashCode()方法和equals()方法都可以通过自定义类重写，是可以做到equals相同，但是hashCode不同的
但是，在Object类的equals()方法中有这么一段话
1 * Note that it is generally necessary to override the {@code hashCode} 2 * method whenever this method is overridden, so as to maintain the 3 * general contract for the {@code hashCode} method, which states 4 * that equal objects must have equal hash codes.
翻译如下：
通常来讲，在重写这个方法的时候，也需要对hashCode方法进行重写，
以此来保证这两个方法的一致性——
当equals返回true的时候，这两个对象一定有相同的hashcode.
两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
所以这个题的答案应该是否定的，但是得搞清楚里面的原委
与C语言开发人员需要手动进行内存资源的释放不同，Java提供垃圾回收机制，自动进行GC，将开发人员从容易犯错的内存资源管理中解放出来。
原理：当某个一个对象，没有任何引用指向它的时候，那么它就满足垃圾回收的条件，在适当的时候，JVM虚拟机进行GC将其回收，释放空间，以供后续再利用。
两种常见的回收机制：
定时回收 每隔30分钟进行一次回收，这种机制的弊端是如果垃圾产生的比较快，有可能30分钟之内垃圾已经把内存占用光了，导致性能变慢
当垃圾占到某个百分比的时候，进行回收 比如，当垃圾占到70%的时候，进行回收。 这种机制的弊端是，如果垃圾产生的频率很快，那么JVM就必须高频率的进行垃圾回收。 而在垃圾回收的过程中， JVM会停顿下来，只做垃圾回收，而影响业务功能的正常运行。
一般说来 JVM会采用两种机制结合的方式进行垃圾回收。
1 常见的集合 2 ArrayList,LinkedList,HashSet,HashMap,TreeSet 等等 3 常见方法： 4 size() 5 add() 6 remove() 7 等等
char是16位的，占两个字节 汉字通常使用GBK或者UNICODE编码，也是使用两个字节 所以可以存放汉字
主要是两种，SAX和DOM:
SAX 就是逐行读取，直到找到目标数据为止
DOM 是先全文档加载，然后读取
throws 用在方法声明上面，表示该方法有可能抛出某个异常
throw 抛出一个指定的异常
try catch 在try中有可能会抛出某个异常，一旦某个异常抛出后，就会在catch中进行捕捉，他俩一般说来都是成对出现的。
finally: 表示无论是否捕捉住异常，都会执行
可以包括多个类，但是只能出现一个public修饰的类，但是可以出现多个非public修饰的类。
Java中所有的流都是基于字节流，所以最基本的流是
输入输出字节流
InputStream OutputStream
在字节流的基础上，封装了字符流
Reader Writer
进一步，又封装了缓存流
BufferedReader PrintWriter
以及数据流
DataInputStream DataOutputStream
对象流
ObjectInputStream ObjectOutputStream
以及一些其他的奇奇怪怪的流 ~~~
因为Java是自动进行垃圾回收管理的，所以不存在 C语言中同等概念的内存泄漏，但是存在Java特色的内存泄漏
当某些对象不被使用，但是又有非直接引用指向的时候，那么就不满足垃圾回收的条件，而形成内存泄漏。
比如代码中的例子，每个Object创建的时候，有一个引用o指向，接着就被放进了集合al中。 下一个Object创建的时候，上一个Object就没有引用指向了。
这些Object都没有引用指向，但是却放在ArrayList中，而这个Arraylist忘记了回收，那么里面的所有对象，都会一直存活下去，虽然不再被使用了。
1 package exercise; 2 3 import java.util.ArrayList; 4 5 public class MemoryLeak { 6 static ArrayList<Object> al = new ArrayList<Object>(); 7 8 public static void main(String[] args) { 9 10 for (int i = 0; i < 100; i++) { 11 Object o = new Object(); 12 al.add(o); 13 } 14 15 } 16 }
类的多态的条件：
父类（接口）引用指向子类对象
方法有重写
静态变量 直接通过类就可以访问，无需实例
实例变量 比如通过类的某个具体实例，才可以访问
序列化指的是把一个Java对象，通过某种介质进行传输，比如Socket输入输出流，或者保存在一个文件里
实现java序列化的手段是让该类实现接口 Serializable，这个接口是一个标识性接口，没有任何方法，仅仅用于表示该类可以序列化。
不行，因为非static方法需要一个具体的实例才可以调用，而调用 static方法的时候，不一定存在一个实例
在外部循环的前一行，加上标签
即能达到结束多重嵌套循环的效果
1 public class HelloWorld { 2 public static void main(String[] args) { 3 //打印单数 4 outloop: //outloop这个标示是可以自定义的比如outloop1,ol2,out5 5 for (int i = 0; i < 10; i++) { 6 for (int j = 0; j < 10; j++) { 7 System.out.println(i+":"+j); 8 if(0==j%2) 9 break outloop; //如果是双数，结束外部循环 10 } 11 } 12 } 13 }
参考源：
标签：mutable 运算 listener 本质 object类 这一 静态 替换 固定
原文地址：https://www.cnblogs.com/jeemia/p/10682417.html
