（一）重载和重写
重载（overload）：发生在同一个类中，方法名必须相同，参数类型、个数、顺序不同，方法返回值和访问修饰符可以不同有也可以相同，发生在编译时。
重写（Override）：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类；如果父类方法访问修饰符为private则子类中就不是重写。
（二）构造器Constructor是否可被override（重写）
构造器不可以被重写，不能被static修饰，只能用public、private、protected这三个修饰符修饰，而且不能有返回语句。
（三）访问控制符public、private、protected
public：如果一个类被声明为公共类，表明它可以被所有的其它类所访问和引用。
private：用 private 修饰的成员变量 ( 域 ) 只有该类本身能够范文
protected：用 protected 修饰的成员变量可以被三种类所引用：1、该类本身；2，与他在同一个包中的其他类；3,、在其他包中该类的子类
缺省访问控制符：如果一个类没有访问控制符，说明它具有缺省的访问控制符特性。此时，这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。
（四）是否可以继承String类
不可以，因为String类是final类（public final class String extends Object），故不可以被继承，一切由final修饰过的都不能被继承
（五）String和StringBuffer和StringBuilder的区别
1、可变性：
String类中使用字符数组保存字符串，private final char value[]，所以string对象是不可变的。
StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，char[] value，这两种对象都是可变的。
2、线程安全性：
String中的对象是不可变的，也就可以理解为常量，线程安全。
AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。
StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。
StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
3、性能：
每次对String 类型进行改变的时候，都会生成一个新的String 对象，然后将指针指向新的String 对象。
StringBuffer每次都会对StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。
StirngBuilder 相比使用 StringBuffer 仅能获得10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
4、三者在执行速度方面的比较：StringBuilder > StringBuffer > String
String：字符串常量
StringBuffer：字符串变量
StringBuilder：字符串变量
从上面的名字可以看到，String是“字符串常量”，也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问 ，比如这段代码：
1 String s = "abcd"; 2 s = s+1; 3 System.out.print(s);// result : abcd1
我们明明就是改变了String型的变量s的，为什么说是没有改变呢? 其实这是一种欺骗，JVM是这样解析这段代码的：首先创建对象s，赋予一个abcd，然后再创建一个新的对象s用来 执行第二行代码，也就是说我们之前对象s并没有变化，所以我们说String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，可想而知这样执行效率会有多底。
而StringBuffer与StringBuilder就不一样了，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，这样就不会像String一样创建一些而外的对象进行操作了，当然速度就快了。
一个特殊的例子：
1 String str = “This is only a” + “ simple” + “ test”; 2 StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
你会很惊讶的发现，生成str对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏，实际上：
String str = “This is only a” + “ simple” + “test”;
其实就是：
String str = “This is only a simple test”;
所以不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String对象的话，速度就没那么快了，譬如：
String str2 = “This is only a”;
String str3 = “ simple”;
String str4 = “ test”;
String str1 = str2 +str3 + str4;
这时候JVM会规规矩矩的按照原来的方式去做。
对于三者使用的总结： 1.如果要操作少量的数据用 = String
2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
（六）hashCode和equals方法的关系
equals相等，hashcode必相等；hashcode相等，equals可能不相等。
1、equals的作用
默认情况下（没有覆盖equals方法）下，equals方法都是调用Object类的equals方法，而Object类的equals方法主要是用于判断对象的内存地址引用是不是同一个地址（是不是同一个对象）
要是类中覆盖了equals方法，那么就要根据具体的代码来确定equals方法的作用了，覆盖后一般都是通过对象的内容是否相等来判断对象是否相等
2、以下是关于HashCode的官方文档定义：http://blog.csdn.net/fenglibing/article/details/8905007/
1 hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点，例如，java.util.Hashtable 提供的哈希表。 2 3 hashCode 的常规协定是： 4 在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。 5 如果根据 equals(Object) 方法，两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。 6 以下情况不 是必需的：如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。 7 实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧。） 8 9 当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
以上这段官方文档的定义，我们可以抽出成以下几个关键点：
1、hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的；
2、如果两个对象相同，就是适用于equals(Java.lang.Object) 方法，那么这两个对象的hashCode一定要相同；
3、如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第2点；
4、两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals(java.lang.Object) 方法，只能够说明这两个对象在散列存储结构中，如Hashtable，他们“存放在同一个篮子里”。
再归纳一下就是hashCode是用于查找使用的，而equals是用于比较两个对象的是否相等的。以下这段话是从别人帖子回复拷贝过来的：
1 1.hashcode是用来查找的，如果你学过数据结构就应该知道，在查找和排序这一章有 2 例如内存中有这样的位置 3 0 1 2 3 4 5 6 7 4 而我有个类，这个类有个字段叫ID,我要把这个类存放在以上8个位置之一，如果不用hashcode而任意存放，那么当查找时就需要到这八个位置里挨个去找，或者用二分法一类的算法。 5 但如果用hashcode那就会使效率提高很多。 6 我们这个类中有个字段叫ID,那么我们就定义我们的hashcode为ID％8，然后把我们的类存放在取得得余数那个位置。比如我们的ID为9，9除8的余数为1，那么我们就把该类存在1这个位置，如果ID是13，求得的余数是5，那么我们就把该类放在5这个位置。这样，以后在查找该类时就可以通过ID除 8求余数直接找到存放的位置了。 7 8 2.但是如果两个类有相同的hashcode怎么办那（我们假设上面的类的ID不是唯一的），例如9除以8和17除以8的余数都是1，那么这是不是合法的，回答是：可以这样。那么如何判断呢？在这个时候就需要定义 equals了。 9 也就是说，我们先通过 hashcode来判断两个类是否存放某个桶里，但这个桶里可能有很多类，那么我们就需要再通过 equals 来在这个桶里找到我们要的类。 10 那么。重写了equals()，为什么还要重写hashCode()呢？ 11 想想，你要在一个桶里找东西，你必须先要找到这个桶啊，你不通过重写hashcode()来找到桶，光重写equals()有什么用啊
（七）自动装箱和拆箱
装箱：将基本类型用它们对应的引用类型包装起来；
拆箱：将包装类型转换为基本数据类型；
因为这里的装箱和拆箱是自动进行的非人为转换，所以就称作为自动装箱和拆箱
Java使用自动装箱和拆箱机制，节省了常用数值的内存开销和创建对象的开销，提高了效率，由编译器来完成，编译器会在编译期根据语法决定是否进行装箱和拆箱动作
原始类型：byte，short， char， int， long， float，double， boolean
引用类型：Byte，Short，Character，Integer，Long， Float，Double， Boolean。
（八）什么是泛型？为什么要使用泛型，泛型的擦除
泛型，即“参数化类型”。
创建集合时就指定集合元素的类型，该集合只能保存其指定类型的元素，避免使用强制类型转换。
Java编译器生成的字节码是不包涵泛型信息的，泛型类型信息将在编译处理是被擦除，这个过程即类型擦除。泛型擦除可以简单的理解为将泛型java代码转换为普通java代码，只不过编译器更直接点，将泛型java代码直接转换成普通java字节码。
类型擦除的主要过程如下：
1）.将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。
2）.移除所有的类型参数。
（九）JAVA中的集合类以及关系图
大致讲解java集合的体系结构
List、Set、Map是这个集合体系中最主要的三个接口。
其中List和Set继承自Collection接口。
Set不允许元素重复。HashSet和TreeSet是两个主要的实现类。
List有序且允许元素重复。ArrayList、LinkedList和Vector是三个主要的实现类。
Map也属于集合系统，但和Collection接口不同。Map是key对value的映射集合，其中key列就是一个集合。key不能重复，但是value可以重复。HashMap、TreeMap和Hashtable是三个主要的实现类。
SortedSet和SortedMap接口对元素按指定规则排序，SortedMap是对key列进行排序。
发现一个特点，上述所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含hashNext(),next(),remove()三种方法。它的一个子接口LinkedIterator在它的基础上又添加了三种方法，分别是add(),previous(),hasPrevious()。也就是说如果是先Iterator接口，那么在遍历集合中元素的时候，只能往后遍历，被遍历后的元素不会在遍历到，通常无序集合实现的都是这个接口，比如HashSet，HashMap；而那些元素有序的集合，实现的一般都是LinkedIterator接口，实现这个接口的集合可以双向遍历，既可以通过next()访问下一个元素，又可以通过previous()访问前一个元素，比如ArrayList。
（十）HashMap实现原理
http://www.cnblogs.com/wangleBlogs/p/7358660.html
HashMap的工作原理
HashMap基于hashing原理，（1）我们通过put()和get()方法储存和获取对象。当我们将键值对传递给put()方法时，它调用键对象的hashCode()方法来计算hashcode，让后找到bucket位置来储存值对象。当获取对象时，通过键对象的equals()方法找到正确的键值对，然后返回值对象。（2）HashMap使用LinkedList解决碰撞问题，当发生碰撞了，对象将会储存在LinkedList的下一个节点中。 HashMap在每个LinkedList节点中储存键值对对象。（3）当两个不同的键对象的hashcode相同时会发生什么？ 它们会储存在同一个bucket位置的LinkedList中。键对象的equals()方法用来找到键值对。
因为HashMap的好处非常多，我曾经在电子商务的应用中使用HashMap作为缓存。因为金融领域非常多的运用Java，也出于性能的考虑，我们会经常用到HashMap和ConcurrentHashMap。你可以查看更多的关于HashMap和HashTable的文章。
归纳起来简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据hash算法来决定其在数组中的存储位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Entry。
（11）HashTable实现原理
HashTable与Map的关系
从图中可以看出：
(01) Hashtable继承于抽象的Dictionary类，实现了Map接口。Map是"key-value键值对"接口，Dictionary是声明了操作"键值对"函数接口的抽象类。
(02) Hashtable是通过"拉链法"实现的哈希表。它包括几个重要的成员变量：table, count, threshold, loadFactor, modCount。
table是一个Entry[]数组类型，而Entry实际上就是一个单向链表。哈希表的"key-value键值对"都是存储在Entry数组中的。
count是Hashtable的大小，它是Hashtable保存的键值对的数量。
threshold是Hashtable的阈值，用于判断是否需要调整Hashtable的容量。threshold的值="容量*加载因子"。
loadFactor就是加载因子。
modCount是用来实现fail-fast机制的
第二步：通过Iterator迭代器遍历“第一步”得到的集合。
1 // 假设table是Hashtable对象 2 // table中的key是String类型，value是Integer类型 3 Integer integ = null; 4 Iterator iter = table.entrySet().iterator(); 5 while(iter.hasNext()) { 6 Map.Entry entry = (Map.Entry)iter.next(); 7 // 获取key 8 key = (String)entry.getKey(); 9 // 获取value 10 integ = (Integer)entry.getValue(); 11 }
第二步：通过Iterator迭代器遍历“第一步”得到的集合。
1 // 假设table是Hashtable对象 2 // table中的key是String类型，value是Integer类型 3 String key = null; 4 Integer integ = null; 5 Iterator iter = table.keySet().iterator(); 6 while (iter.hasNext()) { 7 // 获取key 8 key = (String)iter.next(); 9 // 根据key，获取value 10 integ = (Integer)table.get(key); 11 }
第二步：通过Iterator迭代器遍历“第一步”得到的集合。
// 假设table是Hashtable对象 // table中的key是String类型，value是Integer类型 Integer value = null; Collection c = table.values(); Iterator iter= c.iterator(); while (iter.hasNext()) { value = (Integer)iter.next(); }
第二步：通过Enumeration遍历“第一步”得到的集合。
Enumeration enu = table.keys(); while(enu.hasMoreElements()) { System.out.println(enu.nextElement()); }
（12）HashMap和HashTable的区别
1）.HashTable的方法前面都有synchronized来同步，是线程安全的；HashMap未经同步，是非线程安全的。
2）.HashTable不允许null值(key和value都不可以) ；HashMap允许null值(key和value都可以)。
3）.HashTable有一个contains(Object value)功能和containsValue(ObjectValue）功能一样。
4）.HashTable使用Enumeration进行遍历；HashMap使用Iterator进行遍历。
5）.HashTable中hash数组默认大小是11，增加的方式是old*2+1；HashMap中hash数组的默认大小是16，而且一定是2的指数（2的n次方）。
6）.哈希值的使用不同，HashTable直接使用对象的hashCode； HashMap重新计算hash值，而且用与代替求模。
（13）ArrayList和 Vector的区别
ArrayList和Vector都实现了List接口，都是通过数组实现的。
Vector是线程安全的，而ArrayList是非线程安全的。
List第一次创建的时候，会有一个初始大小，随着不断向List中增加元素，当List 认为容量不够的时候就会进行扩容。Vector缺省情况下自动增长原来一倍的数组长度，ArrayList增长原来的50%。
（14）ArrayLsit和LinkedList的区别以及使用的场景
区别
ArrayList底层是用数组实现的，可以认为ArrayList是一个可改变大小的数组。随着越来越多的元素被添加到ArrayList中，其规模是动态增加的。
LinkedList底层是通过双向链表实现的， LinkedList和ArrayList相比，增删的速度较快。但是查询和修改值的速度较慢。同时，LinkedList还实现了Queue接口，所以他还提供了offer(),
peek(), poll()等方法。
使用场景
LinkedList更适合从中间插入或者删除（链表的特性）。
ArrayList更适合检索和在末尾插入或删除（数组的特性）。
（15）Collecton和Colections的区别
Collection是集合类的上级接口，它提供了对集合对象进行基本操作的通用接口方法。继承与他有关的接口主要有List和Set,Map
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作
java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。
1 public static void main(String args[]) { 2 //注意List是实现Collection接口的 3 List list = new ArrayList(); 4 double array[] = { 112, 111, 23, 456, 231 }; 5 for (int i = 0; i < array.length; i++) { 6 list.add(new Double(array[i])); 7 } 8 Collections.sort(list); //把list按从小到大排序 9 for (int i = 0; i < array.length; i++) { 10 System.out.println(list.get(i)); 11 } 12 // 结果：23.0 111.0 112.0 231.0 456.0 13 }
然后还有混排（Shuffling）、反转（Reverse）、替换所有的元素（fill）、拷贝（copy）、返回Collections中最小元素（min）、返回Collections中最大元素（max）、返回指定源列表中最后一次出现指定目标列表的起始位置（lastIndexOfSubList）、返回指定源列表中第一次出现指定目标列表的起始位置（IndexOfSubList）、根据指定的距离循环移动指定列表中的元素（Rotate）
（16）ConcurrentHashMap的原理----了解甚少
http://ifeve.com/concurrenthashmap/
http://www.cnblogs.com/ITtangtang/p/3948786.html
ConcurrentHashMap的锁分段技术：
HashTable容器在竞争激烈的并发环境下表现出效率低下的原因，是因为所有访问HashTable的线程都必须竞争同一把锁，那假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术，首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。
（17）Error、Exception的区别
二者的不同之处：
Exception：
1．可以是可被控制(checked) 或不可控制的(unchecked)
2．表示一个由程序员导致的错误
3．应该在应用程序级被处理
Error：
1．总是不可控制的(unchecked)
2．经常用来用于表示系统错误或低层资源的错误
3．如何可能的话，应该在系统级被捕捉
Error类和Exception类的父类都是throwable类，他们的区别是：
Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。
Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
Exception类又分为运行时异常（Runtime Exception）和受检查的异常(Checked Exception )
运行时异常;ArithmaticException,IllegalArgumentException，当出现这样的异常时，总是由虚拟机 接管。比如：我们从来没有人去处理过 NullPointerException 异常，它就是运行时异常，并且这种异常还是最常见的异常之一。，编译能通过，但是一运行就终止了，程序不会处理运行时异常，出现这类异常，程序会终止。
受检查的异常（ IO 异常，以及 SQL 异常都是这种异常），要么用try。。。catch捕获，要么用throws字句声明抛出，交给它的父类处理，否则编译不会通过。
异常有两个过程，一个是抛出异常；一个是捕捉异常。
抛出异常：抛出异常有三种形式，1：throw；2：throws，3：系统自动抛异常。下面它们之间的异同。
1、row是语句抛出一个异常。
语法：throw (异常对象) 如： throw e; 一般会用于程序出现某种逻辑时程序员主动抛出某种特定类型的异常。如：
1 public static void main(String[] args) { 2 String s = "abc"; 3 if(s.equals("abc")) { 4 throw new NumberFormatException(); 5 } else { 6 System.out.println(s); 7 } 8 //function(); 9 }
会抛出异常：
Exception in thread "main" java.lang.NumberFormatException
at test.ExceptionTest.main(ExceptionTest.java:67)
2、throws：throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)
语法：[(修饰符)](返回值类型)(方法名)([参数列表])[throws(异常类)]{......}
如： public void function() throws Exception{......}
当某个方法可能会抛出某种异常时用于throws 声明可能抛出的异常，然后交给上层调用它的方法程序处理。如：
1 public static void function() throws NumberFormatException{ 2 String s = "abc"; 3 System.out.println(Double.parseDouble(s)); 4 } 5 6 public static void main(String[] args) { 7 try { 8 function(); 9 } catch (NumberFormatException e) { 10 System.err.println("非数据类型不能转换。"); 11 //e.printStackTrace(); 12 } 13 }
处理结果如下：
非数据类型不能转换
3、系统自动抛出异常：当程序语句出现一些逻辑错误、主义错误或类型转换错误时，系统会自动抛出异常。如：
1 public static void main(String[] args) { 2 int a = 5, b =0; 3 System.out.println(5/b); 4 //function(); 5 }
系统会自动抛出ArithmeticException异常：
Exception in thread "main" java.lang.ArithmeticException: / by zero
at test.ExceptionTest.main(ExceptionTest.java:62)
再例如：
1 public static void main(String[] args) { 2 String s = "abc"; 3 System.out.println(Double.parseDouble(s)); 4 //function(); 5 }
系统会自动抛出NumberFormatException异常：
Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"
at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1224)
at java.lang.Double.parseDouble(Double.java:510)
at test.ExceptionTest.main(ExceptionTest.java:62)
throw与throws的比较
1、throws出现在方法函数头；而throw出现在函数体。
2、throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。
3、两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。
好的编程习惯：
1.在写程序时，对可能会出现异常的部分通常要用try{...}catch{...}去捕捉它并对它进行处理；
2.用try{...}catch{...}捕捉了异常之后一定要对在catch{...}中对其进行处理，那怕是最简单的一句输出语句，或栈输入e.printStackTrace();
3.如果是捕捉IO输入输出流中的异常，一定要在try{...}catch{...}后加finally{...}把输入输出流关闭；
4.如果在函数体内用throw抛出了某种异常，最好要在函数名中加throws抛异常声明，然后交给调用它的上层函数进行处理
（18）（不可检查的异常）Unchecked Exception 和（可检查的异常）Checked Exception
Unchecked Exception：（1）Error和Runtime Exception及其子类，例如OutOfMemoryError、UndeclaredThrowableException、 IllegalArgumentException、IllegalMonitorStateException, NullPointerException, IllegalStateException、IndexOutOfBoundsException等。
2）. 指的是程序的瑕疵或逻辑错误，并且在运行时无法恢复。
3）语法上不需要声明抛出异常。
CheckedException：是需要强制catch的异常，你在调用这个方法的时候，你如果不catch这个异常，那么编译器就会报错，比如说我们读写文件的时候会catch IOException，执行数据库操作会有SQLException等