java面试集锦整理

 

一．        面向对象的特性

1.      面向对象的特征

   继承：经过子类能够实现继承，子类继承父类的全部状态和行为，同时添加自身的状态和行为。

   封装：将代码及处理数据绑定在一块儿的一种编程机制，该机制保证程序和数据不受外部干扰。

   多态：包括重载和重写。重载为编译时多态，重写是运行时多态。重载必须是同类中名称相同参数不一样（包括个数不一样和类型不一样），但返回类型不一样不构成重载；重写发生于子类对父类的覆盖，子类继承父类方法名相同、参数列表相同、返回类型相同才构成重写。

2.      类、对象的概念：

   类：具备共同属性和行为的对象的抽象。类是建立对象的模板。

   对象：现实世界中的实体。在计算机中，是指可标识的存储区域。

   类是对象的抽象、对象是类的实例。

3.      接口与抽象类：

   抽象：是从特定的实例中抽取共同性质造成通常化概念的过程。

   接口和抽象类都用于抽象，接口是抽象类的抽象。

   接口中只有方法声明，没有实现（无方法体）；在接口中声明的方法具备public和abstract属性，一个类能够实现多个接口（即多继承），接口以‘，’分隔；接口中的方法必须所有实现。

   抽象类能够有部分方法实现，抽象类必须经过继承才能使用。

4.      内部类（Inner Class）

   内部类是嵌套在另外一个类中的类。

   内部类用于名称隐藏和程序代码的组织，另外内部类拥有直接访问其外部类全部成员（包括private的）的权限（无需任何关键字修饰）。

   内部类不能够在其余类或main方法里实例化，必须使用以下方法（非静态内部类）

   外部类.内部类 对象名=new 外部类().new 内部类();

   静态内部类调用方式：

   外部类.内部类 对象名=new 外部类.内部类();

   非静态内部类不能够声明静态成员；静态内部类的非静态成员能够访问其外部类的静态成员，声明为静态的成员不能够访问外部的非静态成员。

5.      访问修饰符限制

   Private protected friendly(default) public

   同类 Y Y Y Y

   同包不一样类 N Y Y Y

   同包子类 N Y Y Y

   不一样包不一样类 N N N Y

   不一样包子类 N Y N Y

6.      Static关键字的使用

   类成员，直接使用 类名.成员 调用。

   静态方法只能访问静态成员。

   静态方法不能使用this、super关键字。

   静态方法不能被非静态方法重写或重载。

7.      final关键字：

   被final修饰的变量为常量不能改变。

   被final修饰的方法不能够重写。

   被final修饰的类不能被继承。

8.      abstract关键字

   被abstract修饰的类不能实例化。

   被abstract修饰的方法只能在子类中实现。

9.      native关键字

   非Java语言的编写，例如JNI技术。

10.   synchronized关键字

   多线程的同步访问控制。

11.   简述UML中类的关系

   当一个类是“一种”另外一个类时：is-a关系

   当两个类之间有关联时：

   一个类“包含”另外一个类：has-a关系

   一个类“使用”另外一个类

   还能够细分有聚合和组合（UML宝典）或汇集和组成（包括国内某些知名学术团体都这么说）。

   汇集（aggregation）表示总体与各部分之间的关系。例如汽车与轮胎，没有了汽车轮胎依然是一个总体。（用空心菱形表示）

   组成是一种总体和部分所属更强的汇集关系，每一个部分只能属于一个总体，没有总体部分也就没有存在的价值。好比桌子和桌腿，没有桌子也就没有桌腿的价值了。（用实心菱形表示）

12.   设计模式

  一个设计模式描述了一个被证明可行的方案。这些方案很是广泛，是具备完整定义的最经常使用的模式。通常模式有4个基本要素：模式名称（pattern name）、问题（problem）、解决方案（solution）、效果（consequences）。常见23种模式概述：

   抽象工厂模式（Abstract Factory）：提供一个建立一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

   适配器模式（Adapter）：将一个类的接口转换成客户但愿的另一个接口。适配器模式使得本来因为接口不兼容而不能一块儿工做的类能够一块儿工做。

   桥梁模式（Bridge）：将抽象部分与它的实现部分分离，使它们均可以独立地变化。

   建造模式（Builder）：将一个复杂对象的构建与它的表示分离，使一样的构建过程能够建立不一样的表示。

   责任链模式（Chain of Responsibility）：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。

   命令模式（Command）：将一个请求封装为一个对象，从而可用不一样的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操做。

   合成模式（Composite）：将对象组合成树形结构以表示“部分－总体”的层次结构。它使得客户对单个对象和复合对象的使用具备一致性。

   装饰模式（Decorator）：动态地给一个对象添加一些额外的职责。就扩展功能而言，它能生成子类的方式更为灵活。

   门面模式（Facade）：为子系统中的一组接口提供一个一致的界面，门面模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

   工厂方法（Factory Method）：定义一个用于建立对象的接口，让子类决定将哪个类实例化。Factory Method 使一个类的实例化延迟到其子类。

   享元模式（Flyweight）：运用共享技术以有效地支持大量细粒度的对象。

   解释器模式（Interpreter）：给定一个语言，定义它的语法的一种表示，并定义一个解释器，该解释器使用该表示解释语言中的句子。

   迭代子模式（Iterator）：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需暴露该对象的内部表示。

   调停者模式（Mediator）：用一个中介对象来封装一系列的对象交互。中介者使各对象不须要显式的内部表示。

   备忘录模式（Memento）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象以外保存这个状态。这样之后就可将该对象恢复到保存的状态。

   观察者模式（Observer）：定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，全部依赖于它的对象都获得通知并自动刷新。

   原始模型模式（Prototype）：用原型实例指定建立对象的种类，而且经过拷贝这个原型建立新的对象。

   代理模式（Proxy）：为其余对象提供一个代理以控制对这个对象的访问。

   单例模式（Singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

   状态模式（State）：容许一个对象在其内部状态改变时改变它的行为。对象看起来彷佛修改了它所属的类。

   策略模式（Strategy）：定义一系列的算法，把它们一个个封装起来，而且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。

   模板模式（Template Method）：定义一个操做中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类能够不改变一个算法的结构便可重定义该算法的某些特定步骤。

   访问者模式（Visitor）：表示一个做用于某对象结构中的各元素的操做。该模式能够实如今不改变各元素的类的前提下定义做用于这些元素的新操做。

