java面试易错知识点总结

一.java基础

1.char  x=1+'a';==>x为b

char y='1'+1;==>y为2

这里的数字不是传统意义的int值,只是他的位置变化,可以参考unicode编码表

2.求1!+2!+...10!

public class Test1 {public static void main(String[] args) {int sum=0;int a=1;for (int i = 1; i <=10; i++) {for (int j = 1; j <=i; j++) {    a=a*j;}sum+=a;}System.out.println(sum);}}

3.int x=4;

system.out.println("value is")+(x>4)?88.8:8)

结果是8.0而不是8,因为前面是88.8为double型

4.取模与除运算

5/2 为2 

5%2为1,符号位只与被除数有关

5.求1到100之间的素数和

public class Test1 {public static void main(String[] args) {boolean f=false;int sum=0;for (int i = 2; i <=100; i++) {for (int j =2; j < Math.sqrt(i); j++) {if (i%j==0) {f=true;break;}else {f=false;}}if (f==false) {System.out.println(i);sum+=i;}}System.out.println(sum);}}

6.成员变量与局部变量的区别

• 成员变量定义在整个类中,整个类都可以访问,局部变量定义在方法中,只属于整个方法拥有
• 成员变量存在于堆内存中,局部变量存在栈内存中
• 成员变量有默认的初始化值,局部变量没有

加static修饰的成员变量,只存在一份

7.代码块

普通代码块:当方法执行时执行

构造代码块:每次实例化都会调用一次

静态代码块::在类加载时候只被执行一次

执行顺序:静态代码块----->普通代码块------>构造代码块--------->构造方法

子类与父类:

执行顺序:

父类静态代码块---->子类静态代码块------>父类的普通代码块------->父类的构造代码块-------->子类的普通代码块------->子类的构造代码块

8.在 JAVA  中如何跳出当前的多重嵌套循环？

在 Java 中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环

体的代码中使用带有标号的 break 语句，即可跳出外层循环。例如，

ok:

