java常见面试基础问题整理

1、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？

答案：s1 = s1+1 ; 会提示“cannot convert from int to short”,1本身是int类型，而s1是短整型，所以他们二者运算结果是int类型，要想使表达式成立，需要将结果强制转换成short类型
s1+=1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。所以编译不会有问题。

2、int和Integer的区别？

答案：8大数据类型：（在栈中可以直接分配内存的数据是基本数据类型）

        整型：char、short、int、long

        浮点型：float、double

        逻辑型：boolean

        字符型：char

        基本数据类型和引用数据类型：

        基本数据类型：在栈中可以直接分配内存的数据是基本数据类型。

        引用数据类型：数据的引用在栈中，但是它的对象在堆中。

        对应字节数：

        boolean：1/8个（一个字节有8bit（位）boolean只有true和false两个逻辑值，在编译后的值是用0和1来表示，他们在内存中按位来计算，只需要一位就能表示）

        byte：1个（字节型）

        char：2个（字符型，一个char只能存储一个汉字）

        short：2个（短整型）

        int:4个（整数类型）

        long：8个（长整型）

        float：4个（浮点型）

        double：8个（双精度类型 ）

        java中默认的整数类型是int型，如果要定义成float型，需要在后面加上l或者L

        java中默认的浮点型是double，如果要定义成float型，需要在后面加上f或者F

        小可转大，大转小会丢失精度。

        对应的封装类：

        boolean→Boolean        

        char→Character

        byte→Byte

        short→Short

        int→Integer

        long→Long

        float→Float

        double→Double

        正题：int和Integer的区别？

        （1）Integer是int提供的封装类。int是基本数据类型中的一种。

        （2）Integer的默认值是null。int的默认值是0 。

        （3）Integer是一个对象，需要一个引用来指向这个对象，int是基本数据类型， 直接存储在内存中。

        （4）声明为Integer的变量需要实例化，声明为int的变量不需要实例化。

3、java中的堆和栈？

java中把内存分为两种，一种是堆内存，一种是栈内存。

静态存储分配：是指在编译时就能确定每个数据目标在运行时的存储空间需求，即在编译时就能对应的给它分配对应的固定的内存空间。

栈式存储分配：可称为动态存储分配，是由一个类似于堆栈的运行栈来实现的。和静态存储分配相反，在栈式存储方案中，程序对在编译时候需要的内存空间都是未知的，只有运行的时候才能根据所需的数据区大小分配对应的内存空间。（栈式内存按照先进后出的原则分配。）

通俗一点说堆和栈的区别：堆主要用来存放对象的，栈主要用来执行程序的。

java中在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

堆内存用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。 在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。

引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。

总结：

栈和堆都是java用来在内存中存放数据的地方，（与c++不同的是java自动管理栈和堆，程序员不能直接地设置栈和堆）

堆：（对象）

java的堆是一个运行时数据区，堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度比较慢。

栈：（基本数据）

栈的优势是，存取速度要比堆快，栈数据可以共享。但是缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量。

