成员变量：在这个类中定义的私有变量，属于这个类。
局部变量：在方法体中创建，在方法体外访问不到这个类
差异：
①、上面关于两者的定义也是一种差异；
②、二者的初始值不同：成员变量声明了就可以利用，有默认值；局部变量必须经由声明和赋值两部操作才能利用（局部变量没有默认值）；
③、二者在内存中的位置不一样：成员变量分配到堆中，局部变量分配到栈中
④、二者的生命周期不同：成员变量随着工具的存在而存在，随着工具的销毁而销毁；局部变量随着方法的存在而调用，随着方法的销毁而销毁，局部变量只能在声明它的方法中利用，而成员变量在全体类中都可以利用。
补充一些成员变量的默认值：
int类型的默认值是0
String类型的默认值是null
double类型的默认值是0.0d
Integer类型的默认值是null
Long类型的默认值是null
long类型的默认值是0L
float类型的默认值是0.0f
char类型的默认值是\u0000
byte类型的默认值是(byte)0
short类型的默认值是(short)0
2：int和Integer的差异
1、Integer是int的包装类，int则是java的一种基本数据类型
2、Integer变量必须实例化后才能利用，而int变量不须要
3、Integer实际是工具的引用，当new一个Integer时，实际上是天生一个指针指向此工具；而int则是直接存储数据值
4、Integer的默认值是null，int的默认值是0
如果整型字面量的值在-128到127之间，那么不会new新的Integer工具，而是直接引用常量池中的Integer工具
3：基本数据类型包装类差异
1、包装类是工具，拥有方法和字段，工具的调用都是通过引用工具的地址，基本类型不是
2、包装类型是引用的通报，基本类型是值的通报
3、声明办法不同，基本数据类型不须要new关键字，而包装类型须要new在堆内存中进行new来分配内存空间
4、存储位置不同，基本数据类型直接将值保存在值栈中，而包装类型是把工具放在堆中，然后通过工具的引用来调用他们
5、初始值不同，eg： int的初始值为 0 、 boolean的初始值为false 而包装类型的初始值为null
6、利用办法不同，基本数据类型直接赋值利用就好 ，而包装类型是在凑集如Collection Map时会利用
4：说说&和&&的差异。
&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，全体运算结果才为true，否则，只要有一方为false，则结果为false。
&&还具有短路的功能，即如果第一个表达式为false，则不再打算第二个表达式，例如，对付if(str != null && !str.equals(“”))表达式，当str为null时，后面的表达式不会实行，以是不会涌现NullPointerException如果将&&改为&，则会抛出NullPointerException非常。If(x33 & ++y>0) y会增长，If(x33 && ++y>0)不会增长
&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们常日利用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x01 & 0x0f的结果为0x01。
备注：这道题先说两者的共同点，再说出&&和&的分外之处，并列举一些经典的例子来表明自己理解透彻深入、实际履历丰富。
5：short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
对付short s1 = 1; s1 = s1 + 1; 由于s1+1运算时会自动提升表达式的类型，以是结果是int型，再赋值给short类型s1时，编译器将报告须要逼迫转换类型的缺点。
对付short s1 = 1; s1 += 1;由于 += 是java措辞规定的运算符，java编译器会对它进行分外处理，相称于s1 = (short)(s1 + 1);个中有隐含的逼迫类型转换。因此可以精确编译。
6: switch 是否能浸染在byte 上，是否能浸染在long 上，是否能浸染在String上？
在Java 5以前，在switch（expr1）中，expr1只能是一个整数表达式或者列举常量，整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，以是，这些类型以及这些类型的包装类型也是可以的，从Java 1.5开始，Java中引入了列举类型，expr也可以是enum类型，从Java1.7开始，expr还可以是字符串（String），但是长整型（long）在目前所有的版本中都是不可以的。
7：char型变量中能不能存贮一个中文汉字?为什么?
char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，以是，char型变量中当然可以存储汉字啦。不过，如果某个分外的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个分外汉字。补充解释：unicode编码占用两个字节，以是，char类型的变量也是占用两个字节。
备注：后面一部分回答虽然不是在正面回答题目，但是，为了展现自己的学识和表现自己对问题理解的透彻深入，可以回答一些干系的知识，做到畅所欲言，言无不尽。
8：用最有效率的方法算出2乘以8等於几?
2 << 3，
由于将一个数左移n位，就相称于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，以是，2乘以8等於几的最效率的方法是2 << 3。
9：Java中==号与equals()方法的差异
首先，=号在比较基本数据类型时比较的是值，而用=号比较两个工具时比较的是两个工具的地址值
那equals()方法呢？我们可以通过查看源码知道，equals()方法存在于Object类中，由于Object类是所有类的直接或间接父类，也便是说所有的类中的equals()方法都继续自Object类，而通过源码我们创造，Object类中equals()方法底层依赖的是=号，那么，在所有没有重写equals()方法的类中，调用equals()方法实在和利用==号的效果一样，也是比较的地址值，然而，Java供应的所有类中，绝大多数类都重写了equals()方法，重写后的equals()方法一样平常都是比较两个工具的值
10：静态变量和实例变量的差异？
在语法定义上的差异：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的差异：实例变量属于某个工具的属性，必须创建了实例工具，个中的实例变量才会被分配空间，才能利用这个实例变量。静态变量不属于某个实例工具，而是属于类，以是也称为类变量，只要程序加载了类的字节码，不用创建任何实例工具，静态变量就会被分配空间，静态变量就可以被利用了。总之，实例变量必须创建工具后才可以通过这个工具来利用，静态变量则可以直策应用类名来引用。
例如，对付下面的程序，无论创建多少个实例工具，永久都只分配了一个staticVar变量，并且每创建一个实例工具，这个staticVar就会加1；但是，每创建一个实例工具，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。
public class VariantTest{public static int staticVar = 0; public int instanceVar = 0; public VariantTest(){staticVar++;instanceVar++;System.out.println(“staticVar=” + staticVar + ”,instanceVar=” + instanceVar);}}
备注：这个解答除了说清楚两者的差异外，末了还用一个详细的运用例子来解释两者的差异，表示了自己有很好的讲授问题和设计案例的能力，思维敏捷，超过一样平常程序员，有写作能力！
11：是否可以从一个静态（static）方法内部发出对非静态（non-static）方法的调用？
不可以，静态方法只能访问静态成员，由于非静态方法的调用要先创建工具，在调用静态方法时可能工具并没有被初始化。
12：Math.round(11.5)等於多少? Math.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.round(x+0.5)，即将原来的数字加上0.5后再向下取整，以是，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。四舍五入的事理是在参数上加0.5然后进行下取整。
13：Overload和Override的差异。Overloaded的方法是否可以改变返回值的类型?
方法的重载和重写都是实现多态的办法，差异在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写哀求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的非常（里氏代换原则）。重载对返回类型没有分外的哀求。
Overload是重载的意思，Override是覆盖的意思，也便是重写。
重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。
重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完备相同，通过子类创建的实例工具调用这个方法时，将调用子类中的定义方法，这相称于把父类中定义的那个完备相同的方法给覆盖了，这也是面向工具编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的非常，或者是抛出父类抛出的非常的子非常，由于子类可以办理父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限定，相称于子类中增加了一个全新的方法。
至于Overloaded的方法是否可以改变返回值的类型这个问题，要看你倒底想问什么呢？这个题目很模糊。如果几个Overloaded的方法的参数列表不一样，它们的返回者类型当然也可以不一样。但我估计你想问的问题是：如果两个方法的参数列表完备一样，是否可以让它们的返回值不同来实现重载Overload。这是弗成的，我们可以用反证法来解释这个问题，由于我们有时候调用一个方法时也可以不定义返回结果变量，即不要关心其返回结果，例如，我们调用map.remove(key)方法时，虽然remove方法有返回值，但是我们常日都不会定义吸收返回结果的变量，这时候假设该类中有两个名称和参数列表完备相同的方法，仅仅是返回类型不同，java就无法确定编程者倒底是想调用哪个方法了，由于它无法通过返回结果类型来判断。
override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的浸染。对我们来说最熟习的覆盖便是对接口方法的实现，在接口中一样平常只是对方法进行了声明，而我们在实现时，就须要实现接口声明的所有方法。除了这个范例的用法以外，我们在继续中也可能会在子类覆盖父类中的方法。在覆盖要把稳以下的几点：
1、覆盖的方法的标志必须要和被覆盖的方法的标志完备匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回同等；
3、覆盖的方法所抛出的非常必须和被覆盖方法的所抛出的非常同等，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
overload对我们来说可能比较熟习，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，JVM就会根据不同的参数样式，来选择得当的方法实行。在利用重载要把稳以下的几点：
1、在利用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；
2、不能通过访问权限、返回类型、抛出的非常进行重载；
3、方法的非常类型和数目不会对重载造成影响；
4、对付继续来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
14：布局器Constructor是否可被override?
布局器Constructor不能被继续，因此不能重写Override，但可以被重载Overload。
15：接口是否可继续接口? 抽象类是否可实现(implements)接口? 抽象类是否可继续详细类(concrete class)? 抽象类中是否可以有静态的main方法？
接口可以继续接口。抽象类可以实现(implements)接口，抽象类是否可继续详细类。抽象类中可以有静态的main方法。
备注：只要明白了接口和抽象类的实质和浸染，这些问题都很好回答，你想想，如果你是java措辞的设计者，你是否会供应这样的支持，如果不供应的话，有什么情由吗？如果你没有道理不供应，那答案便是肯定的了。
只有记住抽象类与普通类的唯一差异便是不能创建实例工具和许可有abstract方法。
16：面向工具的特色有哪些方面
面向工具的编程措辞有封装、继续 、抽象、多态等4个紧张的特色。
1封装：
封装是担保软件部件具有优秀的模块性的根本，封装的目标便是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。在面向工具的编程措辞中，工具是封装的最基本单位，面向工具的封装比传统措辞的封装更为清晰、更为有力。面向工具的封装便是把描述一个工具的属性和行为的代码封装在一个“模块”中，也便是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个工具中的属性。常日情形下，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现工具的封装，就很随意马虎找出要分配到这个类上的方法了，就基本上算是会面向工具的编程了。把握一个原则：把对同一事物进行操作的方法和干系的方法放在同一个类中，把方法和它操作的数据放在同一个类中。
例如，人要在黑板上画圆，这一共涉及三个工具：人、黑板、圆，画圆的方法要分配给哪个工具呢？由于画圆须要利用到圆心和半径，圆心和半径显然是圆的属性，如果将它们在类中定义成了私有的成员变量，那么，画圆的方法必须分配给圆，它才能访问到圆心和半径这两个属性，人往后只是调用圆的画圆方法、表示给圆发给而已，画圆这个方法不应该分配在人这个工具上，这便是面向工具的封装性，即将工具封装成一个高度自治和相对封闭的个体，工具状态（属性）由这个工具自己的行为（方法）来读取和改变。一个更便于理解的例子便是，司机将火车刹住了，刹车的动作是分配给司机，还是分配给火车，显然，该当分配给火车，由于司机自身是不可能有那么大的力气将一个火车给停下来的，只有火车自己才能完成这一动作，火车须要调用内部的离合器和刹车片等多个器件协作才能完成刹车这个动作，司机刹车的过程只是给火车发了一个，关照火车要实行刹车动作而已。
抽象：
抽象便是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将把稳力集中在与当前目标有关的方面。例如，看到一只蚂蚁和大象，你能够想象出它们的相同之处，那便是抽象。抽象包括行为抽象和状态抽象两个方面。例如，定义一个Person类，如下：
class Person{
String name;
int age;
}
人本来是很繁芜的事物，有很多方面，但由于当前系统只须要理解人的姓名和年事，以是上面定义的类中只包含姓名和年事这两个属性，这便是一种抽像，利用抽象可以避免考虑一些与目标无关的细节。我对抽象的理解便是不要用显微镜去看一个事物的所有方面，这样涉及的内容就太多了，而是要长于划分问题的边界，当前系统须要什么，就只考虑什么。
继续：
在定义和实现一个类的时候，可以在一个已经存在的类的根本之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入多少新的内容，或修正原来的方法使之更适宜分外的须要，这便是继续。继续是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。
多态：
多态是指程序中定义的引用变量所指向的详细类型和通过该引用变量发出的方法调用在编程时并不愿定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例工具，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。由于在程序运行时才确定详细的类，这样，不用修正源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的详细方法随之改变，即不修处死式代码就可以改变程序运行时所绑定的详细代码，让程序可以选择多个运行状态，这便是多态性。多态性增强了软件的灵巧性和扩展性。例如，下面代码中的UserDao是一个接口，它定义引用变量userDao指向的实例工具由daofactory.getDao()在实行的时候返回，有时候指向的是UserJdbcDao这个实现，有时候指向的是UserHibernateDao这个实现，这样，不用修正源代码，就可以改变userDao指向的详细类实现，从而导致userDao.insertUser()方法调用的详细代码也随之改变，即有时候调用的是UserJdbcDao的insertUser方法，有时候调用的是UserHibernateDao的insertUser方法：
UserDao userDao = daofactory.getDao();
userDao.insertUser(user);
17：java中实现多态的机制是什么？
靠的是父类或接口定义的引用变量可以指向子类或详细实现类的实例工具，而程序调用的方法在运行期才动态绑定，便是引用变量所指向的详细实例工具的方法，也便是内存里正在运行的那个工具的方法，而不是引用变量的类型中定义的方法。
18：abstract class和interface有什么差异？
含有abstract润色符的class即为抽象类，abstract 类不能创建的实例工具。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在详细(Concrete)子类中实现，以是，不能有抽象布局方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
下面比较一下两者的语法差异：
1.抽象类可以有布局方法，接口中不能有布局方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
eclipse下不报错，但该当也弗成），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继续一个抽象类。
下面接着再说说两者在运用上的差异：
接口更多的是在系统架构设计方法发挥浸染，紧张用于定义模块之间的通信左券。而抽象类在代码实现方面发挥浸染，可以实当代码的重用，例如，模板方法设计模式是抽象类的一个范例运用，假设某个项目的所有Servlet类都要用相同的办法进行权限判断、记录访问日志和处理非常，那么就可以定义一个抽象的基类，让所有的Servlet都继续这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理非常的代码，在各个子类中只是完成各自的业务逻辑代码，伪代码如下：
public abstract class BaseServlet extends HttpServlet{public final void service(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException{记录访问日志进行权限判断if(具有权限){try{doService(request,response);}catch(Excetpion e){记录非常信息}}} protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException; //把稳访问权限定义成protected，显得既专业，又严谨，由于它是专门给子类用的}public class MyServlet1 extends BaseServlet{protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException{本Servlet只处理的详细业务逻辑代码} }
父类方法中间的某段代码不愿定，留给子类干，就用模板方法设计模式。
备注：这道题的思路是先从总体阐明抽象类和接口的基本观点，然后再比较两者的语法细节，末了再说两者的运用差异。比较两者语法细节差异的条理是：先从一个类中的布局方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继续性等6个方面逐一去比较回答，接着从第三者继续的角度的回答，特殊是末了用了一个范例的例子来展现自己深厚的技能功底。
19：抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本地方法（native），是否可同时被synchronized润色？
abstract的method 不可以是static的，由于抽象的方法是要被子类实现的，而static与子类扯不上关系！
native方法表示该方法要用其余一种依赖平台的编程措辞实现的，不存在着被子类实现的问题，以是，它也不能是抽象的，不能与abstract混用。例如，FileOutputSteam类要硬件打交道，底层的实现用的是操作系统干系的api实现，例如，在windows用c措辞实现的，以是，查看jdk 的源代码，可以创造FileOutputStream的open方法的定义如下：
private native void open(String name) throws FileNotFoundException;
如果我们要用java调用别人写的c措辞函数，我们是无法直接调用的，我们须要按照java的哀求写一个c措辞的函数，又我们的这个c措辞函数去调用别人的c措辞函数。由于我们的c措辞函数是按java的哀求来写的，我们这个c措辞函数就可以与java对接上，java那边的对接办法便是定义出与我们这个c函数相对应的方法，java中对应的方法不须要写详细的代码，但须要在前面声明native。
关于synchronized与abstract合用的问题，我以为也弗成，由于在我几年的学习和开拓中，从来没见到过这种情形，并且我以为synchronized该当是浸染在一个详细的方法上才故意义。而且，方法上的synchronized同步所利用的同步锁工具是this，而抽象方法上无法确定this是什么。
20：什么是内部类？静态嵌套类（Static Nested Class）和内部类（Inner Class）的不同？
内部类便是在一个类的内部定义的类，内部类中不能定义静态成员（静态成员不是工具的特性，只是为了找一个立足之处，以是须要放到一个类中而已，这么一点小事，你还要把它放到类内部的一个类中，过分了啊！
供应内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员类似c措辞的全局变量，而内部类常日是用于创建内部工具用的，以是，把“全局变量”放在内部类中便是毫无意义的事情，既然是毫无意义的事情，就该当被禁止），内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法表面，也可以定义在外部类的方法体中，如下所示：
public class Outer{int out_x = 0;public void method(){Inner1 inner1 = new Inner1();public class Inner2 //在方法体内部定义的内部类{public method(){out_x = 3;}}Inner2 inner2 = new Inner2();}public class Inner1 //在方法体表面定义的内部类{}}
在方法体表面定义的内部类的访问类型可以是public,protecte,默认的，private等4种类型，这就彷佛类中定义的成员变量有4种访问类型一样，它们决定这个内部类的定义对其他类是否可见；对付这种情形，我们也可以在表面创建内部类的实例工具，创建内部类的实例工具时，一定要先创建外部类的实例工具，然后用这个外部类的实例工具去创建内部类的实例工具，代码如下：
Outer outer = new Outer();Outer.Inner1 inner1 = outer.new Innner1();
在方法内部定义的内部类前面不能有访问类型润色符，就彷佛方法中定义的局部变量一样，但这种内部类的前面可以利用final或abstract润色符。这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例工具可以通报给其他类访问。这种内部类必须是先定义，后利用，即内部类的定义代码必须涌如今利用该类之前，这与方法中的局部变量必须先定义后利用的道理也是一样的。这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加final润色符。
对付这些细节，只要在eclipse写代码试试，根据开拓工具提示的各种缺点信息就可以立时理解到。
在方法体内部还可以采取如下语法来创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例工具，无需为该子类定义名称：
public class Outer{public void start(){new Thread(new Runable(){public void run(){};}).start();}}
末了，在方法外部定义的内部类前面可以加上static关键字，从而成为Static Nested Class，它不再具有内部类的特性，所有，从狭义上讲，它不是内部类。Static Nested Class与普通类在运行时的行为和功能上没有什么差异，只是在编程引用时的语法上有一些差别，它可以定义成public、protected、默认的、private等多种类型，而普通类只能定义成public和默认的这两种类型。在表面引用Static Nested Class类的名称为“外部类名.内部类名”。在表面不须要创建外部类的实例工具，就可以直接创建Static Nested Class，例如，假设Inner是定义在Outer类中的Static Nested Class，那么可以利用如下语句创建Inner类：
Outer.Inner inner = new Outer.Inner();
由于static Nested Class不依赖于外部类的实例工具，以是，static Nested Class能访问外部类的非static成员变量。当在外部类中访问Static Nested Class时，可以直策应用Static Nested Class的名字，而不须要加上外部类的名字了，在Static Nested Class中也可以直接引用外部类的static的成员变量，不须要加上外部类的名字。
在静态方法中定义的内部类也是Static Nested Class，这时候不能在类前面加static关键字，静态方法中的Static Nested Class与普通方法中的内部类的运用办法很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final润色符。
备注：首先根据你的印象说出你对内部类的总体方面的特点：例如，在两个地方可以定义，可以访问外部类的成员变量，不能定义静态成员，这是大的特点。然后再说一些细节方面的知识，例如，几种定义办法的语法差异，静态内部类，以及匿名内部类。
21：内部类可以引用它的包含类的成员吗？有没有什么限定？
完备可以。如果不是静态内部类，那没有什么限定！
如果你把静态嵌套类当作内部类的一种特例，那在这种情形下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，
答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态内部类不能访问外部类的成员，但你一上来就顶牛，这不好，要先顺着人家，让人家满意，然后再说分外情形，让人家吃惊。
22：Anonymous Inner Class(匿名内部类)是否可以继续其它类？是否可以实现接口？
可以继续其他类或实现其他接口，在Swing编程和Android开拓中常用此办法来实现事宜监听和回调。
23：super.getClass()方法调用
下面程序的输出结果是多少？
import java.util.Date;public class Test extends Date{public static void main(String[] args) {new Test().test();}public void test(){System.out.println(super.getClass().getName());}}
很奇怪，结果是Test
在test方法中，直接调用getClass().getName()方法，返回的是Test类名
由于getClass()在Object类中定义成了final，子类不能覆盖该方法，以是，在
test方法中调用getClass().getName()方法，实在便是在调用从父类继续的getClass()方法，等效于调用super.getClass().getName()方法，以是，super.getClass().getName()方法返回的也该当是Test。
如果想得到父类的名称，该当用如下代码：
getClass().getSuperClass().getName();
24：String s = “Hello”;s = s + \公众 world!\公众;这两行代码实行后，原始的String工具中的内容到底变了没有？
没有。由于String被设计成不可变(immutable)类，以是它的所有工具都是不可变工具。在这段代码中，s原来指向一个String工具，内容是 “Hello”，然后我们对s进行了+操作，那么s所指向的那个工具是否发生了改变呢？答案是没有。这时，s不指向原来那个工具了，而指向了另一个 String工具，内容为\"大众Hello world!\"大众，原来那个工具还存在于内存之中，只是s这个引用变量不再指向它了。
通过上面的解释，我们很随意马虎导出另一个结论，如果常常对字符串进行各种各样的修正，或者说，不可预见的修正，那么利用String来代表字符串的话会引起很大的内存开销。由于 String工具建立之后不能再改变，以是对付每一个不同的字符串，都须要一个String工具来表示。这时，该当考虑利用StringBuffer类，它许可修正，而不是每个不同的字符串都要天生一个新的工具。并且，这两种类的工具转换十分随意马虎。
同时，我们还可以知道，如果要利用内容相同的字符串，不必每次都new一个String。例如我们要在布局器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应该这样做：
public class Demo {private String s;...public Demo {s = \"大众Initial Value\"大众;}...}
而非
s = new String(“Initial Value”);
后者每次都会调用布局器，天生新工具，性能低下且内存开销大，并且没故意义，由于String工具不可改变，以是对付内容相同的字符串，只要一个String工具来表示就可以了。也就说，多次调用上面的布局器创建多个工具，他们的String类型属性s都指向同一个工具。
上面的结论还基于这样一个事实：对付字符串常量，如果内容相同，Java认为它们代表同一个String工具。而用关键字new调用布局器，总是会创建一个新的工具，无论内容是否相同。
至于为什么要把String类设计成不可变类，是它的用场决定的。实在不但String，很多Java标准类库中的类都是不可变的。在开拓一个别系的时候，我们有时候也须要设计不可变类，来通报一组干系的值，这也是面向工具思想的表示。不可变类有一些优点，比如由于它的工具是只读的，以是多线程并发访问也不会有任何问题。当然也有一些缺陷，比如每个不同的状态都要一个工具来代表，可能会造成性能上的问题。以是Java标准类库还供应了一个可变版本，即 StringBuffer。
25：String s = new String(“xyz”);创建了几个String Object? 二者之间有什么差异？
两个或一个，”xyz”对应一个工具，这个工具放在字符串常量缓冲区，常量”xyz”不管涌现多少遍，都是缓冲区中的那一个。New String每写一遍，就创建一个新的工具，它依据那个常量”xyz”工具的内容来创建出一个新String工具。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。
26：数组有没有length()方法？String有没有length()方法？
数组没有length()方法，有length 的属性。String 有length()方法。JavaScript中，得到字符串的长度是通过length属性得到的，这一点随意马虎和Java稠浊。
27：下面这条语句一共创建了多少个工具：String s=“a”+“b”+“c”+“d”？
对付如下代码：
String s1 = \"大众a\公众;String s2 = s1 + \"大众b\公众;String s3 = \公众a\"大众 + \公众b\"大众;System.out.println(s2 == \"大众ab\"大众);System.out.println(s3 == \"大众ab\公众);
第一条语句打印的结果为false，第二条语句打印的结果为true，这解释javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉个中的加号，直接将其编译成一个这些常量相连的结果。
题目中的第一行代码被编译器在编译时优化后，相称于直接定义了一个”abcd”的字符串，以是，上面的代码该当只创建了一个String工具。写如下两行代码，
String s = \"大众a\公众 + \"大众b\"大众 + \公众c\"大众 + \公众d\"大众;System.out.println(s == \"大众abcd\公众);
终极打印的结果该当为true。
28：final, finally, finalize的差异。
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继续。
finally：常日放在try…catch…的后面布局总是实行代码块，这就意味着程序无论正常实行还是发生非常，这里的代码只要JVM不关闭都能实行，可以将开释外部资源的代码写在finally块中。
finalize是Object类的一个方法，在垃圾网络器实行的时候会调用被回收工具的此方法，可以覆盖此方法供应垃圾网络时的其他资源回收，例如关闭文件等。JVM不担保此方法总被调用
29：运行时非常与一样平常非常有何异同？
相同点： 两种非常同属于Exception父类。
不同点：
(1)运行时非常都是RuntimeException类及其子类非常，如NullPointerException、IndexOutOfBoundsException等。
(2)一样平常非常是RuntimeException以外的非常，类型上都属于Exception类及其子类。
1、Java非常机制： Java把非常当做工具来处理，并定义一个基类java.lang.Throwable作为所有非常的超类。 Java中的非常分为两大类：缺点Error和非常Exception。
2、运行时非常： 运行时非常是不检讨非常，程序中可以选择捕获处理，也可以不处理。这些非常一样平常是由程序逻辑缺点引起的。 当涌现RuntimeException的时候，我们可以不处理，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException非常，它便是运行时非常，并且这种非常还是最常见的非常之一。 涌现运行时非常后，如果没有捕获处理这个非常（即没有catch），系统会把非常一贯往上层抛，一贯到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的非常，那么这全体程序也就退出了。 运行时非常是Exception的子类，也有一样平常非常的特点，是可以被catch块处理的。只不过每每我们不对他处理罢了。也便是说，你如果不对运行时非常进行处理，那么涌现运行时非常之后，要么是线程中止，要么是主程序终止。 如果不想终止，则必须捕获所有的运行时非常，决不让这个处理线程退出。行列步队里面涌现非常数据了，正常的处理该当是把非常数据舍弃，然后记录日志。不应该由于非常数据而影响下面对正常数据的处理。
3、一样平常非常： 一样平常非常包括IOException、SQLException等以及用户自定义的Exception非常。对付这种非常，JAVA编译器逼迫哀求我们必需对涌现的这些非常进行catch并处理，否则程序就不能编译通过。 以是，面对这种非常不管我们是否乐意，只能自己去写一大堆catch块去处理可能的非常。
4、常见RuntimeException：
ArrayStoreException：试图将缺点类型的工具存储到一个工具数组时抛出的非常
ClassCastException：试图将工具逼迫转换为不是实例的子类时，抛出该非常 IllegalArgumentException：抛出的非常表明向方法通报了一个不合法或禁绝确的参数
IndexOutOfBoundsException：指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出
NoSuchElementException ：表明列举中没有更多的元素
NullPointerException ：当运用程序试图在须要工具的地方利用 null 时，抛出该非常
30：error和exception有什么差异?
Error表示系统级的缺点和程序不必处理的非常，是规复不是不可能但很困难的情形下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情形；Exception表示须要捕捉或者须要程序进行处理的非常，是一种设计或实现问题；也便是说，它表示如果程序运行正常，从不会发生的情形。
31：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非常。
提示答题者：就按照三个级别去思考：虚拟机必须宕机的缺点，程序可以去世掉也可以不去世掉的缺点，程序不应该死掉的缺点；
32：String, StringBuffer和StringBuilder差异
1、String是字符串常量，final润色：StringBuffer字符串变量(线程安全)；
StringBuilder 字符串变量(线程不屈安)。
2、String是不可变的，因此每次对其操作改变其变量值，实在是天生一个新的工具，然后将变量引用指向新工具；因此速率慢。
3、StringBuffer则不同，对其操作即直接操为难刁难象指向的引用，无需产生新工具，速率很快；它是线程安全的，在掩护多线程的同步等也会花费一点性能。
4、StringBuilder是jdk5之后新增的，其用法与StringBuffer完备同等，但它是线程不屈安的，在单线程中最佳，由于其不须要掩护线程的安全，因此是最快的。
5、String.intern()查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode即是str的字符串并返回它的引用。因此在用String进行字符串拼接时，会产生很多临时变量。建议多利用StringBuffer／StringBuilder
6、String是存放在常量池，在编译期已经被确定了。new String()不是字符串常量，它有自己的地址空间，存放在堆空间。而其它两个都存放在堆空间。
33：Set,List,Collection,Collections的差异？
1、List和Set都是接口，他们都继续于接口Collection,List是一个有序的可重复的凑集，而Set的无序的不可重复的凑集。Collection是凑集的顶层接口，Collections是一个封装了浩瀚关于凑集操作的静态方法的工具类,由于布局方法是私有的，以是不能实例化。
2、List接口实现类有ArrayList,LinkedList,Vector。ArrayList和Vector是基于数组实现的,以是查询的时候速率快，而在进行增加和删除的时候速率较慢LinkedList是基于链式存储构造，以是在进行查询的时候速率较慢但在进行增加和删除的时候速率较快。又由于Vector是线程安全的，以是他和ArrayList比较而言，查询效率要低。
34：IO和NIO的差异和事理？
（1）IO是面向流的，NIO是面向缓冲区的
Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果须要前后移动从流中读取的数据，须要先将它缓存到一个缓冲区。 Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，须要时可在缓冲区中前后移动。这就增加了处理过程中的灵巧性。但是，还须要检讨是否该缓冲区中包含所有您须要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。
（2）壅塞与非壅塞IO
Java IO的各种流是壅塞的。这意味着，当一个线程调用read() 或 write()时，该线程被壅塞，直到有一些数据被读取，或数据完备写入。该线程在此期间不能再干任何事情了。 Java NIO的非壅塞模式，使一个线程从某通道发送要求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程壅塞，以是直至数据变的可以读取之前，该线程可以连续做其他的事情。 非壅塞写也是如此。一个线程要求写入一些数据到某通道，但不须要等待它完备写入，这个线程同时可以去做别的事情。 线程常日将非壅塞IO的空闲韶光用于在其它通道上实行IO操作，以是一个单独的线程现在可以管理多个输入和输出通道（channel）。
（3）利用单线程Selector来管理多个通道，减少系统开销
35：HashMap的底层实现事理及扩容机制
在JDK1.6，JDK1.7中，HashMap采取数组+链表实现，即利用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采取数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找韶光。
首先有一个每个元素都是链表（可能表述不准确）的数组，当添加一个元素（key-value）时，就首先打算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表，同一各链表上的Hash值是相同的，以是说数组存放的是链表。而当链表长度太永劫，链表就转换为红黑树，这样大大提高了查找的效率.
在1.6,1.7的时候,底层是通过数组+链表的形式存储数据的。在1.8的时候,通过数组+链表+红黑树的形式,存储数据的。
默认初始化长度为16的数组,加载因子为0.75 ,存放值得时候,通过值得hash值,来判断存放在哪个数组(车厢)当中。然后在数组中以链表的形式存放,当链表达到阀值8的时候,将转换为红黑树的形式。当数组的利用率达到长度加载因子( 160.75 ) 12个的时候,就会对map进行扩容。以2倍的形式扩容。
36：哈希碰撞是什么？怎么办理？
哈希碰撞是两个不同的原始值在经由哈希运算后得到相同的结果。
办理方法：开放地址法，链地址法(拉链法)
Java中的HashMap是采取链地址法来办理HashCode碰撞问题。
37：ArrayList扩容
在jdk1.6之前,初始化会自动创建10个工具。在1.6之后。初始化创建空数组,当添加第一个值的时候,第一个扩容为默认值10个然后安装1.5倍扩容,及当添加第11个的时候,扩容为15个…
38：长连接与短连接
所谓长连接，指在一个TCP连接上可以连续发送多个数据包，在TCP连接保持期间，如果没有数据包发送，须要双方发检测包以坚持此连接，一样平常须要自己做在线坚持。 短连接是指通信双方有数据交互时，就建立一个TCP连接，数据发送完成后，则断开此TCP连接，一样平常银行都利用短连接。
比如http的，只是连接、要求、关闭，过程韶光较短,做事器若是一段韶光内没有收到要求即可关闭连接。
实在长连接是相对付常日的短连接而说的，也便是永劫光保持客户端与做事真个连接状态。
长连接与短连接的操作过程:
常日的短连接操作步骤是：连接→数据传输→关闭连接；
而长连接常日便是：连接→数据传输→保持连接(心跳)→数据传输→保持连接(心跳)→……→关闭连接；
这就哀求长连接在没有数据通信时，定时发送数据包(心跳)，以坚持连接状态，短连接在没有数据传输时直接关闭就行了.
39：ArrayList和Vector的差异
这两个类都实现了List接口（List接口继续了Collection接口），他们都是有序凑集，即存储在这两个凑集中的元素的位置都是有顺序的，相称于一种动态的数组，我们往后可以按位置索引号取出某个元素，，并且个中的数据是许可重复的，这是HashSet之类的凑集的最大不同处，HashSet之类的凑集不可以按索引号去检索个中的元素，也不许可有重复的元素（本来题目问的与hashset没有任何关系，但为了说清楚ArrayList与Vector的功能，我们利用比拟办法，更有利于解释问题）。
接着才说ArrayList与Vector的差异，这紧张包括两个方面：.
（1）同步性：
Vector是线程安全的，也便是说是它的方法之间是线程同步的，而ArrayList是线程序不屈安的，它的方法之间是线程不同步的。如果只有一个线程会访问到凑集，那最好是利用ArrayList，由于它不考虑线程安全，效率会高些；如果有多个线程会访问到凑集，那最好是利用Vector，由于不须要我们自己再去考虑和编写线程安全的代码。
备注：对付Vector&ArrayList、Hashtable&HashMap，要记住线程安全的问题，记住Vector与Hashtable是旧的，是java一出身就供应了的，它们是线程安全的，ArrayList与HashMap是java2时才供应的，它们是线程不屈安的。以是，我们讲课时先讲老的。
（2）数据增长：
ArrayList与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就须要增加ArrayList与Vector的存储空间，每次要增加存储空间时，不是只增加一个存储单元，而是增加多个存储单元，每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍，而ArrayList的增长策略在文档中没有明确规定（从源代码看到的是增长为原来的1.5倍）。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小，而ArrayList没有供应设置增长空间的方法。
总结：即Vector增长原来的一倍，ArrayList增加原来的0.5倍。
40：List 和 Map 差异？
一个是存储单列数据的凑集，另一个是存储键和值这样的双列数据的凑集，List中存储的数据是有顺序，并且许可重复；Map中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。
41：List、Map、Set三个接口，存取元素时，各有什么特点？
首先，List与Set具有相似性，它们都是单列元素的凑集，以是，它们有一个功共同的父接口，叫Collection。Set里面不许可有重复的元素，所谓重复，即不能有两个相等（把稳，不是仅仅是相同）的工具 ，即假设Set凑集中有了一个A工具，现在我要向Set凑集再存入一个B工具，但B工具与A工具equals相等，则B工具存储不进去，以是，Set凑集的add方法有一个boolean的返回值，当凑集中没有某个元素，此时add方法可成功加入该元素时，则返回true，当凑集含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。
List表示有先后顺序的凑集， 把稳，不是那种按年事、按大小、按价格之类的排序。当我们多次调用add(Obj e)方法时，每次加入的工具就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Obj e)方法，就可以指定当前工具在凑集中的存放位置。一个工具可以被反复存储进List中，每调用一次add方法，这个工具就被插入进凑集中一次，实在，并不是把这个工具本身存储进了凑集中，而是在凑集中用一个索引变量指向这个工具，当这个工具被add多次时，即相称于凑集中有多个索引指向了这个工具，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确解释取第几个。
Map与List和Set不同，它是双列的凑集，个中有put方法，定义如下：put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key得到相应的value，即get(Object key)返回值为key 所对应的value。其余，也可以得到所有的key的结合，还可以得到所有的value的结合，还可以得到key和value组合成的Map.Entry工具的凑集。
List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。
42：Collection 和 Collections的差异。
Collection是凑集类的上级接口，继续与他的接口紧张有Set 和List.
Collections是针对凑集类的一个帮助类，他供应一系列静态方法实现对各种凑集的搜索、排序、线程安全化等操作。
43：java中有几种类型的流？JDK为每种类型的流供应了一些抽象类以供继续，请说出他们分别是哪些类？
字节流，字符流。字节流继续于InputStream OutputStream，字符流继续于InputStreamReader OutputStreamWriter。在java.io包中还有许多其他的流，紧张是为了提高性能和利用方便。
44：什么是java序列化，如何实现java序列化？或者请阐明Serializable接口的浸染。
我们有时候将一个java工具变成字节流的形式传出去或者从一个字节流中规复成一个java工具，例如，要将java工具存储到硬盘或者传送给网络上的其他打算机，这个过程我们可以自己写代码去把一个java工具变成某个格式的字节流再传输，但是，jre本身就供应了这种支持，我们可以调用OutputStream的writeObject方法来做，如果要让java 帮我们做，要被传输的工具必须实现serializable接口，这样，javac编译时就会进行分外处理，编译的类才可以被writeObject方法操作，这便是所谓的序列化。须要被序列化的类必须实现Serializable接口，该接口是一个mini接口，个中没有须要实现的方法，implements Serializable只是为了标注该工具是可被序列化的。
45：HTTP要求的GET与POST办法的差异
get是从做事器上获取数据，post是向做事器传送数据。get是把参数数据行列步队加到提交表单的ACTION属性所指的URL中，值和表单内各个字段逐一对应，在URL中可以看到。post是通过HTTP post机制，将表单内各个字段与其内容放置在HTML HEADER内一起传送到ACTION属性所指的URL地址。用户看不到这个过程。对付get办法，做事器端用Request.QueryString获取变量的值，对付post办法，做事器端用Request.Form获取提交的数据。get传送的数据量较小，不能大于2KB。post传送的数据量较大，一样平常被默认为不受限定。但理论上，IIS4中最大量为80KB，IIS5中为100KB。get安全性非常低，post安全性较高。但是实行效率却比Post方法好。建议：1、get办法的安全性较Post办法要差些，包含机密信息的话，建议用Post数据提交办法；2、在做数据查询时，建议用Get办法；而在做数据添加、修正或删除时，建议用Post办法；46：Request工具的紧张方法：
setAttribute(String name,Object)：设置名字为name的request的参数值 getAttribute(String name)：返回由name指定的属性值 getAttributeNames()：返回request工具所有属性的名字凑集，结果是一个列举的实例 getCookies()：返回客户真个所有Cookie工具，结果是一个Cookie数组 getCharacterEncoding()：返回要求中的字符编码办法 getContentLength()：返回要求的Body的长度 getHeader(String name)：得到HTTP协议定义的文件头信息 getHeaders(String name)：返回指定名字的request Header的所有值，结果是一个列举的实例 getHeaderNames()：返回以是request Header的名字，结果是一个列举的实例 getInputStream()：返回要求的输入流，用于得到要求中的数据 getMethod()：得到客户端向做事器端传送数据的方法 getParameter(String name)：得到客户端传送给做事器真个有name指定的参数值 getParameterNames()：得到客户端传送给做事器真个所有参数的名字，结果是一个列举的实例 getParametervalues(String name)：得到有name指定的参数的所有值 getProtocol()：获取客户端向做事器端传送数据所依据的协议名称 getQueryString()：得到查询字符串 getRequestURI()：获取发出要求字符串的客户端地址 getRemoteAddr()：获取客户真个IP地址 getRemoteHost()：获取客户真个名字 getSession([Boolean create])：返回和要求干系Session getServerName()：获取做事器的名字 getServletPath()：获取客户端所要求的脚本文件的路径 getServerPort()：获取做事器的端口号 removeAttribute(String name)：删除要求中的一个属性
47：JSP中动态INCLUDE与静态INCLUDE的差异？
动态INCLUDE用jsp:include动作实现
<jsp:include page=included.jsp flush=true />它总是会检讨所含文件中的变革，适宜用于包含动态页面，并且可以带参数 静态INCLUDE用include伪码实现,定不会检讨所含文件的变革，适用于包含静态页面 <%@ include file=included.htm %>
48：为何利用三次握手机制？
客户端向做事器发送了第一条要求报文，但是该报文并未在网络中被丢弃，而是永劫光阻滞在某处，而客户端收不到做事器确认，以为该报文丢失，于是重新发送该报文，这次的报文成功到达做事器，如果不该用三次握手，则做事器只需对该报文发出确认，就建立了一个连接。而在这个连接建立，并开释后，第一次发送的，阻滞在网络中的报文到达了做事器，做事器以为是客户端又重新发送了一个连接要求（实际上在客户端那里，该连接早已失落效），就又向客户端发送一个确认，但客户端认为他没有发送该要求报文，因此不理睬做事器发送的确认，而做事器以为又建立了一个新的连接，于是一贯等待A发来数据，造成了做事器资源的摧残浪费蹂躏，并且会产生安全隐患。因此，若利用三次握手机制，做事器发送了该确认后，收不到客户端的确认，也就知道并没有建立连接，因此不会将资源摧残浪费蹂躏在这种没故意义的等待上。
49：Cookie与Session的差异
1：cookie数据存放在客户的浏览器上，session数据放在做事器上；
2：cookie不是很安全，别人可以剖析存放在本地的COOKIE并进行COOKIE欺骗，考虑到安全应该利用session；3：session会在一定韶光内保存在做事器上。当访问增多，会比较占用你做事器的性能。考虑到减轻做事器性能方面，应该利用COOKIE；
4：单个cookie在客户真个限定是3K，便是说一个站点在客户端存放的COOKIE不能超过3K；
Cookie和Session的方案虽然分别属于客户端和做事端，但是做事真个session的实现对客户真个cookie有依赖关系的，上面我讲到做事端实行session机制时候会天生session的id值，这个id值会发送给客户端，客户端每次要求都会把这个id值放到http要求的头部发送给做事端，而这个id值在客户端会保存下来，保存的容器便是cookie，因此当我们完备禁掉浏览器的cookie的时候，做事真个session也会不能正常利用（把稳：有些资料说ASP办理这个问题，当浏览器的cookie被禁掉，做事真个session任然可以正常利用，ASP我没试验过，但是对付网络上很多用php和jsp编写的网站，我创造禁掉cookie，网站的session都无法正常的访问）。