二．        JAVA概念

1.      什么是 J2EE

   J2EE是Sun公司提出的多层(multi-diered),分布式(distributed),基于组件(component-base)的企业级应用模型(enterpriese application model).在这样的一个应用系统中，可按照功能划分为不一样的组件，这些组件又可在不一样计算机上，而且处于相应的层次(tier)中。所属层次包括客户层(clietn tier)组件,web层和组件,Business层和组件,企业信息系统(EIS)层。

2.      分类列举服务器和组件技术

   服务器端技术：Jsp、Servlet；

   组件技术：JavaBean、EJB。

3.      Anonymous Inner Class (匿名内部类) 

   匿名的内部类是没有名字的内部类。不能继承其它类，但可做为一个接口，由另外一个内部类实现。

4.      Static Nested Class 和 Inner Class的不一样。

   Nested Class （通常是C++的说法），Inner Class (通常是JAVA的说法)。Java内部类与C++嵌套类最大的不一样就在因而否有指向外部的引用上。

   注：静态内部类（Inner Class）意味着：

l   建立一个static内部类的对象

l   不能从一个static内部类的一个对象访问一个外部类对象

5.      Http与Https

   Https即多了安全的Http，s（Security Socket Layer）指加密套接字协议层（简写SSL）。

6.      OSI（Open System Interconnection）网络抽象模型

   由国际标准化组织（ISO）提出。

   将互联网分为七层，从下至上分别为：物理层（physical）、数据链路层（data link）、网络层（network）、传送层（transport）、会话层（session）、表示层（presentation）、应用层（application）。底层经过提供接口支持上层功能。各层详解：

   物理层：LAN/ATM，为硬件层。

   数据链路层：LAN/ATM

   网络层：IP协议，IOS

   传输层：TCP/UDP协议，支持Java Socket。

   会话层：

   表示层：HTML、XML

   应用层：HTTP协议，使用Java Servlet/JSP

   <第八层（Web服务层）：SOAP/UDDI>

7.      J2EE的容器与服务器

   容器负责EJB组件中生命周期的控制；

   服务器包含在容器外，提供系统级操做底层服务，包括事务、事件、多线程……。

8.      继承限制

   父类对象不能够赋给子类对象，由于子类可能具备更多的成员，反之能够。

9.      列举常见集合框架类型

   List、Set、Map。由这三个接口实现出ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等经常使用集合框架。

   Vector属于重量级组件不推荐使用。

   Map类型维护键/值对，Hashtable与HashMap相近但效率略低于HashMap、高于TreeMap，TreeMap优势是能够排序。

   Set类型可装入惟一值，HashSet效率高于TreeSet但TreeSet能够维护内部元素的排序状态。

   List类型可按某种特定顺序维护元素。ArrayList容许快速随机访问，但若是添加或删除位于中间的元素时效率很低；LikedList提供最佳循序访问及快速的中间位置添加删除元素，并有addFirst、addLast、getFirst、getLast、removeFirst、 removeLast方法。

10.    ArrayList与Vector区别

   同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的 

   数据增加:当须要增加时,Vector默认增加为原来一培，而ArrayList倒是原来的一半 

11.   HashMap与HashTable区别 

   都属于Map接口的类，实现了将唯一键映射到特定的值上。

   历史缘由：Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。

   同步性：Hashtable是线程安全的，也就是说是同步的，它也比 HashMap 慢，而HashMap是线程序不安全的，不是同步的。

   HashMap 类容许一个 null 键和多个 null 值。

   Hashtable 类不容许 null 键和 null 值。

12.   String与StringBuffer以及StringBuilder的区别

   String类型和StringBuffer、StringBuilder类型的主要性能区别其实在于 String是不可变的对象，然后俩者都是可变的。 

   StringBuffer和StringBuilder的Append实现都是调用父类实现的。惟一不一样的是 StringBuffer是线程安全的，方法中多了synchronized，而StringBuilder 是非线程安全的。

13.   Collection 和 Collections的区别

   Collections是个java.util下的类，它包含有各类有关集合操做的静态方法。

   Collection是个java.util下的接口，它是各类集合结构的父接口。

14.   char型变量中可否存储中文汉字

   能，由于java中以unicode编码，一个char占16个字节，所以，存放一个中文是没有问题的。

15.   String s = new String("xyz"); 建立了几个String Object？

   两个对象，一个是String类型的“xyx”,一个是指向“xyx”的引用对象s。

16.  是否能够继承String类?

   String类是final类故不能够继承。