4、Math.round()的原理？
Math.round(11.5)取值结果是12，
Math.round(11.4)取值结果是11，
Math.round(11.6)取值结果是12
Math.round(-11.5)取值结果是-11
Math.round(-11.4)取值结果是-11
Math.round(-11.6)取值结果是-12
原理就是在给要求的值加0.5然后向下取整。
5、String、StringBuffer、StringBuilder的区别？
他们都可以操作和存储字符串。
String是只读字符串，string引用的字符串内容是不能被改变的。
StringBuffer和StringBuilder类表示的字符串对象可以直接进行修改。
StringBuilder是java5之后引入的，与StringBuffer的区别是StringBuilder它是在单线程环境下使用的，所以效率要比StringBuffer高。
6、重载（overload）和重写（override）的区别。重载的方法能否根据返回类型进行区分？
重载和重写都是多态的体现，二者的区别是：
重载说的是：编译时的多态性。它发生在同一个类中，指的是在一个类中，同名的方法如果参数类型不同或者参数个数不同或者参数类型和个数都不同。注：重载对返回类型没有特殊的要求。
重写说的是：运行时的多态性。它发生在父类和子类之间，当子类继承父类且子类中的方法和父类中的方法它们的方法名、参数个数和参数类型都相同，返回类型也相同（不过这一点在java5之后返回类型可以不同，但是必须是父类的返回值的子类，假如父类返回Object类，子类的返回值可以是String等）
7、&和&&的区别？
&：按位与，将左右两边先转换成二进制，然后再进行与的运算。
&&：逻辑与，左右两边表达式都是true才返回true，有一方false则结果false
8、抽象类和接口的区别？
什么时候用抽象类，什么时候用接口？
如果你拥有一些方法并且想让它们中的一些有默认实现，则可以使用抽象类。
如果你想实现多重继承，则需要使用接口（java不支持多继承，子类不能继承多个类，但是可以实现多个接口）

接口是对动作的抽象，抽象类是对根源的抽象。
抽象类表示的是，这个对象是什么，接口表示的是这个对象能做什么。
举例说：人是一个抽象类，猪也是一个抽象类，人有吃喝拉撒睡的动作，猪也有吃喝拉撒睡的动作，那么就可以把吃喝拉撒睡这些动作做成一个接口，然后分别去具体实现它们。

使用抽象类的目的：提高代码的复用性。可以重写抽象类中的方法来达到自己需要的目的。
使用接口的目的：体现多态性，让实现接口的对象可以以不同方式来实现同一个方法。

抽象方法：抽象方法必须用abstract关键字来修饰。如果一个类中存在抽象方法，那么这个类一定是抽象类，抽象类必须在类前用abstract关键字修饰。因为抽象类中含有没有具体实现的方法， 所以不能用抽象类创建对象。（注意：如果一个类中不包含抽象方法，只是用abstract修饰的话也是抽象类。即抽象类不一定必须含有抽象方法。）

抽象类存在的意义就是为了继承。如果定义了一个抽象类，却不去继承它。那么就等于白白创建了这个抽象类。

包含抽象方法的类是抽象类，但并不是说抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。

抽象类和普通类的主要区别：
（1）抽象方法必须为public或者protected，默认为public，因为private无法被继承。
（2）抽象类不能用来创建对象。
（3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为抽象类。

接口中可以含有变量和方法。实际上接口中的变量会被隐式地指定为public static final 变量（只能是）方法也会被隐式的指定为public abstract方法且只能是public abstract方法。
区别：
（1）接口可以多继承，抽象类只能单继承,抽象类可以实现多个接口。
（2）接口中所有的方法都是抽象的（默认public abstract修饰），不能有具体的实现。抽象类中可以有普通方法，也可以有抽象方法，也可以定义静态方法。
（3）接口中成员变量只能是public static final （静态变量），抽象类中的变量可以是各种类型。
（4）接口中没有构造函数，抽象类中有构造函数，但是这里的构造函数不能用于new对象，他的作用主要用来初始化抽象类的操作。

举例：
有一个警报的接口。有一个门的抽象类。那么要写一个防盗门的类的话只需要继承门这个抽象类，实现警报这个接口即可。

接口可以继承接口，而且接口可以继承多个接口，抽象类可以实现接口，而且可以实现多个接口，抽象类可以继承具体类。

