java 笔试

curiousby 2014-10-09

安全 java 线程 string static exception 多线程 class Servlet hashmap arraylist

Java面试题      
java基础                                                                
1.面向对象的特征有哪些方面

1.抽象:
抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节。抽象包括两个方面,一是过程抽象,二是数据抽象
2.继承:
继承是一种联结类的层次模型,并且允许和鼓励类的重用,它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生,这个过程称为类继承。新类继承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变量,并且类可以修改或增加新的方法使之更适合特殊的需要。
3.封装:
封装是把过程和数据包围起来,对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象。
4. 多态性:(重点) 举例:饮料机冲咖啡冲绿茶都 有相同的动作对该动作做出响应
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。

2.描述checked 和 unchecked exception 的区别 

 异常表示程序运行过程中可能出现的非正常状态,运行时异常表示虚拟机的通常操作中可能遇到的异常,是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常,但是并不要求必须声明抛出未被捕获的运行时异常。

异常表示程序运行过程中可能出现的非正常状态,运行时异常表示虚拟机的通常操作中可能遇到的异常,是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常,但是并不要求必须声明抛出未被捕获的运行时异常。
1) Checked exception: 这类异常都是Exception的子类 。异常的向上抛出机制进行处理,如果子类可能产生A异常,那么在父类中也必须throws A异常。可能导致的问题:代码效率低,耦合度过高。C#中就没有使用这种异常机制。
2) Unchecked exception: 这类异常都是RuntimeException的子类,虽然RuntimeException同样也是Exception的子类,但是它们是特殊的,它们 不能通过client code来试图解决,所以称为Unchecked exception 。
checked exception是需要强制catch的异常,你在调用这个方法的时候,你如果不catch这个异常,那么编译器就会报错,比如说我们读写文件的时候会catch IOException,执行数据库操作会有SQLException等
UnChecked Exception是RuntimeException,也就是说运行时的异常,这种异常不是必须需要catch的,你是无法预料的,比如说你在调用一个 list.szie()的时候,如果这个list为null,那么就会报NUllPointerException,而这个异常就是 RuntimeException,也就是UnChecked Exception
Error和RuntimeException及其子类是unchecked exception.其他exception是checked exception.
checked exception可以出现在throws子句中,unchecked exception不可以。
Error是java自己的错误或者诸如内存耗尽等严重错误,是不可抗拒的,显然没有捕捉的必要,而且也没有办法捕捉。
RuntimeException 是你的程序有逻辑错误,是程序员应该积极避免其出现的异常。比如NullPointerException等,完全是程序员马虎出的错。当遇到这种错误 时,java将这个错误自动捕捉到,比如显示到concole里,然后继续运行。而checked exception如果不捕捉则会导致程序终止。
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说,它表示如果程序运行正常,从不会发生的情
error和excption的区别
Error的继承关系:
java.lang.Object
--java.lang.Throwable
--java.lang.Error
Exception的继承关系:
java.lang.Object
--java.lang.Throwable
--java.lang.Exception
二者的不同之处:
Exception:
1.可以是可被控制(checked) 或不可控制的(unchecked)
2.表示一个由程序员导致的错误
3.应该在应用程序级被处理
Error:
1.总是不可控制的(unchecked)
2.经常用来用于表示系统错误或低层资源的错误
3.如何可能的话,应该在系统级被捕捉

举例: int a= Integer.parseInt("包优");  Unchecked exception

            try{  Integer.parseInt("包优");}catch(Exception e){ throw Exception("转换错误");}   checked exception

 3.编写代买实现一个单例(面试对懂的人来说是装逼,对不懂的人来说是装不傻)

 第一种(懒汉,线程不安全):
public class Singleton {  
        private static Singleton instance;  
        private Singleton (){}  
      public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
        }  
    }  
这种写法lazy loading很明显,但是致命的是在多线程不能正常工作。
第二种(懒汉,线程安全):
Java代码  收藏代码
  public class Singleton {  
        private static Singleton instance;  
        private Singleton (){}  
        public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
        }  
    }  
