java基础

1、public、private、protected、friendly区别

作用域       当前类          同一package       子孙类            其他package

public             Y                       Y                     Y                         Y

protected       Y                       Y                    Y                          N

friendly           Y                      Y                    N                          N

private            Y                      N                    N                          N

2、方法length( )、属性length、方法size( )

针对数组提供了length属性来获取数组的长度

针对字符串提供了length()方法来获取字符串的长度

针对泛型集合类提供了size()方法来获取元素的个数

3、Collection和Collections区别

java.util.Collection 是一个集合接口

Collections 是一个集合类的一个工具类/帮助类，其中提供了一系列的静态方法，用于对集合中元素进行排序，搜索以及线程安全等操作

4、String s=new String(‘xyz’); 创建了几个object对象

总共是2个对象

public class Test { public static void main(String [] args) { 

    String s1=new String("test");//创建2个对象，一个Class和一个堆里面 

    String s2="test";//创建1个对象，s2指向pool里面的"test"对象 

    String s3="test";//创建0个对象,指向s2指想pool里面的那个对象 

    String s4=s2;//创建0个对象,指向s2,s3指想pool里面的那个对象 

    String s5=new String("test");//创建1个对象在堆里面，注意，与s1没关系 

    System.out.println(s2=="test");//true s2=="test"很明显true 

    System.out.println(s2==s3);//true,因为指向的都是pool里面的那个"test"

    System.out.println(s2==s4);//true,同上,那么s3和s4...:) 

    System.out.println(s1==s5);//false,很明显,false 

    System.out.println(s1==s2);//false,指向的对象不一样,下面再说 

    System.out.println(s1=="test");//false,难道s1!="tset"？下面再说 

    System.out.println("---------------"); 

    s1=s2; System.out.println(s1=="test");//true,下面说 

} 

5、short s1;  s1 = s1+1;是否有错

因为s1+1是一个int类型，执行第二句的时候被赋值给了short类型，而int是没有办法隐式转换成short类型。会报编译的错误。

但是如果改成short s1 = 1; s1 +=1 ;就可以。+=的运算机制和+不同。或者把short改成long也可以正常编译

6、Overriding和Overloading区别

方法的重写(Overriding)和重载(Overloading)是Java多态性的不同表现。二者多态的差别在于，重载的编译时多态，重写是运行时多态。重写(Overriding)是父类与子类之间多态性的一种表现，而重载(Overloading)是一个类中多态性的一种表现。        

如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)  。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了.

如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型或有不同的参数次序，则称为方法的重载(Overloading)。不能通过访问权限、返回类型、抛出的异常进行重载.

Override 特点 ：        

     1、 override的子类的方法名称、参数类型必须要和父类方法的完全匹配，才能达到重写的效果；         

    2、 override的子类的方法的返回值类型必须和 父类方法的一致，其modifier可以扩大，不可以缩小 ；       

    3、 override的子类的方法所抛出的异常只能是父类方法抛出异常的子异常；        

    4、被private、final等关键字修饰的方法是不能被override的； 

    5、 一个不是用abstract标识的方法不可以override成abstract方法。

Overload 特点 ：         

    1、在使用重载时只能通过不同的参数样式（例如，不同的参数类型，不同的参数个数，不同的参数顺序）；      

    2、方法的异常类型和数目不会对重载造成影响；          

    3、不能通过访问权限、返回类型、抛出的异常进行重载（例如，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果）。

7、常见的runtime exception。

NullPointerException - 空指针引用异常

IllegalArgumentException  -  传递非法参数异常。

ArithmeticException   -   算术运算异常

ArrayStoreException   -   向数组中存放与声明类型不兼容对象异常

IndexOutOfBoundsException  -  下标越界异常

NegativeArraySizeException  -  创建一个大小为负数的数组错误异常

UnsupportedOperationException   -   不支持的操作异常

ClassCastException   -   类型强制转换异常

ArrayIndexOutOfBoundsException   -   数组下标越界异常

SecturityException   -  违背安全原则异常

EOFException   -   文件已结束异常

FileNotFoundException   -   文件未找到异常

NumberFormatException   -   字符串转换为数字异常

SQLException   -   操作数据库异常

IOException   -   输入输出异常

NoSuchMethodException   -   方法未找到异常

8、error和exception区别

Error和Exception都继承自Throwable；

二者不同之处：

Exception：

1.可以是可被控制（checked）或者不可控制（unchecked）；

2.表示一个由程序员导致的错误；

3.应该在应用程序级被处理；

Error：

1.总是不可控制的（unchecked）；

