2015笔试面试经验——java基础

1. 九种基本数据类型的大小，以及他们的封装类。html

2. Switch可否用string作参数？前端

答案：在Java语言中Swith可使用参数类型有：Only convertible int values, strings or enum variables are permittedjava

　　　能够自动转换为整型的（byte,short,int）,String类型，枚举类型。python

　　　Java中不能作为Switch参数的有boolean，float,double,long(不能直接转换为int啊)。android

3. equals与==的区别。ios

　　http://www.cnblogs.com/zhxhdean/archive/2011/03/25/1995431.htmlweb

　　http://www.cnblogs.com/zhxhdean/archive/2011/03/26/1996468.html面试

4. Object有哪些公用方法？算法

clone、equals、finalize、getClass、hashCode、notify、notifyAll、toString、wait。segmentfault

5. Java的四种引用，强弱软虚，用到的场景。

强引用：强引用不会被GC回收，而且在java.lang.ref里也没有实际的对应类型，平时工做接触的最多的就是强引用。
　　　 Object obj = new Object();这里的obj引用即是一个强引用。若是一个对象具备强引用，那就相似于必不可少的生活用品，垃圾回收器毫不会回收它。　　当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具备强引用的对象来解决内存不足问题。

软引用：若是一个对象只具备软引用，那就相似于可有可物的生活用品。若是内存空间足够，垃圾回收器就不会回收它，若是内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就能够被程序使用。软引用可用来实现内存敏感的高速缓存。软引用能够和一个引用队列（ReferenceQueue）联合使用，若是软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

弱引用：

弱引用（weak reference）在强度上弱于软引用，经过类WeakReference来表示。它的做用是引用一个对象，可是并不阻止该对象被回收。若是使用一个强引用的话，只要该引用存在，那么被引用的对象是不能被回收的。弱引用则没有这个问题。在垃圾回收器运行的时候，若是一个对象的全部引用都是弱引用的话，该对象会被回收。弱引用的做用在于解决强引用所带来的对象之间在存活时间上的耦合关系。弱引用最多见的用处是在集合类中，尤为在哈希表中。哈希表的接口容许使用任何Java对象做为键来使用。当一个键值对被放入到哈希表中以后，哈希表对象自己就有了对这些键和值对象的引用。若是这种引用是强引用的话，那么只要哈希表对象自己还存活，其中所包含的键和值对象是不会被回收的。若是某个存活时间很长的哈希表中包含的键值对不少，最终就有可能消耗掉JVM中所有的内存。

对于这种状况的解决办法就是使用弱引用来引用这些对象，这样哈希表中的键和值对象都能被垃圾回收。Java中提供了WeakHashMap来知足这一常见需求。

虚引用：

在介绍幽灵引用以前，要先介绍Java提供的对象终止化机制（finalization）。在Object类里面有个finalize方法，其设计的初衷是在一个对象被真正回收以前，能够用来执行一些清理的工做。由于Java并无提供相似C++的析构函数同样的机制，就经过 finalize方法来实现。可是问题在于垃圾回收器的运行时间是不固定的，因此这些清理工做的实际运行时间也是不能预知的。幽灵引用（phantom reference）能够解决这个问题。在建立幽灵引用PhantomReference的时候必需要指定一个引用队列。当一个对象的finalize方法已经被调用了以后，这个对象的幽灵引用会被加入到队列中。经过检查该队列里面的内容就知道一个对象是否是已经准备要被回收了。

幽灵引用及其队列的使用状况并很少见，主要用来实现比较精细的内存使用控制，这对于移动设备来讲是颇有意义的。程序能够在肯定一个对象要被回收以后，再申请内存建立新的对象。经过这种方式可使得程序所消耗的内存维持在一个相对较低的数量。

6. Hashcode的做用。

快速定位。

7. ArrayList、LinkedList、Vector的区别。

LinkedList类
　　LinkedList实现了List接口，容许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操做使LinkedList可被用做堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。若是多个线程同时访问一个List，则必须本身实现访问同步。一种解决方法是在建立List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类
　　ArrayList实现了可变大小的数组。它容许全部元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。可是add方法开销为分摊的常数，添加n个元素须要O(n)的时间。其余的方法运行时间为线性。
　　每一个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增长，可是增加算法并无定义。当须要插入大量元素时，在插入前能够调用ensureCapacity方法来增长ArrayList的容量以提升插入效率。
　　和LinkedList同样，ArrayList也是非同步的（unsynchronized）。

Vector类
　　Vector很是相似ArrayList，可是Vector是同步的。由Vector建立的Iterator，虽然和ArrayList建立的Iterator是同一接口，可是，由于Vector是同步的，当一个Iterator被建立并且正在被使用，另外一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，所以必须捕获该异常。

8. String、StringBuffer与StringBuilder的区别。

String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）