9、抽象的（abstract）方法是否可同时是静态的（static），是否可同时是本地方法？是否可同时被synchronized修饰？
答案：抽象方法将来是要被重写的，而静态方法是不能重写的，所以这个是错误的。本地方法是由本地代码实现的，而抽象方法是没有实现的，所以这个也是错误的。
synchronized作用主要体现在具体的方法实现上，同样抽象方法是没有实现额，所以这个也是错误的。
10、final关键字的用法？
答案:
(1)修饰类：表示该类不能被继承。
(2)修饰方法：表示该方法不能被重写。
(3)修饰变量：表示该变量赋值后值不能被修改，常量。
11、对象构造器的调用顺序？
先初始化静态成员变量—>然后调用父类构造器–》再初始化非静态成员变量–>最后调用自己构造器
12、是否可以从一个静态（static）方法内部发出对非静态方法的调用？
答案：不可以，静态方法只能访问静态成员，非静态方法的调用要先创建对象。
13、关于GC?
答案：GC是垃圾回收的意思，java的GC功能可以自动检测对象是否超过作用域从而达到自动回收内存的目的。
有效的防止内存泄漏，GC相当于一个单独的低优先级的线程运行，对内存堆中长时间没有使用的对象进行清除和回收。
14、数据类型之间的转换？
将字符串转换成基本数据类型：
调用基本数据类型对应的封装类的parseXXX()
将基本数据类型装换成字符串：
调用String.valueOf(xxx) 方法;
15、如何实现字符串的反转和转换？
答案：

    public static String reverse(String a) {

        String newStr = ""; 
          if(a == null || a.length() <= 1) {
              return a;
          }else{
              newStr=reverse(a.substring(1))+a.charAt(0); 
              return newStr ;
          }
      }

16、java常见异常处理关键字“throws”、“throw”、“try”、“catch”、“finally”？
答案：java中每个异常都是一个对象，都是Throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获异常，并对异常作出处理。
throw：就是我们在开发的时候知道会出现什么异常，明确的抛出该异常。
throws：用来声明一个方法可能抛出的各种异常。
try：用来指定一个段或者说一块需要预防异常的程序，如果有异常对象，可通过它的类型来catch它或者通过总是执行代码块（finally）来处理。
17、常见的运行时异常？
ArithmeticException（算术异常）
ClassCastException（类转换异常）
IllegalArgumentException（非法参数异常）
IndexOutOfBoundsException（下表越界异常）
NullPointerException（空指针异常）
SecurityException(安全异常)
18、final、finally、finalize的区别？
final:修饰符（关键字）有三种用法：
如果一个类被声明为final，意味着它不能再派生出新的子类，即不能被继承，因此它和abstract是反义词，
将变量声明为final，可以保证它们在使用中不被改变，被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改。
如果方法被final修饰也同样只能使用，不能在子类中被重写。

finally：通常放在try……catch的后面构造总是执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码都是会被执行的。

finalize：Object类中定义的方法，Java中允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的，通过重写finalize()方法可以整理系统资源或者执行其他清理工作。

19、List，Set，Map的用法和区别？
list，set都继承于Collection接口，map不是。

list（列表）：元素以线性方式存储，可以存放重复元素。

list主要实现类：
ArrayList():长度可以改变的数组，插入和删除元素效率较慢。检索效率快。
LinkedList():链表数据结构存储，插入和删除元素效率快，检索访问效率慢。
set（集合）：元素没有特定的排列顺序，存放的是对象引用，没有重复元素。

set主要实现类：
HashSet：按照哈希算法来存取集合中的对象，存取速度较快。
TreeSet：实现了SortedSet接口，能够对集合中的对象进行排序。

map（映射）：键对象和值对象映射的集合，每一个元素都有对应的键（key）和值（value）对象，从map中检索元素时候，只需要给出键对象就能返回对应的值对象。
一个map中不能包含相同的key，每个key只能映射一个value

主要实现类：
hashMap：底层使用数据+链表实现，同一个键可以放多个值，但取出的是最后一个值。（非同步）允许放空值空键。
hashTable：hashTable和hashMap一样，唯一的不同就是，它是线程安全的，put和get等操作都加锁，且不允许空值和空键。
LinkedHashMap和LinkedArrayList原理相似，可以放空值空键。（非同步）相比hashMap是一个单向链表来讲， 它是双向链表。（缺点是会保留原值）