0203刷题笔记

2.Python  是动态语言
动态语言的定义：动态编程语言是高级程序设计语言的一个类别，在计算机科学领域已被广泛应用。它是一类在运行时可以改变其结构的语言：
例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。动态语言目前非常具有活力。
众所周知的   ECMAScript   （   JavaScript   ）便是一个动态语言，除此之外如   PHP   、   Ruby   、   Python   等也都属于动态语言，
而   C   、   C++   等语言则不属于动态语言、、

3.
public class Test
{
    public static Test t1 = new Test();
    {
         System.out.println("blockA");
    }
    static
    {
        System.out.println("blockB");
    }
    public static void main(String[] args)
    {
        Test t2 = new Test();
    }
 }
1.首先，需要明白类的加载顺序。
(1) 父类静态对象和静态代码块
(2) 子类静态对象和静态代码块
(3) 父类非静态对象和非静态代码块
(4) 父类构造函数
(5) 子类 非静态对象和非静态代码块
(6) 子类构造函数
其中：类中静态块按照声明顺序执行，并且(1)和(2)不需要调用new类实例的时候就执行了(意思就是在类加载到方法区的时候执行的)
2.因而，整体的执行顺序为 
public static Test  t1 = new Test();         //(1)
static 
{
System.out.println("blockB");                //(2)
}
Test t2 =new Test();                             //(3)
在执行(1)时创建了一个Test对象，在这个过程中会执行非静态代码块和缺省的无参构造函数，在执行非静态代码块时就输出了blockA；然后执行(2)输出blockB；执行(3)的过程同样会执行非静态代码块和缺省的无参构造函数，在执行非静态代码块时输出blockA。因此，最终的结果为
blockA
blockB
blockA

4.
    1、jps：查看本机java进程信息。
    2、jstack：打印线程的栈信息，制作线程dump文件。
    3、jmap：打印内存映射，制作堆dump文件
    4、jstat：性能监控工具
    5、jhat：内存分析工具
    6、jconsole：简易的可视化控制台
    7、jvisualvm：功能强大的控制台
    
5.对于管道，有下面这几种类型：
①普通管道（PIPE）：通常有两种限制，一是单工，即只能单向传输；二是血缘，即常用于父子进程间（或有血缘关系的进程间）。
②流管道（s_pipe）：去除了上述的第一种限制，实现了双向传输。
③命名管道（name_pipe）：去除了上述的第二种限制，实现了无血缘关系的不同进程间通信。
显然，要求是对于不同的服务器之间的通信，是要要求全双工形式的，而管道只能是半双工，虽然可以双向，但是同一时间只能有一个方向传输，全双工和半双工的区别可以如下图示理解：

6.从action类上分析:
1.Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。 
2. Struts 2 Action类可以实现一个Action接口，也可实现其他接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现常用的接口。Action接口不是必须的，任何有execute标识的POJO对象都可以用作Struts2的Action对象。
从Servlet 依赖分析: 
3. Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。 
4. Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。
从action线程模式分析: 
5. Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。 
6. Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）

7.String类没有fromBytes()和encode以及decode方法！！

9.A -126 
原码     11111110
补码      符号位不变，其余取反再加1        //求补码，符号位不变
             10000010 

10.List的三个实现类：
    LinkedList ArrayList Vector（线程安全）
    
12.是否会调用构造方法：
new语句创建对象        //会
调用Java.io.ObjectInputStream的readObject方法    //不会
java反射机制使用java.lang.Class或java.lang.reflect.Constructor的newInstance()方法    //会
调用对象的clone()方法    //不会
构造函数的作用是完成对象的初始化。当程序执行到new操作符时， 首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化。而选项B、D中，对象的初始化并不是通过构造函数完成的，而是读取别的内存区域中的对象的各个域来完成。

13.Java标识符由数字、字母、下划线(_)、美元符号($)或人民币(￥)组成，首位不能是数字。并且Java关键字不能作为标识符。

14.
javac.exe是编译功能javaCompiler
java.exe是执行程序，用于执行编译好的.class文件
javadoc.exe用来制作java文档
jdb.exe是java的调试器
javaprof.exe是剖析工具

15.public class Z extends X{
    Y y=new Y();
    public Z(){
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z();
    }
}
    上述代码中，main方法开始执行时，Z类加载了但没有初始化，

16.
&与操作；
|或操作；
！非操作；
~取反操作；

17.获取ServletContext设置的参数值:context.getInitParameter()