17.   当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

   不能，一个对象的一个synchronized方法只能由一个线程访问。

18.   Math.round(11.5)=? ,  Math.round(-11.5)=?

   Math.round(11.5)返回（long）12

   Math.round(-11.5)返回（long）-11;

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

   都不能

20.   接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

   接口能够继承接口。抽象类能够实现(implements)接口，抽象类能够继承实体类，但前提是实体类必须有明确的构造函数。

21.   &和&&的区别

   &是位运算符。

   &&是布尔逻辑运算符。

22.   Java缓存两种方式

   文件缓存，是指把数据存储在磁盘上，能够XML格式，也能够序列化文件DAT格式仍是其它文件格式。 

   内存缓存，也就是实现一个类中静态Map，对这个Map进行常规的增删查。

23.   Java对象的强、软、弱和虚引用

   在JDK 1.2之前的版本中，若一个对象不被任何变量引用，那么程序就没法再使用这个对象。也就是说，只有对象处于可触及（reachable）状态，程序才能使用它。从JDK 1.2版本开始，把对象的引用分为4种级别，从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

   强引用（StrongReference）：是使用最广泛的引用。若是一个对象具备强引用，那垃圾回收器毫不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具备强引用的对象来解决内存不足的问题。

   软引用（SoftReference）：若是一个对象只具备软引用，则内存空间足够，垃圾回收器就不会回收它；若是内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就能够被程序使用。软引用可用来实现内存敏感的高速缓存。软引用能够和一个引用队列（ReferenceQueue）联合使用，若是软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

   弱引用（WeakReference）：弱引用与软引用的区别在于：只具备弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程当中，一旦发现了只具备弱引用的对象，无论当前内存空间足够与否，都会回收它的内存。不过，因为垃圾回收器是一个优先级很低的线程，所以不必定会很快发现那些只具备弱引用的对象。弱引用能够和一个引用队列（ReferenceQueue）联合使用，若是弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

   虚引用（PhantomReference）：顾名思义，就是形同虚设，与其余几种引用都不一样，虚引用并不会决定对象的生命周期。若是一个对象仅持有虚引用，那么它就和没有任何引用同样，在任什么时候候均可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，若是发现它还有虚引用，就会在回收对象的内存以前，把这个虚引用加入到与之 关联的引用队列中。程序能够经过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。若是程序发现某个虚引用已经被加入到引用队列，那么就能够在所引用的对象的内存被回收以前采起必要的行动。

24.   何时用assert

   断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。若是表达式计算为 false，那么系统会报告一个 AssertionError。示例：

   assert(a > 0); // throws an AssertionError if a <= 0

   断言能够有两种形式：

   assert Expression1 ;

   assert Expression1 : Expression2 ;

   Expression1 应该老是产生一个布尔值。

   Expression2 能够是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。

   断言在默认状况下是禁用的。要在编译时启用断言，须要使用 source 1.4 标记：

   javac -source 1.4 Test.java

   要在运行时启用断言，可以使用 -enableassertions 或者 -ea 标记。

   要在运行时选择禁用断言，可以使用 -da 或者 -disableassertions 标记。

   要系统类中启用断言，可以使用 -esa 或者 -dsa 标记。还能够在包的基础上启用或者禁用断言。

   能够在预计正常状况下不会到达的任何位置上放置断言。断言能够用于验证传递给私有方法的参数。不过，断言不该该用于验证传递给公有方法的参数，由于无论是否启用了断言，公有方法都必须检查其参数。不过，既能够在公有方法中，也能够在非公有方法中利用断言测试后置条件。另外，断言不该该以任何方式改变程序的状态。

25.   多线程以及同步的实现

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

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

26.   Java垃圾回收机制

   Java的垃圾回收机制是Java虚拟机提供的能力，用于在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间。

   须要注意的是：垃圾回收的是无任何引用的对象占据的内存空间而不是对象自己。

   显示通知JVM进行垃圾回收：

System.gc()

Runtime.getRuntime().gc() 

    上面的方法调用时用于显式通知JVM能够进行一次垃圾回收，但真正垃圾回收机制具体在什么时间点开始发生动做这一样是不可预料的，这和抢占式的线程在发生做用时的原理同样。

27.   Java中判断int, float的值是否相等

   int：a == b;

   float：a – b < 0.000001f;

28.   编程题: 用最有效率的方法算出2乘以8等於几?

   位运算符计算：2《3 = 8

29.   当一个对象被看成参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里究竟是值传递仍是引用传递?

   Java 编程语言只有值传递。当一个对象实例做为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容能够在被调用的方法中改变，但对象的引用是永远不会改变的。

   这里的内存模型涉及到两种类型的内存：栈内存(stack)和堆内存(heap)。传递的是栈内存中的数据。

30.   swtich是否能做用在byte上，是否能做用在long上，是否能做用在String上?

   switch（expr1）中，expr1是一个整数表达式，所以传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者byte。

   long，string 都不能做用于swtich。

31.   final, finally, finalize的区别

   final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。若是一个类被声明为final，意味着它不能再派生出新的子类，所以一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，能够保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在之后的引用中只能读取，不可修改。被声明为final的方法也一样只能使用，不能重载。内部类要访问局部变量，局部变量必须定义成final类型，例如，一段代码……

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

   finalize是Object类的一个方法，所以全部的类都继承了它，在垃圾收集器执行的时候会调用被回收对象的此方法，能够覆盖此方法提供垃圾收集时的其余资源回收，例如关闭文件等。JVM不保证此方法总被调用