简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 所以在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，而后将指针指向新的 String 对象，因此常常改变内容的字符串最好不要用 String ，由于每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了之后， JVM 的 GC 就会开始工做，那速度是必定会至关慢的。
而若是是使用 StringBuffer 类则结果就不同了，每次结果都会对 StringBuffer 对象自己进行操做，而不是生成新的对象，再改变对象引用。因此在通常状况下咱们推荐使用 StringBuffer ，特别是字符串对象常常改变的状况下。而在某些特别状况下， String 对象的字符串拼接实际上是被 JVM 解释成了 StringBuffer 对象的拼接，因此这些时候 String 对象的速度并不会比 StringBuffer 对象慢。

java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用做 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种状况很广泛）。若是可能，建议优先采用该类，由于在大多数实现中，它比 StringBuffer 要快。二者的方法基本相同。

9. Map、Set、List、Queue、Stack的特色与用法。

10. HashMap和HashTable的区别。

　　1 HashMap不是线程安全的

hastmap是一个接口是map接口的子接口，是将键映射到值的对象，其中键和值都是对象，而且不能包含重复键，但能够包含重复值。HashMap容许null key和null value，而hashtable不容许。

　　2 HashTable是线程安全的一个Collection。

HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap容许空（null）键值（key）,因为非线程安全，效率上可能高于Hashtable。
HashMap容许将null做为一个entry的key或者value，而Hashtable不容许。
HashMap把Hashtable的contains方法去掉了，改为containsvalue和containsKey。由于contains方法容易让人引发误解。
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
最大的不一样是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不须要本身为它的方法实现同步，而HashMap 就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概同样，因此性能不会有很大的差别。

11. HashMap和ConcurrentHashMap的区别，HashMap的底层源码。

　　HashMap是容许插入key和value是null的数据的，而ConcurrentHashMap是不容许key和value是null的。

12. TreeMap、HashMap、LindedHashMap的区别。

13. Collection包结构，与Collections的区别。

　　Collection是集合类的上级接口，子接口主要有Set 和List、Map。

　　Collections是针对集合类的一个帮助类，提供了操做集合的工具方法：一系列静态方法实现对各类集合的搜索、排序、线程安全化等操做。

14. try catch finally，try里有return，finally还执行么？

　　会执行。

15. Excption与Error包结构。OOM你遇到过哪些状况，SOF你遇到过哪些状况。

16. Java面向对象的三个特征与含义。

　　面向对象的三个基本特征是：封装、继承、多态。

17. Override和Overload的含义去区别。

方法的重写(Overriding)和重载(Overloading)是Java多态性的不一样表现。重写(Overriding)是父类与子类之间多态性的一种表现，而重载(Overloading)是一个类中多态性的一种表现。

若是在子类中定义某方法与其父类有相同的名称和参数，咱们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。

若是在一个类中定义了多个同名的方法，它们或有不一样的参数个数或有不一样的参数类型或有不一样的参数次序，则称为方法的重载(Overloading)。不能经过访问权限、返回类型、抛出的异常进行重载.

18. Interface与abstract类的区别。

参数	抽象类	接口
默认的方法实现	它能够有默认的方法实现	接口彻底是抽象的。它根本不存在方法的实现
实现	子类使用extends关键字来继承抽象类。若是子类不是抽象类的话，它须要提供抽象类中全部声明的方法的实现。	子类使用关键字implements来实现接口。它须要提供接口中全部声明的方法的实现
构造器	抽象类能够有构造器	接口不能有构造器
与正常Java类的区别	除了你不能实例化抽象类以外，它和普通Java类没有任何区别	接口是彻底不一样的类型
访问修饰符	抽象方法能够有public、protected和default这些修饰符	接口方法默认修饰符是public。你不可使用其它修饰符。
main方法	抽象方法能够有main方法而且咱们能够运行它	接口没有main方法，所以咱们不能运行它。
多继承	抽象方法能够继承一个类和实现多个接口	接口只能够继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，由于它须要时间去寻找在类中实现的方法。
添加新方法	若是你往抽象类中添加新的方法，你能够给它提供默认的实现。所以你不须要改变你如今的代码。	若是你往接口中添加方法，那么你必须改变实现该接口的类。

19. Static class 与non static class的区别。

http://blog.csdn.net/zhandoushi1982/article/details/8453522

20. java多态的实现原理。

21. 实现多线程的两种方法：Thread与Runable。

http://blog.csdn.net/touch_2011/article/details/6891026

22. 线程同步的方法：sychronized、lock、reentrantLock等。

23. 锁的等级：方法锁、对象锁、类锁。

24. 写出生产者消费者模式。

25. ThreadLocal的设计理念与做用。

26. ThreadPool用法与优点。

27. Concurrent包里的其余东西：ArrayBlockingQueue、CountDownLatch等等。

28. wait()和sleep()的区别。