18.Java中的类加载器
Java 中的类加载器大致可以分成两类，一类是系统提供的，另外一类则是由Java 应用开发人员编写的。系统提供的类加载器主要有下面三个：
引导类加载器（bootstrap class loader）：
它用来加载 Java 的核心库，是用原生代码来实现的，并不继承自 java.lang.ClassLoader。主要负责jdk_home/lib目录下的核心api 或 -Xbootclasspath 选项指定的jar包装入工作（其中的jdk_home是指配置jdk环境变量是java_home的配置路径，一般是jdk/jre所在目录）。
扩展类加载器（extensions class loader）：
它用来加载 Java 的扩展库。Java虚拟机的实现会提供一个扩展库目录，扩展类加载器在此目录里面查找并加载 Java 类，主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作。
系统类加载器（system class loader）：
它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()来获取它。主要负责CLASSPATH/-Djava.class.path所指的目录下的类与jar包装入工作.
除了系统提供的类加载器以外，开发人员可以通过继承java.lang.ClassLoader类的方式实现自己的类加载器，从而进行动态加载class文件，以满足一些特殊的需求，这体现java动态实时类装入特性。
除了引导类加载器之外，所有的类加载器都有一个父类加载器，通过getParent()方法可以得到。对于系统提供的类加载器来说，系统类加载器的父类加载器是扩展类加载器，而扩展类加载器的父类加载器是引导类加载器；对于开发人员编写的类加载器来说，其父类加载器是加载此类加载器 Java 类的类加载器。因为类加载器 Java 类如同其它的 Java 类一样，也是要由类加载器来加载的。一般来说，开发人员编写的类加载器的父类加载器是系统类加载器。类加载器通过这种方式组织起来，形成树状结构。树的根节点就是引导类加载器。下图中给出了一个典型的类加载器树状组织结构示意图，其中的箭头指向的是父类加载器。

19.
反射指的是在运行时能够分析类的能力的程序。
反射机制可以用来：
1.在运行时分析类的能力--检查类的结构--所用到的就是java.lang.reflect包中的Field、Method、Constructor，分别用于描述类的与、方法和构造器。A中的Class类在java.lang中。
2.在运行时查看对象。
3.实现通用的数组操作代码。
反射机制的功能：
在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态***。
反射机制常见作用：
动态加载类、动态获取类的信息（属性、方法、构造器）；动态构造对象；动态调用类和对象的任意方法、构造器；动态调用和处理属性；获取泛型信息（新增类型：ParameterizedType,GenericArrayType等）；处理注解（反射API:getAnnotationsdeng等）。
反射机制性能问题：
反射会降低效率。
void setAccessible(boolean flag):是否启用访问安全检查的开关，true屏蔽Java语言的访问检查，使得对象的私有属性也可以被查询和设置。禁止安全检查，可以提高反射的运行速度。
可以考虑使用：cglib/javaassist操作

20.类加载：
默认情况下，Java应用启动过程涉及三个ClassLoader: Boostrap, Extension, System    
一般的情况不同ClassLoader装载的类是不相同的，但接口类例外，对于同一接口所有类装载器装载所获得的类是相同的    //错误
类装载器需要保证类装载过程的线程安全
ClassLoader的loadClass在装载一个类时，如果该类不存在它将返回null    //错误
ClassLoader的父子结构中，默认装载采用了父优先
所有ClassLoader装载的类都来自CLASSPATH环境指定的路径    //错误
A、java中类的加载有5个过程，加载、验证、准备、解析、初始化；这便是类加载的5个过程，而类加载器的任务是根据一个类的全限定名来读取此类的二进制字节流到JVM中，然后转换为一个与目标类对应的java.lang.Class对象实例，在虚拟机提供了3种类加载器，引导（Bootstrap）类加载器、扩展（Extension）类加载器、系统（System）类加载器（也称应用类加载器）。A正确
B、一个类，由不同的类加载器实例加载的话，会在方法区产生两个不同的类，彼此不可见，并且在堆中生成不同Class实例。所以B前面部分是正确的，后面接口的部分真的没有尝试过，等一个大佬的讲解吧；
C、类加载器是肯定要保证线程安全的；C正确
D、装载一个不存在的类的时候，因为采用的双亲加载模式，所以强制加载会直接报错，D错误
java.lang.SecurityException: Prohibited package name: java.lang
E、双亲委派模式是在Java 1.2后引入的，其工作原理的是，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己想办法去完成，所以默认是父装载，E正确
F、自定义类加载器实现 继承ClassLoader后重写了findClass方法加载指定路径上的class，F错误

21.ServerSocket(int port) 是服务端绑定port端口，调accept()监听等待客户端连接，它返回一个连接队列中的一个socket。
Socket(InetAddress address , int port)是创建客户端连接主机的socket流，其中InetAddress是用来记录主机的类，port指定端口

22.
public class Test {
public static void main(String[] args) {
System.out.println(test());
 
}
private static int test() {
int temp = 1;
try {
System.out.println(temp);
return ++temp;
} catch (Exception e) {
System.out.println(temp);
return ++temp;
} finally {
++temp;
System.out.println(temp);
}
}
}
执行顺序为：
输出try里面的初始temp：1；
temp=2；
保存return里面temp的值：2；
执行finally的语句temp：3，输出temp：3；
返回try中的return语句，返回存在里面的temp的值：2；
输出temp：2。