32.   运行时异常与通常异常异同

   运行异常表示程序运行过程当中可能出现的非正常状态，运行时异常表示虚拟机的一般操做中可能遇到的异常，是一种常见运行错误。

   java编译器要求方法必须声明抛出可能发生的非运行时异常，可是并不要求必须声明抛出未被捕获的运行时异常。

33.   error和exception的区别

   error 表示恢复不是不可能但很困难的状况下的一种严重问题。好比说内存溢出。不可能期望程序能处理这样的状况。

   exception 表示一种设计或实现问题。也就是说，它表示若是程序运行正常，从不会发生的状况。

34.   Java中的异常处理机制的简单原理和应用

   异常是指java程序运行时（非编译）所发生的非正常状况或错误，与现实生活中的事件很类似，现实生活中的事件能够包含事件发生的时间、地点、人物、情节等信息，能够用一个对象来表示，Java使用面向对象的方式来处理异常，它把程序中发生的每一个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。

   Java对异常进行了分类，不一样类型的异常分别用不一样的Java类表示，全部异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，Error 表示应用程序自己没法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception表示程序还可以克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件自己缺陷所致使的问题，也就是软件开发人员考虑不周所致使的问题，软件使用者没法克服和恢复这种问题，但在这种问题下还可让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所致使的问题，是用户可以克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不该该死掉。

   java为系统异常和普通异常提供了不一样的解决方案，编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，因此普通异常也称为checked异常，而系统异常能够处理也能够不处理，因此，编译器不强制用try..catch处理或用throws声明，因此系统异常也称为unchecked异常。

    提示答题者：就按照三个级别去思考：虚拟机必须宕机的错误，程序能够死掉也能够不死掉的错误，程序不该该死掉的错误；

35.   写出你最多见到的5个runtime exception

   这道题主要考你的代码量到底多大，若是你长期写代码的，应该常常都看到过一些系统方面的异常，你不必定真要回答出5个具体的系统异常，但你要可以说出什么是系统异常，以及几个系统异常就能够了，固然，这些异常彻底用其英文名称来写是最好的，若是实在写不出，那就用中文吧，有总比没有强！

   所谓系统异常，就是…..，它们都是RuntimeException的子类，在jdk doc中查RuntimeException类，就能够看到其全部的子类列表，也就是看到了全部的系统异常。我比较有印象的系统异常有：NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException。

36.   JAVA语言如何进行异常处理

   Java 经过面向对象的方法进行异常处理,把各类不一样的异常进行分类,并提供了良好的接口。在 Java 中,每一个异常都是一个对象,它是 Throwable 类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象,该对象中包含有异常信息,调用这个对象的方法能够捕获到这个异常并进行处理。Java 的异常处理是经过 5 个关键词来实现的:try、catch、throw、throws 和 finally。一

   般状况下是用 try 来执行一段程序,若是出现异常,系统会抛出(throws)一个异常,这时候你能够经过它的类型来捕捉(catch)它,或最后(finally)由缺省处理器来处理;

    try 用来指定一块预防全部“异常”的程序;

    catch 子句紧跟在 try 块后面,用来指定你想要捕捉的“异常”的类型;

    throw 语句用来明确地抛出一个“异常”;

    throws 用来标明一个成员函数可能抛出的各类“异常”;

    Finally 为确保一段代码无论发生什么“异常”都被执行一段代码;

    能够在一个成员函数调用的外面写一个 try 语句,    在这个成员函数内部写另外一个 try 语句保护其余代码。每当遇到一个 try 语句,“异常”的框架就放到堆栈上面,直到全部的 try 语句都完成。若是下一级的 try 语句没有对某种“异常”进行处理,堆栈就会展开,直到遇到有处理这种“异常”的 try 语句。

37.   Web Service名词解释

   Web Service描述语言WSDL SOAP即简单对象访问协议(Simple Object Access Protocol)，它是用于交换XML编码信息的轻量级协议。 

   UDDI 的目的是为电子商务创建标准；UDDI是一套基于Web的、分布式的、为Web Service提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业可以发现的访问协议的实现标准。

38.   Java命名规范

   必须以英文字母、下划线（’_’）或’$’开始，其他能够有数字但不容许 包含空格，且组合后的名称不能是Java关键字或保留字。

   匈牙利命名法：以m开始为类成员变量，以g开始为全局变量，以v开始为本地局部变量，常量命名通常不如下划线、美圆符开始。

   驼峰命名：通常称由多个单词或缩写组成的变量名，而且该变量名每一个单词首字母均为大写（通常类名所有首字母大写，方法或属性名第一个字母小写）的称为驼峰命名。

39.   线程中的Run和Start方法

    用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。经过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并无运行，一旦获得spu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

   run()方法只是类的一个普通方法而已，若是直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径仍是只有一条，仍是要顺序执行，仍是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

40.   Java建立多线程程序的方法

   经过建立Thread类的子类来实现

l   设计Thread的子类

l   根据工做须要从新设计线程的run方法

l   线程类Thread中提供的run是一个空方法。为此，咱们能够继承Thread，而后覆盖(override)其中的run，使得该线程可以完成特定的工做。

l   使用start方法启动线程，将执行权转交到run。

   经过实现Runable接口的类来实现（推荐）

l   建立某个类实现Runnable接口，实现run()方法。

l   建立Thread对象，用实现Runnable接口的对象做为参数实例化该Thread对象。

