java练习
java练习题
-
- java题1
- java题2
- java题3
- java题4
- java题5
- java题6（1）
- java题7（2）
- java题8（3）
java题1
解析：
编译不会编译注释中的内容。javac编译后的字节码文件中也不会出现自己手打的注释。
解析：
Java中类是单继承，但接口可以多继承
解析：
先要理解什么是类的方法，所谓类的方法就是指类中用static 修饰的方法（非static 为实例方法），比如main 方法，那么可以以main 方法为例，可直接调用其他类方法，必须通过实例调用实例方法，this 关键字不是这么用的
解析：
解决哈希冲突常用的两种方法是：开放定址法和链地址法
解析：
接口方法默认是public abstract的，且实现该接口的类中对应的方法的可见性不能小于接口方法的可见性，因此也只能是public的。
解析：
选C
父类没有无参的构造函数，所以子类需要在自己的构造函数中显式调用父类的构造函数，会编译报错
解析：
A不用解释，B中JVM将字节码转换成不同平台(OS)下可执行的机器码指令。D中说的与硬件交互是JVM机器指令与硬件的交互。
解析：
A.函数中定义的变量是局部变量，作用域为当前函数或循环等
B.局部变量在函数内部或循环内部，随函数的退出或循环退出就不存在了
解析：
解析：
字节流必是一个接点流，字符流就是一个操作流
解析：
这道题，首先没有初始化对象根本没有输出。
其次，即使初始化了对象，也该是输出
我是父类
我是父类
我是子类
解析：
导包关键词import
解析：
值传递，传递的是原来值的副本。
引用传递，除了一些特殊的（String，包装类属于不可变类），一般的引用类型在进行传递的时候，一开始形参和实参都是指向同一个地址的，这个时候形参对对象的改变会影响到实参
解析：
类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。boolean类型默认值是false
解析：
this表示当前类的对象，由static修饰的方法是由类直接调用，不需要创建对象，所以在static里不能用this.
解析：
关于抽象类
JDK 1.8以前，抽象类的方法默认访问权限为protected
JDK 1.8时，抽象类的方法默认访问权限变为default
关于接口
JDK 1.8以前，接口中的方法必须是public的
JDK 1.8时，接口中的方法可以是public的，也可以是default的
解析：
第一，记住wait必须要进行异常捕获
第二，记住调用wait或者notify方法必须采用当前锁调用，即必须采用synchronized中的对象
解析：
newSupper().get()和newSub().get()只调用了get()方法，又没有打印输出get()返回的数值，所以肯定没有5
解析：
Collection
-----List
-----LinkedList 非同步
----ArrayList 非同步，实现了可变大小的元素数组
----Vector 同步
-----Set 不允许有相同的元素
Map
-----HashTable 同步，实现一个key–value映射的哈希表，key和value都不允许出现nul值
-----HashMap 非同步，
-----WeakHashMap 改进的HashMap，实现了“弱引用”，如果一个key不被引用，则被GC收
注：
List接口中的对象按一定顺序排列，允许重复
Set接口中的对象没有顺序，但是不允许重复
Map接口中的对象是key、value的映射关系，key不允许重复
解析：
A、LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。
B、LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性。
C、PriorityQueue是一个队列，不允许null值，入队和出队的时间复杂度是O（log(n)）。
D、PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的线程安全队列，该队列的元素遵循FIFO原则。
解析：
continue是跳出本次循环
解析：
A：一个类里面多个内部类，构造方法名是与和.java文件同名的public类名。内部类也是类，构造方法名和内部类名不同。
B:构造方法不返回任何值，也没有返回类型。无异议。
C：子类在构造方法里面调用父类的构造方法时，会在第一行使用“super(参数列表)”显示调用父类的构造方法。这里是显示地直接调用，而且没有创建新对象。
D：每一个和.java文件同名的public类可以有多个构造方法，构造方法允许重载。内部类也可以有多个构造方法，而匿名内部类一个构造方法都没有。
解析：
基类是抽象类，子类继承父类，但是没有实现基类的抽象方法，那么子类也是抽象类。抽象类不能创建对象，所以在主函数中创建对象编译不会通过。
解析：
- 在类的其他构造方法中可以用this()的方式调用其他构造方法；
- 在类的子类中则可以通过super调用父类中指定的构造方法；
- 在反射中可以使用newInstance()的方式调用。
解析：
解析：
a++ 先把10赋值给a 再+1 所以左边是10 但此时a=11。右边a-- 也是先赋值 a=11，再-1。10+11=21 此时a=10。
解析：
公式-n=n+1可推出n=-n-1，所以~10=-11再加5结果为-6
解析：
抛InterruptedException的代表方法有：
java.lang.Object 类的 wait 方法
java.lang.Thread 类的 sleep 方法
java.lang.Thread 类的 join 方法
解析：
JVM内存区：程序计数器、虚拟机栈、本地方法栈、堆、方法区（包括常量池）。
不属于JVM内存区：直接内存（Direct Memory），用户I/O操作
解析：
1、abstract类不能用来创建abstract类的对象；
2、final类不能用来派生子类，因为用final修饰的类不能被继承；
3、如2所述，final不能与abstract同时修饰一个类，abstract类就是被用来继承的；
4、类中有abstract方法必须用abstract修饰，但abstract类中可以没有抽象方法，接口中也可以有abstract方法。
java题2
解析：
A、一旦执行到return，就不再执行后续的代码。
B、类的封装性可不是这么体现的，数据域和方法都可以被封装。数据域可以是基本数据类型也可以是引用类型。
C、方法的返回值可以是引用类型。
D、重载，判定方法只有方法名一致，形参列表不同。
解析：
Java是一门面向对象编程语言，属于计算机语言。故正确答案为D选项。
解析：
instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例，而Object是所有类的父类。
解析：
+号两边如果有一边为字符类型 则为字符串连接。
解析：
A，类是一个封装，类的成员只能在类内部使用，外部需要 “对象名.变量名” 来引用。
B，正确，局部变量只在定义它的代码块或者函数内部可见
C，跟类的成员变量一样，需要指定对象才能引用
D，如果类没有构造方法，JVM会生成一个默认构造方法，如果定义了任意类型的构造方法，编译器都不会自动生成构造方法。
解析：
在同一个java原文件中，可以有多个class类，但是只有有一个公共的 public class
解析：
覆盖是发生在子类与基类中，重载发生在一个类中重载要求方法名一样，形参类型、顺序和个数不能完全一样，返回值类型不能作为判断的标准覆盖要求 方法名、形参类型、顺序和个数都完全一样。
解析：
try:可能发生异常的语句
catch:捕获，并处理异常（printStackTrace()用来跟踪异常事件发生时执行堆栈的内容）
throw:方法内部抛异常
throws:声明方法异常
finaly：代码中无论是否有异常都会执行，清除资源
解析：
内部类可以是静态static的，也可用public，default，protected和private修饰，外部类的修饰符只能是public，abstract，final。
解析：
Set 不能有重复的元素，且是无序的，要有空值也就只能有一个。因为它不允许重复。 L ist 可以有重复元素，且是有序的，要有空值也可以有多个，因为它可重复。
解析：
++i就是先赋值 再计算 当到9的时候直接+1超过了10直接输出。
解析：
此题的父类方法有private修饰，所以对子类不可见，子类不能覆盖。所以子类方法和父类是两个方法。
解析：
package语句只能放在第一行。
解析：
&& 运算时出现false时运算结果就判断为false
a != 3 && a != 4 && a != 5 && a != 6
a = 4;
因为a != 4 false 所以 结果false；
a = 6;
因为a != 6 false 所以 结果false；
a = 8;
因为a != 3 a != 4 a != 5 a != 6都为 ture 所以 结果true
所以
答案D
解析：
结果中数组的第一个元素 0 是 原数组中的第二个0。
这个程序就是在删除数组中的0 ，但是会有个小问题，就是连续的0会只删除一个。
原因：当执行remove的时候，ArrayList 数组的 size 会变小一个，原本的位置上的 0 会被后面的 0 给替代；而在执行完remove后执行了k++;所以跳过了第二个0
解析：
y是2，返回的结果是2+（z–/++x），再来看z–/++x，结果应该是3/2，但是因为x,y,z都是int型的，所以最后的返回值只能是int，这时候z–/++x的值就是1，那么最终的结果就是2+1=3。
解析：
\D 匹配一个非数字字符。
解析：
Step 1: new B()构造一个B类的实例
此时super(5)语句调用显示调用父类A带参的构造函数，该构造函数调用setValue(v)，这里有两个注意点一是虽然构造函数是A类的构造函数，但此刻正在初始化的对象是B的一个实例，因此这里调用的实际是B类的setValue方法，于是调用B类中的setValue方法 ==> 而B类中setValue方法显示调用父类的setValue方法，将B实例的value值设置为2 x 5 = 10。
紧接着，B类的构造函数还没执行完成，继续执行setValue(getValue()- 3) // 备注1语句。
先执行getValue方法，B类中没有重写getValue方法，因此调用父类A的getValue方法。这个方法比较复杂，需要分步说清楚：
调用getValue方法之前，B的成员变量value值为10。
value++ 执行后， B的成员变量value值为11，此时开始执行到return语句，将11这个值作为getValue方法的返回值返回出去
但是由于getValue块被try finally块包围，因此finally中的语句无论如何都将被执行，所以步骤2中11这个返回值会先暂存起来，到finally语句块执行完毕后再真正返回出去。
这里有很重要的一点：finally语句块中 this.setValue(value)方法调用的是B类的setValue方法。因为此刻正在初始化的是B类的一个对象（运行时多态），就像最开始第一步提到的一样(而且这里用了使用了this关键词显式指明了调用当前对象的方法)。因此，此处会再次调用B类的setValue方法，同上，super.关键词显式调用A的setValue方法，将B的value值设置成为了2 * 11 = 22。
因此第一个打印项为22。
finally语句执行完毕 会把刚刚暂存起来的11 返回出去，也就是说这么经历了这么一长串的处理，getValue方法最终的返回值是11。
回到前面标注了 //备注1 的代码语句，其最终结果为setValue(11-3)=>setValue(8)
这里执行的setValue方法，将会是B的setValue方法。 之后B的value值再次变成了2*8 = 16;
Step2: new B().getValue()
B类中没有独有的getValue方法，此处调用A的getValue方法。同Step 1，
调用getValue方法之前，B的成员变量value值为16。
value++ 执行后， B的成员变量value值为17，此时执行到return语句，会将17这个值作为getValue方法的返回值返回出去
但是由于getValue块被try finally块包围而finally中的语句无论如何都一定会被执行，所以步骤2中17这个返回值会先暂存起来，到finally语句块执行完毕后再真正返回出去。
finally语句块中继续和上面说的一样: this.setValue(value)方法调用的是B类的setValue()方法将B的value值设置成为了2 * 17 = 34。
因此第二个打印项为34。
finally语句执行完毕 会把刚刚暂存起来的17返回出去。
因此new B().getValue()最终的返回值是17.
Step3: main函数中的System.out.println
将刚刚返回的值打印出来，也就是第三个打印项：17
最终结果为 22 34 17。
解析：
插入排序：最佳O（N）
快速排序：最佳O（NlogN）
堆 排序：最佳O（NlogN）
归并排序：最佳O（NlogN）
因此选择插入排序。
解析：
A.很明显是赋值符号
B.<<=左移赋值
C.不是
D.>>>= 右移赋值，左边空出的位以0填充
解析：
ArrayList 是线程不安全的， Vector 是线程安全的，这两个类底层都是由数组实现的
LinkedList 是线程不安全的，底层是由链表实现的
HashTable 是线程安全的，不能存储 null 值
HashMap 不是线程安全的，可以存储 null 值
解析：
解析：
1、一个类可以实现多个接口
2、抽象类可以没有抽象方法；
3、有抽象方法的类必须定义为抽象类
解析：
Jsp只会在客户端第一次发请求的时候被编译，之后的请求不会再编译，同时tomcat能自动检测jsp变更与否，变更则再进行编译。
第一次编译并初始化时调用： init() ；销毁调用： destroy() 。在整个jsp生命周期中均只调用一次。
service()方法是接收请求，返回响应的方法。每次请求都执行一次，该方法被HttpServlet封装为doGet和doPost方法
解析：
HttpSessionAttributeListener：可以实现此侦听器接口获取此web应用程序中会话属性列表更改的通知；
HttpSessionBindingListener：当该对象从一个会话中被绑定或者解绑时通知该对象，这个对象由HttpSessionBindingEvent对象通知。这可能是servlet程序显式地从会话中解绑定属性的结果，可能是由于会话无效，也可能是由于会话超时；
HttpSessionObjectListener：没有该接口API；
HttpSessionListener：当web应用程序中的活动会话列表发生更改时通知该接口的实现类，为了接收该通知事件，必须在web应用程序的部署描述符中配置实现类；
HttpSessionActivationListener：绑定到会话的对象可以侦听容器事件，通知它们会话将被钝化，会话将被激活。需要一个在虚拟机之间迁移会话或持久会话的容器来通知所有绑定到实现该接口会话的属性
解析：
java中只有byte, boolean是一个字节, char是两个字节, 所以对于java来说127不会发生溢出, 输出328
但是对于c/c++语言来说, char是一个字节, 会发生溢出, 对127加一发生溢出, 0111 1111 --> 1000 0000, 1000 0000为补码-128, 所以结果为200-128=72
解析：
静态内部类：不可以访问外部非静态资源；
成员内部类:可以访问外部所有资源，但本身内部不可以有静态属性(需要被外部实例化)
局部内部类:不可被访问符合和static修饰，只能访问final变量和形参
匿名内部类：a没有构造器,没有静态资源，无法被访问符修饰 b只能在匿名内部类中创建一个实。
解析：
byte类型的变量在做运算时被会转换为int类型的值，故A、B左为byte，右为int，会报错；而C、D语句中用的是a+=b的语句，此语句会将被赋值的变量自动强制转化为相对应的类型。
解析：
A、错，Hashtable 是一个哈希表，该类继承自Dictionary类，实现了 Map 接口
B、错，HashMap是基于哈希表实现的，每一个元素是一个key-value对，其内部通过单链表解决冲突问题，容量不足（超过了阀值）时，同样会自动增长。该类继承AbstractMap，实现Map接口
C、 对，Hashtable 线程安全的，而 HashMap 是线程不安全的。Hashtable 中的方法是Synchronize的，而HashMap中的方法在缺省情况下是非Synchronize的。
D、讲的没错，但是不符合题意
E、对。
解析：
- 只看尖括号里边的！！明确点和范围两个概念
- 如果尖括号里的是一个类，那么尖括号里的就是一个点，比如
List,List,List - 如果尖括号里面带有问号，那么代表一个范围， 代表小于等于A的范围，代表大于等于A的范围，代表全部范围
- 尖括号里的所有点之间互相赋值都是错，除非是俩相同的点
- 尖括号小范围赋值给大范围，对，大范围赋值给小范围，错。如果某点包含在某个范围里，那么可以赋值，否则，不能赋值
- List和List 是相等的，都代表最大范围
- List既是点也是范围，当表示范围时，表示最大范围
public static void main(String[] args) {
List<A> a;
List list;
list = a; //A对，因为List就是List，代表最大的范围，A只是其中的一个点，肯定被包含在内
List<B> b;
a = b; //B错，点之间不能相互赋值
List<?> qm;
List<Object> o;
qm = o; //C对，List代表最大的范围，List
List<D> d;
List<? extends B> downB;
downB = d; //D对，List代表小于等于B的范围，List是一个点，在其中
List<?extends A> downA;
a = downA; //E错，范围不能赋值给点
a = o; //F错，List
downA = downB; //G对，小于等于A的范围包含小于等于B的范围，因为B本来就比A小，B时A的子类嘛
}
java题3
解析：
构造方法用于对象属性的实例化
解析：
类除了无参构造方法，还有有参构造方法，有参构造方法还可以通过重载写出多参的构造方法（2参，3参，4参）
解析：
子类调用父类的构造器使用super(),放在子类构造函数的首行
解析：
m++ ，这里m输出12后，m=13.
++n, 这里n输出35， n依旧=35.
n++, 这里n输出35, n=36.
++m,这里m输出14,m=14,
解析：
java采用局部优先的思想。局部变量可以和成员变量相同，使用标识符调用时，优先使用局部变量。在实例方法中出现变量名相同时，可以使用this关键字来调用。
解析：
通俗的讲，就是基本数据类型和包装类之间的转换。如： int 类型和 Integer 类的转换
基本数据类型转化成包装类是装箱 (如： int --> Integer)。
包装类转化成基本数据类型就是拆箱 (如：Integer --> int)。
包装类就是引用类型，基本数据类型就是值类型。所以选C
解析：
局部变量：方法定义中或者方法声明上。
局部变量：在内存的栈中。
局部变量：随方法的调用而存在，随着方法的调用完毕而消失。
局部变量：没有默认值，必须定义，赋值，然后才能使用
解析：
重复题
解析：
Java中数组是对象，不是基本数据类型（原生类），大小不可变且连续存储，因为是对象所以存在堆中。
解析：
&& 和 || 为短路与 短路或
&&若前面的表达式为false,整个逻辑表达式为false,所以后面的表达式无论true和false都无法影响整个表达式的逻辑结果，所以为了提高代码执行速率，这里后面的表达式就不会执行。
同理，若前面表达式为true,则后面的表达式无需计算。
& 和 | 为不短路与 不短路或
无论什么情况，前面的和后面的都要执行。
因此：
++i先自增再运算，i++先运算在自增，所以i=1。||短路前一部分不正确就不会继续执行，所以j=0.
解析：
substring 方法将返回一个包含从 start 到最后（不包含 end ）的子字符串的字符串。
解析：
final的作用：
1. 修饰变量，变量的引用地址不可变，但是地址中的内容可以变。
2. 修饰方法，方法不可被重写，但是还是可以重载
3. 修饰类，类不可继承。
解析：
服务器端：ServerSocket提供的实例 ServerSocket server = new ServerSocket(端口号)
客户端：Socket提供的实例 Socket client = new Socket(IP地址，端口号)
解析：
log4j在运行期间是不可以重新设置日志级别的
解析：
若调用start，则先执行主线程的，后执行子线程的，即结果为pingpong
若调用run，相当于函数调用，顺序执行，即结果为pongping
解析：
会产生信息丢失不如说丢失精度，这样可能更容易明白，而精度丢失只会发生在从大范围到小范围的转换，上面四个选项，只有 B 是从 double 到 int ，也就是从大范围到小范围。
解析：
写写数字, 观察规律
i= 1, 2, 3, 4, 5, 6, 7, 8
k=1, 3, 6, 10, 15, 21, 28, 36
把k的数字两个两个一起看的话, 也就是(1,3), (6,10), (15, 21), (7,8), 求和后可以发现规律(1+3=4), (6+10=16), (15+21=36), (28+36=64)
也就是2^2, 4^2, 6^2, 8^2…偶数的平方
循环在x^2>=n时终止, 可得x等于根号n,也就是n^(1/2)
循环的次数是x/2, 时间复杂度为O((1/2)n^(1/2)), 一般而言时间复杂度认为常系数为1, 所以答案就是O(n^(1/2))
解析：
Java中静态变量只能在类主体中定义，不能在方法中定义。 静态变量属于类所有而不属于方法。
解析：
关于抽象类
JDK 1.8以前，抽象类的方法默认访问权限为protected
JDK 1.8时，抽象类的方法默认访问权限变为default
关于接口
JDK 1.8以前，接口中的方法必须是public的
JDK 1.8时，接口中的方法可以是public的，也可以是default的
解析：
静态方法先行执行，导致变量x还未被初始化，所以编译出错
解析：
子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。
否则报错：
Implicit super constructor Person() is undefined. Must explicitly invoke another constructor
解析：
AWT，抽象窗口工具包，是Java提供的建立图形用户界面的工具集，可用于生成现代的、鼠标控制的图形应用接口，且无需修改，就可以在各种软硬件平台上运行。
而swing是Java语言在编写图形用户界面方面的新技术，Swing采用模型-视图-控制设计范式，Swing可以使Java程序在同一个平台上运行时能够有不同外观以供用户选择。
两者不同在于一个是初代工具集，一个是进化版的工具集，用户不会再满足于初始的功能，而是更加注重于附加价值，明显从这点上，Swing是比AWT要好很多。
写法上，Swing的头文件引用包需要用到Javax，组件调用时也需要在AWT的基础上加上“J”。
解析：
创建线程的方法：1）从Java.lang.Thread类派生一个新的线程类，重写它的run()方法；2） 实现Runnable接口，重写Runnable接口中的run()方法。
解析：
解析：
方法重写
1.参数列表必须完全与被重写方法的相同；
2.返回类型必须完全与被重写方法的返回类型相同；
3.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
4.父类的成员方法只能被它的子类重写。
5.声明为final的方法不能被重写。
6.声明为static的方法不能被重写，但是能够被再次声明。
7.子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
8.子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
9.重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
10.构造方法不能被重写。
11.如果不能继承一个方法，则不能重写这个方法。
解析：
A:Java中所有错误和异常的父类是java.lang.Throwable
B：基本数据类型不是对象，不能用new的方法获取，但是每个基本数据类型都对应着封装类型，这些封装类型为了解决基本数据类型面向对象用的。
C:Java垃圾回收器负责回收无用对象占据的内存资源,但对象没有使用new获取了一块特殊区域，这块特殊区域的回收使用finallize（）
D：Java跨平台是因为有JVM的存在，Java的三个版本的运行需要各自不同的环境。
解析：
搞不懂
解析：
resume与suspended一起使用
wait与notify(notifyAll)一起使用
sleep会让线程暂时不执行
解析：
1、 PreparedStatement 继承 Statement ， PreparedStatement 实例包含已编译的 SQL 语句， 所以其执行速度要快于 Statement 对象。
2、作为 Statement 的子类，PreparedStatement 继承了 Statement 的所有功能。三种方法
execute、 executeQuery 和 executeUpdate 已被更改以使之不再需要参数
3. PreparedStatement尽最大可能提高性能. 最重要的一点是极大地提高了安全性.
解析：
字符流和字节流每次读入的字节数是不确定的，可能相同也可能不相同；字符流和字节流都有缓冲流
java题4
解析：
关键的来了，不论向上或者向下转型，都是一句话，“编译看左边，运行看右边”。也就是编译时候，会看左边引用类型是否能正确编译通过，运行的时候是调用右边的对象的方法。
就本题来说，编译时候会发现左边满足条件所以编译通过，运行时候又会调用右边也就是 class B 的方法，所以答案都是150。
解析：
abstract 关键字，这个关键字声明了以后该类不能被实例化，之能让其子类继承它，这个类中必须声明有抽象方法才能被称为抽象类如果其中没有抽象方法则该类无法被称为抽象类。
解析：
a++很好记的，表示先用后+，而++a表示先+后用。看+在前在后，也决定第一步。
解析：
String x=“fmn”; “fmn”是在常量池里的不可变对象。
x.toUpperCase(); 在堆中new一个"FMN"对象，但无任何引用指向它。
String y=x.replace(‘f’,‘F’); 在堆中 new一个"Fmn"对象，y指向它。
y=y+“wxy”; 在堆中 重新new一个"Fmnwxy"对象， 修改y指向，现在y指向它。
解析：
静态成员和静态方法，可以直接通过类名进行调用；其他的成员和方法则需要进行实例化成对象之后，通过对象来调用。
解析：
- 静态内部类：
- 静态内部类本身可以访问外部的静态资源，包括静态私有资源。但是不能访问非静态资源，可以不依赖外部类实例而实例化。
- 成员内部类：
- 成员内部类本身可以访问外部的所有资源，但是自身不能定义静态资源，因为其实例化本身就还依赖着外部类。
- 局部内部类：
- 局部内部类就像一个局部方法，不能被访问修饰符修饰，也不能被static修饰。
- 局部内部类只能访问所在代码块或者方法中被定义为final的局部变量。
- 匿名内部类：
- 没有类名的内部类，不能使用class，extends和implements，没有构造方法。
- 多用于GUI中的事件处理。
- 不能定义静态资源
- 只能创建一个匿名内部类实例。
- 一个匿名内部类一定是在new后面的，这个匿名类必须继承一个父类或者实现一个接口。
- 匿名内部类是局部内部类的特殊形式，所以局部内部类的所有限制对匿名内部类也有效。
解析：
通常一个类实现序列化方式是实现序列化接口 Serializable
序列化的作用：把数据长久的保存在磁盘中，磁盘和内存是不同的，内存一般在程序运行时占用，数据保存周期短，随程序结束而结束，磁盘可以长久保存数据
transient关键字的作用，在已实现序列化的类中，有的变量不需要保存在磁盘中，就要transient关键字修饰，如银行卡密码等，就这个作用------在已序列化的类中使变量不序列化
解析：
就把内部类理解成类的成员，成员有4种访问权限吧，内部类也是！分别为private、protected、public以及默认的访问权限
解析：
Java中的四类八种基本数据类型
第一类：整数类型 byte short int long
第二类：浮点型 float double
第三类：逻辑型 boolean(它只有两个值可取true false)
第四类：字符型 char
解析：
final修饰的成员变量在赋值时可以有三种方式。1、在声明时直接赋值。2、在构造器中赋值。3、在初始代码块中进行赋值。
解析：
首先执行try，遇到算术异常，抛出，执行catch，打印1，然后抛出RuntimeException，缓存异常，执行finally，打印2，然后抛出RuntimeException。
如果catch中没有抛出RuntimeException，则执行结果为123。
解析：
总页数=总记录数/每页显示的条数（每页显示的条数是人为规定的）
因此总页数要根据总记录数确定，因此要首先获取总记录数
解析：
CountDownLatch 是等待一组线程执行完，才执行后面的代码。此时这组线程已经执行完。
CyclicBarrier 是等待一组线程至某个状态后再同时全部继续执行线程。此时这组线程还未执行完。
解析：
ArrayList内部是动态数组实现，在增加空间时会复制全部数据到新的容量大一些的数组中。而LinkedList内部为双向链表，可以按需分配空间，扩展容量简单，因此LinkedList用时少。
解析：
Servlet的生命周期分为5个阶段：加载、创建、初始化、处理客户请求、卸载。
(1)加载：容器通过类加载器使用servlet类对应的文件加载servlet
(2)创建：通过调用servlet构造函数创建一个servlet对象
(3)初始化：调用init方法初始化
(4)处理客户请求：每当有一个客户请求，容器会创建一个线程来处理客户请求
(5)卸载：调用destroy方法让servlet自己释放其占用的资源
解析：
首先不能两个public类，其次child类中无法访问父类的私有变量
解析：
在接口中，属性都是默认public static final修饰的，所以：
A（错误）：不能用private修饰；
B（正确）：在接口中，属性默认public static final，这三个关键字可以省略；
C（错误）：没写属性的类型；
D（错误）：final修饰的属性必须赋值；
解析：
考察的是值传递与引用传递，Java中原始数据类型都是值传递，传递的是值得副本，形参的改变不会影响实际参数的值， 引用传递传递的是引用类型数据，包括String,数组，列表, map,类对象等类型，形参与实参指向的是同一内存地址，因此形参改变会影响实参的值。
解析：
java在运行时才进行翻译指令
解析：
list,set,vector 是基本的集合
解析：
boolean类型只有两个直接量值:true和false.
解析：
继承只能有一个，接口可以有多个
解析：
init() --> 初始化
service() --> 处理请求
destory () --> 销毁（停止）
解析：
&不短路，&&短路。
解析：
is-a 表示继承：Gadget is-a Widget就表示Gadget 继承 Widget；
has-a表示从属：Gadget has-a Sprocket就表示Gadget中有Sprocket的引用，Sprocket是Gadget的组成部分；
like-a表示组合：如果A like-a B，那么B就是A的接
解析：
解析：
在初次标记，重新标志的时候，要求我们暂停其它应用程序，那么这两个阶段用户线程是不会参与的
解析：
str += ‘a’ 和 str +="a"都是对的，但是如果a前面加一个空格，那么只能用双引号了。代表字符串
解析：
A:Java中所有错误和异常的父类是java.lang.Throwable
B：基本数据类型不是对象，不能用new的方法获取，但是每个基本数据类型都对应着封装类型，这些封装类型为了解决基本数据类型面向对象用的。
C:Java垃圾回收器负责回收无用对象占据的内存资源,但对象没有使用new获取了一块特殊区域，这块特殊区域的回收使用finallize（）
D：Java跨平台是因为有JVM的存在，Java的三个版本的运行需要各自不同的环境。
解析：（英文看不太懂）
翻译：
MVC是一种在web应用中常用的架构，下列说法正确的是（）
A. 模型通常代表应用程序中的数据以及用于操纵数据的业务逻辑；
B. 视图是其对应的模型的可视化呈现，视图 将模型渲染成适合于交互的形式（通常为用户界面元素）；
C. 控制器是用户与系统之间的纽带，它接受用户输入，并指示模型和视图基于用户输入执行操作（处理数据、展示数据）；
D. MVC模式在web应用中的常见实践是：模型接受来自于用户的GET或POST请求数据并决定如何处理，模型将用户数据转交给控制器，控制器将控制权转交给视图（视图由HTML生成）；
E. 以上全不是。
1.模型(model)它是应用程序的主体部分，主要包括业务逻辑模块（web项目中的Action,dao类）和数据模块（pojo类）。模型与数据格式无关，这样一个模型能为多个视图提供数据。由于应用于模型的代码只需写一次就可以被多个视图重用，所以减少了代码的重复性
2.视图(view) 用户与之交互的界面、在web中视图一般由jsp,html组成
3.控制器(controller)接收来自界面的请求 并交给模型进行处理 在这个过程中控制器不做任何处理只是起到了一个连接的作用。 本题中显然D错误，应该是控制器接收请求，并将其交给模型进行处理，正确答案为A,B,C.
java题5
解析：
java.lang：java的语言包，是核心包，默认导入到用户程序，包中有object类，数据类型包装类，数学类，字符串类，系统和运行时类，操作类，线程类，错误和异常处理类，过程类。
解析：
静态方法用static修饰
解析：
interface 接口
解析：
public static void的main方法才是主类
解析：
主函数默认返回为void
解析：
A，接口中方法的默认修饰符时public abstract，抽象方法可是没有方法体的，没有大括号{}
B，JDK8中，接口中的方法可以被default和static修饰，但是！！！被修饰的方法必须有方法体。
C，注意一下，接口是可以多继承的。整个没毛病，和A选项一样，抽象方法不能有方法体
解析：
final修饰变量，则等同于常量
解析：
思路：
首先排除include和最后一个
其次：
1.PrintWriter
2.OutputStreamWriter
注意：
在创建OutputStreamWriter的时候，使用的是类的全名称。所以不需要使用import
故：选择A
解析：
nums.add(6);//把6添加到list中，变为｛5,3,1,6｝
nums.add(0,4);//在list的第0个位置添加4，list变为｛4,5,3,1,6｝
nums.remove(1);//移除list的第一个元素，list变为｛4,3,1,6｝
解析：
构造方法不能被static、final、synchronized、abstract、native修饰，但可以被public、private、protected修饰；
解析：
元数据区是用来替换永久代的
解析：
JVM如何理解泛型概念 —— 类型擦除。事实上，JVM并不知道泛型，所有的泛型在编译阶段就已经被处理成了普通类和方法。 处理方法很简单，我们叫做类型变量T的擦除(erased) 。 总结：泛型代码与JVM ① 虚拟机中没有泛型，只有普通类和方法。 ② 在编译阶段，所有泛型类的类型参数都会被Object或者它们的限定边界来替换。(类型擦除) ③ 在继承泛型类型的时候，桥方法的合成是为了避免类型变量擦除所带来的多态灾难。 无论我们如何定义一个泛型类型，相应的都会有一个原始类型被自动提供。原始类型的名字就是擦除类型参数的泛型类型的名字。
解析：
异常抛出基本形式
解析：
for(1;2;3){
4;
}
这题考察的应该是for循环的执行顺序：
1只在开头执行一次便不再执行；然后是2->4->3->2->4->3这样循环下去；等到满足终止条件时到2就停止了
解析：
1、如果两个对象相等，那么他们一定有相同的哈希值（hash code）。
2、如果两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（需要再通过equals来判断）
解析：
sout split(6) = {
sout split(3) = {
sout split(2) = {
sout split(1)
return 2
}
sout split(1)
return 3;
}
return 6
}
解析：
i1和i2为128，超出范围，所以都需要新建对象，对象比较为false；
i5和i6为100，在范围之内，在执行Integer i5=100时，就会直接缓存到内存中，但执行执行Integer i6=100时，就直接从缓存里取，而不需要新建对象，所以为true。
Jvm确实对型如String str1=”java”;的String对象放在常量池里，但是它是在编译时那么做的，而String s=str1+str2;是在运行时刻才能知道，也就是说str1+str2是在堆里创建的，所以结果为false了
解析：
通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的。
解析：
for关键字
解析：
lable显示标签
解析：
桥接模式：
定义 ：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
JDBC提供两套接口，一个面向数据库厂商，一个面向JDBC使用者。
解析：
静态块：用static申明，JVM加载类时执行，仅执行一次
构造块：类中直接用{}定义，每一次创建对象时执行
执行顺序优先级：静态块>main()>构造块>构造方法
静态块按照申明顺序执行，先执行Test t1 = new Test();
所有先输出blockA，然后执行静态块，输出blockB，最后执行main
方法中的Test t2 = new Test();输出blockA。
解析：
编译看左边，运行看右边。意思编译时候，看左边有没有该方法，运行的时候结果看 new 的对象是谁，就调用的谁。
解析：
子类可以继承父类的全部数据域和方法
解析：
isErrorPage为true才表示这是错误页面，才能使用exception对象
解析：
实现多线程的方法：
1.继承Thread类
2.实现Runnable接口
3.实现Callable接口
解析：
序列化：将数据结构转换称为二进制数据流或者文本流的过程。序列化后的数据方便在网络上传输和在硬盘上存储。
反序列化：与序列化相反，是将二进制数据流或者文本流转换称为易于处理和阅读的数据结构的过程。
解析：
在java中，子类构造器会默认调用super()(无论构造器中是否写有super（）),用于初始化父类成员，同时当父类中存在有参构造器时，必须提供无参构造器，子类构造器中并不会自动继承有参构造器，仍然默认调用super()，使用无参构造器。因此，一个类想要被继承必须提供无参构造器。
解析：
Hashtable：
（1）Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。
（2）Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。
（3）HashTable直接使用对象的hashCode。
HashMap：
（1）由数组+链表组成的，基于哈希表的Map实现，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的。
（2）不是线程安全的，HashMap可以接受为null的键(key)和值(value)。
（3）HashMap重新计算hash值
解析：
A 显然是错误的，Java一律采用Unicode编码方式，每个字符无论中文还是英文字符都占用2个字节。
B 也是不正确的，不同的编码之间是可以转换的，通常流程如下：
将字符串S以其自身编码方式分解为字节数组，再将字节数组以你想要输出的编码方式重新编码为字符串。
例：String newUTF8Str = new String(oldGBKStr.getBytes(“GBK”), “UTF8”);
C 是正确的。Java虚拟机中通常使用UTF-16的方式保存一个字符
D 也是正确的。ResourceBundle能够依据Local的不同，选择性的读取与Local对应后缀的properties文件，以达到国际化的目的。
java题6（1）
解析：
A 接口与抽象类是不同的概念。抽象类是用于捕捉子类的通用特性，接口是抽象方法的集合；
B 实现接口必须实现接口的所有方法；
C 接口可以继承一个或多个接口，抽象类只能继承一个类或者实现多个接口；
D 一个类只能继承一个类，但是可以实现多个接口。
解析：
二维数组的遍历，即每个元素之和
解析：
非静态方法只能通过实例对象来调用，不能直接通过类名调用。静态方法（static）才能通过类名直接调用.
解析：
定义的数组长度为10，角标即为0-9
访问数组角标10会出现数组角标越界异常
解析：
在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间
解析：
每次循环都是减二，i一直不为0，所以循环为无限执行
解析：
内部类可以是静态static的，也可用public，default，protected和private修饰，外部类的修饰符只能是public，abstract，final
解析：
运行异常，可以通过java虚拟机来自行处理。非运行异常，我们应该捕获或者抛出
解析：
答案是 A foobar 这道题是考线程的调用情况，线程的启动方式只能通过start这种方式启动才能真正的实现多线程的效果，如果是手动调用run方法和普通方法调用没有区别，所以这个还是按照顺序执行首先执行run方法之后，执行输出语句所以最终得到结果foobar.
解析：
根据官方的JVM规范：
如果try语句里有return，返回的是try语句块中变量值。
详细执行过程如下：
- 如果有返回值，就把返回值保存到局部变量中；
- 执行jsr指令跳到finally语句里执行；
- 执行完finally语句后，返回之前保存在局部变量表里的值。
如果try，finally语句里均有return，忽略try的return，而使用finally的return.
解析：
Java中静态变量只能在类主体中定义，不能在方法中定义。 静态变量属于类所有而不属于方法。
解析：
A：java的访问权限有public、protected、private和default的，default不能修饰变量
C：普通变量不能用abstract修饰，abstract一般修饰方法和类
D：被定义为abstract的类需要被子类继承，但是被修饰为final的类是不能被继承和改写的
解析：
解析：
重写 要求两同两小一大原则， 方法名相同，参数类型相同，子类返回类型小于等于父类方法返回类型， 子类抛出异常小于等于父类方法抛出异常， 子类访问权限大于等于父类方法访问权限。［注意：这里的返回类型必须要在有继承关系的前提下比较］
重载 方法名必须相同，参数类型必须不同，包括但不限于一项，参数数目，参数类型，参数顺序
再来说说这道题 A B 都是方法名和参数相同，是重写，但是返回类型没与父类返回类型有继承关系，错误 D 返回一个类错误 c的参数类型与父类不同，所以不是重写，可以理解为广义上的重载访问权限小于父类，都会显示错误
虽然题目没点明一定要重载或者重写，但是当你的方法名与参数类型与父类相同时，已经是重写了，这时候如果返回类型或者异常类型比父类大，或者访问权限比父类小都会编译错误
解析：
A 错误 运行命令是 java + 你的 Java 程序的名字但是不加后缀 所以这道题错在多了 .class这个后缀
C javac 是编译命令，后跟 你的 Java 程序名字加后缀，也就是 YourClassName.java 所以答案正确
D JVM （Java 虚拟机）运行的是编译后的字节码文件（以.class为后缀的文件），也就是 YourClassName.class 所以答案正确
解析：
解析：
if(flag = true)的时候flag已经是true了，所以输出true；
要是为if(flag == true)输出才为false
解析：
操作步骤就是先解码再编码
用new String(src，“GBK”)解码得到字符串
用getBytes(“UTF-8”)得到UTF8编码字节数组
解析：
好吧 首字母大写没有注意到
解析：
线程安全的map:HashTable,SynchronizedMap,ConcurrentHashMap
解析：
is-a 表示继承：Gadget is-a Widget就表示Gadget 继承 Widget；
has-a表示从属：Gadget has-a Sprocket就表示Gadget中有Sprocket的引用，Sprocket是Gadget的组成部分；
like-a表示组合：如果A like-a B，那么B就是A的接口
解析：
题目的四个选项是构造方法new，序列化对象，反射，克隆分别创建一个对象的方法，，只有new和反射用到了构造方法
解析：
A选项正确，Java中一般通过interrupt方法中断线程
B选项正确，线程使用了wait方法，会强行打断当前操作，进入阻塞（暂停）状态，然后需要notify方法或notifyAll方法才能进入就绪状态
C选项错误，新创建的线程不会抢占时间片，只有等当前线程把时间片用完，其他线程才有资格拿到时间片去执行。
D选项错误，调度算法未必是剥夺式的，而准备就绪但是还没有获得CPU，它的权限更高只能说明它获得CPU被执行的几率更大而已
解析：
Java有5种方式来创建对象：
- 使用 new 关键字（最常用）： ObjectName obj = new ObjectName();
- 使用反 射的Class类的newInstance()方法： ObjectName obj = ObjectName.class.newInstance();
- 使用反射的Constructor类的newInstance()方法： ObjectName obj = ObjectName.class.getConstructor.newInstance();
- 使用对象克隆clone()方法： ObjectName obj = obj.clone();
- 使用反序列化（ObjectInputStream）的readObject()方法： try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME))) { ObjectName obj = ois.readObject(); }
解析：
解析：
D中说的与硬件交互是JVM机器指令与硬件的交互
解析：
解析：
解析：
java题7（2）
解析：
类支持单继承，接口支持多继承
解析：
1、本类的方法可以访问
2、反射也可以访问
解析：
解析：
this()和super()都是构造器，this()调用本类构造器，super()调用父类构造器
解析：
javac将源程序编译成.class文件，字节码；java将字节码转为机器码，.exe程序
解析：
解析：
java 中String是 引用数据类型的，也就是不可变，一旦初始化，其引用指向的内容是不可变的。
也就是说，String str = “aa”；str=“bb”；第二句不是改变“aa”所存储地址的内容，而是另外开辟了一个空间用来存储“bb”；同时由str指向
原来的“aa”，现在已经不可达，GC时会自动回收。
因此String作为参数传进来时候，str= “test ok”; 实际给副本引用str指向了新分配的地址，该地址存储“test ok”。
因此，原先的str仍然指向“good”
解析：
example调用run(),而不是启动线程的start(),所以该程序会依次执行，先打印run,再打印main,所以选A
解析：
在类方法中不能有this关键字，直接调用类方法即可，A错误，B正确，在类方法中可以通过创建实例对象调用类的实例方法，C\D错误
解析：
hashcode和equals的约定关系如下：
1、如果两个对象相等，那么他们一定有相同的哈希值（hash code）。
2、如果两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（需要再通过equals来判断）
解析：
1.start方法
用 start方法来启动线程，是真正实现了多线程， 通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法。但要注意的是，此时无需等待run()方法执行完毕，即可继续执行下面的代码。所以run()方法并没有实现多线程。
2.run方法
run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码。
解析：
继承是根源，重写是表现形式
解析：
解析：
枚举类是一种特殊对的类，既然是类。那他就不是原始数据类型了
解析：
- 构造方法可以被重载，一个构造方法可以通过this关键字调用另一个构造方法，this语句必须位于构造方法的第一行；
重载：方法的重载(overload)：重载构成的条件：方法的名称相同，但参数类型或参数个数不同，才能构成方法的重载。 - 当一个类中没有定义任何构造方法，Java将自动提供一个缺省构造方法；
- 子类通过super关键字调用父类的一个构造方法；
- 当子类的某个构造方法没有通过super关键字调用父类的构造方法，通过这个构造方法创建子类对象时，会自动先调用父类的缺省构造方法
- 构造方法不能被static、final、synchronized、abstract、native修饰，但可以被public、private、protected修饰；
- 构造方法不是类的成员方法；
- 构造方法不能被继承。
解析：
位异运算符号。
运算规则是：两个数转为二进制，然后从高位开始比较，如果相同则为0，不相同则为1。
17：0001 0001
5： 0000 0101
结果：0001 0100 转10进制：20
解析：
方法区在JVM中也是一个非常重要的区域，它与堆一样，是被 线程共享 的区域。 在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。
解析：
因为byte是有符号单字节整形，所以存储数字范围是[-128·127]
解析：
Iterator接口是Collection接口的父接口。
解析：
线程安全的类有hashtable concurrentHashMap synchronizedMap
解析：
s为null，因此只要调用了s.length()都会抛出空指针异常。因此这个题目就是考察if语句的后半部分会不会执行。
A，单个与操作的符号& 用在整数上是按位与，用在布尔型变量上跟&&功能类似，但是区别是无论前面是否为真，后面必定执行，因此抛出异常
B，与操作，前半部分判断为假，后面不再执行
C，这里跟 & 和&& 的区别类似，后面必定执行，因此抛出异常
D，或语句，前面为真，整个结果必定为真，后面不执行
解析：
1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。
java题8（3）
解析：
被sataic声明的为静态方法，可以直接通过类名调用而不需要通过对象调用
解析：
这是多重catch块的顺序问题，由于异常处理系统就近寻找匹配异常处理程序，应先子类后父类。
解析：
解析：
ArrayIndexOutOfBoundsException
解析：
一轮排序之后，最大值在最后面，选D
解析：
定义在类中的变量是类的成员变量，可以不进行初始化，Java会自动进行初始化，如果是引用类型默认初始化为null,如果是基本类型例如int则会默认初始化为0
局部变量是定义在方法中的变量，必须要进行初始化，否则不同通过编译
被static关键字修饰的变量是静态的，静态变量随着类的加载而加载，所以也被称为类变量
被final修饰发变量是常量
解析：
一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性
解析：
get()采用立即加载方式,而load()采用 延迟加载
解析：
导入java.util.*不能读取其子目录的类，因为如果java.util里面有个a类，java.util.regex里面也有个a类，我们若是要调用a类的方法或属性时，应该使用哪个a类呢
解析：
i==j ，这个是基本类型与 Integer 的比较， j 会自动拆箱成 int 类型，然后比较的是值。因此返回真。
j.equals(i) ，调用 equals 方法后，这个 i 会自动装箱成 Integer 类型，然后再比较值，所以也返回真。
解析：
"|"是按位或：先判断条件1，不管条件1是否可以决定结果（这里决定结果为true)，都会执行条件2
"||"是逻辑或：先判断条件1，如果条件1可以决定结果（这里决定结果为true)，那么就不会执行条件2
解析：
C中，应该是Arrays.asList()，其将一个数组转化为一个List对象，这个方法返回一个ArrayList类型的对象， 这个ArrayList类并非java.util.ArrayList类，而是Arrays类的内部类
解析：
解析：
考察点1：重载静态多分派——根据传入重载方法的参数类型，选择更加合适的一个重载方法
考察点2：static方法不能被子类覆写，在子类中定义了和父类完全相同的static方法，则父类的static方法被隐藏，Son.staticmethod()或new Son().staticmethod()都是调用的子类的static方法，如果是Father.staticmethod()或者Father f = new Son(); f.staticmethod()调用的都是父类的static方法。
考察点3：此题如果都不是static方法，则最终的结果是A. 调用子类的getType，输出collection
解析：
调用getName()方法而getName()是：包名+类名
解析：
case 1和case 2后都没有break语句，故都会执行到打印Test2的语句
解析：
局部变量，没有像成员变量那样类加载时会有初始化赋值，所以要使用局部变量时，一定要显式的给它赋值，也就是定义时就给它数值。
解析：
USES-A：依赖关系，A类会用到B类，这种关系具有偶然性，临时性。但B类的变化会影响A类。这种在代码中的体现为：A类方法中的参数包含了B类。
关联关系：A类会用到B类，这是一种强依赖关系，是长期的并非偶然。在代码中的表现为：A类的成员变量中含有B类。
HAS-A：聚合关系，拥有关系，是关联关系的一种特例，是整体和部分的关系。比如鸟群和鸟的关系是聚合关系，鸟群中每个部分都是鸟。
IS-A：表示继承。父类与子类，这个就不解释了。
解析：
通过阅读源码可以知道，string与stringbuffer都是通过字符数组实现的。
其中string的字符数组是final修饰的，所以字符数组不可以修改。
stringbuffer的字符数组没有final修饰，所以字符数组可以修改。
string与stringbuffer都是final修饰，只是限制他们所存储的引用地址不可修改。
至于地址所指内容能不能修改，则需要看字符数组可不可以修改。