下列Java代码中的变量a、b、c分别在内存的 堆 栈 栈____存储区存放。
class A {
    private String a = “aa”;
    public boolean methodB() {
        String b = “bb”;
        final String c = “cc”;
    }
}

23.
这道题目想考察的知识点是MySQL组合索引（复合索引）的最左优先原则。最左优先就是说组合索引的第一个字段必须出现在查询组句中，这个索引才会被用到。只要组合索引最左边第一个字段出现在Where中，那么不管后面的字段出现与否或者出现顺序如何，MySQL引擎都会自动调用索引来优化查询效率。
根据最左匹配原则可以知道B-Tree建立索引的过程，比如假设有一个3列索引(col1,col2,col3),那么MySQL只会会建立三个索引(col1),(col1,col2),(col1,col2,col3)。
所以题目会创建三个索引（plat_order_id）、（plat_order_id与plat_game_id的组合索引）、（plat_order_id、plat_game_id与plat_id的组合索引）。根据最左匹配原则，where语句必须要有plat_order_id才能调用索引（如果没有plat_order_id字段那么一个索引也调用不到），如果同时出现plat_order_id与plat_game_id则会调用两者的组合索引，如果同时出现三者则调用三者的组合索引。
题目问有哪些sql能使用到索引，个人认为只要Where后出现了plat_order_id字段的SQL语句都会调用到索引，只不过是所调用的索引不同而已，所以选BCDE。如果题目说清楚是调用到三个字段的复合索引，那答案才是BD。

24.
doGet/doPost 则是在 javax.servlet.http.HttpServlet 中实现的

25.double d=Math.cos（Math.toRadians（42））    //计算余弦值，先转弧度值

26.PreparedStatement是CallableStatement的父接口

27.运行时多态：
    class Test {
        public static void main(String[] args) {
            System.out.println(new B().getValue());
        }
        static class A {
            protected int value;
            public A (int v) {
                setValue(v);        --1
            }
            public void setValue(int value) {
                this.value= value;
            }
        }
        static class B extends A {
            public B () {
                super(5);
            }
            public void setValue(int value) {
                super.setValue(2 * value);
            }
        }
    }
    
    B对象实例化时，先调用super(5);即父类的构造，执行父构造方法中1行的代码时，会调用B中重写的setValue方法
    
28.yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。
    
29.
    A. long test = 012;   （八进制整型）
    B. float f = -412;   （自动转  -412.0f  单精度 浮点数）    //小数不加F默认是double类型，double类型不会自动转成float类型，编译是通不过的，但将整数赋予float是可以的。
    D. double d = 0x12345678;  （十六进制整数，自动转 双精度浮点数）    

30.
    Properties 类 继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
    HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。
    Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口。
    
31.标准ASCII只使用7个bit，扩展的ASCII使用8个bit。

32.ThreadLocalMap中使用开放地址法来处理散列冲突，而HashMap中使用的是分离链表法。之所以采用不同的方式主要是因为：在ThreadLocalMap中的散列值分散得十分均匀，
很少会出现冲突。并且ThreadLocalMap经常需要清除无用的对象，使用纯数组更加方便。

33.java.util.concurrent.ConcurrentHashMap 线程安全
java.util.Map 接口
java.util.TreeMap
java.util.SortedMap 接口
java.util.Hashtable 线程安全
java.util.HashMap

34.JVM内存区：程序计数器、虚拟机栈、本地方法栈、堆、方法区（包括常量池）。
不属于JVM内存区：直接内存（Direct Memory），用户I/O操作

35.动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，
也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。

36.Servlet过滤器配置：
    <filter>
        <filter-mapping>
        
37.JVM内存五大区域：
    虚拟机栈（包含栈帧）、本地方法栈、堆、方法区（包括常量池），pc寄存器
    
38.
    能被java.exe成功运行的java class文件必须有main()方法    //正确，main方法是入口
    J2SDK就是Java API                                        //J2SDK当然不仅仅包含java API
    Appletviewer.exe可利用jar选项运行.jar文件                //jar选项是java.exe 的选项
    能被Appletviewer成功运行的java class文件必须有main()方法    //Appletviewer是运行applet的， applet 不用main方法，继承applet类即可
    
39.
Ant和Maven都是基于Java的构建(build)工具。理论上来说，有些类似于（Unix）C中的make ，但没有make的缺陷。Ant是软件构建工具，Maven的定位是软件项目管理和理解工具。  
Ant特点
没有一个约定的目录结构 必须明确让ant做什么，什么时候做，然后编译，打包 
没有生命周期，必须定义目标及其实现的任务序列 
没有集成依赖管理  
Maven特点  
拥有约定，知道你的代码在哪里，放到哪里去 
拥有一个生命周期，例如执行 mvn install 就可以自动执行编译，测试，打包等构建过程 
只需要定义一个pom.xml,然后把源码放到默认的目录，Maven帮你处理其他事情 
拥有依赖管理，仓库管理