2.经常用来表示系统错误或者底层资源错误；

3.如果可能的话，应该在系统级被捕捉；

Java 中定义了两类异常： 

1) Checked exception: 这类异常都是Exception的子类。异常的向上抛出机制进行处理，假如子类可能产生A异常，那么在父类中也必须throws A异常。可能导致的问题：代码效率低，耦合度过高。

2) Unchecked exception: 这类异常都是RuntimeException的子类，虽然RuntimeException同样也是Exception的子类，但是它们是非凡的，它们不能通过client code来试图解决，所以称为Unchecked exception 。

Java语言要求java程序中（无论是谁写的代码）所有抛出（throw）的异常都必须是从Throwable派生而来。当然，实际的Java编程中，由于JDK平台已经为我们设计好了非常丰富和完整的异常对象分类模型。因此，java程序员一般是不需要再重新定义自己的异常对象。而且即便是需要扩展自定义的异常对象，也往往会从Exception派生而来。所以，对于java程序员而言，它一般只需要在它的顶级函数中catch(Exception ex)就可以捕获出所有的异常对象。 所有异常对象的根基类是 Throwable ，Throwable从Object直接继承而来（这是java系统所强制要求的），并且它实现了 Serializable接口（这为所有的异常对象都能够轻松跨越Java组件系统做好了最充分的物质准备）。

从Throwable直接派生出的异常类有Exception和Error 。Exception是java程序员所最熟悉的，它一般代表了真正实际意义上的异常对象的根基类。也即是说， Exception 和从它派生而来的所有异常都是应用程序能够catch到的，并且可以进行异常错误恢复处理的异常类型。而Error则表示Java系统中出现了一个非常严重的异常错误，并且这个错误可能是应用程序所不能恢复的，例如LinkageError ，或 ThreadDeath 等

9、List和Set是否继承自Collection接口

List，Set是。  

Map不是。 

List特点：元素有放入顺序，元素可重复 

Map特点：元素按键值对存储，无放入顺序 

Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） 

List接口有三个实现类：LinkedList，ArrayList，Vector 

LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身内存地址的同时还存储下一个元素的地址。链表增删快，查找慢 

ArrayList和Vector的区别：ArrayList是非线程安全的，效率高；Vector是基于线程安全的，效率低 

Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet 

SortedSet接口有一个实现类：TreeSet（底层由平衡二叉树实现） 

Query接口有一个实现类：LinkList 

Map接口有三个实现类：HashMap，HashTable，LinkeHashMap 

HashMap非线程安全，高效，支持null；HashTable线程安全，低效，不支持null 

SortedMap有一个实现类：TreeMap 

其实最主要的是，list是用来处理序列的，而set是用来处理集的。Map是知道的，存储的是键值对

set 一般无序不重复.map kv 结构 list 有序

10、abstract class和interface 的区别

共同点

A.两者都是抽象类，都不能实例化

B.Interface实现类和abstract继承类都必须实现抽象方法

不同点

A.Interface需要实现,用implements;Abstract 需要继承,用exends

B.一个类可以实现多个Interface ;一个类只能继承一个Abstract

C.Interface强调功能的实现；Abstract强调从属关系

D.Interface的所有抽象类都只有声明没有方法体；Abstract抽象方法可以选择实现，也可以选择继续声明为抽象方法，无需实现，留给子类去实现

interface的应用场合

类与类之间需要特定的接口进行协调，而不在乎其如何实现。

11、是否可以继承String类

不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变

12、try{}里有一个return语句，紧跟在try后的finally里的code会不会被执行，什么时候执行，return前执行还是return后执行

finally中的代码肯定会执行，但是会先执行try中的代码，如果try中有return，那么return的东西会先放到函数栈中，然后再执行finally中的代码，

①、如果finally中也有return，则会直接返回并终止程序，函数栈中的return不会被完成！；

②、如果finally中没有return，则在执行完finally中的代码之后，会将函数栈中的try中的return的内容返回并终止程序

13、最有效率的方法算2*8等于几

2*8=2 << 3；

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

14、两个对象值相同，x.equal(y)==true，但是却可有不同的hashcode，这句话对不对

不对。

有相同的hash code这是java语言的定义：

1) 对象相等则hashCode一定相等；

2) hashCode相等对象未必相等

15、值传递和引用传递

