java开发岗位技能鉴定 java开发工程师考核

三次面试笔记，给最近需要找工作的小伙伴做参考，高手勿喷~

仅仅供需要谋求“Java开发工程师”岗位的朋友参考，涉及内容偏基础，但是经常会被问到~

1.浅克隆和深克隆

1. //浅克隆（类要实现Cloneable接口） 
2. 
3. //浅复制仅仅复制所考虑的对象，而不复制它所引用的对象   //如果复制后的对象重新设置了原对象引用对象的值，则两个对象的引用对象都成了被修改后的引用对象的值
4. 
5. //浅复制指向的还是原对象
6. 
7. public
8. null;
9. try{

10. super.clone();
11. catch(Exception e){

12.           e.printStackTrace();
13.       }
14. return
15.   }
16. 
17. //深克隆（类要实现Serializable接口）
18. 
19. //深复制把要复制的对象所引用的对象都复制了一遍
20. 
21. //深复制复制后的对象指向的是一个新的地址空间，与原对象没关系
22. 
23. public Object deepClone() throws
24.           ByteArrayOutputStream bos =
25. new
26. new
27. this);
28.           ObjectInputStream ois =
29. new
30. new
31. return
32.   }

2.Comparable(compareTo)和Comparator(compare和equals)

排序规则：

1.自然排序

1. class Person implements
2.       public int
3.             if(this>o) return 1;
4.             else if(this==0) return 0;
5.             else  return -1;
6.        }
7.  }

2.客户化排序

1. class Person implements
2.       public int
3.             if(o1>o2) return 1;
4.             else if(o1==o2) return 0;
5.             else return -1;
6.        }
7.  }

3.Map集合使用时，用到的hashCode()和equals()方法

如果需要自定义插入元素的重复规则，需要分别重写hashCode方法和equals方法，

并且应该在equals方法返回结果为false时，让hashCode的返回结果尽可能散列(尽可能不同)，以此减少equals方法的调用，提高插入效率。

为什么在重写equals方法时要重写hashCode方法？

1.如果两个对象相同（即用equals比较返回true）,那么它们的hashCode值一定相同；

2.如果两个对象的hashCode相同，它们并不一定相同（即用equals比较返回false）

为什么equals（）方法要重写？

判断两个对象在逻辑上是否相等，如果根据类的成员变量来判断两个类的实例是否相等，而继承Object中的equals方法只能判断两个引用变量是否是同一个对象，这样往往需要重写equals（）方法

重写equals方法：

1. public boolean
2.       //判断对象是否是同一个
3.       if(this==obj){ return true;}
4.       //判断对象是否属于当前类型
5.       if(!(obj instanceof
6.       return false;
7.        }
8.       //对象内容是否相等。
9.        Student s = (Student)obj;
10. this.sno&&s.age==this.age&&s.name.equals(this.name);
11.  }

==:判断两个对象是否是同一个对象。

4.如果对象的引用被置为 null，垃圾收集器是否会立即释放对象占用的内存？

不会，在下一个垃圾回收周期中，这个对象将是可被回收的。

5.写出2个常见的检查时异常以及4个运行时异常。

    非检查性异常（UnCheckedException/RuntimeException）:java中所有的UncheckExcepiton都是RuntimeException类型的子类类型。编译时不会强制要求进行显式处理，但是在运行时一旦复合某种条件，会抛出异常。一旦程序发生运行时异常，一般会认为时代码逻辑控制不够严谨，或者代码顺序不够合理造成的，建议增加代码逻辑，或者微调代码顺序来规避异常。

  

运行时异常(非检查时异常)：ClassCastException、IndexOutOfBoundsException、

NullPointerException、IllegalArgumentException（向方法中传递了一个不合法或不正确的参数）

检查时异常：IOException、FileNotFoundException、ClassNotFoundException

6.下面都是正确的main方法签名

public static void main(String[] args)
 public static final   void main(String[] args)
 static public void main(String[] args)
 static public synchronized void main(String[] args)
 static public abstract void main(String[] args)//错误（abstract修饰的方法没有方法体，并且类必须也是abstract修饰的）

7.抽象类是否可继承实体类?但前提是实体类必须有无参的构造函数(系统自定义或者自己定义),原因如下:

每一个class都必须有一个构造方法， 如果你没有在代码中声明构造方法，系统会自定义给你生成一个公有的无参构造方法，只要你自己声明了一个构造方法，无论有参无参私有公有，系统就不再帮你生成默认无参构造器了。

所有的子类构造器都要求在第一行代码中调用父类构造器,如果不写,系统默认去调用父类的无参构造器。

8.String和StringBuffer的区别？

String的特点是一旦赋值，便不能更改其指向的字符对象,如果更改，则会指向一个新的字符对象。

StringBuffer是一个具有对象引用传递特点的字符串对象，此对象可以调用其方法动态的进行增删改查操作，