40.java接口包含函数声明和常量，没有变量声明

41.
PROPAGATION_REQUIRED
表示当前方法必须运行在一个事务中，如果当前存在一个事务，那么该方法运行在这个事务中，否则，将创建一个新的事务
PROPAGATION_REQUIRES_NEW
表示当前方法必须运行在自己的事务中，如果当前存在一个事务，那么这个事务将在该方法运行期间被挂起
PROPAGATION_SUPPORTS
表示当前方法不需要运行在一个是事务中，但如果有一个事务已经存在，该方法也可以运行在这个事务中
PROPAGATION_NEVER
表示方法不能运行在一个事务中，否则抛出异常

42.
obj.wait();需要捕获InterruptedException

43.
1，新生代：（1）所有对象创建在新生代的Eden区，当Eden区满后触发新生代的Minor GC，将Eden区和非空闲Survivor区存活的对象复制到另外一个空闲的Survivor区中。
（2）保证一个Survivor区是空的，新生代Minor GC就是在两个Survivor区之间相互复制存活对象，直到Survivor区满为止。
2，老年代：当Survivor区也满了之后就通过Minor GC将对象复制到老年代。老年代也满了的话，就将触发Full GC，针对整个堆（包括新生代、老年代、持久代）进行垃圾回收。
3，持久代：持久代如果满了，将触发Full GC

43.Stack，Vector线程安全

44.三.finalize
方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。
这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。
finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。注意：finalize不一定被jvm调用，只有当垃圾回收器要清除垃圾时才被调用。
protected void finalize() throws Throwable { }

45.选A、D。考察的是浏览器的内置对象管理模型，简称BOM(Browser Object Model)中的Histroy属性和方法。
length 返回浏览器历史列表中的URL数量。所以C中表述的长度信息是错误的。
back() 加载 history列表中的前一个URL。
forward() 加载  history  列表中的下一个URL。
go()  加载history列表中的某个具体页面。所以B的表述刷新当前页面是错误的。

46.Float类和Double类都重写对于的equals方法，在比较之前都会判断是否同属于Float对象或Double对象，如果不是直接返回false，如果是再继续比较对应的数值大小。

47.
    int count = 0; count = count++;     //执行完count值为0
    
48.
    二维数组定义，一维长度必须定义，二维可以后续定义
    
49.对象空间被收集前执行finalize（）方法，而不是对象空间被收集之后再执行，如果这样的话执行finalize（）就没有意义了
1、在java中，对象的内存在哪个时刻回收，取决于垃圾回收器何时运行。
2、一旦垃圾回收器准备好释放对象占用的存储空间，将首先调用其finalize()方法， 并且在下一次垃圾回收动作发生时，才会真正的回收对象占用的内存（《java 编程思想》）
3、在C++中，对象的内存在哪个时刻被回收，是可以确定的，在C++中，析构函数和资源的释放息息相关，能不能正确处理析构函数，关乎能否正确回收对象内存资源。
在java中，对象的内存在哪个时刻回收，取决于垃圾回收器何时运行，在java中，所有的对象，包括对象中包含的其他对象，它们所占的内存的回收都依靠垃圾回收器，因此不需要一个函数如C++析构函数那样来做必要的垃圾回收工作。
当然存在本地方法时需要finalize()方法来清理本地对象。在《java编程思想》中提及，finalize()方法的一个作用是用来回收“本地方法”中的本地对象

50.
A，structs可以进行文件上传
B，structs基于MVC模式，MVC是模型，视图，控制器，是一种设计模式
C，structs框架让流程结构更清晰
D，structs需要很多 action类，会增加类文件数目

51.
    Java 中的堆是 JVM 所管理的最大的一块内存空间，主要用于存放各种类的实例对象。
在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。
这样划分的目的是为了使 JVM 能够更好的管理堆内存中的对象，包括内存的分配以及回收。

52.
    匿名内部类的创建格式为： new 父类构造器（参数列表）|实现接口（）{
                                             //匿名内部类的类体实现
                                        }
    使用匿名内部类时，必须继承一个类或实现一个接口
    匿名内部类由于没有名字，因此不能定义构造函数
    匿名内部类中不能含有静态成员变量和静态方法

53.容器panel缺省使用的布局编辑策略是Flow Layout

54.中间件是一种独立的系统软件或服务程序，分布式应用软件借助这种软件在不同的技术之间共享资源。
中间件位于客户机/ 服务器的操作系统之上，管理计算机资源和网络通讯。是连接两个独立应用程序或独立系统的软件。
相连接的系统，即使它们具有不同的接口，但通过中间件相互之间仍能交换信息。执行中间件的一个关键途径是信息传递。通过中间件，应用程序可以工作于多平台或OS环境。
（简单来说，中间件并不能提高内核的效率，一般只是负责网络信息的分发处理）