这种写法能够在多线程中很好的工作,而且看起来它也具备很好的lazy loading,但是,遗憾的是,效率很低,99%情况下不需要同步。
第三种(饿汉):
Java代码  收藏代码
 public class Singleton {  
        private static Singleton instance = new Singleton();  
        private Singleton (){}  
        public static Singleton getInstance() {  
        return instance;  
        }  
    }  
这种方式基于classloder机制避免了多线程的同步问题,不过,instance在类装载时就实例化,虽然导致类装载的原因有很多种,在单例模式中大多数都是调用getInstance方法, 但是也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance显然没有达到lazy loading的效果。
第四种(饿汉,变种):
Java代码  收藏代码
 public class Singleton {  
        private Singleton instance = null;  
        static {  
        instance = new Singleton();  
        }  
        private Singleton (){}  
        public static Singleton getInstance() {  
        return this.instance;  
     }  
    }  
表面上看起来差别挺大,其实更第三种方式差不多,都是在类初始化即实例化instance。
五种(静态内部类):
Java代码  收藏代码
public class Singleton {  
        private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
        }  
        private Singleton (){}  
        public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
        }  
    }  

 这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程,它跟第三种和第四种方式不同的是(很细微的差别):第三种和第四种方式是只要Singleton类被装载了,那么instance就会被实例化(没有达到lazy loading效果),而这种方式是Singleton类被装载了,instance不一定被初始化。因为SingletonHolder类没有被主动使用,只有显示通过调用getInstance方法时,才会显示装载SingletonHolder类,从而实例化instance。想象一下,如果实例化instance很消耗资源,我想让他延迟加载,另外一方面,我不希望在Singleton类加载时就实例化,因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载,那么这个时候实例化instance显然是不合适的。这个时候,这种方式相比第三和第四种方式就显得很合理。
第六种(枚举):
Java代码  收藏代码
public enum Singleton {  
        INSTANCE;  
        public void whateverMethod() {  
        }  
    }  

 这种方式是Effective Java作者Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象,可谓是很坚强的壁垒啊,不过,个人认为由于1.5中才加入enum特性,用这种方式写不免让人感觉生疏,在实际工作中,我也很少看见有人这么写过。
第七种(双重校验锁):
Java代码  收藏代码
   public class Singleton {  
        private volatile static Singleton singleton;  
        private Singleton (){}  
        public static Singleton getSingleton() {  
        if (singleton == null) {  
            synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
            }  
        }  
        return singleton;  
        }  
    }  
这个是第二种方式的升级版,俗称双重检查锁定,详细介绍请查看:http://www.ibm.com/developerworks/cn/java/j-dcl.html
在JDK1.5之后,双重检查锁定才能够正常达到单例效果说出Servlet的生命周期,并说出Servlet和CGI的区别。

4.Servlet 生命周期 Servlet GenericServlet HttpServlet区别

init(servletconfig   config)   
service(servletrequest   req,servletresponse   resp)   
destroy()   
getservletconfig()   
getservletinfo()     service是执行应用逻辑的入口点,包容器调用此方法来响应进来得请求,只是在servlet被成功初始化后才能调用它 
 其实servlet和applet差不多,当一个servlet被实例化后,包容器自动去调用固定的方法首先是init(),然后是service()

Servlet被服务器实例化后,容器运行其init方法,请求到达时运行其service方法,service方法自动派遣运行与请求对应的doXXX方法(doGet,doPost)等,当服务器决定将实例销毁的时候调用其destroy方法。
HttpServlet是GenericServlet的子类。
GenericServlet是个抽象类,必须给出子类才能实例化。它给出了设计servlet的一些骨架,定义了servlet生命周期,还有一些得到名字、配置、初始化参数的方法,其设计的是和应用层协议无关的,也就是说你有可能用非http协议实现它(其实目前Java Servlet还是只有Http一种)。
HttpServlet是子类,当然就具有GenericServlet的一切特性,还添加了doGet, doPost, doDelete, doPut, doTrace等方法对应处理http协议里的命令的请求响应过程。