for(int i=0;i<10;i++) {

for(int j=0;j<10;j++) {

System.out.println(“i=” + i + “,j=” + j);

if(j == 5) break ok;

}

9.byte------short-------int-------long

1字节         2字节      4字节    8字节

8bit            16bit        32bit      64bit

float  4字节

double  8字节 

char  2字节(一个中文占两字节   一个英文占一字节)

10.位运算符

2<<3  2*2^3

2>>3  2*2^-3

11.BIgInteger来操作大数据

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

使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容

还是可以改变的。例如，对于如下语句：

final StringBuffer a=new StringBuffer("immutable");

执行如下语句将报告编译期错误：

a=new StringBuffer("");

但是，执行如下语句则可以通过编译：

a.append(" broken!");

13.非static方法可以对static的调用,但是static方法不能从外部对非static的调用

14.Integer 与 与 int  的区别

integer是int的封装类,integer的默认值是 null,int的默认值是0,所以在web开发中,用integer而不是int

15.round ,ceil ,floor的使用

Math.round(-11.5)==>-11

Math.round(11.5)==>12

Math.ceil(11.2)==>12

Math.ceil(-11.2)==>-11

Math.floor(11.2)==>11

Math.floor(-11.2)==>-12

15.作用域  当前类  同一包（package）  不同包的子类   不同包的非子类

  public         √            √                              √                             √

protected     √            √                              √                              ×

default       √            √                               ×                             ×

private         √            ×                              ×                             ×

16.重载与重写的区别

重载:指的是同一个类中有多个方法具有相同的方法名,但是他们的参数列表或者返回值不同.

重写:子类继承了父类,子类的方法名与形参列表与返回值与父类中重写的方法完全相同,但是抛出的异常一定小于父类

17.抽象类与接口的区别

抽象类:

       1.有抽象方法的一定是抽象类,但是抽象类不一定有抽象方法

       2.如果一个具体类继承抽象类,必须重写里面的抽象方法

          3.抽象类可以继承抽象类也可以继承具体类

       4.抽象类里可以有main方法

      5.抽象类有构造方法

接口:1.接口的成员默认的修饰符是public static final,方法的修饰符是public abstract 

        2.接口没有构造方法 

        3.一个类实现接口时候,必须把所有的方法给实现

        4.接口可以继承接口,也可以实现接口

        5,抽象类可以实现接口

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

clone 有缺省行为，

super.clone();

因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

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

靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象

20.abstract 的 的 method  是否可同时是 static, 是否可同时是 native，是否可同 ，是否可同

时是 时是 synchronized?

都不可以

21.内部类可以引用它的包含类的成员吗？有没有什么限制？

可以,静态内部类只能访问外部静态变量

22.Anonymous Inner Class ( 匿名内部类) 是否可以 extends( 继承)其它类， 其它类，

是否可以 是否可以 implements( 实现)interface( 接口)?

可以继承其他类或实现其他接口。

abstract class Person {

    public abstract void eat();

}

 

public class Demo {

    public static void main(String[] args) {

        Person p = new Person() {

            public void eat() {

                System.out.println("eat something");

            }

        };

        p.eat();

    }

23.

import java.util.Date;public class Test3 extends Date{public static void main(String[] args) {new Test3().test();}public void test(){System.out.println(super.getClass().getName());//输出success.Test3System.out.println(getClass().getSuperclass().getName());//输出java.util.Date}}

24.

public class Test3{public static void main(String[] args) {String s1="ja";String s2="va";String s3="java";String s4=s1+s2;System.out.println(s3==s4);//falseSystem.out.println(s3.equals(s4));//trueString a=new String("abc");//此时创建了两个对象,一个是对象a,一个是常量abc,把常量放在常量池里

String b=new String("abc");//此时创建了一个对象b,因为常量池里已经存在abc了,直接从里面拿就行System.out.println(a==b);//falseString c="abc";String d="abc";System.out.println(c==d);//true}}

25.String与StringBuffer的区别

StringBuffer是存放String的一个容器,可以在里面对String的一系列操作,他是没有equals方法的.

举例子:

当我们对string的字符串拼接100次,你会发现StringBuffer速度快多了,自始至终自创建了一个StringBuffer,而String创建了好多次

26.//字节数组==>字符串

char[]  c= {'a','b','c'};

String s1=new String(c);

//字符串==>字节数组

char[] c2=s1.toCharArray();

//字符串数组==>字符串

String a[]= {"hello","world"};

StringBuffer sBuffer=new StringBuffer();

for (String string : a) {

sBuffer.append(string);

}

System.out.println(sBuffer);

//字符串==>字符串数组

String s3="我,哎,你";

String []s=s3.split(",");

for (String string : s) {

System.out.println(string);

}

27.如何去除数组中的重复元素

public class Test {public static void main(String[] args) {int a[]={6,2,9,6,1,2,6,7,8};//方法一List list=new ArrayList<>();//声明一个集合for(int i=0;i<a.length;i++){        //如果集合里面没有相同的元素才往里存        if(!list.contains(a[i])){            list.add(a[i]);        }    }Object[] b=list.toArray();//将list转为数组for (Object object : b) {System.out.print(object+" ");}//方法二Set set=new HashSet<>();for (int i = 0; i < a.length; i++) {set.add(a[i]);}Object[] c=set.toArray();for (Object object : b) {System.out.print(object+" ");}}}

28.数组有length的属性,没有length的方法,String有length的方法

29.异常

定义:中断程序运行的一种指令流

产生异常===>出现一个异常的实例化对象==>在try中对此异常进行补捉==>产生的异常与catch里的类型进行匹配

30.常见的异常

1.类型转化异常

ClassCastException

2.数组下标越界异常

ArrayIndexOutBoundsException

3.算数异常

ArithMeticException

4.java系统内部异常

InteralException

5.内存溢出异常

OutMemoryException

6.空指针异常

NullPointerException

try {} 里有一个 return 语句，那么 语句，那么紧跟在这个 紧跟在这个 try  后的 finally {} 里的 code

会不会被执行，什么时候被执行，在 会不会被执行，什么时候被执行，在 return  前还是后?

会执行,在return之前

public class Test2 {public static void main(String args[]){Test2 t = new Test2();int b = t.get();System.out.println(b);//try 中的 return 语句调用的函数先于 finally 中调用的函数执行，也就是说 return 语句先执行，//finally 语句后执行，所以，返回的结果是2。Return 并不是让函数马上返回，而是 return 语//句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行 finally 语//句后才真正开始返回。}public int get(){try{System.out.println("1a");return 1;}finally{System.out.println("2a");return 2 ;}}}

31final, finally, finalize  的区别。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally 是异常处理语句结构的一部分，表示总是执行。

finalize 是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可

以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM 不保证此方法总被

调用

32.error与exception的区别

Error(错误)表示系统级的错误和程序不必处理的异常，是java运行环境中的内部错误或者硬件问题，比如，内存资源不足等，对于这种错误，程序基本无能为力，除了退出运行外别无选择。  Exception(违例)表示需要捕捉或者需要程序进行处理的异常，它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。

33.

throws 捕获并向外抛出异常

throw 抛出异常

try catch 是内部捕获异常并做自定义处理

(try里面)

finally 是无论是否有异常都会被处理的语句，除非在 finally 前存在被执行的

System.exit(int i)时除外

try {throw new Exception("异常");//捕捉异常-->直接跳到catch     int a=9;//不会执行} catch (Exception e) {//匹配异常// TODO Auto-generated catch blocke.printStackTrace();//打印异常}finally{}

34.、、java  中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()

和 和 suspend()

35.sleep与wait方法的区别

sleep 是线程类（Thread）的方法，导致此线程暂停执行指定时间，

给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用 sleep 不会释放

对象锁。 wait 是 Object 类的方法，对此对象调用 wait 方法导致本线程放弃对象锁，进入

等待此对象的等待锁定池，只有针对此对象发出 notify 方法（或 notifyAll）后本线程才进入

对象锁定池准备获得对象锁进入运行状态。

36.run方法与start()方法的区别

  start()是创建一个新的线程,并且在start()内部有run方法,这个可以看源码就能知道.当你调用run ()方法时,只能在原来的线程中调用,但是strat()可以创建新的线程

37. 简述 synchronized 和 和 java.util.concurrent.locks.Lock  的异同？

主要相同点：Lock 能完成 synchronized 所实现的所有功能

主要不同点：Lock 有比 synchronized 更精确的线程语义和更好的性能。synchronized 会自

动释放锁，而 Lock 一定要求程序员手工释放，并且必须在 finally 从句中释放。

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

话对不对 话对不对?

对。

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

值就必须相等。

如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode

不等是可以的，例如 arrayList 存储的对象就不用实现 hashcode，当然，我们没有理由不实

现，通常都会去实现的

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

常用的类

          java.util.Date,List,HashMap,BufferedReader BufferedWriter ,FileReader FileWirter ,String

  

常用的包

          java.util java.lang java.io,java.sql,Mysql-Connector

常用的接口

Servlet,HttpServletRequest,HttpServletResponse,Transaction(Hibernate)、

Session(Hibernate),HttpSession

40.什么是 java  序列化，如何实现 java  序列化？或者请解释 Serializable 接口 接口

的作用。

序列化:通过对象流将java的类与对象写入到文件中

反序列化:通过对象流将文件中读取类与对象的过程

implements Serializable  只是为了标注该对象是可被序列化的。

41.时间格式化

public class Time {public static void main(String[] args) {Date date=new Date();SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");    String time=sdf.format(date);    System.out.println(time);}}

42.JVM 中类的装载是由 ClassLoader 和它的子类来实现的,Java ClassLoader 是一个重要的

Java 运行时系统组件。它负责在运行时查找和装入类文件的类。

43.JAVA的内存分为栈内存与堆内存

栈内存是指程序进入一个方法时，

会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法

结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。

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

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

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

44.GC  是什么? 为什么要有 GC?

垃圾回收

内存处理是编程人员容易出现问题的地方，

忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java 提供的 GC 功能可以

自动监测对象是否超过作用域从而达到 自动回收内存的目的，Java 语言没有提供释放已分

配内存的显示操作方法。

一块内存空间符合垃圾回收的标准,并不一定就会被垃圾回收,就算是提供了system.gc()的方法

45.什么是内存泄露

是动态存储为函数开辟的动态空间,使用完毕未释放,结果导致一直占据着该内存单元,直到程序结束

46.什么是垃圾回收机制

是Java虚拟机提供的能力,在空闲时间内不定时的回收无任何引用的对象所占据的空间

分代复制垃圾回收,标记垃圾回收,增量垃圾回收

47.垃圾回收的原理

对于gc来说,当程序员创建对象时候,gc就开始监控这个对象的地址.大小以及使用情况,通常gc采用有向图的方式记录和管理这些对象,确定哪些对象是可达的哪些对象是不可达的,对一些不可达的对象进行垃圾回收

48.遍历map

for(Map.Entry<String,Obeject> m:map.entrySet()) {

System.out.println(m.getKey()+"==>"+m.getValue());

}