l   调用Thread的start方法。

41.   try{}中有return语句，那么紧跟在这个try后的finally {}里的code什么时候执行

   会执行，在return前执行。

 1 public  class Test {
 2 
 3          public static void main(String[] args) {
 4 
 5                    System.out.println(new Test().test());
 6 
 7          }
 8 
 9          static int test(){
10 
11                    int x = 1;
12 
13                    Try{
14 
15                             return x;
16 
17                   }Finally{
18 
19                             ++x;
20 
21                    }
22 
23          }
24 
25 }

View Code

输出结果 1

 1 public class  smallT{
 2 
 3      public static void main(String args[]){
 4 
 5                    smallT t  = new  smallT();
 6 
 7                    int  b  =  t.get();
 8 
 9                    System.out.println(b);
10 
11          }
12 
13          Public  int  get(){
14 
15                    Try{
16 
17                             return 1 ;
18 
19                    }Finally{
20 
21                             return 2 ;
22 
23                    }
24 
25          }
26 
27 }

View Code

输出结果 2

42.   Singleton实现对比              

  

三．        框架的理解与运用

1.      Hibernate框架相关

Ø  Hibernate总览

    SessionFactory (net.sf.hibernate.SessionFactory)：对编译过的映射文件的一个线程安全的，不可变的缓存快照。它是Session的工厂。是ConnectionProvider的客户。

   可能持有事务之间重用的数据的缓存。

l   会话，Session (net.sf.hibernate.Session) 单线程，生命期短促的对象，表明应用程序和持久化层之间的一次对话。封装了一个JDBC链接。也是Transaction的工厂。

   持有持久化对象的缓存。

l   持久化对象（Persistent Object)及其集合(Collection)：生命期短促的单线程的对象，包含了持久化状态和商业功能。它们多是普通的JavaBeans，惟一特别的是他们如今从属于且仅从属于一个Session。

l   临时对象(Transient Object)及其集合（Collection） ：目前没有从属于一个Session的持久化类的实例。他们多是刚刚被程序实例化，尚未来得及被持久化，或者是被一个已经关闭的Session所实例化的。

l   事务，Transaction (net.sf.hibernate.Transaction)：（可选） 单线程，生命期短促的对象，应用程序用它来表示一批工做的原子操做。是底层的JDBC,JTA或者CORBA事务的抽象。一个Session可能跨越多个Transaction 事务。

l   ConnectionProvider (net.sf.hibernate.connection.ConnectionProvider)：（可选）JDBC链接的工厂和池。从底层的Datasource或者 DriverManager抽象而来。对应用程序不可见。

l   TransactionFactory (net.sf.hibernate.TransactionFactory)：（可选）事务实例的工厂。对应用程序不可见。

   在上面的轻型结构中，程序没有使用Transaction / TransactionFactory 或者ConnectionProvider API,直接和JTA/JDBC对话了。

Ø  Hibernate持久化对象标识（Persistent Object Identity ）

   应用程序可能同时在两个不一样的session中存取同一个持久化对象。然而，两个Session实例是不可能共享一个持久化类的实例的。有两种不一样的用来辨别对象是否相同的方法。

   Persistent Identity，持久化辨别

   foo.getId().equals( bar.getId() )

   JVM Identity， JVM辨别

   foo==bar

   对于同一个特定的Session返回的对象来讲，这两者是等价的。然而，当程序并行在两个不一样的session中访问含义上“相同”（持久化辨别）的商业对象时，两个对象实例从JVM的角度上来看倒是“不一样”的（JVM辨别）

   这种方式把并行访问（应用程序不须要对任何商业对象进行同步，只要求遵循每一个Session一个线程的原则)和对象辨别(在应用程序的一个session之中，能够安全的用==来比较对象)的难题留给了Hibernate和数据库。

Ø  Hibernate工做原理

   读取并解析配置文件

   读取并解析映射信息，建立SessionFactory

   打开Session

   建立事务Transation

   持久化操做

   提交事务

   关闭Session

   关闭SesstionFactory

Ø  Hibernate优势

   对JDBC访问数据库的代码作了封装，大大简化了数据访问层繁琐的重复性代码。

   Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工做。

   大多数 EJB CMP CMR 解决方案使用代码生成实现持久性代码，而 JDO 使用字节码修饰。与之相反，Hibernate 使用反射和运行时字节码生成，使它对于最终用户几乎是透明的 hibernate使用Java反射机制，而不是字节码加强程序来实现透明性。

   Hibernate的性能很是好，由于它是个轻量级框架。映射的灵活性很出色。它支持各类关系数据库，从一对一到多对多的各类复杂关系。

Ø  Hibernate如何延迟加载

   Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）

   Hibernate3 提供了属性的延迟加载功能 当Hibernate在查询数据的时候，数据并无存在与内存中，当程序真正对数据的操做时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提升了服务器的性能。 

Ø  Hibernate中怎样实现类之间的关系(如：一对多、多对多的关系)

   类与类之间的关系主要体如今表与表之间的关系进行操做，它们都市对对象进行操做，咱们程序中把全部的表与类都映射在一块儿，它们经过配置文件中的many-to-one、one-to-many、many-to-many

2.      Spring框架相关