http://www.cnblogs.com/DreamSea/archive/2012/01/16/SleepAndWaitDifferent.html

29. foreach与正常for循环效率对比。

垃圾回收机制

http://www.cnblogs.com/laoyangHJ/articles/java_gc.html

30. Java IO与NIO。

http://segmentfault.com/q/1010000000314712

31. 反射的做用于原理。

http://www.cnblogs.com/chenliang901114/archive/2013/04/23/javalearner.html

32. 泛型经常使用特色，List<String>可否转为List<Object>。

http://www.zhihu.com/question/19822505

33. 解析XML的几种方式的原理与特色：DOM、SAX、PULL。

34. Java与C++对比。

http://www.weixueyuan.net/view/5944.html

35. Java1.7与1.8新特性。

36. 设计模式：单例、工厂、适配器、责任链、观察者等等。

37. JNI的使用。

Java抽象类与接口的区别

2014/07/16 | 分类：基础技术 | 2 条评论 | 标签：抽象类, 接口

分享到： 60

本文由 ImportNew - jessenpan 翻译自 javacodegeeks。欢迎加入翻译小组。转载请见文末要求。

不少常见的面试题都会出诸如抽象类和接口有什么区别，什么状况下会使用抽象类和什么状况你会使用接口这样的问题。本文咱们将仔细讨论这些话题。

在讨论它们之间的不一样点以前，咱们先看看抽象类、接口各自的特性。

抽象类

抽象类是用来捕捉子类的通用特性的。它不能被实例化，只能被用做子类的超类。抽象类是被用来建立继承层级里子类的模板。以JDK中的GenericServlet为例：

 
           public 
           abstract 
           class 
           GenericServlet  
           implements 
           Servlet, ServletConfig, Serializable { 
          
           // abstract method 
          
           abstract 
           void 
           service(ServletRequest req, ServletResponse res); 
          
           void 
           init() { 
          
           // Its implementation 
          
           } 
          
           // other method related to Servlet 
          
           }

当HttpServlet类继承GenericServlet时，它提供了service方法的实现：

 
           public 
           class 
           HttpServlet  
           extends 
           GenericServlet { 
          
           void 
           service(ServletRequest req, ServletResponse res) { 
          
           // implementation 
          
           } 
          
           protected 
           void 
           doGet(HttpServletRequest req, HttpServletResponse resp) { 
          
           // Implementation 
          
           } 
          
           protected 
           void 
           doPost(HttpServletRequest req, HttpServletResponse resp) { 
          
           // Implementation 
          
           } 
          
           // some other methods related to HttpServlet 
          
           }

接口

接口是抽象方法的集合。若是一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，若是实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能作任何事情。以Externalizable接口为例：

 
           public 
           interface 
           Externalizable  
           extends 
           Serializable { 
          
           void 
           writeExternal(ObjectOutput out)  
           throws 
           IOException; 
          
           void 
           readExternal(ObjectInput in)  
           throws 
           IOException, ClassNotFoundException; 
          
           }

当你实现这个接口时，你就须要实现上面的两个方法：

 
           public 
           class 
           Employee  
           implements 
           Externalizable { 
          
           int 
           employeeId; 
          
           String employeeName; 
          
           @Override 
          
           public 
           void 
           readExternal(ObjectInput in)  
           throws 
           IOException, ClassNotFoundException { 
          
           employeeId = in.readInt(); 
          
           employeeName = (String) in.readObject(); 
          
           } 
          
           @Override 
          
           public 
           void 
           writeExternal(ObjectOutput out)  
           throws 
           IOException { 
          
           out.writeInt(employeeId); 
          
           out.writeObject(employeeName); 
          
           } 
          
           }

抽象类和接口的对比

参数	抽象类	接口
默认的方法实现	它能够有默认的方法实现	接口彻底是抽象的。它根本不存在方法的实现
实现	子类使用extends关键字来继承抽象类。若是子类不是抽象类的话，它须要提供抽象类中全部声明的方法的实现。	子类使用关键字implements来实现接口。它须要提供接口中全部声明的方法的实现
构造器	抽象类能够有构造器	接口不能有构造器
与正常Java类的区别	除了你不能实例化抽象类以外，它和普通Java类没有任何区别	接口是彻底不一样的类型
访问修饰符	抽象方法能够有public、protected和default这些修饰符	接口方法默认修饰符是public。你不可使用其它修饰符。
main方法	抽象方法能够有main方法而且咱们能够运行它	接口没有main方法，所以咱们不能运行它。
多继承	抽象方法能够继承一个类和实现多个接口	接口只能够继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，由于它须要时间去寻找在类中实现的方法。
添加新方法	若是你往抽象类中添加新的方法，你能够给它提供默认的实现。所以你不须要改变你如今的代码。	若是你往接口中添加方法，那么你必须改变实现该接口的类。