55.
    super.getClass().getName()
    返回：包名+类名
    
57.
两个最基本的java回收算法：复制算法和标记清理算法：
新生代基本采用复制算法，老年代采用标记整理算法。cms采用标记清理。

58.
  java中true ,false , null在java中不是关键字，也不是保留字，它们只是显式常量值，但是你在程序中不能使用它们作为标识符。
其中const和goto是java的保留字。java中所有的关键字都是小写的，
还有要注意true,false,null不是java的关键字,但是你不能把它们作为java标识符用。

friendly，sizeof不是java中关键字，且可以作为java标识符

59.
USES-A：依赖关系，A类会用到B类，这种关系具有偶然性，临时性。但B类的变化会影响A类。这种在代码中的体现为：A类方法中的参数包含了B类。
关联关系：A类会用到B类，这是一种强依赖关系，是长期的并非偶然。在代码中的表现为：A类的成员变量中含有B类。
HAS-A：聚合关系，拥有关系，是关联关系的一种特例，是整体和部分的关系。比如鸟群和鸟的关系是聚合关系，鸟群中每个部分都是鸟。
IS-A：表示继承。父类与子类，这个就不解释了。
要注意：还有一种关系：组合关系也是关联关系的一种特例，它体现一种contains-a的关系，
这种关系比聚合更强，也称为强聚合。它同样体现整体与部分的关系，但这种整体和部分是不可分割的。

60.
方法调用时，会创建栈帧在栈中，调用完是程序自动出栈释放，而不是gc释放

61.函数（fseek）把文件位置重定位到文件中的指定位置

62.计算机中负数是以补码的形式保存:
两个二进制数相加，先相加再转源码：
变量a是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF;变量b是一个64位有符号的整数，
初始值用16进制表示为：0x8000000000000000。则a+b的结果用10进制表示为多少？
a+b的16进制表示为：OxFFFFFFFFFFFFFFF（16位F），转为2进制为111……111（64位1，每个F->4位2）。
（2）有符号数：是针对二进制来讲的。用最高位作为符号位，“0”代表“+”，“1”代表“-”。所以a+b的结果是一个负数。
（3）计算机中负数是以补码的形式保存的，将补码转换成原码的计算方式如下：
①. 对于正数，原码与补码相同。
②.对于负数，将补码除符号位之外，按位取反，末位加1，即得到原码。
（4）a + b = 111……111（64位1）
取反：100……000（1位1，后面63位0）
加一：100……00（中间62位0）
10进制：-1。

63.
程序设计语言中，数组元素在内存中是一个接着一个线性存放的，通过第一个元素就能访问随后的元素，这样的数组称之为“真数组”。
实现了真数组为Java语言健壮性的特点之一。
Java还实现了真数组，避免了覆盖数据的可能。//注意，是避免数据覆盖的可能，而不是数据覆盖类型

64.
是Arrays.asList()，其将一个数组转化为一个List对象，这个方法返回一个ArrayList类型的对象，
这个ArrayList类并非java.util.ArrayList类，而是Arrays类的内部类：

65.Swing的顶层容器：含JApplet、JDialog、JFrame和JWindow

66.ServletConfig接口默认是哪里实现的：GenericServlet

67.HashTable使用Enumeration，HashMap使用Iterator

68.在Java7之前，switch只能支持 byte、short、char、int或者其对应的封装类以及Enum类型。在Java7中，也支持了String类型
String byte short int char Enum 类型

69.按照流是否直接与特定的地方（如磁盘、内存、设备等）相连，分为节点流和处理流两类。
节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader.
处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。
一个流对象经过其他流的多次包装，称为流的链接。
常用处理流（关闭处理流使用关闭里面的节点流）
缓冲流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter 增加缓冲功能，避免频繁读写硬盘。
转换流：InputStreamReader OutputStreamReader 实现字节流和字符流之间的转换。
数据流 DataInputStream DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来.

70.Java体系结构包括四个独立但相关的技术：
Java程序设计语言
Java.class文件格式
Java应用编程接口（API）
Java虚拟机

71.2.String对象的两种创建方式:
(1)第一种方式: String str1 = "aaa"; 是在常量池中获取对象("aaa" 属于字符串字面量，因此编译时期会在常量池中创建一个字符串对象，如果常量池中已经存在该字符串对象则直接引用)
(2)第二种方式: String str2 = new String("aaa") ; 一共会创建两个字符串对象一个在堆中，一个在常量池中（前提是常量池中还没有 "aaa" 象）。
System.out.println(str1==str2);//false