值传递：(形式参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

引用传递：(形式参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象(或数组)，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数

16、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中可以是枚举类型(JDK1.5之后)

17、ArrayList和Vector区别，HashMap和Hashtable区别（了解这几个类的底层jdk中的编码方式）

ArrayList和HashMap是异步的。Vector和HashTable是同步的。所以Vector和HashTable是线程安全的，而ArrayList和HashMap并不是线程安全的。因为同步需要花费机器时间，所以Vector和HashTable的执行效率要低于ArrayList和HashMap

18、GC是什么，为什么要有GC，简单介绍GC

Java有了GC，就不需要程序员去人工释放内存空间。当Java虚拟机发觉内存资源紧张的时候，就会自动地去清理无用变量所占用的内存空间。当然，如果需要，程序员可以在Java程序中显式地使用System.gc()来强制进行一次立即的内存清理。

19、float f=3.4是否正确

不正确。精度不准确,应该用强制类型转换，如下所示：

float f=(float)3.4 或float f = 3.4f 

在java里面，没小数点的默认是int,有小数点的默认是 double；

20、String和Stringbuffer的区别

（1）String:是对象不是原始类型.为不可变对象,一旦被创建,就不能修改它的值.对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.String 是final类,即不能被继承

（2）StringBuffer:是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象。它只能通过构造函数来建立对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer中付值的时候可以通过它的append方法.

21、final、finally、finalize区别

final

　当用final修饰类的时，表明该类不能被其他类所继承。当我们需要让一个类永远不被继承，此时就可以用final修饰，注意：final类中所有的成员方法都会隐式的定义为final方法。

当用final修饰方法时

　　(1) 把方法锁定，以防止继承类对其进行更改。

　　(2) 效率，在早期的java版本中，会将final方法转为内嵌调用。但若方法过于庞大，可能在性能上不会有多大提升。因此在最近版本中，不需要final方法进行这些优化了。

final方法意味着“最后的、最终的”含义，即此方法不能被重写。

注意：若父类中final方法的访问权限为private，将导致子类中不能直接继承该方法，因此，此时可以在子类中定义相同方法名的函数，此时不会与重写final的矛盾，而是在子类中重新地定义了新方法。

当用final修饰变量时final成员变量表示常量，只能被赋值一次，赋值后其值不再改变。类似于C++中的const。

finally

    finally作为异常处理的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行（不管有没有抛出异常），经常被用在需要释放资源的情况下。（×）（这句话其实存在一定的问题）

    finally 语句块还是没有执行，为什么呢？因为我们在 try 语句块中执行了 System.exit (0) 语句，终止了 Java 虚拟机的运行。那有人说了，在一般的 Java 应用中基本上是不会调用这个 System.exit(0) 方法的。OK ！没有问题，我们不调用 System.exit(0) 这个方法，那么 finally 语句块就一定会执行吗？

　　再一次让大家失望了，答案还是否定的。当一个线程在执行 try 语句块或者 catch 语句块时被打断（interrupted）或者被终止（killed），与其相对应的 finally 语句块可能不会执行。还有更极端的情况，就是在线程运行 try 语句块或者 catch 语句块时，突然死机或者断电，finally 语句块肯定不会执行了。可能有人认为死机、断电这些理由有些强词夺理，没有关系，我们只是为了说明这个问题。

finalize　　

　　finalize()是在java.lang.Object里定义的，也就是说每一个对象都有这么个方法。这个方法在gc启动，该对象被回收的时候被调用。其实gc可以回收大部分的对象（凡是new出来的对象，gc都能搞定，一般情况下我们又不会用new以外的方式去创建对象），所以一般是不需要程序员去实现finalize的。特殊情况下，需要程序员实现finalize，当对象被回收的时候释放一些资源，比如：一个socket链接，在对象初始化时创建，整个生命周期内有效，那么就需要实现finalize，关闭这个链接。　　使用finalize还需要注意一个事，调用super.finalize();

　　一个对象的finalize()方法只会被调用一次，而且finalize()被调用不意味着gc会立即回收该对象，所以有可能调用finalize()后，该对象又不需要被回收了，然后到了真正要被回收的时候，因为前面调用过一次，所以不会调用finalize()，产生问题。 所以，推荐不要使用finalize()方法，它跟析构函数不一样

22、面向对象的特征

面向对象的编程语言有封装、继承、抽象、多态等4个主要的特征

面向对象编程有三大特性：封装、继承、多态

23、String是最基本的数据类型吗

不是

基本数据类型包括byte、int、char、long、float、double、boolean和short。

引用数据类型包括:类,数组,接口等（简单来说就是除了基本数据类型之外的所有类型）

所以String 是引用数据类型

24、运行时异常和一般异常的区别

Java提供了两类主要的异常:运行时异常runtime exception和一般异常checked exception。checked 异常。对于后者这种异常，JAVA要求程序员对其进行catch。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。运行时异常我们可以不处理。这样的异常由虚拟机接管。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止

不同点：

(1)运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等。

(2)一般异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。

1、Java异常机制：

Java把异常当做对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。

Java中的异常分为两大类：错误Error和异常Exception。

2、运行时异常：

运行时异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的。

当出现RuntimeException的时候，我们可以不处理，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException异常，它就是运行时异常，并且这种异常还是最常见的异常之一。

出现运行时异常后，如果没有捕获处理这个异常（即没有catch），系统会把异常一直往上层抛，一直到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，那么这整个程序也就退出了。

运行时异常是Exception的子类，也有一般异常的特点，是可以被catch块处理的。只不过往往我们不对他处理罢了。也就是说，你如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。

如果不想终止，则必须捕获所有的运行时异常，决不让这个处理线程退出。队列里面出现异常数据了，正常的处理应该是把异常数据舍弃，然后记录日志。不应该由于异常数据而影响下面对正常数据的处理。

3、一般异常：

一般异常包括IOException、SQLException等以及用户自定义的Exception异常。对于这种异常，JAVA编译器强制要求我们必需对出现的这些异常进行catch并处理，否则程序就不能编译通过。

所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。

4、常见RuntimeException：

ArrayStoreException：试图将错误类型的对象存储到一个对象数组时抛出的异常

ClassCastException：试图将对象强制转换为不是实例的子类时，抛出该异常

IllegalArgumentException：抛出的异常表明向方法传递了一个不合法或不正确的参数

IndexOutOfBoundsException：指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出

NoSuchElementException ：表明枚举中没有更多的元素

NullPointerException ：当应用程序试图在需要对象的地方使用 null 时，抛出该异常

25、说出ArrayList、Vector、Linkedlist的存储性能和特性

ArrayList 是一个数组队列。它由数组实现，实现了RandomAccess, Cloneable, java.io.Serializable接口，所以可以随便访问，克隆，序列化，随机访问效率高，随机插入、随机删除效率低。

LinkedList 是一个双向链表。它也可以被当作堆栈、队列或双端队列进行操作。LinkedList随机访问效率低，但随机插入、随机删除效率低。

Vector 是矢量队列，和ArrayList一样，它也是一个动态数组，由数组实现。但是ArrayList是非线程安全的，而Vector是线程安全的。

Stack 是栈，继承于Vector。栈的特点是：先进后出(First In Last Out)。

List和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。

26、heap和stack区别

要点： 堆 : 队列优先,先进先出（FIFO—first in first out）。

            栈 : 先进后出

heap 和 stack有什么区别

（1）堆栈空间分配区别：

　　1、栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；

　　2、堆（操作系统）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。

（2）堆栈缓存方式区别：

　　1、栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放；

　　2、堆是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。

（3）堆栈数据结构区别：

　　堆（数据结构）：堆可以被看成是一棵树，如：堆排序；

　　栈（数据结构）：一种先进后出的数据结构。

Java中栈和堆的区别：

　　栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

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

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

Java中变量在内存中的分配:

　　1、类变量（static修饰的变量）：在程序加载时系统就为它在堆中开辟了内存，堆中的内存地址存放于栈以便于高速访问。静态变量的生命周期–一直持续到整个”系统”关闭。

　　2、实例变量：当你使用java关键字new的时候，系统在堆中开辟并不一定是连续的空间分配给变量（比如说类实例），然后根据零散的堆内存地址，通过哈希算法换算为一长串数字以表征这个变量在堆中的”物理位置”。 实例变量的生命周期–当实例变量的引用丢失后，将被GC（垃圾回收器）列入可回收“名单”中，但并不是马上就释放堆中内存。

　　3、局部变量：局部变量，由声明在某方法，或某代码段里（比如for循环），执行到它的时候在栈中开辟内存，当局部变量一但脱离作用域，内存立即释放。

这里要涉及到Java内存问题，可以参考：Java的内存机制

27、排序的几种方法，了解。（算法和数据结构在面试的时候还没有被问到）

冒泡排序

public static void sort(int data[]) {

    for (int i = 0; i < data.length - 1; i++) {

        for (int j = 0; j < data.length - i - 1; j++) {

            if (data[j] > data[j + 1]) {

                int temp = data[j];

                data[j] = data[j + 1];

                data[j + 1] = temp;

            }

        }

    }

}

插入排序

public static void sort(int data[]) {

    for (int i = 1; i < data.length; i++) {

        for (int j = i; j > 0; j--){

            if (data[j] < data[j - 1]) {

                int temp = data[j];

                data[j] = data[j - 1];

                data[j - 1] = temp;

            }

        }

    }

}

28、Java语言如何进行异常处理，throws，throw，try catch finally代表什么意义，try块中可以抛出异常吗

try块表示程序正常的业务执行代码。如果程序在执行try块的代码时出现了“非预期”情况，JVM将会生成一个异常对象，这个异常对象将会被后面相应的catch块捕获。

catch块表示一个异常捕获块。当程序执行try块引发异常时，这个异常对象将会被后面相应的catch块捕获。

throw用于手动地抛出异常对象。throw后面需要一个异常对象。

throws用于在方法签名中声明抛出一个或多个异常类，throws关键字后可以紧跟一个或多个异常类。

finally块代表异常处理流程中总会执行的代码块。

对于一个完整的异常处理流程而言，try块是必须的，try块后可以紧跟一个或多个catch块，最后还可以带一个finally块。

try块中可以抛出异常

29、一个’.java’源文件是否可以包括多个类，有什么限制

这个是可以的，一个“.java”源文件里面可以包含多个类，但是只允许有一个public类，并且类名必须和文件名一致。

每个编译单元只能有一个public 类。这么做的意思是，每个编译单元只能有一个公开的接口，而这个接口就由其public 类来表示。

你可以根据需要，往这个文件里面添加任意多个提供辅助功能的package 权限的类。但是如果这个编译单元里面有两个或两个以上的public 类的话，程序就不知道从哪里导入了，编译器就会报错

30、是否可以从一个static方法内部发生对非static方法调用

不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，

 才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以

 直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例

 对象，如果从一个static方法中发出对非static方法的调用，那个非static

 方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部

 发出对非static方法的调用

31、说出常用类、包、接口，各举5个

常用的类：BufferedReader BufferedWriter FileReader FileWirter String Integer java.util.Date，System，Class，List,HashMap

常用的包：java.lang java.io java.util

java.sql ,javax.servlet,org.apache.strtuts.action,org.hibernate

常用的接口：Remote List Map Document

NodeList,Servlet,HttpServletRequest,HttpServletResponse,Transaction(Hibernate)

Session(Hibernate),HttpSession

32、同步和异步区别

同步交互：指发送一个请求,需要等待返回,然后才能够发送下一个请求，有个等    待过程；

异步交互：指发送一个请求,不需要等待返回,随时可以再发送下一个请求，即不需要等待。区别：一个需要等待，一个不需要等待，在部分情况下， 我们的项目开发中都会优先选择不需要等待的异步交互方式

33、简述面向对象的理解，并举例说出你的理解

面向对象是基于万物皆对象这个哲学观点. 把一个对象抽象成类,具体上就是把一个对象的静态特征和动态特征抽象成属性和方法

34、继承和实现的区别

表面的区别就是单继承多实现

继承：如果多个类的某个部分的功能相同，那么可以抽象出一个类出来，把他们的相同部分都放到父类里，让他们都继承这个类。

实现：如果多个类处理的目标是一样的，但是处理的方法方式不同，那么就定义一个接口，也就是一个标准，让他们的实现这个接口，各自实现自己具体的处理方法来处理那个目标

35、介绍Java中的Collection framework

Java collection是java提供的工具包，包含了常用的数据结构：集合、链表、队列、栈、数组、映射等。

Java集合主要可以划分为4个部分：List列表、Set集合、Map映射、工具类(Iterator、Arrays和Collections)。

Collection是一个interface ，Collection有List和Set两大分支。

List<E>是一个队列，根据下标索引，第一个元素的下标是0，List的实现类有LinkedList, ArrayList, Vector, Stack。List是有序的队列，List中可以有重复的值。

Set<E>是一个集合，SET中的值是唯一的，我们经常会遇到List去重的问题，把List转为SET就可以快速实现 Set的实现类有HastSet和TreeSet。HashSet。其中TreeSet是有序的。

Ma<K,V>是一个interface，即key-value键值对。Map中的每一个元素包含“一个key”和“key对应的value”。 

AbstractMap是个抽象类，它实现了Map接口中的大部分API。而HashMap，TreeMap，WeakHashMap都是继承于AbstractMap。

Iterator。它是遍历集合的工具，我们经常使用Iterator迭代器来遍历集合。Collection的实现类都要实现iterator()函数，返回一个Iterator对象。

抽象类AbstractCollection、AbstractList、AbstractSet、AbstractMap是抽象类，他们都实现了各自的大部分方法，我们直接继承Abstract类就可以省去重复编码相同的方法 。PS当时来面试的时候被问到这个问题竟然一下没想起来。