1.权限修饰符 public ,protected ,默认, private 的区别是?java
当前类 相同包下 子类 项目中其余包下数组
public √ √ √ √ 安全
protected √ √ √ ×多线程
默认 √ √ × ×app
private √ × × × ide
2.java中的基本数据类型有哪些? String 属于基本类型吗?性能
答:java中基本类型有8种 , byte short,int ,long ,float , double ,char ,boolean ,String 属于引用类型,不属于基本类型测试
整数类型: byte, short ,int ,log 优化
byte (1字节,8位 取值范围:-128 ~ 127) ,short(2字节,16 位，不多用) ,int(4字节,32位最经常使用) ,long(8字节,64位) ui
数值类型
小数类型: float(4字节 32位) , double (8字节,64位)
字符类型 : char 占2个字节,16位 ; 单引号引发的字符,能够为中文
布尔类型 : boolean 值为true 或者 false
java中默认的整数类型是 int , 默认的小数类型是double
类型的自动提高:
例如:
double d = 1L;//类型小转大,能够自动提高 long l = 1.0; //类型大转小,只能强转
3. int 与 Integer 的区别是什么?
答:一、Integer是int的包装类，int则是java的一种基本数据类型
二、Integer变量必须实例化后才能使用,而int变量不须要
三、Integer实际是对象的引用，当new一个Integer时，其实是生成一个指针指向此对象；而int则是直接存储数据值
四、Integer的默认值是null，int的默认值是0
拓展: int 与 Integer 的比较 , Integer 与 Integer 的比较
//情形1 Integer 与 int类型比较 Integer i = 1; int j = 1; System.out.println(i == j); //情形2 Integer 与 Integer 比较(不经过new 的形式) Integer i1 = 100; Integer i2 = 100; System.out.println(i1 == i2); //情形3 Integer 与 Integer 比较(不经过new 的形式) Integer i3 = 128; Integer i4 = 128; System.out.println(i3 == i4); //情形4 Integer 与 Integer 经过new Integer i5 = new Integer(110); Integer i6 = 110; System.out.println(i5 == i6); //情形5 Integer 与 Integer 经过new Integer i7 = new Integer(120); Integer i8 = new Integer(120); System.out.println(i7 == i8);
最终执行结果:
true true false false false
分析:
//写在前面 ,对于 == ,int 类型之间的比较,比较的是值, Integer对象之间比较的是内存地址 /* 情形一: Integer 与 int 的比较 , 会将Integer 拆箱成 int 类型的值再作比较,因此最终是两个int类型的比较. 而两个int类型比较的是字面值,因此结果为true */ /* 情形二: Integer i1 = 100;这句最终执行的代码是 Integer i1 = Integer.valueOf(100); 此时查看Integer.valueOf(int)的源码: */ public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); } //继续查看IntegerCache的源码: private static class IntegerCache { static final int low = -128; static final int high; static final Integer cache[]; static { // high value may be configured by property int h = 127; String integerCacheHighPropValue = sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high"); if (integerCacheHighPropValue != null) { try { int i = parseInt(integerCacheHighPropValue); i = Math.max(i, 127); // Maximum array size is Integer.MAX_VALUE h = Math.min(i, Integer.MAX_VALUE - (-low) -1); } catch( NumberFormatException nfe) { // If the property cannot be parsed into an int, ignore it. } } high = h; //即至关于 new Integer[256]; cache = new Integer[(high - low) + 1]; int j = low; //最终cache[0] ~ cache[255] 等价于 -128 ~ 127 for(int k = 0; k < cache.length; k++) cache[k] = new Integer(j++); // range [-128, 127] must be interned (JLS7 5.1.7) assert IntegerCache.high >= 127; } private IntegerCache() {} } /* 也就是说, i1 与 i2 都是从IntegerCache 数据中取出,且内存地址一致.因此结果为true; */ /* 情形三: 同上,仍然会调用Integer.valueOf()方法,因为不知足判断条件: */ if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); } /* 因此 两次i3 ,i4 至关于分别执行了 new Integer(128); 而Integer 对象之间的比较,比较的是内存地址; 因为new 了两次,因此内存地址不一样,故结果为false; */ /* 情形四: 参考情形二, i5,i6 至关于从新new了两次,内存地址不一致,故比较结果为false 情形五: 同上,每次new 都会新开辟内存空间,故结果为false; */
4.String s = "Hello", s = "World" 此时s的值已经改变了, 为何还说String 是不可变的?
答: 第一次 s = ''Hello'',至关于建立了 1个 String对象 ''Hello'' , 同时将该对象在内存中的引用地址赋给了变量s
而当执行 s = ''Hello''时,一样也会建立一个String对象 "World", 将此对线的地址赋给 变量s ,并打破原来的引用关系
也就是说,每次更改 s 的值都会新开辟一块内存空间,而不是修改原有内存空间中的值 ,因此说 String 是不可变的;
如何验证?
能够经过System.identityHashCode(obj)验证,该方法能够根据变量的内存地址计算出相应的hashCode值(官方API,并无这么说):
String s = "Hello"; System.out.println(System.identityHashCode(s)); //s = "World"; System.out.println(System.identityHashCode(s));
此时执行的结果为:
1068824137 1068824137
不难发现,两次执行的结果是一致的,所以 s 引用的内存地址没有改变, 将上面的注释打开再执行,结果为:
1068824137 864237698
能够发现,两次的值不一致,能够直观的说明.s的内存地址已经发生了改变
除此以外,查看String 代码能够发现 String 是有 char[] 组成;
private final char value[];//等价于 private final char[] value; 只是写法不一样而已
而char[] value 使用了private 与 final修饰 因此一旦初始化就不能够更改;
经过 内存地址 与 String中的成员变量 足以说明String是不可变的;
4. String ,StringBuilder,StringBuffer 之间的区别是什么?
从拼接速度上来讲:StringBuilder > StringBuffer > String
测试案例:
@Test public void testAppend() { long start_time = 0; long end_time = 0; start_time = System.currentTimeMillis(); StringBuffer sf = new StringBuffer("str"); for (int j = 0; j < 100000; j++) { sf = sf.append("str"); } end_time = System.currentTimeMillis(); System.out.println("StringBuffer 拼接总耗时:"+(end_time - start_time)+"ms"); /*start_time = System.currentTimeMillis(); StringBuilder sb = new StringBuilder("str"); for (int j = 0; j < 100000; j++) { sb = sb.append("str"); } end_time = System.currentTimeMillis(); System.out.println("StringBuilder 拼接总耗时:"+(end_time - start_time)+"ms");*/ /*start_time = System.currentTimeMillis(); String s = "str"; for (int j = 0; j < 100000; j++) { s += "str"; } end_time = System.currentTimeMillis(); System.out.println("String 拼接总耗时:"+(end_time - start_time)+"ms");*/ }
一样执行10W次拼接str字符串,5次执行取平均耗时结果:
StringBuffer :4.4ms
StringBuilder:3.4ms
String:16.4ms
从结果来看 StringBuffer 与 StringBuilder的拼接速度远远大于String的拼接, 这是由于 StringBuffer与StringBuilder 的拼接是对同一对象进行操做,而String的拼接则是不停的开辟新的内存
StringBuilder 与 StringBuffer 的差别会随着拼接次数的增大而增大,有兴趣的伙伴能够动手试一下
从线程安全上来看:StringBuffer > StringBuilder
缘由:StringBuffer 的 append方法 都加上了 synchronized关键字,实现了方法的同步,多线程下是安全的,而StringBuilder中在多线程中可能出现数据不一致的状况
5. java中重写是什么意思? 重写的原则是什么?
答:重写是指复写父类中的方法
原则: 1同 , 2小, 1大
1同:方法签名相同,即方法名称,参数类型,参数个数彻底相同
2小:子类抛出的异常类型小于等于父类 , 子类的返回值类型小于等于父类
1大:子类方法的访问权限大于等于父类
6.什么是overload ,即方法的重载?
类中存在多个,方法名称相同,可是参数列表不一样(参数个数, 参数类型)的方法 .这些方法为重载关系
重载的注意事项:
- 在使用重载时只能经过不一样的参数样式。例如，不一样的参数类型，不一样的参数个数，不一样的参数顺序（固然，同一方法内的几个参数类型必须不同，例如能够是fun(int,float)，可是不能为fun(int,int)）；
- 不能经过访问权限、返回类型、抛出的异常进行重载；
- 方法的异常类型和数目不会对重载形成影响；
- 对于继承来讲，若是某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，若是定义的话，也只是定义了一个新方法，而不会达到重载的效果。
7.Error 与 Exception 有什么区别? 运行时异常与受检异常有什么区别?
答:
Error 与 Exception 都是Throwable的子类:
1.Error 表示是JVM没法处理的重大错误,例如:OutOfMemoryError ;Error是咱们没法处理的错误 ;
2.Exception 能够分为两大类: Check(受检)异常,Runtime(运行时)异常:
通常运行时异常指的是RuntimeException下的子类,除了RuntimeException外.其余的Exception都称之为受检异常
2.1 受检异常:咱们必需要在程序中去处理他,不然代码编译不经过;
处理的方式有两种:①在方法声明时经过throws直接抛出 ②使用try ... catch ...代码块捕获处理
常见的受检异常有:IOException
2.2 运行时异常:程序不要求代码中必定要处理他,不会影响编译经过,只有在运行时的时候出现才会抛出;
通常RuntimeException的出现,都是代码编写的逻辑不够严谨致使的;
常见的RuntimeException有:
Java.lang.ArithmeticException (算数异常)
Java.lang.NumberFormatException (数字格式化异常:;例如:Integer.parseInt("a");)
Java.lang.ClassCastException(类型转换异常)
Java.lang.IndexOutOfBoundsException(索引越界)
Java.lang.NullPointerException(常见的空指针异常)
如下列会触发上述异常的代码:
//System.out.println(1 / 0);//java.lang.ArithmeticException: / by zero
//int a = Integer.parseInt("a");//java.lang.NumberFormatException: For input string: "a"
//new ArrayList<>().get(0);//java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
String s = null; s.toString();//java.lang.NullPointerException
8. ArrayList,Vector, LinkedList 的存储性能和特性的区别:
对于查找,更改而言:
ArrayList 与 Vector 基于Object数组,能够直接根据下标获取到元素,LinkedList 是基于链表的结构,获取某个元素,须要经过首尾一级级才能够找到
对于增删而言:
而Object数组 在指定索引位置插入 或 删除一个数据则须要将索引后面的全部元素索引进行加一,链表结构则比较擅长插入与删除
结论: ArrayList,Vector 查找和更改速度优于 LinkedList , 增删速度则慢于LinkedList;
ArrayList 与Vector的区别:
安全性方面:
Vector中的大部分方法都是synchronized的,因此Vector是线程安全的,ArrayList则不是
速度方面:
synchronized会增长性能的消耗,所以ArrayList处理速度是要快于Vector的
如何选择:
若是是多线程场景建议选择Vector,保证数据的安全;
若是是单线程,没有线程安全的问题;则选择ArrayList更好
9.HashMap ,Hashtable的区别?
从两方面解答:
1.安全性方面:Hashtable中的许多方法是synchronized的,而HashMap不是;
2.速度方面:安全意味着性能的下降;
3.key,value方面:HashMap的key,value 均可觉得null ; 而 Hashtable中不容许为null,不然会抛出NullPointerException异常
10. final, finally, finalize 的区别?
虽然长得挺像,可是功能却差异很大,此题只需回答出各自的功能就行;
final:
修饰类:表示该类不能够被继承
修饰方法:表示方法不能够被重写
修饰变量:若是修饰的是基本类型的变量,则表示该变量初始化后 值不能够再被更改;修饰引用类型的变量则初始化后,不能再指向别的对象
finally:
通常搭配 try - catch - finally 或 try - finally 使用;表示无论try-catch语句中发生了什么 ,执行完try - cathch后都会执行finally中的代码;
finalize:
是object中的一个protected方法,在GC(垃圾收集器)清理对象以前,会调用该对象的finalize方法
11.java中 try - catch - finally 语句中若是都还有return,那么执行哪一个return?
12.在try-catch代码块中若是有return,那么在执行return以前会判断是否存在finally代码块?
若是不存在:很好理解,程序未出异常则执行try中的return ,若是出了异常则执行catch中的return
若是存在:再判断finally中是否有return语句
若是没有return:等待finally执行完毕以后再执行 try 或 catch中的return
若是有return:则再也不使用try 或 catch中的return,直接使用finally中的return做为返回值;
额外的,若是try-catch-finally中无论执行了谁的return, 程序都再也不日后执行
13.关于 new String("HelloWorld");总共建立了几个对象?
对于String而言,经过new 关键字建立对象,是必定会在堆中建立1个对象;
但java对String作了优化,除了堆中以外,还有一个String的常量池;
每当建立String类型的对象时(不论是经过new的形式 仍是 字面量的形式) ,都会首先在常量池中寻找是否已经有了"HelloWorld"这个对象
若是有的话则不会在额外建立,若是没有的话,则会在常量池中建立1个新的对象
因此答案是:最少建立1个新对象,可能建立1个或2个新对象;
而String s = "HelloWorld" 则是 最少0个,可能建立1个新对象;
更详细的能够参考这篇博客:new String()究竟建立几个对象?
14.String中的实例方法,intern()做用是什么?
答:intern方法的做用时,检查常量池中是否存在某个字符串,若是存在则该方法返回该字符串在常量池中的引用,不然将字符串添加到常量池中同时返回在常量池中的引用;
String s = new String("hello") + new String("World"); System.out.println(s == "helloWorld");//false 此时比较的是s在堆中的地址 System.out.println(s.intern() == "helloWorld");//true 此时比较的是"helloWorld"在常量池中的地址
更详细的intern()介绍,请参考该博客(提示:文章有必定长度,请耐心看):Java技术——你真的了解String类的intern()方法吗
15.关于String类型的拼接
若是是字面量值之间的拼接则会在编译阶段进行优化,例如:
String s = "Hello" + "World"
编译优化后:
String s = "HelloWorld"
若是不是字面量值的拼接,则会转为StringBuilder的append拼接,例如:
String s = new String("Hello") + new String("World")
这种状况,不会再进行编译优化;经过反编译能够看到:
String s = (new StringBuilder("Hello")).append(new String("World")).toString();
详情参考本文:关于字符串拼接的问题