Ø  Spring总览

    Core包是框架的最基础部分， 并提供依赖注入（Dependency Injection）特性来使你可管理Bean容器功能。 这里的基础概念是BeanFactory，它提供Factory模式来消除对程序性单例的须要， 并容许你从程序逻辑中分离出依赖关系的配置和描述。

   构建于Beans包上Context包，提供了一种框架式的Bean访问方式， 有些象JNDI注册。Context包的特性得自Beans包，并添加了文本消息的发送，经过好比资源串， 事件传播，资源装载的方式和Context的透明建立，如经过Servlet容器。

   DAO包提供了JDBC的抽象层，它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码。 该包也提供了一种方法实现编程性和声明性事务管理，不只仅是针对实现特定接口的类， 并且对全部的POJO。

   ORM包为流行的关系－对象映射APIs提供了集成层，包括JDO，Hibernate和iBatis。 经过ORM包，你可与全部Spring提供的其余特性相结合来使用这些对象/关系映射， 如前边提到的简单声明性事务管理。

   Spring的AOP包提供与AOP联盟兼容的面向方面编程实现，容许你定义， 如方法拦截器和切点，来干净地给从逻辑上说应该被分离的功能实现代码解耦。 使用源码级的元数据

   功能，你可将各类行为信息合并到你的代码中，有点象.Net的attribute。

   Spring的Web包提供了基本的面向Web的综合特性，如Multipart功能， 使用Servlet监听器的Context的初始化和面向Web的Applicatin Context。 当与WebWork或Struts一块儿使用Spring时，这个包使Spring可与其余框架结合。

   Spring的Web MVC包提供了面向Web应用的Model-View-Controller实现。 Spring的MVC实现不只仅是一种实现，它提供了一种domain model代码和web form的清晰分离， 这使你可以使用Spring框架的全部其余特性，如校验.

Ø  Spring概念

   Spring是一个集成了许多第三方框架的大杂烩，其核心技术是IOC（控制反转，也称依赖注入）和AOP（面向切面编程）。

   简单地说，AOP 让开发人员能够建立非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务（好比日志、持久性、事务等）就能够分解成方面并应用到域对象上，同时不会增长域对象的对象模型的复杂性。

   IOC 容许建立一个能够构造对象的应用环境，而后向这些对象传递它们的协做对象。正如单词“倒置”所代表的，IOC 就像反过来的JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每个对象都是用其协做对象构造的。所以是由容器管理协做对象（collaborator）。

   Spring既是一个AOP框架，也是一个IOC容器。 Spring 最好的地方是它有助于您替换对象。有了Spring，只要用 JavaBean 属性和配置文件加入依赖性（协做对象）。而后能够很容易地在须要时替换具备相似接口的协做对象。

   Spring中I0C的三种实现机制：经过setter方法注入、经过构造方法注入和接口注入。

3.      Spring IOC与Hibernate配置

  

四．        JSP运用

1.      JSP的内置对象及做用

   JSP共有如下9种基本内置组件（可与ASP的6种内部组件相对应）： 

   request 用户端请求，此请求会包含来自GET/POST请求的参数 

   response 网页传回用户端的回应 

   pageContext 网页的属性是在这里管理 

   session 与请求有关的会话期 

   application servlet 正在执行的内容 

   out 用来传送回应的输出 

   config servlet的构架部件 

   page JSP网页自己 

   exception 针对错误网页，未捕捉的例外

2.      JSP经常使用的方法及做用

   JSP共有如下6种基本动做 

   jsp:include：在页面被请求的时候引入一个文件。 

   jsp:useBean：寻找或者实例化一个JavaBean。 

   jsp:setProperty：设置JavaBean的属性。 

   jsp:getProperty：输出某个JavaBean的属性。 

   jsp:forward：把请求转到一个新的页面。 

   jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记

3.      JSP中动态INCLUDE与静态INCLUDE的区别

   动态INCLUDE用jsp:include动做实现 

   <jsp:include page="included.jsp" flush="true" />它老是会检查所含文件中的变化，适合用于包含动态页面，而且能够带参数 

   静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面 

   <%@ include file="included.htm" %>

4.      JSP两种跳转方式

   有两种，分别为： 

   <jsp:include page="included.jsp" flush="true"> 

   <jsp:forward page= "nextpage.jsp"/> 

   前者页面不会转向include所指的页面，只是显示该页的结果，主页面仍是原来的页面。执行完后还会回来，至关于函数调用。而且能够带参数.后者彻底转向新页面，不会再回来。至关于go to 语句。

五．        Servlet相关

1.      Servlet的生命周期?

   servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。

   这个生存期由javax.servlet.Servlet接口的init,service和destroy方法表达。

2.      JAVA Servlet API中forward()与redirect()的区别

   前者仅是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；

   后者则是彻底的跳转，浏览器将会获得跳转的地址，并从新发送请求连接。

   这样，从浏览器的地址栏中能够看到跳转后的连接地址。因此，前者更加高效，在前者能够知足须要时，尽可能使用forward()方法，而且，这样也有助于隐藏实际的连接。在有些状况下，好比，须要跳转到一个其它服务器上的资源，则必须使用sendRedirect()方法。

3.      Servlet的基本架构 

 1 public class ServletName extends HttpServlet {  2 
 3 public void doPost(HttpServletRequest request, HttpServletResponse response) throws 
 4 
 5 ServletException, IOException {  6 
 7 }  8 
 9 public void doGet(HttpServletRequest request, HttpServletResponse response) throws 
10 
11 ServletException, IOException { 12 
13 } 14 
15 }

View Code

 

六．        数据库

1.      MySQL相关

Ø  MYSQL支持事务吗？ 

   在缺省模式下，MYSQL是autocommit模式的，全部的数据库更新操做都会即时提交，因此在缺省状况下，mysql是不支持事务的。 