3.String类型的常量池比较特殊。它的主要使用方法有两种：
(1)直接使用双引号声明出来的String对象会直接存储在常量池中。
(2)如果不是用双引号声明的String对象,可以使用 String 提供的 intern 方法。 String.intern() 是一个 Native 方法，它的作用是： 如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用； 如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用。
String s1 = new String("AAA");
String s2 = s1.intern();
String s3 = "AAA";
System.out.println(s2);//AAA
System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，
System.out.println(s2 == s3);//true， s1,s2指向常量池中的”AAA“
4字符串拼接：
String a = "a";
String b = "b";

String str1 = "a" + "b";//常量池中的对象
String str2 = a + b; //在堆上创建的新的对象
String str3 = "ab";//常量池中的对象
System.out.println(str1 == str2);//false
System.out.println(str1 == str3);//true
System.out.println(str2 == str3);//false

72.DynaValidatorActionForm 动态验证表单

73.Applet显示相关的方法主要有3个。
1. paint(Graphicsg)方法，具体执行Applet的绘制。
2. update(Graphicsg)()方法，主要用于更新Applet的显示。
3. repaint()方法，主要用于Applet的重新显示，它调用update()方法实现对Applet的更新。
而draw()方法与显示无关，故选A draw

74.A、Semaphore：类，控制某个资源可被同时访问的个数;
B、ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
C、 Future：接口，表示异步计算的结果；
D、 CountDownLatch： 类，可以用来在一个线程中等待多个线程完成任务的类

75.一个简便的记忆法：0：48 A:65 a:97，数字连起来是486597 -> 486 597 -> 486 (486 + 111)

76.字符流和字节流每次读入的字节数是不确定的，可能相同也可能不相同

77.StringBuilder , StringBuffer ,String 都是 final 的

78.Servlet的生命周期一般可以用三个方法来表示：
init()：仅执行一次，负责在装载Servlet时初始化Servlet对象
service() ：核心方法，一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。
destory()：在停止并且卸载Servlet时执行，负责释放资源
初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，
将ServletConfig作为参数来调用init()方法。所以选ACD。B是在调用service方法时才构造的

79.
Collections 类提供了synchronizedXxx()方法，可以将指定的集合包装成线程同步的集合。比如，
List list = Collections.synchronizedList(new ArrayList());
Set set = Collections.synchronizedSet(new HashSet());

80. CyclicBarrier让一组线程等待其他线程
CyclicBarrier可以使一定数量的线程反复地在栅栏位置处汇集。当线程到达栅栏位置时将调用await方法，
这个方法将阻塞直到所有线程都到达栅栏位置。如果所有线程都到达栅栏位置，那么栅栏将打开，
此时所有的线程都将被释放，而栅栏将被重置以便下次使用。

81.A:.java编译成的是字节码，再被各系统的jvm翻译成本系统可以识别的机器码，这就是java一次编程多平台应用的跨平台性
B:java源文件生成的是class文件，与系统无关
C:注意字节码和机器码不是一回事 java程序在运行时字节码才会被jvm翻译成机 器码，所以说java是解释性语言
D:注意jvm的版本，好比人穿裤子，一条裤子能被任何人穿上吗

82.虚拟机规范严格规定了有且只有五种情况必须立即对类进行“初始化”：
1. 使用new关键字实例化对象的时候、读取或设置一个类的静态字段的时候，已经调用一个类的静态方法的时候。
2. 使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有初始化，则需要先触发其初始化。
3. 当初始化一个类的时候，如果发现其父类没有被初始化就会先初始化它的父类。
4. 当虚拟机启动的时候，用户需要指定一个要执行的主类（就是包含main()方法的那个类），虚拟机会先初始化这个类；
5. 使用Jdk1.7动态语言支持的时候的一些情况。

除了这五种之外，其他的所有引用类的方式都不会触发初始化，称为被动引用。下面是被动引用的三个例子：
1. 通过子类引用父类的的静态字段，不会导致子类初始化。
2. 通过数组定义来引用类，不会触发此类的初始化。
public class NotInitialization {
public static void main(String[] args) {
SuperClass[] sca = new SuperClass[10];
}
}
3. 常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
public class ConstClass {
static {
System.out.println("ConstClass init!");
}
public static final int value = 123;
}
public class NotInitialization{
public static void main(String[] args) {
int x = ConstClass.value;
}
}
上述代码运行之后，也没有输出“ConstClass init！”，这是因为虽然在Java源码中引用了ConstClass类中的常量HELLOWORLD，
但其实在编译阶段通过常量传播优化，已经将此常量的值“hello world”存储到了NotInitialization类的常量池中，
以后NotInitialization对常量ConstClass.HELLOWORLD的引用实际都被转化为NotInitialization类对自身常量池的引用了。
也就是说，实际上NotInitialization的Class文件之中并没有ConstClass类的符号引用入口，这两个类在编译成Class之后就
不存在任何联系了。

