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

最新推荐文章于 2024-09-04 22:27:53 发布

weixin_30940783

最新推荐文章于 2024-09-04 22:27:53 发布

阅读量106

点赞数

文章标签：面试 c/c++ java

原文链接：http://www.cnblogs.com/qiuz/p/4856531.html

版权

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

2. Switch能否用string做参数？

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

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

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

3. equals与==的区别。

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

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

4. Object有哪些公用方法？

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

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方法，因此我们不能运行它。
多继承	抽象方法可以继承一个类和实现多个接口	接口只可以继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
添加新方法	如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。	如果你往接口中添加方法，那么你必须改变实现该接口的类。

转载于:https://www.cnblogs.com/qiuz/p/4856531.html

weixin_30940783

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2015笔试面试经验——java基础

1.九种基本数据类型的大小，以及他们的封装类。2.Switch能否用string做参数？答案：在Java语言中Swith可以使用参数类型有：Only convertible int values, strings or enum variables are permitted　　　可以自动转换为整型的（byte,short,int）,String类型，枚举类型。　　　Java中...
复制链接

扫一扫