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.在java中如何跳出多重循环？ 

外层循环使用 一个boolean变量控制循环，想在内层循环结束外层循环，只需要更改控制外层循环的变量值。

int arr[][] = {{1,2,3},{4,5,6,7},{9}};
boolean found = false;
for(int i=0;i<arr.length && !found;i++)	{
		for(int j=0;j<arr[i].length;j++){
			System.out.println(“i=” + i + “,j=” + j);
			if(arr[i][j]  == 5) {
				found = true;
				break;
			}
		}
} 

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

在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。

4.short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错? 

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

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

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

char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

6.用最有效率的方法算出2乘以8等於几? 

2 << 3，

因为将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2 << 3。

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

final(值不变、引用地址不变（StringBuffer内容可变）)

（1）final StringBuffer a=new StringBuffer("immutable");引用不能变

执行如下语句将报告编译期错误：a=new StringBuffer("");

但是，执行如下语句则可以通过编译：a.append(" broken!"); 

（2）String s = “a”;s=”ab”.String类型是final的，内容不能变。这里的写法没有问题，s只是指向了其他的地方，原来的串a是没有变化的，存在于常量池中。

有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：

public void method(final  StringBuffer  param){

}

实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：

param.append("a");

8."=="和equals方法究竟有什么区别？

（1）==比较基本数值是否相等，或者比较引用类型的地址是否相等。

Objet obj = new Object(); 有两块内存，如果想看是否指的是同一个对象

变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。

（2）equals方法默认在object中比较的是地址，但是重写之后比较的是内容

重写equals方法的类：包装类，String,File,Date

String a=new String("foo");

String b=new String("foo");

两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。一般想比较内容的话就使用equals方法。

（3）一般在实际项目中都要进行串的比较，就需要使用equals方法，比如HashSet,HashMap。一般都要重写equals，一般也会把hashCode也重写。如果不重写就会继承父类的方法：

boolean equals(Object o){

     return this==o;

}

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

(1)在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

(2)在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。

(3)实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

(4)内存区：一个在堆内存，一个在静态区

(5)使用例子

package cn.bishe.solrj;
//客户端
public class SolrJManager {
	public static void main(String[] args) {
		Test t1 = new Test();
		Test t2 = new Test();
		System.out.println(Test.staticValue);//3
		System.out.println(t1.instanValue+":"+t2.instanValue);//2:2
	}
}
class Test{
	static int staticValue = 1;
	int instanValue = 1;
	
	Test(){
		staticValue++;
		instanValue++;
	}
}

从运行结果中可以看的出来，实例变量是每个对象单独有的，静态变量是所有对象共有的。

10.Integer与int的区别

（1）int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。

（2）int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，结果为0，所以，int不适合作为web层的表单数据的类型。

（3）另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。

11.Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

（1）Math类中提供了三个与取整有关的方法：ceil、floor、round

（2）round = floor(x+0.5)

12.请说出作用域public，private，protected，以及不写时的区别

public :全部：本类，本包，子类，其他包

private：本类

默认：friendly：本类，本包

protected：本类，本包，子类

需要注意的是：他们都是修饰成员的，不修饰局部的。修饰类的只能是public和默认。

13.overload和override的区别。overload的方法是否可以改变返回值的类型?

Overload是重载的意思，Override是覆盖的意思，也就是重写。

（1）重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。

（2）重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。

overload是否可以改变返回值类型，这句话问的有问题吧，重载不看返回值的类型，重载看的是方法的名字一样，参数不一样。

14.构造器Constructor不可被override? 

构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。 

抽象类中有构造方法，接口中没有

15.面向对象的特征

封装，继承，多态。为了实现代码的易维护，易复用，易扩展，灵活使用。

16.java中实现多态的机制是什么？

（1）父类或者接口引用指向子类对象或者实现类对象

（2）变量不管是编译期还是运行期看的都是左边，方法编译期看左边，运行期的时候方法在动态绑定，看的是右边的类，也就是堆内容中的那个类。

17.抽象类与接口的区别？

（1）抽象类：不能实例化对象，含有抽象方法的一定是抽象类，抽象类不一定有抽象方法，抽象类中可以有构造函数，抽象类可以有静态方法。

抽象类与普通类的区别是：有抽象的方法，被abstract修饰的类。

因为抽象类需要被继承，所以：

a.创建子类实例的时候会先调用父类的构造方法

b.静态方法和普通方法一样都可以被自己继承

因为抽象类是需要被子类继承的，所以抽象类中不能有抽象的构造方法或者抽象静态方法。

（2）接口，接口中只有常量属性和public abstract方法，没有构造方法，不能实例化对象

（3）两者的语法上的区别

a.都不能创建实例，抽象类有构造方法，接口中没有构造方法

b.抽象类中的成员可以和普通类一样，接口中的成员只能是public static final的变量和public abstract的方法