83.
在源码中 toLowerCase 是重新 new String()

84.
catch块中有return情况下，抛出异常，执行catch中return之前的语句，然后执行finally中的语句，最后在执行return语句

85.不属于jdk1.6垃圾收集器:G1收集器

86. 复制的效率System.arraycopy>clone>Arrays.copyOf>for循环

87.C.混合赋值运算符的使用
<<表示左移位
>>表示带符号右移位
>>>表示无符号右移
但是没有<<<运算符

88.exception是JSP九大内置对象之一，其实例代表其他页面的异常和错误。
只有当页面是错误处理页面时，即isErroePage为 true时，该对象才可以使用。

89.javax是Sun公司提供的一个扩展包，算是对原 JAVA 包的一些优化处理，现在已经有很多都是基于JAVAX的程序开发而不是java包。

90.local variable：局部变量

还有两种是实现Runnable接口或者实现Callable接口

式(short)10/10.2*2 //short优先级高，值类型double

Swing 是在AWT的基础上构建的一套新的图形界面系统，它提供了AWT 所能够提供的所有功能，并且用纯粹的Java代码对AWT 的功能进行了大幅度的扩充。AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT 的Java程序，其运行速度比较慢。

-Xmx：最大堆大小
-Xms：初始堆大小
-Xmn:年轻代大小
-XXSurvivorRatio：年轻代中Eden区与Survivor区的大小比值
年轻代5120m， Eden：Survivor=3，Survivor区大小=1024m（Survivor区有两个，即将年轻代分为5份，每个Survivor区占一份），总大小为2048m。
-Xms初始堆大小即最小内存值为10240m

-Xmx10240m：代表最大堆
-Xms10240m：代表最小堆
-Xmn5120m：代表新生代
-XXSurvivorRatio=3：代表Eden:Survivor = 3 根据Generation-Collection算法(目前大部分JVM采用的算法)，一般根据对象的生存周期将堆内存分为若干不同的区域，一般情况将新生代分为Eden ，两块Survivor； 计算Survivor大小， Eden:Survivor = 3，总大小为5120,3x+x+x=5120 x=1024
新生代大部分要回收，采用Copying算法，快！
老年代 大部分不需要回收，采用Mark-Compact算法

10原码：0000000000000000,0000000000001010；
~10： 1111111111111111,1111111111110101 变为负数，计算机用补码存储
~10反码：10000000000000000,0000000000001010
~10补码：10000000000000000,0000000000001011，等于 -11

计算~n
公式-n=~n+1可推出~n=-n-1，所以~10=-11再加5结果为-6

Thread.join被打断会抛出InterruptedException

Enclosingone.InsideOne obj1 = new Enclosingone().new InsideOne();//非静态内部类对象
Enclosingone.InsideTwo obj2 = new Enclosingone.InsideTwo();//静态内部类对象

*p表示指针p
&a表示取a的内存地址

Java一个源程序只能有一个public类存在，且类名与文件名相同。

编译看左边，运行看右边。

setDaemon()方法必须在线程启动之前调用，当线程正在运行时调用会产生异常。

Java(1.6.x)里提供了几种Reader的直接继承类，具体的有：BufferedReader, CharArrayReader, FileReader, InputStreamReader, PipedReader, StringReader等，
子类须实现的方法只有 read(char[], int, int) 和 close()。

17^5：^是异或运算符，相同为0，不同为1

解析：这是一个关于java的垃圾回收机制的题目。垃圾回收主要针对的是堆区的回收，因为栈区的内存是随着线程而释放的。堆区分为三个区：年轻代（Young Generation）、年老代（Old Generation）、永久代（Permanent Generation，也就是方法区）。
年轻代：对象被创建时（new）的对象通常被放在Young（除了一些占据内存比较大的对象）,经过一定的Minor GC（针对年轻代的内存回收）还活着的对象会被移动到年老代（一些具体的移动细节省略）。
年老代：就是上述年轻代移动过来的和一些比较大的对象。Minor GC(FullGC)是针对年老代的回收
永久代：存储的是final常量，static变量，常量池。

常量池是PermGen的

变量不能被defalut修饰

指定URL不存在，会抛异常

>>带符号右移 >>> 无符号右移

子类不能继承构造方法，只能调用

java + 你的 Java 程序的名字但是不加后缀

在Web应用程序中，( Web容器 )负责将HTTP请求转换为HttpServletRequest对象

。由于replaceAll方法的第一个参数是一个正则表达式，而"."在正则表达式中表示任何字符，
所以会把前面字符串的所有字符都替换成"/"。如果想替换的只是"."，那么久要写成"\\.".

：线程在MediaTracker上执行了waitforID（）调用。
这个应该大家也不太熟悉。这个类是awt里面的，我查API才知道。
然后他的功能是加载图像，直到完成之前，该方法一直等待！这个方法是必须要抛出A选项的InterruptedException 异常的
说明这玩意会让其他线程 wait他完成！ 所以会暂停当前线程

