Java基础面试汇总

概述

★★★★★"=="和equals方法有什么区别？

==
它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。(基本数据类型比较的是值，引用数据类型比较的是内存地址)

equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：

情况1：类没有覆盖 equals() 方法。则通过 equals()
比较该类的两个对象时，等价于通过“==”比较这两个对象。

情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals()
方法来两个对象的内容相等；若它们的内容相等，则返回 true
(即，认为这两个对象相等)。

举个例子：

public class test1 { public static void main(String[] args) { String a = new String(“ab”); // a 为一个引用 String b = new String(“ab”); // b为另一个引用,对象的内容一样 String aa = “ab”; // 放在常量池中 String bb = “ab”; // 从常量池中查找 if (aa == bb) // true System.out.println(“aabb"); if (a == b) // false，非同一对象 System.out.println("ab”); if (a.equals(b)) // true System.out.println(“aEQb”); if (42 == 42.0) { // true System.out.println(“true”); } } }

说明：

String 中的 equals 方法是被重写过的，因为 object 的 equals
方法是比较的对象的内存地址，而 String 的equals 方法比较的是对象的值。

当创建 String
类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个
String 对象。

值类型（int,char,long,boolean等）都是用==判断相等性。对象引用的话，判断引用所指的对象是否是同一个。equals是Object的成员函数，有些类会覆盖（override）这个方法，用于判断对象的等价性。例如String类，两个引用所指向的String都是”abc”，但可能出现他们实际对应的对象并不是同一个（和jvm实现方式有关），因此用判断他们可能不相等，但用equals判断一定是相等的。

**操作符专门用来比较两个变量的值是否相等，**也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用操作符。

如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objetobj=newObject();变量obj是一个内存，newObject()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。

**equals方法是用于比较两个独立对象的内容是否相同，**就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：

String a = new String(“foo”);

String b = new String(“foo”);

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

在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String
input=…;input.equals(“quit”)，如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：

boolean equals(Objecto){

return this == o;

}

这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object类继承的）就是使用操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

int和Integer有什么区别

int是基本数据类型

Integer是其包装类，注意是一个类。

为什么要提供包装类呢？？？

一是为了在各种类型间转化，通过各种方法的调用。否则你无法直接通过变量转化。

比如，现在int要转为String

int a = 0;

String result = Integer.toString(a);

在java中包装类，比较多的用途是用在于各种数据类型的转化中。

我写几个demo

//通过包装类来实现转化的

intnum = Integer.valueOf(“12”);

intnum 2= Integer.parseInt(“12”);

double num3 = Double.valueOf(“12.2”);

double num4 = Double.parseDouble(“12.2”);

//其他的类似。通过基本数据类型的包装来的valueOf和parseXX来实现String转为XX

String a= String.valueOf(“1234”);//这里括号中几乎可以是任何类型

String b= String.valueOf(true);

String c= newInteger(12).toString();//通过包装类的toString()也可以

String d= newDouble(2.3).toString();

再举例下。比如我现在要用泛型

List nums;

这里<>需要包装类。如果你用int。它会报错的。

父类的静态方法能否被子类重写

不能。重写只适用于实例方法,不能用于静态方法，而子类当中含有和父类相同签名的静态方法，我们一般称之为隐藏。

什么是不可变对象

不可变对象指对象一旦被创建，状态就不能再改变。任何修改都会创建一个新的对象，如
String、Integer 及其它包装类。

静态变量和实例变量的区别?

静态变量存储在方法区，属于类所有。实例变量存储在堆当中，其引用存在当前线程栈。

MVC设计思想

MVC就是

M:Model模型

V:View视图

C:Controller控制器

模型就是封装业务逻辑和数据的一个一个的模块,控制器就是调用这些模块的(java中通常是用Servlet来实现,框架的话很多是用Struts2来实现这一层),视图就主要是你看到的,比如JSP等.

当用户发出请求的时候,控制器根据请求来选择要处理的业务逻辑和要选择的数据,再返回去把结果输出到视图层,这里可能是进行重定向或转发等.

能否创建一个包含可变对象的不可变对象?

当然可以创建一个包含可变对象的不可变对象的，你只需要谨慎一点，不要共享可变对象的
引用就可以了，如果需要变化时，就返回原对象的一个拷贝。最常见的例子就是对象中包含
一个日期对象的引用。

java 创建对象的几种方式

采用 new

通过反射

采用 clone

通过序列化机制

前 2
者都需要显式地调用构造方法。造成耦合性最高的恰好是第一种，因此你发现无论什么
框架，只要涉及到解耦必先减少 new 的使用。

switch 中能否使用 string 做参数

在 idk 1.7 之前，switch 只能支持 byte, short, char, int 或者其对应的封装类以及
Enum 类型。 从 idk 1.7 之后 switch 开始支持 String。

switch 能否作用在 byte, long 上?

可以用在 byte 上，但是不能用在 long 上。

String s1=”ab”, String s2=”a”+”b”, String s3=”a”, String

s4=”b”, s5=s3+s4 请问 s5==s2 返回什么？

返回 false。在编译过程中，编译器会将 s2
直接优化为”ab”，会将其放置在常量池当中，s5则是被创建在堆区，相当于 s5=new
String(“ab”);

你对 String 对象的 intern()熟悉么?

intern()方法会首先从常量池中查找是否存在该常量值，如果常量池中不存在则现在常量池
中创建，如果已经存在则直接返回。

比如

String s1=”aa”; String s2=s1.intern();

System.out.print(s1==s2);//返回 true

.foreach和while的区别(编译之后)

while会读一行输入，把它存入某个变量并执行循环体然后再找其他行的输入，适用于不确定循环次数的情况。

foreach是增强for循环，它是逐条读取，在循环开始前会将所有输入全部读入，适用于，数组、集合等确定长度的情况。当输入内容非常大的时候foreach会非常占内存。

Object 中有哪些公共方法?

equals()

clone()

getClass()

notify(),notifyAll(),wait()

toString

WeakReference 与 SoftReference 的区别?

这点在四种引用类型中已经做了解释,这里简单说明一下即可: 虽 然 WeakReference 与
SoftReference 都 有 利 于 提 高 GC 和 内 存 的 效 率 ， 但 是

WeakReference ，一旦失去最后一个强引用，就会被 GC 回收，而软引用虽然不能阻止被
回收，但是可以延迟到 JVM 内存不足的时候。

为什么要有不同的引用类型

不像 C 语言，我们可以控制内存的申请和释放，在 Java
中有时候我们需要适当的控制对象
被回收的时机，因此就诞生了不同的引用类型，可以说不同的引用类型实则是对 GC 回收时
机不可控的妥协。有以下几个使用场景可以充分的说明：

利用软引用和弱引用解决 OOM 问题：用一个 HashMap 来保存图片的路径和相应图
片对象关联的软引用之间的映射关系，在内存不足时，JVM 会自动回收这些缓存图
片对象所占用的空间，从而有效地避免了 OOM 的问题.

通过软引用实现 Java 对象的高速缓存:比如我们创建了一 Person 的类，如果每次需
要查询一个人的信息,哪怕是几秒中之前刚刚查询过的，都要重新构建一个实例，这
将引起大量 Person 对象的消耗，并且由于这些对象的生命周期相对较短，会引起多 次 GC
影响性能。此时，通过软引用和 HashMap 的结合可以构建高速缓存，提供性 能。

java 中==和 eqauls()的区别,equals()和`hashcode 的区别

是运算符，用于比较两个变量是否相等，而 equals 是 Object
类的方法，用于比较两个对 象是否相等。默认 Object 类的 equals
方法是比较两个对象的地址，此时和的结果一样。
换句话说：基本类型比较用==，比较的是他们的值。默认下，对象用==比较时，比较的是内
存地址，如果需要比较对象内容，需要重写 equal 方法。

equals()和 hashcode()的联系

hashCode()是 Object 类的一个方法，返回一个哈希值。如果两个对象根据
equal()方法比较 相等，那么调用这两个对象中任意一个对象的
hashCode()方法必须产生相同的哈希值。 如果两个对象根据
eqaul()方法比较不相等，那么产生的哈希值不一定相等(碰撞的情况下还 是会相等的。)

a.hashCode()有什么用?与 a.equals(b)有什么关系

hashCode() 方法是相应对象整型的 hash 值。它常用于基于 hash 的集合类，如
Hashtable、 HashMap、LinkedHashMap 等等。它与 equals() 方法关系特别紧密。根据
Java 规范，使用 equal() 方法来判断两个相等的对象，必须具有相同的 hashcode。

将对象放入到集合中时，首先判断要放入对象的 hashcode 是否已经在集合中存在，不存在
则直接放入集合。如果 hashcode 相等，然后通过
equal()方法判断要放入对象与集合中的任 意对象是否相等：如果
equal()判断不相等，直接将该元素放入集合中，否则不放入。

有没有可能两个不相等的对象有相同的 hashcode

有可能，两个不相等的对象可能会有相同的 hashcode 值，这就是为什么在 hashmap 中会
有冲突。如果两个对象相等，必须有相同的 hashcode 值，反之不成立。

可以在 hashcode 中使用随机数字吗?

不行，因为同一对象的 hashcode 值必须是相同的

a==b 与 a.equals(b)有什么区别

如果 都是对象，则 a==b 是比较两个对象的引用，只有当 a 和 b 指向的是堆中的

同一个对象才会返回 true，而 a.equals(b)
是进行逻辑比较，所以通常需要重写该方法来提 供逻辑一致性的比较。例如，String
类重写 equals() 方法，所以可以用于两个不同对象， 但是包含的字母相同的比较。

3*0.1==0.3 返回值是什么

false，因为有些浮点数不能完全精确的表示出来。

a=a+b 与 a+=b 有什么区别吗?

+=操作符会进行隐式自动类型转换，此处 a+=b
隐式的将加操作的结果类型强制转换为持有 结果的类型，而 a=a+b
则不会自动进行类型转换。如：

byte a = 127; byte b = 127;

b = a + b; // error : cannot convert from int to byte b += a; // ok

（译者注：这个地方应该表述的有误，其实无论 a+b 的值为多少，编译器都会报错，因为
a+b

操作会将

提升为 int 类型，所以将 int 类型赋值给 byte 就会编译出错）

short s1= 1; s1 = s1 + 1; 该段代码是否有错,有的话怎么改？

有错误，short 类型在进行运算时会自动提升为 int 类型，也就是说 s1+1 的运算结果是
int 类型。

short s1= 1; s1 += 1; 该段代码是否有错，有的话怎么改？

+=操作符会自动对右边的表达式结果强转匹配左边的数据类型，所以没错。

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

对。

如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。

如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode方法。

字节流与字符流的区别

要把一片二进制数据数据逐一输出到某个设备中，或者从某个设备中逐一读取一片二进制数据，不管输入输出设备是什么，我们要用统一的方式来完成这些操作，用一种抽象的方式进行描述，这个抽象描述方式起名为IO流，对应的抽象类为OutputStream和InputStream，不同的实现类就代表不同的输入和输出设备，它们都是针对字节进行操作的。

在应用中，经常要完全是字符的一段文本输出去或读进来，用字节流可以吗？计算机中的一切最终都是二进制的字节形式存在。对于“中国”这些字符，首先要得到其对应的字节，然后将字节写入到输出流。读取时，首先读到的是字节，可是我们要把它显示为字符，我们需要将字节转换成字符。由于这样的需求很广泛，人家专门提供了字符流的包装类。

底层设备永远只接受字节数据，有时候要写字符串到底层设备，需要将字符串转成字节再进行写入。字符流是字节流的包装，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备，这为我们向IO设别写入或读取字符串提供了一点点方便。

字符向字节转换时，要注意编码的问题，因为字符串转成字节数组，

其实是转成该字符的某种编码的字节形式，读取也是反之的道理。

讲解字节流与字符流关系的代码案例：

importjava.io.BufferedReader;

importjava.io.FileInputStream;

importjava.io.FileOutputStream;

importjava.io.FileReader;

importjava.io.FileWriter;

importjava.io.InputStreamReader;

importjava.io.PrintWriter;

publicclassIOTest{

publicstaticvoidmain(String[]args)throwsException{

Stringstr=“中国人”;

/*FileOutputStreamfos=newFileOutputStream(“1.txt”);

fos.write(str.getBytes(“UTF-8”));

fos.close();*/

/*FileWriterfw=newFileWriter(“1.txt”);

fw.write(str);

fw.close();*/

PrintWriterpw=newPrintWriter(“1.txt”,“utf-8”);

pw.write(str);

pw.close();

/*FileReaderfr=newFileReader(“1.txt”);

char[]buf=newchar[1024];

intlen=fr.read(buf);

StringmyStr=newString(buf,0,len);

System.out.println(myStr);*/

/*FileInputStreamfr=newFileInputStream(“1.txt”);

byte[]buf=newbyte[1024];

intlen=fr.read(buf);

StringmyStr=newString(buf,0,len,“UTF-8”);

System.out.println(myStr);*/

BufferedReaderbr=newBufferedReader(

newInputStreamReader(

newFileInputStream(“1.txt”),“UTF-8”

)

);

StringmyStr=br.readLine();

br.close();

System.out.println(myStr);

}

}

java里面的io跟nio有什么区别

1、JavaNIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。

2、JavaIO的各种流是阻塞的。而JavaNIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。

3、选择器上，JavaIO无选择器，而NIO有选择器，JavaNIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。

Java中会存在内存泄漏吗，请简单描述。

所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。java中有垃圾回收机制，它可以保证一对象不再被引用的时候，即对象变成了孤儿的时候，对象将自动被垃圾回收器从内存中清除掉。由于Java使用有向图的方式进行垃圾回收管理，可以消除引用循环的问题，例如有两个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的，例如下面的代码可以看到这种情况的内存回收：

packagecom.huawei.interview;

importjava.io.IOException;

publicclassGarbageTest{

/**

*@paramargs

*@throwsIOException

*/

publicstaticvoidmain(String[]args)throwsIOException{

//TODOAuto-generatedmethodstub

try{

gcTest();

}catch(IOExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

System.out.println(“hasexitedgcTest!”);

System.in.read();

System.in.read();

System.out.println(“outbegingc!”);

for(inti=0;i<100;i++)

{

System.gc();

System.in.read();

System.in.read();

}

}

privatestaticvoidgcTest()throwsIOException{

System.in.read();

System.in.read();

Personp1=newPerson();

System.in.read();

System.in.read();

Personp2=newPerson();

p1.setMate(p2);

p2.setMate(p1);

System.out.println(“beforeexitgctest!”);

System.in.read();

System.in.read();

System.gc();

System.out.println(“exitgctest!”);

}

privatestaticclassPerson

{

byte[]data=newbyte[20000000];

Personmate=null;

publicvoidsetMate(Personother)

{

mate=other;

}

}

}

java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景，通俗地说，就是程序员可能创建了一个对象，以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是java中可能出现内存泄露的情况，例如，缓存系统，我们加载了一个对象放在缓存中(例如放在一个全局map对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。

检查java中的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。

如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。

[]是对象已不可到达，而内存又没有回收，真正的内存黑洞。

而Java的泄漏，则是因为各种原因，对象对应用已经无用，但一直被持有，一直可到达。

总结原因无外乎几方面：

1. 被生命周期极长的集合类不当持有，号称是Java内存泄漏的首因。

2. 这些集合类的生命周期通常极长，而且是一个辅助管理性质的对象，在一个业务事务运行完后，如果没有将某个业务对象主动的从中清除的话，这个集合就会吃越来越多内存，可以用WeakReference，如WeakHashMap，使得它持有的对象不增加对象的引用数。

3. Scope定义不对，这个很简单了，方法的局部变量定义成类的变量，类的静态变量等。

4. 异常时没有加finally{}来释放某些资源，JDBC时代也是很普遍的事情。

5. 另外一些我了解不深的原因，如：Swing里的Listener没有显式remove；内部类持有外部对象的隐式引用；Finalizers造成关联对象没有被及时清空等。

内存泄漏的检测

有不少工具辅助做这个事情的，如果手上一个工具也没有，可以用JDK自带的小工具：

• 看看谁占满了Heap？

• 用JDK6的jmap可以显示运行程序中对象的类型，个数与所占的大小

• 先用jps找到进程号，然后jmap-histopid显示或jmap-dump:file=heap_file_namepid导出heap文件

• 为什么这些对象仍然可以到达？

• 用jhat(JavaHeapAnalysisTool)分析刚才导出的heap文件。

• 先jhatheap_file_name，然后打开浏览器http://localhost:7000/浏览。

Hashcode和Equals的联系

首先equals()和hashcode()这两个方法都是从object类中继承过来的，主要用来比较对象时进行调用。在object类中定义如下：

1. 、如果两个对象相同，那么它们的hashCode值一定要相同；

2. 、如果两个对象的hashCode相同，它们并不一定相同上面说的对象相同指的是用eqauls方法比较。

作用域public等写不写的区别？【北京永中软件面试题】

作用域不写将采用默认的作用域,默认作用域的访问权限是包的权限，也就是除本包中的所有类能访问，不同包只有子类能访问。

Static方法和static字段有什么用处？可以被重载吗？

用static修饰的方法叫类方法，被所有实例共享；static修饰的字段为类变量，被所有实例共享，在使用类变量时，一般会结合final一起使用定义类常量，不允许被其它的类实例修改。

可以被重载，重载只是参数类型、顺序和个数不同。

列举出JAVA中6个比较常用的包【天威诚信面试题】

java.lang;java.util;java.io;java.sql;java.awt;java.net;javax.swing

JDK中哪些类是不能继承的？【信雅达面试题】

不能继承的是类是那些用final关键字修饰的类。一般比较基本的类型或防止扩展类无意间破坏原来方法的实现的类型都应该是final的。

shorts1=1;s1=s1+1;有什么错?shorts1=1;s1+=1;有什么错?【博炎科技面试题】

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

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

主要考查几种基本数据类型在运算时的，由低到高会自动转换，而由高到低时会强制转换。

Java对象初始化顺序？【腾鹏科技】

分为两种，一种是本类的初始化，一种是含有父类的初始化顺序。这里分开来说，

本类的初始化顺序是：静态变量、静态初始化块、变量、初始化块、构造函数

继承类的初始化顺序是：父类静态变量、父类静态初始化块、子类静态变量、子类静态初始块、父类变量、父类初始化块、父类构造函数、子类变量、子类初始化块、子类构造函数。

static{

System.out.println(“静态块”);

}

{

System.out.println(“初始化模块”);}

publicClassName(){

System.out.println(“构造方法”);

}

说明：

原则上回答全面的话，应该是完整的说出带有继承的这种类的初始化过程，下面有个步骤可以参考：

1. 装载程序的时候首先找到的是它的基（父）类,如果有多层基（父）类则会一级一级的往上找最后找到根基（父）类。

2. 执行根基础（父）类中的static初始化,再执行下一个衍生类中的static,依此类推,一直保持这个顺序。

3. 此时类已经装载完毕,开始创建对象,所有的基本数据类型都会设成它们的默认值,对象句柄设为null

4. 调用基础（父）类的构造方法,基础（父）类的构建采用与衍生类构造方法完全相同的处理过程。

5. 构造方法初始完之后,进行变量的初始化。

6. 执行构造方法中剩余的部分。

构造器的名能不能和类的名字相同？

构造器的名称必须与类名相同。

构造器或构造函数（有些书这样叫）主要用来对类的成员变量进行初始化，当类创建实例时调用。

在一个主方法类可不可以调用一个非静态的方法？

可以调用。因为Java的主方法（main）方法本身也是static类型方法，一个static类型方法，发起对另一个static方法的调用没有问题。

静态方法可以调用其它的静态方法，但是不能调用非静态方法，这个好比Java中的类变量与实例变量的关系。类变量是被所有类成员共享，而实例变量只被该实例共享，

一个类中可不可以有2个公共的方法？

可以。Java中对公共方法的个数没有约束，但是对公共的类有约束，一个Java源文件中只能定义一个public类型的类。

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

（小的数据类型可以转成大数据类型大不能转小）

(比int小的数据类型都可以用在switch语句上)

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

Integer与int的区别？

**int是java提供的8种原始数据类型之一，**另外Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况。

自动装箱与拆箱

装箱：将基本类型用它们对应的引用类型包装起来；

拆箱：将包装类型转换为基本数据类型；

写几个java.lang.Object类中的方法名称。

主要有equals()、toString()、getClass()、hashCode()、clone()、notify()、wait()、notify()方法。

public final native Class getClass()//native方法，用于返回当前运行时对象的Class对象，使用了 final关键字修饰，故不允许子类重写。 public native int hashCode() //native方法，用于返回对象的哈希码，主要使用在哈希表中，比如JDK中的 HashMap。 public boolean equals(Object obj)//用于比较2个对象的内存地址是否相等，String类对该方法进行了重写用 户比较字符串的值是否相等。 protected native Object clone() throws CloneNotSupportedException//naitive方法，用于创建并返 回当前对象的一份拷贝。一般情况下，对于任何对象 x，表达式 x.clone() != x 为true， x.clone().getClass() == x.getClass() 为true。Object本身没有实现Cloneable接口，所以不重写clone 方法并且进行调用的话会发生CloneNotSupportedException异常。 public String toString()//返回类的名字@实例的哈希码的16进制的字符串。建议Object所有的子类都重写这个 方法。 public final native void notify()//native方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监 视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。 public final native void notifyAll()//native方法，并且不能重写。跟notify一样，唯一的区别就是会唤 醒在此对象监视器上等待的所有线程，而不是一个线程。 public final native void wait(long timeout) throws InterruptedException//native方法，并且不 能重写。暂停线程的执行。注意：sleep方法没有释放锁，而wait方法释放了锁 。timeout是等待时间。 public final void wait(long timeout, int nanos) throws InterruptedException//多了nanos参 数，这个参数表示额外时间（以毫微秒为单位，范围是 0-999999）。 所以超时的时间还需要加上nanos毫秒。 public final void wait() throws InterruptedException//跟之前的2个wait方法一样，只不过该方法一直 等待，没有超时时间这个概念 protected void finalize() throws Throwable { }//实例被垃圾回收器回收的时候触发的操作

&和&&的区别？

&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。

&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式。

&还可以用作位运算符，任何时候都全计算，所有为真，则返回真。当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位。

先说分别说两者的作用，再说出&&和&各自的不同之处。

能不能自己写个类，也叫java.lang.String？

可以，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载jre.jar包中的那个java.lang.String。由于在tomcat的web应用程序中，都是由webapp自己的类加载器先自己加载WEB-INF/classess目录中的类，然后才委托上级的类加载器加载，如果我们在tomcat的web应用程序中写一个java.lang.String，这时候Servlet程序加载的就是我们自己写的java.lang.String，但是这么干就会出很多潜在的问题，原来所有用了java.lang.String类的都将出现问题。

虽然java提供了endorsed技术，可以覆盖jdk中的某些类，具体做法是….。但是，能够被覆盖的类是有限制范围，反正不包括java.lang这样的包中的类。

例如，运行下面的程序：

packagejava.lang;

publicclassString{

/**

*@paramargs

*/

publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

System.out.println(“string”);

}

}

报告的错误如下：

java.lang.NoSuchMethodError:main

Exceptioninthread"main"

这是因为加载了jre自带的java.lang.String，而该类中没有main方法。

用JDBC来实现访问数据库记录可以采用下面的几个步骤：

1、通过驱动器管理器获取连接接口（Connection）。

2、获得Statement或它的子类。

3、指定Statement中的参数。

4、通过Statement发送SQL语句。

5、检查并处理返回的结果。

6、关闭Statement。

7、关闭连接接

这道题的难点在Error很多时候由于我们无法重现这种Error导致很多同学甚至不知道Error到底是什么，所以很容易把题目中的两种错误划上等号。

面向对象的特征有哪些方面？

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

• 封装

• 将其具体的属性和方法的实现隐藏起来只提供方法的调用）

封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。

• 继承

• 将已有的方法和属性和方法保留再加上自己特有的的属性和方法形成一个新类即继承

在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

• 多态（分为重写和重载）

• 重写：子类和父类具有相同的方法名和参数返回值类型，即子类重写父类的方法

• 重载：在同一类中方法名相同方法的参数类型或个数不同

多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。

Extends和Implement的不同？

extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开。

比如classAextendsBimplementsC,D,E

1. 接口的方法默认是 public，所有方法在接口中不能有实现(Java 8
   开始接口方法可以有默认实现），抽象类可以有非抽象的方法。

2. 接口中的实例变量默认是 final 类型的，而抽象类中则不一定。

3. 一个类可以实现多个接口，但最多只能实现一个抽象类。

4. 一个类实现接口的话要实现接口的所有方法，而抽象类不一定。

5. 接口不能用 new 实例化，但可以声明，但是必须引用一个实现该接口的对象
   从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

备注:在JDK8中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，必须重写，不然会报错。(issue:https://github.com/Snailclimb/JavaGuide/issues/146)

抽象类是否可以没有抽象方法？为什么？

可以在java中用abstract关键字来修饰一个类时，这个类叫做抽象类。

抽象类中不一定要包含abstract方法，但一个类中包含了abstract方法，则这个类必须声明为abstract类。

静态的多态和动态的多态的区别？

静态的多态:即为重载；方法名相同，参数个数或类型不相同。(overloading)

动态的多态:即为重写；子类覆盖父类的方法，将子类的实例传与父类的引用调用的是子类的方法实现接口的实例传与接口的引用调用的实现类的方法。

说出一些常用的类，包，接口，请各举5个?

常用的类：String、StringBuffer、Integer、Vector、ArrayList、Hashtable等

常用的包：java.langjava.iojava.util、java.sql。

常用的接口：集合中的List、Set、Map接口；与ServletAPI相关的Servlet接口、HttpServletRequest,HttpServletResponse,HttpSession接口等。

Socket如何获取本地ip地址？

InetAddress类提供的API来访问。InetAddress.getLocalAddress()

接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承具体类【天威诚信面试题】

接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承具体类。抽象类中可以有静态的main方法。

备注：只要明白了接口和抽象类的本质和作用，这些问题都很好回答，你想想，如果你是java语言的设计者，你是否会提供这样的支持，如果不提供的话，有什么理由吗？如果你没有道理不提供，那答案就是肯定的了。

只有记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法。

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

2<<3

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

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

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

写clone()方法时，通常都有一行代码，是什么？

clone有缺省行为，super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

说说常用集合类有哪些？有哪些方法？

通常我们使用的集合类都大多是由List、Set、Map这三类接口派生出来的类，例如：

ArrayList、Vector、LinkedList、Stack、TreeSet、Hashtable、HashMap等

集合类的大部分方法都是由Collection接口定义的，主要包括有：

add(E　e)、remove(Objecte)、addAll(),remove()、contains(Objectobj)、clear()等

请说出作用域public，private，protected，以及不写时的区别?【天威诚信面试题】

这四个作用域的可见范围如下表所示。

这些作用域也称介词

说明：如果在修饰的元素上面没有写任何访问修饰符，则表示friendly。

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

Public（公共的）√√√√

protected（受保护的）√√√×

default（默认的）√√××

private（私有的）√×××

备注：只要记住了有4种访问权限，4个访问范围，然后将全选和范围在水平和垂直方向上分别按排从小到大或从大到小的顺序排列，就很容易画出上面的图了。

构造器Constructor是否可被override?【亿阳通讯面试题】

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

是否可以从一个static方法内部发出对非static方法的调用？【世承软件面试题】

不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。

Math.round(11.5)等於多少?Math.round(-11.5)等於多少?【雾隐美地传媒】

Math类中提供了三个与取整有关的方法：ceil、floor、round，这些方法的作用与它们的英文名称的含义相对应，例如，ceil的英文意义是天花板**，该方法就表示向上取整**，所以，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，该方法就表示向下取整，所以，Math.floor(11.6)的结果为11,Math.floor(-11.6)的结果是-12；最难掌握的是round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。

abstractclass（抽象类）和interface（接口）有什么区别? 【百度应用】

含有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstractclass，abstractclass类中的方法不必是抽象的。abstractclass类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为publicabstract类型，接口中的成员变量类型默认为publicstaticfinal。

共同点：都不能new对象

下面比较一下两者的语法区别：

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4.一个类可以实现多个借口但只能继承一个抽象类

5.抽象类中可以包含静态方法，接口中不能包含静态方法

4.抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然

eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为publicabstract类型。

5.抽象类中可以包含静态方法，接口中不能包含静态方法

6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是publicstaticfinal类型，并且默认即为publicstaticfinal类型。

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

下面接着再说说两者在应用上的区别：

这道题的思路是先从总体解释抽象类和接口的基本概念，然后再比较两者的语法细节，最后再说两者的应用区别。比较两者语法细节区别的条理是：先从一个类中的构造方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继承性等方面来回答。

Collection框架中实现比较要实现什么接口?

Comparable、Comparator接口

是否可以继承String类?

String类是final类故不可以继承。

多线程有几种实现方法?同步有几种实现方法?

多线程有两种实现方法，分别是继承Thread类与实现Runnable接口。

同步的实现方面有两种，分别是synchronized,wait与notify。

1. wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

2. sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

3. notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

4. allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

内部类可以引用外部类的成员吗？有没有什么限制？

完全可以。如果不是静态内部类，那没有什么限制！

如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员。

heap和stack有什么区别。

Java的内存分为两类，一类是栈内存，一类是堆内存。栈内存是指程序进入一个方法时，会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。

堆是与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据，例如，使用

new创建的对象都放在堆里，所以，它不会随方法的结束而消失。方法中的局部变量使

用final修饰后，放在堆中，而不是栈中。

Java类实现序列化的方法（二种）？如在collection框架中实现排序，要实现什么样的接口

java.io.Serializable接口或实现Externalizable接口。

Collection框架中实现比较要实现Comparable接口或Comparator接口，并实现比较方法

JAVA实现向数据库添加一列。

Connectioncon=null;

ResultSetrs=null;

Class.forName(“com.microsoft.jdbc.sqlserver.SQLServerDriver”);

Stringurl=“jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name”;

Connectioncon=DriverManager.getConnection(url,"","");

StateManagersm=con.createStateMent();

Stringsql=“altertablestudentaddageint;”;

rs=sm.excute(sql);

什么是Java序列化，如何实现java序列化？或者请解释Serializable接口的作用。【东软国际】

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implementsSerializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，使用ObjectOutputStream对象的writeObject(Objectobj)方法就可以将参数为obj的对象写出,那么在另一端，通过ObjectInputStream对象的readObject(Objectobj)获取到字节流数据后，要将字节流转换成原对象，这叫反序列化,以便将数据存储在文件中或在网络传输。

Serializable接口描述启用其序列化功能，未实现此接口的类将无法使其任何状态序列化或反序列化。Serializable接口没有方法或字段，仅用于标识可序列化的语义，标识实现了该接口的对象属性可被序列化。

Java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？

字节流，字符流两种类型流。字节流继承于InputStream、OutputStream；字符流继承于Reader**、**Writer。其它与IO操作相关的类都是派生至上述4个抽象类，如字节相关的：FileInputStream、FileOutputStream类；字符相关的：BufferedReader、BufferedWriter类

用JDBC如何调用存储过程

通过JDBC组件中的CallableStatement接口实现调用存储过程。

核心代码如下：

Class.forName(“com.mysql.jdbc.Driver”);

Connectionconn=

DriverManager.getConnection(“jdbc:mysql:///test”,“root”,“root”);

CallableStatementcstmt=cn.prepareCall("{callinsert_Student(?,?,?)}");

cstmt.registerOutParameter(3,Types.INTEGER);

cstmt.setString(1,“wangwu”);

cstmt.setInt(2,25);

cstmt.execute();

JAVA事件有哪些模式？

1、事件直接驱动模式。它的特点是直接而且快，是必须经常使用的，主要适合于迅速处理前台的命令，通常就是我们说的command（命令）模式。。2.监控式事件模式。主要借助第三者来监控和触发事件，就是通常我们说的观察者模式。特点是：有一个观察者置身事外在定期独立运行着，我们将我们要监听的事件向这个观察者注册，这样观察者就代替我们来监听这个事件，应用客户端通过观察者来获得事件状况。

SOCKET中有几中连接方式，各有什么区别？

Sockets有两种主要的操作方式:面向连接(TCP/IP)的和无连接(UDP)的。无连接的操作使用数据报协议，无连接的操作是快速的和高效的,但是数据安全性不佳.面向连接的操作使用TCP协议.面向连接的操作比无连接的操作效率更低,但是数据的安全性更高

抽象类能否被实例化？抽象类的作用是什么？

抽象类一般不能被实例化；抽象类通常不是由程序员定义的，而是由项目经理或模块设计人设计抽象类的原因通常是为了规范方法名抽象类必须要继承，不然没法用，作为模块设计者，可以把让底层程序员直接用得方法直接调用，而一些需要让程序员覆盖后自己做得方法则定义称抽象方法

JDBC中的PreparedStatement相比Statement的好处？

预编译语句[java](javascript:?.sql.PreparedStatement,扩展自Statement,不但具有Statement的所有能力而且具有更强大的功能。不同的是，PreparedStatement是在创建语句对象的同时给出要执行的sql语句。这样，sql语句就会被系统进行预编译，执行的速度会有所增加，尤其是在执行大语句的时候，效果更加理想

（网上的答案：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。）

sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行。对于wait的讲解一定要配合例子代码来说明，才显得自己真明白。

packagecom.huawei.interview;

publicclassMultiThread{

/**

*@paramargs

*/

publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

newThread(newThread1()).start();

try{

Thread.sleep(10);

}catch(InterruptedExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

newThread(newThread2()).start();

}

privatestaticclassThread1implementsRunnable

{

@Override

publicvoidrun(){

//TODOAuto-generatedmethodstub

//由于这里的Thread1和下面的Thread2内部run方法要用同一对象作为监视器，我们这里不能用this，因为在Thread2里面的this和这个Thread1的this不是同一个对象。我们用MultiThread.class这个字节码对象，当前虚拟机里引用这个变量时，指向的都是同一个对象。

synchronized(MultiThread.class){

System.out.println(“enterthread1…”);

System.out.println(“thread1iswaiting”);

try{

//释放锁有两种方式，第一种方式是程序自然离开监视器的范围，也就是离开了synchronized关键字管辖的代码范围，另一种方式就是在synchronized关键字管辖的代码内部调用监视器对象的wait方法。这里，使用wait方法释放锁。

MultiThread.class.wait();

}catch(InterruptedExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

System.out.println(“thread1isgoingon…”);

System.out.println(“thread1isbeingover!”);

}

}

}

privatestaticclassThread2implementsRunnable

{

@Override

publicvoidrun(){

//TODOAuto-generatedmethodstub

synchronized(MultiThread.class){

System.out.println(“enterthread2…”);

System.out.println(“thread2notifyotherthreadcanreleasewaitstatus…”);

//由于notify方法并不释放锁，即使thread2调用下面的sleep方法休息了10毫秒，但thread1仍然不会执行，因为thread2没有释放锁，所以Thread1无法得不到锁。

MultiThread.class.notify();

System.out.println(“thread2issleepingtenmillisecond…”);

try{

Thread.sleep(10);

}catch(InterruptedExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

System.out.println(“thread2isgoingon…”);

System.out.println(“thread2isbeingover!”);

}

}

}

}）

Java中实现多态的机制是什么?（同31题一样）

重写，重载

方法的重写Overriding和重载Overloading是Java多态性的不同表现。

重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。

果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

Overload和Override的区别？Overloaded的方法是否可以改变返回值的类型?【软通动力】（同31题一样）

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

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

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

是否可以改变返回值类型，在重载的定义中，与方法是什么类型返回值无关。

override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：

1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；

2、不能通过访问权限、返回类型、抛出的异常进行重载；

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

4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

hashCode方法的作用？

hashcode这个方法是用来鉴定2个对象是否相等的。hashcode方法一般用户不会去调用，比如在hashmap中，由于key是不可以重复的，他在判断key是不是重复的时候就判断了hashcode这个方法，而且也用到了equals方法。这里不可以重复是说equals和hashcode只要有一个不等就可以了！所以简单来讲，hashcode相当于是一个对象的编码。我们一般在覆盖equals的同时也要覆盖hashcode，让他们的逻辑一致。

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

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

native方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现的问题，所以，它也不能是抽象的，不能与abstract混用。例如，FileOutputSteam类要硬件打交道，底层的实现用的是操作系统相关的api实现，例如，在windows用c语言实现的，所以，查看jdk的源代码，可以发现FileOutputStream的open方法的定义如下：

privatenativevoidopen(Stringname)throwsFileNotFoundException;

如果我们要用java调用别人写的c语言函数，我们是无法直接调用的，我们需要按照java的要求写一个c语言的函数，又我们的这个c语言函数去调用别人的c语言函数。由于我们的c语言函数是按java的要求来写的，我们这个c语言函数就可以与java对接上，java那边的对接方式就是定义出与我们这个c函数相对应的方法，java中对应的方法不需要写具体的代码，但需要在前面声明native。

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

AnonymousInnerClass(匿名内部类)是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

可以继承其他类或实现其他接口。不仅是可以，而是必须!

什么是数据交换格式？

客户端与服务器常用数据交换格式xml、json、html

数据交换格式用场景

移动端(安卓、IOS)通讯方式采用http协议+JSON格式 走restful风格。

很多互联网项目都采用Http协议+JSON

因为xml比较重WebService服务采用http+xml格式 银行项目使用比较多

同学们可以思考下？移动端和PC端服务器是接口是怎么设计的？

JSON解析框架有哪些？

fastjson(阿里)、gson(谷歌)、jackson(SpringMVC自带)

XML解析方式？

Dom4j、Sax、Pull

Dom4j与Sax区别

dom4j不适合大文件的解析，因为它是一下子将文件加载到内存中，所以有可能出现内存溢出，sax是基于事件来对xml进行解析的，所以他可以解析大文件的xml，也正是因为如此，所以dom4j可以对xml进行灵活的增删改查和导航，而sax没有这么强的灵活性，所以sax经常是用来解析大型xml文件，而要对xml文件进行一些灵活（crud）操作就用dom4j。

XML与JSON区别

Xml是重量级数据交换格式，占宽带比较大。

JSON是轻量级交换格式，xml占宽带小。

所有很多互联网公司都会使用json作为数据交换格式

很多银行项目，大多数还是在使用xml。

面向对象

面向对象的三个特征

封装，继承，多态，这个应该是人人皆知，有时候也会加上抽象。

你对面向对象思想的理解？

面向对象编程（Object-OrientedProgramming）简称OOP技术，是开发计算机应用程序的一种新方法、新思想。过去的面向过程编程中常常会导致所有的代码都包含在几个模块中，使程序难以阅读和维护，在做一些修改时常常牵一动百，使以后的开发和维护难以为继。而使用OOP技术，使用许多代码模块，每个模块都只提供特定的功能，它们是彼此独立的，可以增加代码重用的几率，更加有利于软件的开发、维护和升级。另外OOP的三大核心特性：继承、封装、多态的特性，使得在面对象编上能够设计出高内聚、低耦合的系统结构，使得系统更灵活、更容易扩展，而且成本较低，所以这一编程思想是目前一种应用最为普遍的软件设计思想。

接口的意义

接口的意义用三个词就可以概括：规范，扩展，回调。

抽象类和接口有什么区别

接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，

另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。

还有，接口可以实现多重继承，而一个类只能继承一个超类，但可以通过继承多个接口实现多重继承，接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。

抽象类的意义

抽象类的意义可以用三句话来概括： 为其他子类提供一个公共的类型

封装子类中重复定义的内容

定义抽象方法,子类虽然有不同的实现，但是定义时一致的

面向对象特征

封装，继承，多态和抽象

封装

封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改变它内部的数据。在Java当中，有3种修饰符：public，private和protected。每一种修饰符给其他的位于同一个包或者不同包下面对象赋予了不同的访问权限。

下面列出了使用封装的一些好处：

• 通过隐藏对象的属性来保护对象内部的状态。

• 提高了代码的可用性和可维护性，因为对象的行为可以被单独的改变或者是扩展。

• 禁止对象之间的不良交互提高模块化

继承

继承给对象提供了从基类获取字段和方法的能力。继承提供了代码的重用行，也可以在不修改类的情况下给现存的类添加新特性。

多态

多态是编程语言给不同的底层数据类型做相同的接口展示的一种能力。一个多态类型上的操作可以应用到其他类型的值上面。

抽象

抽象是把想法从具体的实例中分离出来的步骤，因此，要根据他们的功能而不是实现细节来创建类。Java支持创建只暴漏接口而不包含方法实现的抽象的类。这种抽象技术的主要目的是把类的行为和实现细节分离开。

封装:★★★★★

**概念:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。 **

**好处：将变化隔离；便于使用；提高重用性；安全性。 **

原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

**继承 **★★★★★

好处：

1：提高了代码的复用性。

2：让类与类之间产生了关系，提供了另一个特征多态的前提。

注意：

子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();

如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。

如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

final特点：

1：这个关键字是一个修饰符，可以修饰类，方法，变量。

2：被final修饰的类是一个最终类，不可以被继承。

3：被final修饰的方法是一个最终方法，不可以被覆盖。

4：被final修饰的变量是一个常量，只能赋值一次。

抽象类的特点：

1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。

2：抽象方法只定义方法声明，并不定义方法实现。

3：抽象类不可以被创建对象(实例化)。

4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

5: 抽象类只能单继承。

抽象类的细节：

1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。

2：抽象类中是否可以定义非抽象方法？

可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。

3：抽象关键字abstract和哪些不可以共存？final , private , static

4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。

接 口：

★★★★★   抽象类和接口的区别：

**1：抽象类只能被继承，而且只能单继承。 **

**接口需要被实现，而且可以多实现。  **

**2：抽象类中可以定义非抽象方法，子类可以直接继承使用。 **

接口中都有抽象方法，需要子类去实现。

**3：抽象类使用的是  is a 关系。 **

**接口使用的 like a 关系。 **

**4：抽象类的成员修饰符可以自定义。 **

**接口中的成员修饰符是固定的。全都是public的。    **

多态

多 态★★★★★

函数本身就具备多态性，某一种事物有不同的具体的体现。

体现：

父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();

多态的好处：

提高了程序的扩展性。 灵活性 简化性

允许不同类对象对同一消息做出响应 ，即同一消 息可以根据发送对象的不同而采用多
种不同的行为方式(发送消息就是函数调用)。主要有以下优点：

可替换性：多态对已存在代码具有可替换性

可扩充性：增加新的子类不影响已经存在的类结构

接口性： 多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写
它来实现的。

多态的弊端：

当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

多态的前提：

1：必须要有关系，比如继承、或者实现。

2：通常会有覆盖操作。 重写

代码中如何实现多态

实现多态主要有以下三种方式：

1. 接口实现

2. 继承父类重写方法

3. 同一类中进行方法重载

虚拟机是如何实现多态的

动态绑定技术(dynamic
binding)，执行期间判断所引用对象的实际类型，根据实际类型调用对应的方法。

匿名内部类

没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用

这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。

**匿名内部类的格式：**new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。

匿名内部类的使用场景：

当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。

其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内。

重载和重写的区别

override（重写）

1.方法名、参数、返回值相同。

2.子类方法不能缩小父类方法的访问权限。

3.子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。

4.存在于父类和子类之间。

5.方法被定义为final不能被重写。

overload（重载）

1.参数类型、个数、顺序至少有一个不相同。

2.不能重载只有返回值不同的方法名。

3.存在于父类和子类、同类中。

泛型

**泛型：**jdk1.5版本以后出现的一个安全机制。表现格式：< >

好处：

1：将运行时期的问题ClassCastException问题转换成了编译失败，体现在编译时期，程序员就可以解决问题。

2：避免了强制转换的麻烦。

只要带有<>的类或者接口，都属于带有类型参数的类或者接口，在使用这些类或者接口时，必须给<>中传递一个具体的引用数据类型。

**泛型技术：**其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了。 为什么? 因为

**泛型的擦除：**也就是说，编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的。

**在运行时，如何知道获取的元素类型而不用强转呢？ **

**泛型的补偿：**因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，在内部进行一次转换即可，所以使用者不用再做转换动作了。 什么时候用泛型类呢？

当类中的操作的引用数据类型不确定的时候，以前用的Object来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。

----------------------------------------------------------

**泛型在程序定义上的体现： **

**//泛型类：将泛型定义在类上。 **

**class Tool { **

**private Q obj; **

**public  void setObject(Q obj) { **

**this.obj = obj; } **

public Q getObject() { r

**eturn obj; **

**} **

**} **

//当方法操作的引用数据类型不确定的时候，可以将泛型定义在方法上。

**public  void method(W w) { **

**System.out.println(“method:”+w); **

}

//静态方法上的泛型：静态方法无法访问类上定义的泛型。如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

**public static  void function(Q t) { **

**System.out.println(“function:”+t); **

**} **

**//泛型接口. **

**interface Inter { void show(T t); } **

**class InterImpl implements Inter { **

**public void show(R r) { **

**System.out.println(“show:”+r); **

}

**} **

**------------------------------------------------------------ **

**泛型中的通配符：**可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

泛型限定：

上限：？extends E：可以接收E类型或者E的子类型对象。

下限：？super E：可以接收E类型或者E的父类型对象。

**上限什么时候用：**往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。

**下限什么时候用：**当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。

泛型的细节：

1）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；

1. 、使用带泛型的类创建对象时，等式两边指定的泛型必须一致； 原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；

2. 3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；

ArrayList al = new ArrayList