且不用像数组那样事先定义大小，从而实现多次插入字符，一次整体取出的效果，因此操作字符串非常灵活方便。

一旦通过StringBuffer生成最终想要的字符串，就可调用它的toString方法将其转换为一个String对象

速度：StringBuilder>StringBuffer(加锁)>String

9.&和&&的区别？

按位与：a&b是把a和b都转换成二进制数然后再进行与运算

逻辑与：a&&b就是当且仅当两个操作数均为true时，其结果才为true，如果第一个为false，后面的就不需要再判断了。

10.不可变类的解释

不可变类（Immutable class）是指当创建了这个类的实例后，就不允许修改它的值了，也就是说，一个对象一旦被创建出来，在其整个生命周期中，它的成员变量就不能被修改了。它有点类似于常量（const），即只允许其他程序进行读操作，而不允许其他程序进行修改操作。

在 Java 类库中，所有基本类型的包装类都是不可变类，例如 Integer、Float 等。此外，

String 也是不可变类。可能有人会有疑问，既然 String 是不可变类，为什么还可以写出如下代码来修改 String 类型的值呢？

1. public class
2.       public static void
3. "Hello";   s+=" world";
4.              System.out.println(s);
5.        }
6.  }

程序的运行结果为

Hello world

表面上看，s+="world"的作用好像是修改 String 类型对象 s 的值，其实不是，String s="Hello"语句声明了一个可以指向 String 类型对象的引用，这个引用的名字为 s，它指向了一个字符串常量"Hello"。s+="world"并没有改变 s 所指向的字符串的值（由于"Hello"是 String 类型的对象，而 String 又是不可变量），在这行代码运行后，s 指向了另外一个 String 类型的对象，该对象的内容为"Hello world"。原来的那个字符串常量"Hello"还存在于内存中，并没有被改变。

在 Java 语言中，除了 8 种原始的数据类型（分别为 byte、short、int、long、float、double、 char 和 boolean）外，其他的类型都是对象，在方法调用的时候，传递的都是引用。引用从本质上来讲也是按值传递，只不过传递的这个值是对象的引用而已，因此，在方法调用的时候，对形参引用所指对象属性值的修改对实参可见。但是对引用值本身的修改对实参是不可见的。

11. 字符串分为两大类：

一类是字符串常量（ String   ）；另一类是字符串变量（ StringBuffer   ）。

12.接口与抽象类的相同点如下：

1） 都不能被实例化。

2） 接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能被实     例化。

接口与抽象类的不同点如下：

1） 接口只有定义，不能有方法的实现，而抽象类可以有定义与实现，即其方法可以在抽象类中被实现。

2） 实现接口的关键字为 implements，继承抽象类的关键字为 extends。一个类可以实     现多个接口，但一个类只能继承一个抽象类，因此，使用接口可以间接地达到多重继承的    目的。

3） 接口强调特定功能的实现，其设计理念是“has-a”关系，而抽象类强调所属关系，其设计理念为“is-a”关系。

4） 接口中定义的成员变量默认为 public static final，只能够有静态的不能被修改的数据成员，而且，必须给其赋初值，其所有的成员方法都是 public、abstract 的，而且只能被这两个关键字修饰。而抽象类可以有自己的数据成员变量，也可以有非抽象的成员方法，而且，抽象类中的成员变量默认为 default，当然也可以被定义为 private、protected 和 public，这些成员变量可以在子类中被重新定义，也可以被重新赋值，抽象类中的抽象方法（其前有 abstract 修饰）不能用 private、static、synchronized 和 native 等访问修饰符修饰，同时方法必须以分号结尾，并且不带花括号{}。所以，当功能需要累积时，使用抽象类；不需要累积时，使用接口。

接口被运用于实现比较常用的功能，便于日后维护或者添加删除方法，而抽象类更倾向于充当公共类的角色，不适用于日后重新对里面的代码进行修改。

13.CoreJava和高级Java包括的课程:

CoreJava：对象与类、继承、接口与内部类、GUI、事件处理、异常和日志、泛型程序设计、集合、多线程、

高级Java:流与文件，XML，网络，数据库（JDBC）编程

14.大学中上过的课程（只说与专业最相关的）：

CoreJava技术、Java高级开发技术、JavaWeb编程、HTML与CSS技术、C++课程设计、C#编程技术、Linux操作系统、算法分析与设计、数据库课程设计、大型数据库技术、计算机网络、编译原理

15.ooad和ajax中每个字母的含义

ooad:Object-Orient Analysis and Design

ajax:Asynchronous JavaScript and XML(异步JavaScript和XML)

16.创建对象的几种方式：

1.通过new关键字

2.使用Class类的newInstance方法

3.使用Constructor类的newInstance方法

4.使用clone方法

5.使用反序列化

17.TCP与UDP的区别

1.tcp是基于连接的，udp是无连接的

2.对系统资源的要求（TCP较多，UDP较少）