5.doget dopost 区别

 doget和dopost的区别
get和post是http协议的两种方法,另外还有head, delete等
这两种方法有本质的区别,get只有一个流,参数附加在url后,大小个数有严格限制且只能是字符串。post的参数是通过另外的流传递的,不通过url,所以可以很大,也可以传递二进制数据,如文件的上传。
在servlet开发中,以doGet()和doPost()分别处理get和post方法。
首先判断请求时是get还是post,如果是get就调用doGet(), 如果是post就调用doPost()。都会执行这个方法。
1.doGet
GET 调用用于获取服务器信息,并将其做为响应返回给客户端。当经由Web浏览器或通过HTML、JSP直接访问Servlet的URL时,一般用GET调用。 GET调用在URL里显示正传送给SERVLET的数据,这在系统的安全方面可能带来一些问题,比如用户登录,表单里的用户名和密码需要发送到服务器端, 若使用Get调用,就会在浏览器的URL中显示用户名和密码
2.doPost
它用于客户端把数据传送到服务器端,也会有副作用。但好处是可以隐藏传送给服务器的任何数据。Post适合发送大量的数据

 6.说出ArrayList,Vector, LinkedList的存储性能和特性

 ArrayList和Vector都是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢,Vector由于使用了synchronized方法(线程安全),通常性能上较ArrayList差,而LinkedList使用双向链表实现存储,按序号索引数据需要进行前向或后向遍历,但是插入数据时只需要记录本项的前后项即可,所以插入速度较快。

ArrayList 源码:

