java基础面试题

1.说说&和&&的区别

&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。
&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str != null && !str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException如果将&&改为&，则会抛出NullPointerException异常。If(x==33 & ++y>0) y会增长，If(x==33 && ++y>0)不会增长

&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。

2.switch语句能否作用在byte上，能否作用在long上，能否作用在String上?

• switch可作用于char byte short int

• switch可作用于char byte short int对应的包装类

• switch不可作用于long double float boolean，包括他们的包装类

• switch中可以是字符串类型,String(jdk1.7之后才可以作用在string上)

• switch中可以是枚举类型

3.short s1= 1; s1 = （s1+1是int类型，而等号左边的是short类型，所以需要强转）1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?(没有错)

对于short s1= 1; s1 = s1 + 1;由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。

对于short s1= 1; s1 += 1;由于 +=是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。

4.char型变量中能不能存贮一个中文汉字?为什么?

• char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，

• 所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在

• unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充

• 说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

5.使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。

6.静态变量和实例变量的区别？

1）在语法定义上的区别：静态变量前要加 static 关键字，而实例变量（成员变量）前则不加。 2）在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。

静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，只分配一次，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。 7.是否可以从一个static方法内部发出对非static方法的调用？

不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部发出对非static方法的调用。

8.深入理解int和integer

public static void main(String[] args) {
    Integer i = 10;
    Integer j = 10;
    System.out.println(i == j);
    Integer a = 128;
    Integer b = 128;
    System.out.println(a == b);
 
    int k = 10;
    System.out.println(k == i);
    int kk = 128;
    System.out.println(kk == a);
  
    Integer m = new Integer(10);java
    Integer n = new Integer(10);
    System.out.println(m == n);
}

　　我们使用反编译工具Jad，得到的代码如下：

public static void main(String args[])
{
    Integer i = Integer.valueOf(10);
    Integer j = Integer.valueOf(10);
    System.out.println(i == j);
    Integer a = Integer.valueOf(128);
    Integer b = Integer.valueOf(128);
    System.out.println(a == b);
    int k = 10;
    System.out.println(k == i.intValue());
    int kk = 128;
    System.out.println(kk == a.intValue());
    Integer m = new Integer(10);
    Integer n = new Integer(10);
    System.out.println(m == n);
}　　

打印结果为：

　t f t t f

　　首先，直接声明Integer i = 10，会自动装箱变为Integer i = Integer.valueOf(10)；Integer i 会自动拆箱为 i.intValue()。

　　①、第一个打印结果为 true

　　对于 i == j ,我们知道这是两个Integer类，他们比较应该是用equals，这里用==比较的是地址，那么结果肯定为false，但是实际上结果为true，这是为什么？

　　我们进入到Integer 类的valueOf()方法：　

　　分析源码我们可以知道在 i >= -128 并且 i <= 127 的时候，第一次声明会将 i 的值放入缓存中，第二次直接取缓存里面的数据，而不是重新创建一个Ingeter 对象。那么第一个打印结果因为 i = 10 在缓存表示范围内，所以为 true。

　　②、第二个打印结果为 false

　　从上面的分析我们知道，128是不在-128到127之间的，所以第一次创建对象的时候没有缓存，第二次创建了一个新的Integer对象。故打印结果为false

　　③、第三个打印结果为 true

　　Integer 的自动拆箱功能，也就是比较两个基本数据类型，结果当然为true

　　④、第四个打印结果为 true

　　解释和第三个一样。int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比较。

　　⑤、第五个打印结果为 false

　　因为这个虽然值为10，但是我们都是通过 new 关键字来创建的两个对象，是不存在缓存的概念的。两个用new关键字创建的对象用 == 进行比较，结果当然为 false。

回到顶部 5、测试　

Integer a = 1;
Integer b = 2;
Integer c = 3;
Integer d = 3;
​
Integer e = 321;
Integer f = 321;
​
Long g = 3L;
Long h = 2L;
​
System.out.println(c == d);
System.out.println(e == f);
System.out.println(c == (a + b));
System.out.println(c.equals((a+b)));
System.out.println(g == (a+b));
System.out.println(g.equals(a+b));
System.out.println(g.equals(a+h));

　　打印结果为： true false true true true false true 　　分析：第一个和第二个结果没什么疑问，Integer类在-128到127的缓存问题；

　　第三个由于 a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法）,==比较符又将左边的自动拆箱，因此它们比较的是数值是否相等。

　　第四个对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较。

　　第五个对于 g == (a+b)，首先计算 a+b,也是先调用各自的intValue方法，得到数值之后，由于前面的g是Long类型的，也会自动拆箱为long，==运算符能将隐含的将小范围的数据类型转换为大范围的数据类型，也就是int会被转换成long类型，两个long类型的数值进行比较。

　　第六个对于 g.equals(a+b),同理a+b会先自动拆箱，然后将结果自动装箱，需要说明的是 equals 运算符不会进行类型转换。所以是Long.equals(Integer)，结果当然是false

　　第七个对于g.equals(a+h),运算符+会进行类型转换，a+h各自拆箱之后是int+long，结果是long，然后long进行自动装箱为Long，两个Long进行equals判断。