3.UDP程序结构较简单

4.流模式与数据报模式

5.TCP保证数据正确性，UDP可能丢包，TCP保证数据顺序，UDP不保证

18.hashTable和hashMap的区别

Hashmap:线程不安全 允许有null的键和值 效率高一点 方法不是synchronize有containsvalue和containsKey方法

Hashtable:线程安全 不允许有null的键和值 效率稍微低一点 方法是synchronized 有contains方法

19.线程池和数据库连接池

线程池：先启动若干数量的线程，并让这些线程都处于睡眠状态，当客户端有一个新请求时，就会唤醒线程池中的某一个睡眠线程，让它来处理客户端的这个请求，当处理完这个请求后，线程又处于睡眠状态。

数据库连接池的解决方案是在应用程序启动时建立足够的数据库连接，并将这些连接组成一个连接池(简单说：在一个“池”里放了好多半成品的数据库联接对象)，由应用程序动态地对池中的连接进行申请、使用和释放。对于多于连接池中连接数的并发请求，应该在请求队列中排队等待。并且应用程序可以根据池中连接的使用率，动态增加或减少池中的连接数。

20.Java中的队列？

在java5中新增加了java.util.Queue接口，用以支持队列的常见操作。Queue接口与List、Set同一级别，都是继承了Collection接口。
Queue使用时要尽量避免Collection的add()和remove()方法，而是要使用offer()来加入元素，使用poll()来获取并移出元素。它们的优
点是通过返回值可以判断成功与否，add()和remove()方法在失败的时候会抛出异常。 如果要使用前端而不移出该元素，使用
element()或者peek()方法。
值得注意的是LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。LinkedList实现了Queue接口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。

21.基于TCP和udp的协议有哪些？

TCP支持的应用协议主要有：Telnet、FTP、SMTP等；

UDP支持的应用层协议主要有：NFS（网络文件系统）、SNMP（简单网络管理协议）、DNS（主域名称系统）、TFTP（通用文件传输协议）等。

22.Java中的线性结构

常用的线性结构有：线性表，栈，队列，循环队列，数组，串。线性表中包括顺序表、链表等，其中，栈和队列只是属于逻辑上的概念，实际中不存在，仅仅是一种思想，一种理念；线性表则是在内存中数据的一种组织、存储的方式。

23.被final和static修饰

static修饰的方法：

1、父类中的静态方法可以被继承、但不能被子类重写。

2、如果在子类中写一个和父类中一样的静态方法，那么该静态方法由该子类特有，两者不构成重写关系。

final修饰：

1、修饰类表示不允许被继承。

2、修饰方法表示不允许被子类重写，但是可以被子类继承，不能修饰构造方法。

3、修饰变量表示不允许被修改
a）方法内部的局部变量，使用前被赋值即可（只能赋值一次），没有必要非得初始化。
b）类中的成员变量（如果没有在定义时候初始化，那么只能在构造代码块中或者构造方法中赋值）
c）基本数据类型的变量（初始化赋值之后不能更改）
d）引用数据类型的变量（初始化之后不能再指向另外一个对象，但对象的内容是可以变的）

24.xml有4种解析方式：

XML的解析方式分为四种：1、DOM解析；2、SAX解析；3、JDOM解析；4、DOM4J解析。其中前两种属于基础方法，是官方提供的平台无关的解析方式；后两种属于扩展方法，它们是在基础的方法上扩展出来的，只适用于java平台。

25.jsp内置的九大对象

request,response,session,application,out,pagecontext,config,page,exception

26.Spring框架中用到了什么设计模式

    简单工厂、工厂方法、单例模式、适配器、包装器、代理、观察者、策略、模板方法

27.Ajax解释：

    AJAX即“Asychronous Javascript And XML”(异步JavaScript和XML)，是指一种创建交互式网页应用的网页开发技术。通过在后台与服务器进行少量数据交换，AJAX可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。

28.MVC根据项目介绍：

MVC全名是Model View Controller，是模型（model）-试图（view）-控制器（controller）的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。

29.mybatis框架和hibernate的区别？

1.hibernate是全自动的，而mybatis是半自动的

2.hibernate数据库移植性远大于mybatis

3.hibernate拥有完整的日志系统，mybatis则欠缺一些

4.mybatis相比hibernate需要关心很多细节

5.sql直接优化上，mybatis要比hibernate方便很多

总结:mybatis:小巧、方便、高效、简单、直接、半自动

Hibernate：强大、方便、高效、复杂、绕弯、全自动

30.如果有多个中断同时发生,系统将根据中断优先级响应优先级高的中断请求 . 若要调整中断事件的响应次序,可以利用

中断屏蔽

31.js中的null==null(true),NaN==NaN(false)

32.设计模式

设计模式绝对是重点，这里就不过多做介绍了，最好是知道15个左右的模式，熟练掌握七八个，会写代码，会讲原理图。