Java基础面试汇总

概述

★★★★★”==”和equals方法有什么区别/h2>

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

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是其包装类，注意是一个类。

为什么要提供包装类呢/p>

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

比如，现在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 及其它包装类。

静态变量和实例变量的区别/h2>

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

MVC设计思想

MVC就是

M:Model模型

V:View视图

C:Controller控制器

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

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

能否创建一个包含可变对象的不可变对象/p>

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

java 创建对象的几种方式

采用 new

通过反射

采用 clone

通过序列化机制

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

switch 中能否使用 string 做参数

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

switch 能否作用在 byte, long 上/h2>

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

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

s4=”b”, s5=s3+s4 请问 s5==s2 返回什么/p>

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

你对 String 对象的 intern()熟悉么/h2>

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

比如

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

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

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

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

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

Object 中有哪些公共方法/h2>

equals()

clone()

getClass()

notify(),notifyAll(),wait()

toString

WeakReference 与 SoftReference 的区别/h2>

这点在四种引用类型中已经做了解释,这里简单说明一下即可: 虽 然 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 中使用随机数字吗/p>

不行，因为同一对象的 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 有什么区别吗/p>

+=操作符会进行隐式自动类型转换，此处 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; 该段代码是否有错,有的话怎么改/h2>

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

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

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

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

对。

如果对象要保存在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

{

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/p>

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

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

• 为什么这些对象仍然可以到达/p>

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

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

Hashcode和Equals的联系

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

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

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

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

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

Static方法和static字段有什么用处以被重载吗/h2>

用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;有什么错horts1=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. 执行构造方法中剩余的部分。

构造器的名能不能和类的名字相同/h2>

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

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

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

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

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

一个类中可不可以有2个公共的方法/h2>

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

switch语句能否作用在byte上，能否作用在long上，能否作用在String上/h2>

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

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

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

Integer与int的区别/h2>

**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

&和&&的区别/h2>

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

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

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

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

能不能自己写个类，也叫java.lang.String/h2>

可以，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载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到底是什么，所以很容易把题目中的两种错误划上等号。

面向对象的特征有哪些方面/h2>

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

• 封装

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

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

• 继承

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

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

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

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

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

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

Extends和Implement的不同/h2>

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)

抽象类是否可以没有抽象方法什么/h2>

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

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

静态的多态和动态的多态的区别/h2>

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

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

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

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

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

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

Socket如何获取本地ip地址/h2>

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

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

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

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

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

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

2

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

char型变量中能不能存贮一个中文汉字什么/h2>

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

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

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

说说常用集合类有哪些哪些方法/h2>

通常我们使用的集合类都大多是由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)等於多少ath.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框架中实现比较要实现什么接口/h2>

Comparable、Comparator接口

是否可以继承String类/h2>

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

多线程有几种实现方法步有几种实现方法/h2>

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

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

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

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

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

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

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

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

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

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中有几种类型的流DK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类/h2>

字节流，字符流两种类型流。字节流继承于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事件有哪些模式/h2>

1、事件直接驱动模式。

来源：清欢ysy