c.访问修饰符：抽象类中除了不能有抽象构造方法，抽象静态方法，类不能被private修饰外，其他的修饰符合普通类是一样的，但是接口中的修饰符只有public

d.一个类可以实现多个接口，但是只能继承一个抽象类

（4）两种在应用上的区别

接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。

而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类。

18.abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized? 

abstract的method 不可以是static的，因为抽象的方法是要被子类实现的，而static与子类扯不上关系！

native方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现的问题，所以，它也不能是抽象的，不能与abstract混用。

关于synchronized与abstract合用的问题，我觉得也不行，因为在我几年的学习和开发中，从来没见到过这种情况，并且我觉得synchronized应该是作用在一个具体的方法上才有意义。而且，方法上的synchronized同步所使用的同步锁对象是this，而抽象方法上无法确定this是什么。

19.什么是内部类，内部类与静态内部类的区别？

（1）内部类就是定义在一个类内部的一个类。

a.在内部类中有static成员没有意义，因为静态不是对象的特征，只是为了找一个放置的位置，所以静态成员完全没有必要放在内部类中。

b.内部类可以直接访问外部类的成员，内部类可以定义在外部类的成员位置，也可以定义在方法内部。如果定义在外部类的成员的位置上就作为了外部类的成员变量，可以使用四大访问修饰符，但是如果定义在外部类的方法内，就是局部的内部类，不能使用访问修饰符，可以使用abstract，final。

c.在外部类或者外面使用内部类的时候要先创建他的实例对象：

    在外部类中使用的时候：Inner in = new Inner();

    在外面使用的时候：

        内部类使用：Outer.Inner in = new Outer().new Inner();

        静态内部类使用：Outer.Inner in = new Outer.Inner();

d.局部内部类可以访问方法体中的局部变量，但是必须是final修饰的局部变量。

e.局部内部类可以定义在方法中，也可以作为匿名内部类（继承父类或者实现接口）

(2)静态内部类与非静态内部类的区别

语法上：静态的加了static

在外面使用内部类：

        内部类使用：Outer.Inner in = new Outer().new Inner();

        静态内部类使用：Outer.Inner in = new Outer.Inner();

静态的只能访问静态的。

20.内部类可以引用他的包含类的成员吗？

可以，同名的时候：this.a表示的是内部类的，Ouuter.this.a表示的是外部类的。静态只能访问静态。

21.super.getClss()方法的使用

使用this.getClass().getName();或者super.getClass().getName();得到的都是本类的类名。

super.getClass().getName()得不到父类的类名。

getClass()方法是Object类的方法，是final的。所以上述的方法不可以，可以使用下面的方法：

getClass().getSuperClass().getName();

22.String s = new String("a")创建了几个对象?

（1）常量区，一块内存

String s1 = "a";

String s2 = "a";

（2）常量区、堆内存两块内存

String s  =new String("a");

23.String s = "a"+"b"+"c"一共创建了几个对象？

创建了一个对象。

String s1 = "a";

String s2 = s1 + "b";

String s3 = "a"+"b";

s3 == "ab"//true

s2 == "ab"//false

String是final的。字符串常量在java编译期就可以对串常量加法进行优化，所以直接就是常量区的对象。

24.return与finally的使用

在异常的try-catch-finally中finally是一定会执行的。

理解return：他不是结束方法，是在函数栈中放值。

try{
			
   }catch(Exception e){
	return 1;
   }finally{
	return 2;
   }

finally是一定会执行的，return是在函数栈中放1，然后执行finally之后，函数栈中的值变为2。函数的返回值是2.

25.异常

（1）异常分类

异常体系Throwable分为error和Exception。error是严重的问题，比如内存溢出，解决不了，Exception是我们程序员研究的异常。Exception异常分为运行时异常和非运行时异常。

运行时异常：RuntimeException：希望程序停止掉的，是因为程序员处理不当造成的异常，程序员可以处理的，如数组越界

非运行时异常：Exception：希望程序继续执行的，是用户造成的异常，用户可以解决的，如电源关了

非运行时异常在编译期就会进行检查，而运行时异常运行时才会检查。

RuntimeException抛出后可以不处理，Exception必需处理或者再次抛出throws

26.java中异常处理机制的原理应用

（3）Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，

（4）Error：严重问题，解决不了，如内存溢出，程序死锁

（5）Exception：可以解决的，其中又分为系统异常（运行时异常的子类）和普通异常（非运行时异常）

（4）Error 表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。

（5）Exception表示程序还能够克服和恢复的问题，其中又分为系统异常（运行时异常的子类）和普通异常（非运行时异常），

（6）系统异常RuntimeException是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；

（7）普通异常Exception是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。

（8）java为RuntimeException和Exception提供的解决方案

（*）普通异常：必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常。

（*）运行时异常：系统异常可以处理也可以不处理，所以，编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常。

27.写出5个常见的运行时异常

NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException、ArithmethicException，BufferOverFlowException