可是若是你的MYSQL表类型是使用InnoDB Tables 或 BDB tables的话，你的MYSQL就可使用事务处理,使用SET AUTOCOMMIT=0就可使MYSQL容许在非autocommit模式， 在非autocommit模式下，你必须使用COMMIT来提交你的更改，或者用ROLLBACK来回滚你的更改。 示例以下： 

START TRANSACTION; 

SELECT @A:=SUM(salary) FROM table1 WHERE type=1; 

UPDATE table2 SET summmary=@A WHERE type=1; 

COMMIT;

Ø  MYSQL相比于其余数据库有哪些特色？ 

   MySQL是一个小型关系型数据库管理系统，开发者为瑞典MySQL AB公司，如今已经 被Sun公司收购，支持FreeBSD、Linux、MAC、Windows等多种操做系统 与其余的大型数据库例如Oracle、DB二、SQL Server等相比功能稍弱一些 

l   能够处理拥有上千万条记录的大型数据 

l   支持常见的SQL语句规范 

l   可移植行高，安装简单小巧 

l   良好的运行效率，有丰富信息的网络支持 

l   调试、管理，优化简单（相对其余大型数据库）

Ø  如何提升MySql的安全性？ 

   若是MYSQL客户端和服务器端的链接须要跨越并经过不可信任的网络，那么须要使用ssh隧道来加密该链接的通讯。 

   使用set password语句来修改用户的密码，先“mysql -u root”登录数据库系统，而后“mysql> update mysql.user set password=password(’newpwd’)”，最后执行“flush privileges”就能够了。 

   Mysql须要提防的攻击有，防偷听、篡改、回放、拒绝服务等，不涉及可用性和容错方面。对全部的链接、查询、其余操做使用基于acl即访问控制列表的安全措施来完成。也有一些对ssl链接的支持。 

   设置除了root用户外的其余任何用户不容许访问mysql主数据库中的user表; 加密后存放在user表中的加密后的用户密码一旦泄露，其余人能够随意用该用户名/密码相应的数据库; 

   使用grant和revoke语句来进行用户访问控制的工做; 

   不要使用明文密码，而是使用md5()和sha1()等单向的哈系函数来设置密码; 

   不要选用字典中的字来作密码; 

   采用防火墙能够去掉50%的外部危险，让数据库系统躲在防火墙后面工做，或放置在dmz区域中; 

   从因特网上用nmap来扫描3306端口，也可用telnet server_host 3306的方法测试，不容许从非信任网络中访问数据库服务器的3306号tcp端口，须要在防火墙或路由器上作设定; 10.为了防止被恶意传入非法参数，例如where id=234，别人却输入where id=234 or 1=1致使所有显示，因此在web的表单中使用”或”"来用字符串，在动态url中加入%22表明双引号、%23表明井号、%27表明单引号;传递未检查过的值给mysql数据库是很是危险的; 11.在传递数据给mysql时检查一下大小; 

   应用程序须要链接到数据库应该使用通常的用户账号，开放少数必要的权限给该用户; $page_devide$ 

   在各编程接口(c c++ php perl java jdbc等)中使用特定‘逃脱字符’函数; 

   在因特网上使用mysql数据库时必定少用传输明文的数据，而用ssl和ssh的加密方式数据来传输; 

   学会使用tcpdump和strings工具来查看传输数据的安全性，例如tcpdump -l -i eth0 -w -src or dst port 3306 strings。以普通用户来启动mysql数据库服务; 15.不使用到表的联结符号，选用的参数 –skip-symbolic-links; 

   确信在mysql目录中只有启动数据库服务的用户才能够对文件有读和写的权限; 

   不准将process或super权限付给非管理用户，该mysqladmin processlist能够列举出当前执行的查询文本;super权限可用于切断客户端链接、改变服务器运行参数状态、控制拷贝复制数据库的服务器; 

   file权限不付给管理员之外的用户，防止出现load data ‘/etc/passwd’到表中再用select 显示出来的问题; 

   若是不相信dns服务公司的服务，能够在主机名称容许表中只设置ip数字地址; 20.使用max_user_connections变量来使mysqld服务进程，对一个指定账户限定链接数; 21.grant语句也支持资源控制选项; 

   启动mysqld服务进程的安全选项开关，–local-infile=0或1 如果0则客户端程序就没法使用local load data了，赋权的一个例子grant insert(user) on mysql.user to ‘user_name’@'host_name’;若使用–skip-grant-tables系统将对任何用户的访问不作任何访问控制，但能够用 mysqladmin flush-privileges或mysqladmin reload来开启访问控制;默认状况是show databases语句对全部用户开放，能够用–skip-show-databases来关闭掉。 

   碰到error 1045(28000) access denied for user ‘root’@'localhost’ (using password:no)错误时，你须要从新设置密码，具体方法是:先用–skip-grant-tables参数启动mysqld，而后执行 mysql -u root mysql,mysql>update user set password=password(’newpassword’) where user=’root’;mysql>flush privileges;，最后从新启动mysql就能够了。

2.      NoSQL相关

Ø  NoSQL介绍

   NoSQL(NoSQL = Not Only SQL )，意即“不只仅是SQL”，是一项全新的数据库革命性运动，早期就有人提出，发展至2009年趋势愈加高涨。NoSQL的拥护者们提倡运用非关系型的数据存储，相对于铺天盖地的关系型数据库运用，这一律念无疑是一种全新的思惟的注入。