java.lang.OutOfMemoryError: PermGen space
查了一下为"永久代"内存大小不足，“永久代”的解释应该为JVM中的方法区，主要用于存储类信息，常量，静态变量，即时编译器编译后代码等。本错误仅限于Hotspot虚拟机，本区进行垃圾回收很少，不够直接加大简单粗暴。
java.lang.OutOfMemoryError: Requested array size exceeds VM limit
直接翻译报错信息：数组过长导致堆内存溢出，加大堆内存或者减少数组长度。
java.lang.OutOfMemoryError: Java heap space
堆内存不足，直接增大堆内存。

Java语言与其它语言相比，独有的特点是：跨平台

Java 提供的事件处理模型：
事件源，事件对象，事件监听器

Integer s=new Integer(9);
Integer t=new Integer(9); s==t //false
Integer a = 1000, b = 1000;
System.out.println(a == b);//1 false
Integer c = 100, d = 100;
System.out.println(c == d);//2 true

c++虚类相当与java里面的抽象类
c++中没有接口的概念，与之对应的是纯虚类，对应的是java的接口

创建Servlet的实例是由Servlet容器来完成的，且创建Servlet实例是在初始化方法init()之前

public final native void notify() throws IllegalMonitorStateException
该方法也要在同步方法或同步块中调用，即在调用前，线程也必须要获得该对象的对象级别锁，的如果调用 notify()时没有持有适当的锁，也会抛出 IllegalMonitorStateException。
该方法用来通知那些可能等待该对象的对象锁的其他线程。如果有多个线程等待，则线程规划器任意挑选出其中一个 wait()状态的线程来发出通知，并使它等待获取该对象的对象锁（notify 后，当前线程不会马上释放该对象锁，wait 所在的线程并不能马上获取该对象锁，
要等到程序退出 synchronized 代码块后，当前线程才会释放锁，wait所在的线程也才可以获取该对象锁

方法区,java堆被线程共享

取到http请求中的cookie值：request.getHeader request.getCookies

TextField 的事件监听器接口是ActionListener

notifyAll()不会马上释放锁，会在执行完当前代码块代码之后

私有:java虚拟机栈，程序计数器，本地方法栈 共享:java堆，方法区

C，java不完全算是编译型语言，他编译的字节码文件运行时是解释执行的，
其次，java和C++的类也不都完全是静态绑定的，比如C+++的虚函数，java的父类引用子类对象等情况。

判断一块内存空间是否符合垃圾收集器收集的标准有：
a.给对象赋予了空值null,以下再没有调用过
b.对象重新分配了内存空间
c.给对象赋予了新值

java.lang包包含
包装类
String 类
Math 类 —— 包含函数
Class 类
Object 类

int y = (int)1.0; //强转的int必须加括号

在JDK1.8之前运行时常量池被放在方法区,属于线程共享,JDK1.8之后,元空间取代了方法区,运行时常量池被也被放在元空间中

public class Father {
public void say(){
System.out.println("father");
}
public static void action(){
System.out.println("爸爸打儿子！");
}
}
public class Son extends Father{
public void say() {
System.out.println("son");
}
public static void action(){
System.out.println("打打！");
}
public static void main(String[] args) {
Father f=new Son();
f.say();
f.action();
}
}
输出：son
爸爸打儿子！
当调用say方法执行的是Son的方法，也就是重写的say方法
而当调用action方法时，执行的是father的方法。
普通方法，运用的是动态单分配，是根据new的类型确定对象，从而确定调用的方法；
静态方法，运用的是静态多分派，即根据静态类型确定对象，因此不是根据new的类型确定调用的方法

捕获到的异常不仅可以在当前方法中处理，还可以将异常抛给调用它的上一级方法来处理。

ReadWriteLock适用于读多写少的并发场景

Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，
通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

JMX是在1.3JDK版本开始支持

RandomAccessFile 可以通过 seek(long pos) 方法去移动文件指针进行追加更新写入.

Servlet的生命周期初始化阶段：
加载Servlet类及.class对应的数据
创建Servlet对象
创建ServletConfig对象

而且map和multimap都是由RB_tree（红黑树）来实现的，本就合适于查找，复杂度为 O( ln(N) )

总结来说就是：字面量"+"拼接是在编译期间进行的，拼接后的字符串存放在字符串池中；而字符串引用的"+"拼接运算实在运行时进行的，新创建的字符串存放在堆中。

default顾名思义是缺省情况，只有任何条件都不匹配的情况下才会执行，故会匹配到s[i]为‘4’，‘5’，‘0’ 的情况。于是v4++三次，v4=3.
并且这个default后没有使用break语句，于是case‘1’、‘2’、‘3’都会执行三次。

1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
2、两个Integer类型进行“==”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。