private transient Object[] elementData;
private int size;
public void ensureCapacity(int minCapacity) {//注意是public类型,也就是说可以我门自己来重新分配空间  
modCount++;  
int oldCapacity = elementData.length;//老的容量  
if (minCapacity > oldCapacity) {  
    Object oldData[] = elementData;//把当前数组临时保存起来  
    int newCapacity = (oldCapacity * 3)/2 + 1;//加1是为了保证oldCapacity为1或者0的情况下  
        if (newCapacity < minCapacity)//是按1.5被来增加容量的  
    newCapacity = minCapacity;  
           // minCapacity is usually close to size, so this is a win:  
           elementData = Arrays.copyOf(elementData, newCapacity);  
}  

LinkedLIst源码

private static class Entry<E> { 
    E element; 
    Entry<E> next; 
    Entry<E> previous; 
    Entry(E element, Entry<E> next, Entry<E> previous) { 
        this.element = element; 
        this.next = next; 
        this.previous = previous; 
    } 
 } 
public LinkedList() { 
      header.next = header.previous = header; 
}

7.Collection 和 Collections的区别

 Collection是集合类的上级接口,继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类,他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作

 8.HashMap和Hashtable的区别

 HashMap是Hashtable的轻量级实现(非线程安全的实现),他们都完成了Map接口,主要区别在于HashMap允许空(null)键值(key),由于非线程安全,效率上可能高于Hashtable。
HashMap允许将null作为一个entry的key或者value,而Hashtable不允许。
HashMap把Hashtable的contains方法去掉了,改成containsvalue和containsKey。因为contains方法容易让人引起误解。
Hashtable继承自Dictionary类,而HashMap是Java1.2引进的Map interface的一个实现。
最大的不同是,Hashtable的方法是Synchronize的,而HashMap不是,在多个线程访问Hashtable时,不需要自己为它的方法实现同步,而HashMap 就必须为之提供外同步(如果是ArrayList:List lst = Collections.synchronizedList(new ArrayList());如果是HashMap:Map map = Collections.synchronizedMap(new HashMap());)。
Hashtable和HashMap采用的hash/rehash算法都大概一样,所以性能不会有很大的差异

 

Hashtable  extends Dictionary 线程安全

HashMap  extends AbstractMap  null作为一个entry的key或者value

 

(重点) 通过hash(key)定位Entry  table[] 位置

 参考源码 : http://www.cnblogs.com/super-d2/archive/2013/02/22/2922800.html

 9.final, finally, finalize的区别

 final 用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承。
finally是异常处理语句结构的一部分,表示总是执行。
finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提供垃圾收集时的其他资源回收,例如关闭文件等

 

 

 

 

 1.描述synchronized 的作用 ,用法      

 2.java线程的sleep wait notify 方法的区别

 

4.java 中的hashmap 是如何通过key 快速定位value的

 

6.描述 stackoverflowerror 和 outofmemoryError  区别以及java 内存回收机制

7.描述 http 协议中session 机制

8.spring 是如何处理事务的

9.spring 中如何实现 aop

10.请列出你用过的设计模式

 

 

struts+ hibernate+spring                                                                

 1.struts流程 hibernate流程 spring 流程

  2. struts 实现Action还是继承ActionSupport ()

 1、实现Action接口
public static final java.lang.String SUCCESS = "success";
public static final java.lang.String NONE = “none";
public static final java.lang.String ERROR = "error";
public static final java.lang.String INPUT = "input";
public static final java.lang.String LOGIN = "login";
public abstract java.lang.String execute()throws java.lang.Exception;
2、继承ActionSupport类
(1)Actionsupport这个工具类在实现了Action接口的基础上还定义了一个validate()方法,重写该方法,它会在execute()方法之前执行,如校验失败,会转入input处,必须在配置该Action时配置input属性。
(2)另外,Actionsupport还提供了一个getText(String key)方法还实现国际化,该方法从资源文件上获取国际化信息,这样在自定义标签时可以定义一个变量为new actionsupport对象实现国际化。

 

 

数据库                                                                

 1.连接数据库

 private Connection conn=null;
Class.forName("com.mysql.jdbc.Driver");  
conn=DriverManager.getConnection("jdbc:mysql://localhost/lyvee",username,password);
pstmt = conn.prepareStatement(sql);
resultSet = pstmt.executeQuery();
conn.close();

 2.class.forName()?

 Class.forName(String className)这个方法的作用是装载className这个字符串指定的类。调用 forName("X") 将导致名为 X 的类被初始化
Class.forName(className, true, currentLoader) 其中 currentLoader 表示此类的定义类加载器。
Class的装载分了三个阶段,loading(装载),linking(连接)和initializing(实例化)
Class.forName(className)实际上是调用Class.forName(className, true, this.getClass().getClassLoader())。注意第二个参数,是指Class被loading后是不是必须被初始化。
ClassLoader.loadClass(className)实际上调用的是ClassLoader.loadClass(name, false),第二个参数指出Class是否被link。

3.Connection conn 为什么要我关闭?

 rs, ps close,就会有java虚拟机out of memory.
按理说java虚拟机会自动垃圾回收,但为什么这里会这样呢?
原因是rs, ps没有关闭,java虚拟机认为它还在被使用。很多循环以后,就内存满了

x.

 

 

 

 

 

 
 
 
 
 
 
 
 
 
 
 

捐助开发者

在兴趣的驱动下,写一个免费的东西,有欣喜,也还有汗水,希望你喜欢我的作品,同时也能支持一下。 当然,有钱捧个钱场(右上角的爱心标志,支持支付宝和PayPal捐助),没钱捧个人场,谢谢各位。



 
 
 谢谢您的赞助,我会做的更好!

 

 

登录 后评论
下一篇
云栖号资讯小编
20036人浏览
2020-07-13
相关推荐
Java程序员,笔试必读
1107人浏览
2017-11-11 17:00:00
【Java】广州三本秋招经历
2634人浏览
2018-10-22 17:35:58
一个Java程序员的阿里之路
1585人浏览
2018-10-20 17:32:18
Java笔试面试题合集
566人浏览
2017-03-11 10:22:40
为什么程序员都反感笔试?
1078人浏览
2017-10-09 08:32:00
NIO学习笔试(5)-提高篇
660人浏览
2017-10-29 17:22:00
企业的烦恼(1)
855人浏览
2017-11-16 14:19:00
java笔试三
421人浏览
2015-08-01 20:46:00
笔试题解答
637人浏览
2018-08-22 23:46:00
0
0
0
774