Ø  NoSQL特色

   它们能够处理超大量的数据。

   它们运行在便宜的PC服务器集群上。

   PC集群扩充起来很是方便而且成本很低，避免了“sharding”操做的复杂性和成本。

   它们击碎了性能瓶颈。

   NoSQL的支持者称，经过NoSQL架构能够省去将Web或Java应用和数据转换成SQL友好格式的时间，执行速度变得更快。

   “SQL并不是适用于全部的程序代码，” 对于那些繁重的重复操做的数据，SQL值得花钱。可是当数据库结构很是简单时，SQL可能没有太大用处。

   没有过多的操做。

   虽然NoSQL的支持者也认可关系数据库提供了无可比拟的功能集合，并且在数据完整性上也发挥绝对稳定，他们同时也表示，企业的具体需求可能没有那么多。

   Bootstrap支持

   由于NoSQL项目都是开源的，所以它们缺少供应商提供的正式支持。这一点它们与大多数开源项目同样，不得不从社区中寻求支持。

Ø  NoSQL优势

   易扩展：NoSQL数据库种类繁多，可是一个共同的特色都是去掉关系数据库的关系型特性。数据之间无关系，这样就很是容易扩展。也无形之间，在架构的层面上带来了可扩展的能力。

   大数据量，高性能：NoSQL数据库都具备很是高的读写性能，尤为在大数据量下，一样表现优秀。这得益于它的无关系性，数据库的结构简单。通常MySQL使用 Query Cache，每次表的更新Cache就失效，是一种大粒度的Cache，在针对web2.0的交互频繁的应用，Cache性能不高。而NoSQL的 Cache是记录级的，是一种细粒度的Cache，因此NoSQL在这个层面上来讲就要性能高不少了。

   灵活的数据模型：NoSQL无需事先为要存储的数据创建字段，随时能够存储自定义的数据格式。而在关系数据库里，增删字段是一件很是麻烦的事情。若是是很是大数据量的表，增长字段简直就是一个噩梦。这点在大数据量的web2.0时代尤为明显。

   高可用：NoSQL在不太影响性能的状况，就能够方便的实现高可用的架构。好比Cassandra，HBase模型，经过复制模型也能实现高可用。

Ø  NoSQL开源软件

   MongoDB

l   MongoDB更像一个关系型数据库。它的数据模型顶层是一个数据库（database），之下一个相似于MySql表结构的集合 （collection），而后collection内包含的是文档（document）就像MySql里的数据行。每一个文档有一个域（field）和一 个值（value）相似于MySql里的列和值。field能够是简单的键/值（例如 { 'name': 'David Mytton' }）也能够包含别的document（例如 { 'name': { 'first' : David, 'last' : 'Mytton' } }）。

l   MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。它的特色是高性能、易部署、易使用，存储数据很是方便。主要功能特性有：

*面向集合存储，易存储对象类型的数据。

*模式自由。　　

*支持动态查询。　　

*支持彻底索引，包含内部对象。　　

*支持查询。　　

*支持复制和故障恢复。　　

*使用高效的二进制数据存储，包括大型对象（如视频等）。　　

*自动处理碎片，以支持云计算层次的扩展性　　

*支持RUBY，PYTHON，JAVA，C++，PHP等多种语言。　　

*文件存储格式为BSON（一种JSON的扩展）　　

*可经过网络访问

   Cassandra

l   在Cassandra里，document对应的是“column”，即一个键值对（例如{ 'key': 'name', 'value': 'David Mytton' }），还包括一个时间戳字段用于内部的复制和一致性。值能够是一个值也能够包含其它的“column”，这些column按照某个指定值的顺序保存在column family里，顶层是一个键空间（keyspace）相似于MongoDB的database。

七．        笔试题

1.      在数组{m, m+1, m+2, m+3, …, N, 1, 2, 3, 4, …, m-1}中获取某个值的索引。

   提示：二分法查找

2.    大数相乘，即输入两个较大的数，输出相乘的结果。

   提示：三个数组

3.      将一个句子按单词反序，好比“what is your name”反序后变为“name your is what”。

   提示：先整个反序，而后局部反序

4.      判断一个数是否是2的n次幂。

   提示：x &(x-1)，结果为0则是

5.      小明家过桥。

   小明一家过一座桥，过桥时是黑夜，因此必须有灯。如今小明过桥要1秒，小明的弟弟要3秒，小明的爸爸要6秒，小明的妈妈要8秒，小明的爷爷要12秒。每次此桥最多可过两人，而过桥的速度依过桥最慢者而定，并且灯在点燃后30秒就会熄灭。问：小明一家如何过桥？

   答案：

小明与弟弟过去，小明回来，用4s；

妈妈与爷爷过去，弟弟回来，用15s；

小明与弟弟过去，小明回来，用4s；

小明与爸爸过去，用6s；

总共用29s。

6.      三只蚂蚁不相撞的几率

   在三角形的三个顶点上各有一只蚂蚁，它们向另外一个顶点运动，目标随机（可能为另外两个顶点的任意一个）。问三只蚂蚁不相撞的几率是多少？

   答案：若是蚂蚁顺时针爬行记为0，逆时针爬行记为1。那么三只蚂蚁的状态可能为000，001，...，110，111中的任意一个，且为每种状态的几率相等。在这8种状态中，只有000和111能够避免相撞，因此蚂蚁不相撞的几率是1/4。