基本语法(关键字, 标识符, 修饰符)
修饰符: 可见性作用域修饰符 (public, protected, 默认, private)
static(类, 方法, 属性, 静态块)
final(类, 方法, 属性)
类: 类不能被继承
方法: 方法不能被重写
属性: 基础类型属性值不能被修改; final修饰的基本数据类型为常量
对象类型属性值可以被修改; final修饰的对象表示地址不能改;
interface接口: 默认所有方法都是抽象的,并且public修饰的.
属性: 默认为public修饰的常量(public final修饰的)
abstract抽象类: 类名被abstract修饰的类; 里面可以有抽象方法, 也可以没有抽象方法; 实现接口类,可以重写也可以不重写接口中的方法;
子类创建的时候, 先调用父类中的构造器, 然后才调用子类的构造器
super: 调用父类的构造方法
this: 调用本类的对象(父类继承下来的)
native: 本地调用(跨语言调用)
volatile: 对变量同步
循环: for, do-while, while, 加强for循环(for in)
跳出循环: break; continue; return;
一维数组
多维数组
面向对象:
1.三大特性(封装, 继承,实现, 多态)
2.构造器限制,作用
创建类的实例
初始化变量
3.
包的作用(1.管理类的集合, 2.protected作用域范围同包下可访问此修饰符的变量和方法)
4.重写Override, 重载Overload
重写: 父子类之间, 方法名相同,返回值相同, 参数相同; 修饰符不同, 返回异常可以不一样;
重写的修饰符访问权限的范围只能大,不能小;
返回异常只能小不能大;
重载: 一个类之间; 只需要方法名相同, 返回值可以不同, 修饰符可以不同, 返回异常可以不同, 参数列表可以不同;
构造器;
5.抽象类和接口的区别:
相同点：都不能实例化，需要子类或实现类去继承或者实现
不同点：用abstract修饰的为抽象类，抽象类可以构造器，可以有抽象方法和普通方法
用interface修饰的是接口，接口不能有构造器，可以有常量属性，方法只能是抽象方法
抽象类的继承是单继承，接口可以实现多个接口
6.异常和错误的区别(Exception, Error)
Error:错误是一种故障，是程序员无法处理的也不需要程序员处理 如：内存溢出 虚拟机上出现的问题
Exception:异常是一种编译异常或者运行异常，程序员可以自行处理
编译异常：SQLException IOException
运行异常：
ArithmeticException 算术异常
NullPointerException空指针异常
ClassCastException 类型转换异常
NumberFormatException数字格式化异常
IndexOutOfBoundsException索引越界
ArrayIndexOutOfBoundsException数组越界
7.int和integer 的区别(基本数据类型和包装数据类型的区别)
char 和 character 的区别
long 和Long 的区别
初始值, 存放的地址
基本数据类型在栈中，直接储存数值
包装类型创建的是对象，拥有对象和字段，对象的调用都是通过引用对象的地址
8.io
io中有哪些流(字节流, 字符流, 对象流, 管道流, 缓冲流)
字节流: inputStream, outputstream
字符流: reader ,writer
对象流: 实现序列化接口, ObjectInputStream, ObjectOutputStream
管道流: PipedReader, PipedWrite
缓冲流: BufferedInputStream, BufferedOutputStream
9.静态内部类 和 内部类的区别
静态内部类可以访问外部的静态成员，不能访问非静态成员；静态内部类自身可以有静态成员
非静态内部类可以访问外部的非静态和静态成员；非静态内部类自身不能有静态成员
9. equals 和 hashcode 方法的联系:
两个方法都是Object下的子类;
equals等于true, hashcode一定相等;
equals等于false, hashcode不一定相等;
反过来说:
hashcode数据相同, equals不一定为true;
10.util
collection和collections的区别
collection是集合的父类, 是一个接口; Map不是collection下的子类;
collections是一个集合对象的工具类,里面提供了大量的静态方法(初始化, 置空, 排序, 反转, 最大最小值.....)
collection下的子类有哪些
List, Set, Queue, Deque
List集合下的ArrayList,Vector, LinkedList, Stack类的区别和特色
ArrayList 以object数组作为存储单元, 线程不安全;
Vector 以Object数组作为存储单元, 线程安全的;
LInkedList 以链表作为存储单元, 并且为双向链表;
Stack: 堆栈类; 是Vector类的子类; 所以以数组未做存储单元,并且为线程安全的;
Map 集合下的 HashMap, Hashtable, Properties 键值对作为存储单元;
key键, 不能重复; 根据equals和hashcode方法判断的; key的结构是Object数组+链表实现key检索的;
properties 是hashtable下的子类; 线程安全的, 不允许有null键值;
hashtable和hashMap的区别
1.hashMap是新集合, hashtable是老集合Dictionary
2.hashmap可以有null的key值, hashtable不允许有null的key值;
3.hashmap是线程不安全的, hashtable是线程安全的;
Set 集合 HashSet
值不能重复; 并且无序; Set的数据是存放在hashMap的key中的;
TreeSet, TreeMap 都有自然排序的功能; 实现了 Comparator 接口;
数组存储的优缺点: 线性存储结果, 以下标索引检索数据, 所以查询数据极快,便于查询和修改; 插入和删除效率极差(移位)
链表存储的优缺点: 线性存储结果, 每次都根据头数据检索数据, 所以查询数据效率极差; 插入和删除数据效率极高;
队列: 先进先出; 后进后出; (12306付款买票排队, 支付宝付款排队) + 线程池
堆栈: 先进后出; 后进先出; 具体的运用: 递归; java方法中的调用;
二叉树: 排序, 二叉查找;
-----------------java之api:
1.HashMap与Hashtable的比较：
答：1)、HashMap类比较新
2）、HashMap的key值可以为null，Hashtable的key值不能为null
3）、Hashable的线程比HashMap更安全
2.java.awt中常用的布局方式
3.实现线程通信的方法有哪些
答：线程同步，资源共享
Thread Runnable（共享资源）
4.String和StringBuffer, StringBulider的区别
答：String 是字符串常量
StringBuffer 、StringBulider是字符串变量
运行速度：StringBulider>StringBuffer>String
StringBuffer和StringBulider的区别：
StringBuffer线程是安全的
StringBulider线程是不安全的
但是我们一般是在单线程下面操作的，所以我们推荐用StringBulider
5.至少写出String中的10常用方法
6.重写clone方法的步骤
class CloneClass implements Cloneable{
public Object clone(){
CloneClass o = null;
try{
o = (CloneClass)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return o;
}
｝
7.Collection和Collections的区别
Collection:它是除Map集合外的其他集合的父接口
Collections:它是一个集合对象的工具类，里面包含大量的静态方法
8.Collection的三个子接口的特点：
List:是有序集合,元素可以重复
Set：无序集合，元素不能重复
Queue:队列类型的数据结构，遵循着先进先出的模式
9.创建线程的两个方法
Thread:继承Thread类
Runnable：实现Runnable接口
10.设置线程优先级的方法
12.在hashset中equals与hashcode之间的关系
《1》equals方法用于比较对象的内容是否相等（覆盖以后）
《2》hashcode方法只有在集合中用到
《3》当覆盖了equals方法时，比较对象是否相等通过覆盖后的equals方法进行比较（判断对象的内容是否相等）
《4》将对象放入到集合时，首先判断要放入对象的hashcode值与集合的任意一个元素的hashcode值是否相等，
如果不想等直接将该对象放入集合中。如果hashcode只想等，然后再通过equals方法判断要放入该对象与集合
中的任意一个对象是否相等，equals判断不相等，直接将该元素放入到集合中，否则不放入。
13.自然排序实现哪个接口，重写哪个方法
14.什么是对象序列化和对象反序列化：Serializable接口
答：主要用于存储对象状态为另一种通用格式，比如存储为二进制、xml、json等等，
把对象转换成这种格式就叫序列化，而反序列化通常是从这种格式转换回来。
使用序列化主要是因为跨平台和对象存储的需求，因为网络上只允许字符串或者二进制格式，
而文件需要使用二进制流格式，如果想把一个内存中的对象存储下来就必须使用序列化转换为xml（字符串）
、json（字符串）或二进制（流）
15.Strings="Helloworld!"声明了什么？
答：声明了一个字符串类型的引用s
s指向字符串常量"Hello world!"..
字符串常量是放在常量池中的~
常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。
它包括了关于类、方法、接口等中的常量，也包括字符串常量。Java会确保一个字符串常量只有一个拷贝。
17.File类在创建实例的时候会不会生成实际存在的文件？那要怎么样才能生成这么一个实例？如果不能，那么请说出一个能够生成的类。
答：不会，可以通过判断，如果该文件不存在，我们可以调用File的creatNewFile()的方
String path="E://08//a.txt";
File file= new File(path);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(file.exists());
法创建一个文件
可以通过FileWriter 类来生成文件
String path="E://08//b.txt";
try {
FileWriter fl= new FileWriter(path);
fl.write("写入");
fl.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
18.列出五个字节输出流类.
OutputStream 基类
FileOutputStream 访问文件
BufferOutputStream 缓存流
ObjectOutputStream 对象流
PrintStream 打印流
19.静态方法能不能调用非静态方法和访问非静态变量，说出理由。
答：静态方法不能调用非静态方法和防问非静态变量
原因：静态方法属于类的方法，调用的时候用类名.方法的方式调用
而非静态方法和非静态变量属于对象的，必须通过对象来调用
而且静态方法的生存期比非静态的长，如果非静态消亡，静态的该
该怎么存在
21.解析一下同步和异步的区别，分别在什么情况下使用?
《答》：如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，
或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，
就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
22.实现同步的方法有哪些？
《答》：实现同步有几种方法：例如：synchronized,wait,notify都可以实现同步。
23.构造方法必须满足哪些条件？
《答》：1.构造方法不能被子类继承，但可以被子类调用，可以重载（同一个类）。
2.方法名与类名相同
3.不能声明返回类型
4.不能被static、final、synchronized、abstarct修饰，不能有return语句返回值
5.有3种构造方法，分别为隐式无惨（默认构造方法）、显示无参、显示有参构造方法。
6.如果在类中自己编写了一个构造方法，编译器就不会提供那个默认无参构造方法，
如果还想调用那个无参构造方法创建实例，就必须明确添加这个默认构造方法。
24.当类被加载是，请简述一下类中的静态声明执行顺序
首先初始化静态属性值
然后执行静态块
最后执行类加载时的构造函数
25.error与exception的区别：
《答》：Exception：
1．可以是可被控制(checked) 或不可控制的(unchecked)
2．表示一个由程序员导致的错误
3．应该在应用程序级被处理
Error：
1．总是不可控制的(unchecked)
2．经常用来用于表示系统错误或低层资源的错误
3．如何可能的话，应该在系统级被捕捉
另一种：Error(错误)表示系统级的错误和程序不必处理的异常，
是java运行环境中的内部错误或者硬件问题，比如，内存资源不足等
，对于这种错误，程序基本无能为力，除了退出运行外别无选择。
Exception(违例)表示需要捕捉或者需要程序进行处理的异常，
它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题
，是程序必须处理的。
27.Strings tr=new String("miss")中有几个对象,分别为?
如果常量池中没有miss，那就创建了两个对象分别是new String () 、 miss
否则就是 new String()
28.集合类与数组的区别
集合长度是可变的，数组长度是不可变的
集合里面装的是对象，数组里面可以装对象和基本数据类型
数组运行速度比集合快
29.集合中的iterator()方法是用来做什么的;
Iterator()是迭代器，在集合中是循环遍历集合中的元素的
32.精灵线程和用户线程的区别：
答：精灵线程是运行在程序后台的线程，为其他线程提供服务，精灵线程不会单独运行，
如果非精灵线程停止运行，即使精灵线程在运行，程序也会关闭
33.流按功能可以分为哪几类？
1. 按流的方向分为：输入流和输出流 2. 按流的数据单位不同分为：字节流和字符流 3. 按流的功能不同分为：节点流和处理流
34.字节流的父类和字符类的父类分别是什么？
答：字节流父类：OutputStream InputStream
字符流父类：Writer Reader
35.缓冲流的有什么优点？
答：缓冲流就是先把数据读入或者写入一个缓冲区，待缓冲区满了再取出来，这样能够提高读或者写的效率
36.解释下死锁发生的原因，以及怎么样解决死锁
37.判断线程是否被中断并且写出来.
38.按钮应该添加什么事件,鼠标应该添加什么事件,获得焦点和失去焦点应该添加什么事件
《答》：按钮添加事件
<script type="text/javascript" src="js.js">
</script>
</head>
<body>
<input id="but1" type="button" value="全选" />
</body>
</html>搜索
鼠标添加事件
39.数组，LinkedList,Vector,ArrayList他们的性能差异
《答》：ArrayList,Vector底层是由数组实现，LinkedList底层是由双线链表实现，
从底层的实现可以得出它们的性能问题，ArrayList,Vector插入速度相对较慢，
查询速度相对较快，而LinkedList插入速度较快,而查询速度较慢。
再者由于Vevtor使用了线程安全锁，所以ArrayList的运行效率高于Vector。
40.jvm是如何加载类的?
《答》：(1)程序执行System.exit()
(2)程序正常结束
(3)程序抛出异常，一直向上抛出，没有try{}catch（）finally{}处理。
(4)由于操作系统的异常，导致JVM退出
类的加载过程主要包括三个部分：加载，连接（验证，准备，解析），初始化
简单介绍这几个环节的作用：
加载：就是将class二进制文件由类加载器加载到内存。
连接-验证：主要验证class文件的格式是否正确，语法是否正确，
字节码是否正确，二进制是否兼容。
连接-准备：为类的静态变量分配空间，且赋予默认的初始值。
连接-解析：将class文件中符号引用转变成直接引用。
初始化：为类的静态变量赋予正确的初始值，只有在类首次主动使用的时候，才会进行初始化。
41.jdk1.5 1.6的新特性;
《答》：jdk1.5新特性
1.泛型
2.foreach
3.自动拆箱装箱
4.枚举
5.静态导入（Static import）
6.元数据（Metadata）
7.线程池
8.Java Generics
jdk1.6新特性
1.Desktop类和SystemTray类
2.使用JAXB2来实现对象与XML之间的映射
3.StAX
4.使用Compiler API
5.轻量级Http Server API
6.插入式注解处理API(Pluggable Annotation Processing API)
7.用Console开发控制台程序
8.对脚本语言的支持
9.Common Annotations
jdk1.7新特性
1 对集合类的语言支持；
2 自动资源管理；
3 改进的通用实例创建类型推断；
4 数字字面量下划线支持；
5 switch中使用string；
6 二进制字面量；
7 简化可变参数方法调用。
42.线程的生命周期.
《答》：分为五个阶段 新建---就绪---运行---死亡---堵塞
1 新建（new Thread）
当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。
例如：Thread t1=new Thread();
2 就绪（runnable）
线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：t1.start();
3 运行（running）
线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。
4 死亡（dead）
当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。
自然终止：正常运行run()方法后终止
异常终止：调用stop()方法让一个线程终止运行
5 堵塞（blocked）
由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。
正在睡眠：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。
正在等待：调用wait()方法。（调用motify()方法回到就绪状态）
被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）
-----------java之面向对象:
1.重载与重写的区别：
答： 重写Override, 重载Overload
重写: 父子类之间, 方法名相同,返回值相同, 参数相同; 修饰符不同, 返回异常可以不一样;
重写的修饰符访问权限的范围只能大,不能小;
返回异常只能小不能大;
重载: 一个类之间; 只需要方法名相同, 返回值可以不同, 修饰符可以不同, 返回异常可以不同,
参数列表可以不同;
2.抽象类与接口的比较
接口和抽象类相同点：
都可以包含抽象方法，实现接口或抽象类的普通类必须实现这些抽象方法
(1) 都可以被继承
(2) 都不能被实例化
(3) 都可以包含方法声明
(4) 派生类必须实现未实现的方法
接口和抽象类的区别：
而接口只是一个行为的规范或规定，抽象类作为多个子类的共同父类，体现的是一种模板设计思想
1.类是对对象的抽象，可以把抽象类理解为把类当作对象，抽象成的类叫做抽象类
2. 接口基本上不具备继承的任何具体特点，它仅仅承诺了能够调用的方法；
3. 一个类一次可以实现若干个接口，但是只能扩展一个父类；
4. 接口可以用于支持回调，而继承并不具备这个特点；
5. 抽象类不能被密封；
(1)抽象类里面可以有非抽象方法但接口里只能有抽象方法 声明方法的存在而不去实现它的类被叫做抽像类（abstract class），它用于要创建一个体现某些基本行为的类，
并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽像类，并让它指向具体子类的一个实例。
不能有抽像构造函数或抽像静态方法。Abstract 类的子类为它们父类中的所有抽像方法提供实现，否则它们也是抽像类为。取而代之，在子类中实现该方法。
知道其行为的其它类可以在类中实现这些方法。
(2)接口（interface）是抽像类的变体。在接口中，所有方法都是抽像的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽像的，没有一个有程序体。
接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）
所有这种接口的方法。然后，它可以在实现了该接口的类的任何对像上调用接口的方法。由于有抽像类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。
引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口
3.抽象类和非抽象类的不同点？
使用abstract修饰的类即为抽象类，abstract修饰的方法即为抽象方法，有抽象方法的类只能定义为抽象类，抽象类里面可以没有抽象方法
4.链表的优点
答： 采用动态存储分配，不会造成内存浪费和溢出；另外，链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素。
5.循环有哪几种形式？
do{循环体}while(条件)------------先执行循环体，再判断条件，如果条件满足，继续执行，不满足，退出循环，最少执行一次
while（条件）{循环体}-------------先判断条件，满足就执行循环体，不满足退出
for(循环初始化语句; 循环条件; 迭代语句){循环体}
foreach--------遍历
6.Person person = new Person();执行的步骤
A：将Person.class文件加载到内存中。
B：在堆内存中创建一个对象Person。
C：把Person中的属性进行默认初始化。
D：把Person中的属性进行显示初始化。
E：调用构造代码块(如果没有，不执行这个操作)。
F：调用构造函数进行初始化。
G：在栈内存中声明Person类型的变量person
H：把堆内存的地址(引用)赋给了栈内存中person
7.8大基本类型以及其对应的封装类
数据类型 默认值 封装类(都在java.lang包下)
byte 字节型 (byte)0 Byte
short 短整形 (short)0 Short
int 整形 0 Integer
long 长整形 0L Long
float 浮点型 0.0f Float
double双精度浮点型 0.0d Double
char 字符型 \u0000 Character
boolean 布尔型 false Boolean
8.final的作用
1、final修饰类中的属性或者变量
无论属性是基本类型还是引用类型，final所起的作用都是变量里面存放的“值”不能变。
这个值，对于基本类型来说，变量里面放的就是实实在在的值，如1，“abc”等。
而引用类型变量里面放的是个地址，所以用final修饰引用类型变量指的是它里面的地址不能变，并不是说这个地址所指向的对象或数组的内容不可以变
2、final修饰类中的方法---------------可以被继承，但继承后不能被重写。
3、final修饰类-------------------------类不可以被继承。
关于final的重要知识点
final关键字可以用于成员变量、本地变量、方法以及类。
final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。
你不能够对final变量再次赋值。
本地变量必须在声明时赋值。
在匿名类中所有变量都必须是final变量。
final方法不能被重写。
final类不能被继承。
final关键字不同于finally关键字，后者用于异常处理。
final关键字容易与finalize()方法搞混，后者是在Object类中定义的方法，是在垃圾回收之前被JVM调用的方法。
接口中声明的所有变量本身是final的。
final和abstract这两个关键字是反相关的，final类就不可能是abstract的。
final方法在编译阶段绑定，称为静态绑定(static binding)。
没有在声明时初始化final变量的称为空白final变量(blank final variable)，它们必须在构造器中初始化，或者调用this()初始化。不这么做的话，编译器会报错“final变量(变量名)需要进行初始化”。
将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。
按照Java代码惯例，final变量就是常量，而且通常常量名要大写：
9.构造器Constructor是否可被override(重写)
答： Constructor不能被继承，所以Constructor也就不能被override,但是可以overload(重载),所以你可以看到有多个构造函数这种情况。
构造器不是方法，那么用来修饰方法特性的所有修饰符都不能用来修饰构造器（并不等与构造具备这些特性，虽然不能用static修饰构造器，但它却有静态特性）
构造器只能用 public private protected这三个权限修饰符，且不能有返回语句
10.子类继承父类的特点。
答： 子类将拥有父类所有的非私有的方法和属性，子类还可以拥有自己独有的方法和属性声明父类，实例化子类时，子类会自动向上转型为父类
①子类和父类在同一个包中时，子类可以继承父类的除private属性的所有方法和成员变量，当子类与 父类不在同一个包中时，
子类只能继承父类的protected和public属性的成员变量和方法。
②子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量；子类中定义一个方法，并且这个方法的名字、返回类型、参数个数
和类型与从父类继承的方法完全相同，子类就隐藏从父类继承来的方法（方法的重写）。
③在子类中允许有一个方法和父类的方法名字相同而类型不同。
11.throw throws的区别
(1)throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。-----throws 语句用在方法声明后面，表示再抛出异常，由该方法的调用者来处理。
(2)throws 主要是声明这个方法会抛出这种类型的异常，使它的调用者知道要捕获这个异常。-----throw 是具体向外抛异常的动作，所以它是抛出一个异常实例。
(3)throws 说明你有那个可能，倾向。-----throw 的话，那就是你把那个倾向变成真实的了。
13.equals()和==比较两个字符串是否相同有什么区别
(1) == 是比较两个字符串引用的地址是否相同，即是否指向同一个对象，而 equals 方法则比较字符串的内容是否相同。
(2) 1、string是一个特殊的引用类型。对于两个字符串的比较，不管是 == 和 Equals 这两者比较的都是字符串是否相同；
2、当你创建两个string对象时，内存中的地址是不相同的，你可以赋相同的值。所以字符串的内容相同。引用地址不一定相同，
（相同内容的对象地址不一定相同），但反过来却是肯定的；
3、基本数据类型比较(string 除外) == 和 Equals 两者都是比较值；
14.java的权限修饰符有哪几种，它们的可见性分别是什么
public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段。
包外 子类 包内 类内
public yes yes yes yes
protected no yes yes yes
default no no yes yes
private no no no yes
15.说出能用于switch()后的括号中的数据类型
答： byte、char、short、int四种基本类型以及它们的包装类（需要Java5.0/1.5以上版本支持） 都可以用于switch语句。
16.throw、throws、try、catch、finally他们在java异常机制中起到的作用
throws是获取异常,-----throw是抛出异常
try是将会发生异常的语句括起来，从而进行异常的处理，catch是如果有异常就会执行他里面的语句
finally不论是否有异常都会进行执行的语句。
throw 仅用于方法定义后面，指示该方法可能会抛出什么异常，使用该方法的方法必须处理该异常，或者再次抛出。
throws 用于当程序判断发生异常时，用该语句抛出异常，或处理异常时再次抛出异常。
try {
//这里放可能会发生异常的语句
} catch(Exception e) {
//这里处理异常
} finally {
//这里的语句必然会得到执行，不管异常发省与否，
//用于关闭数据库，关闭连接等收尾操作（非必要）
}
17.包的意义：
Package的作用就是把若干类按包结构进行分类管理。其中最重要的用途是为了解决同名但作用不同的类同时存在的问题
Java中提供的包主要有以下3种用途:
1) 将功能相近的类放在同一个包中，可以方便查找与使用。
2) 由于在不同包中可以存在同名类，所以使用包在一定程度上可以避免命名冲突。
3) 在Java中，某次访问权限是以包为单位的。
18.接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承实体类(concreteclass)?
1.接口可以继承接口..但是要使用extends~而不是用implements
如:interface a{}
interface b extends a{}
2.抽象类可以实现接口..
比如java.util中的AbstractCollection类就是实现的Collection接口
3.抽象类可以继承实体类
19.当类被加载是，请简述一下类中的静态声明执行顺序
首先初始化静态属性值
然后执行静态块
最后执行类加载时的构造函数
20.多态的好处
多态性：在程序中的体现。
就是：父类或者接口的引用指向自己的子类对象。
好处：提高了代码的扩展性。
弊端：前期建立父类的引用虽然可以接收后期所有该类的子类对象。
但是只能使用父类中的功能，不能使用子类中的特有功能，
因为前期的程序无法知道后期的子类的特有内容的。
但是前期的程序可以使用子类覆盖了父类的方法的内容。
前提：---1，必须存在着继承关系。-----2，通常要有覆盖操作。
21.类与对象的关系
类是拥有相同行为特征对象的一个抽象概念，而对象是类这个抽象概念中事实存在的个体。
打个比方：类;人，对象：你。人这个类可以是黄种人、黑种人、白种人等等，但是对象实实在在的
就是指类当中的一个个体..
22.静态方法注意事项
1，静态方法不能访问非静态的成员。
但是非静态可以访问静态成员的。
说明：静态的弊端在于访问出现局限性。好处是可以直接被类名调用。
2. 静态方法中不允许出现this，super关键字。
1，静态是随着类的加载就加载了。也是随着类的消失而消失了。
2，静态优先于对象存在，被对象共享。
3，因为静态先存在于内存中无法访问后来的对象的中的数据，所以静态无法访问非静态。 而且内部无法书写this。因为这时对象有可能不存在，this没有任何指向。
23.int和Integer有什么区别(基本数据类跟包装器类有什么区别?)
答：1. 数据类型和包装类型
2. 1.声明方式不同，基本类型不适用new关键字，而包装类型需要使用new关键字来在堆中分配存储空间；
2.存储方式及位置不同，基本类型是直接将变量值存储在堆栈中，而包装类型是将对象放在堆中，然后通过引用来使用；
3.初始值不同，基本类型的初始值如int为0，boolean为false，而包装类型的初始值为null
4.使用方式不同，基本类型直接赋值直接使用就好，而包装类型在集合如Collection、Map时会使用到。
24.子类与父类的生成顺序关系?
父类的静态代码块—>子类的静态代码块—>主方法（执行哪个程序就执行哪个程序的主方法）—>父类的非静态代码块—>父类的无参构造函数—>子类的非静态代码块
—>子类的无参构造函数（若实际子类执行的是有参构造函数，则不执行无参构造函数）
—>成员函数（指定执行哪个就执行哪个成员函数，若重写了父类成员函数，则只执行子类的成员函数）
25.两个对象值相同(x.equals(y)==true)，但却可有不同的hashcode，这句话对不对?
答：对的------每个对象都有自己的hashcode码，这是唯一的，当两个对象用==比较时，比较他们的内存地址是否一致，如果一致，他们的hashcode一定相同。
而用equals比较时 ，许多类都重载该方法，单比较值而已，他们的内存地址可能不一致。
26.float f=3.4这个表达式是否正确？
不正确。 3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，
因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;。
27.char a='晕';char能不能存放一个中文？为什么
可以。一个char是两个字节，而一个中文也是两个字节。java默认采用unicode，2个字节（16位）来表示一个字符， 无论是汉字还是数字字母，或其他语言。
28.instanceof是什么东东？
instanceof用来判断内存中实际对象属于那个类的，例如A nstanceof B，就是判断A是不是B类型.
instanceof是Java、php的一个二元操作符（运算符），和==，>，<是同一类东西。由于它是由字母组成的，所以也是Java的保留关键字。
它的作用是判断其左边对象是否为其右边类的实例，返回boolean类型的数据。可以用来判断继承中的子类的实例是否为父类的实现。
30.当类被加载是，请简述一下类中的静态声明执行顺序
首先初始化静态属性值
然后执行静态块
最后执行类加载时的构造函数
31.面向对象的特点,各有什么特点?
1、易维护
采用面向对象思想设计的结构，可读性高，由于继承的存在，即使改变需求，那么维护也只是在局部模块，所以维护起来是非常方便和较低成本的。
2、质量高
在设计时，可重用现有的，在以前的项目的领域中已被测试过的类使系统满足业务需求并具有较高的质量。
3、效率高
在软件开发时，根据设计的需要对现实世界的事物进行抽象，产生类。使用这样的方法解决问题，接近于日常生活和自然的思考方式，势必提高软件开发的效率和质量。
4、易扩展
由于继承、封装、多态的特性，自然设计出高内聚、低耦合的系统结构，使得系统更灵活、更容易扩展，而且成本较低。
32.String和StringBuffer的区别
就是一个变量和常量的关系。StringBuffer对象的内容可以修改；而String对象一旦产生后就不可以被修改，重新赋值其实是两个对象。
（1）String类对象为不可变对象，一旦你修改了String对象的值，隐性重新创建了一个新的对象，释放原String对象，
StringBuffer类对象为可修改对象，可以通过append()方法来修改值
（2）String类对象的性能远不如StringBuffer类。
33.运行时异常与一般异常有何异同？
运行时异常runtime exception和一般异常checked exception。checked 异常。对于后者这种异常，JAVA要求程序员对其进行catch。
所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。
运行时异常我们可以不处理。这样的异常由虚拟机接管。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。
如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。
34.说出ArrayList,Vector,LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，
但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，
Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，
而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
35.Collection和Collections的区别。
Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
36.&和&&的区别。&,|,~,>>,<< ,>>>
&是位运算符。&&是布尔逻辑运算符。
在运行上，&两边的条件都要判断（不管前面的是ture还是false），而&&先判断前面的，若为false，则后面的不再判断。
37.HashMap和Hashtable的区别。
1.hashMap去掉了HashTable 的contains方法，但是加上了containsValue（）和containsKey（）方法。
2.hashTable同步的，而HashMap是非同步的，效率上逼hashTable要高。
3.hashMap允许空键值，而hashTable不允许。
38.final,finally,finalize的区别。
1.final:凡是被final修饰过的类是不能被继承的，比如String，被final修饰过的熟悉是不能被更改的，被final修饰过的方法是不能被重写的。
2.finally:是在try{}catch{}组合中放在catch末尾的，不管有没捕获到异常finally都会执行。
在连接数据发生异常时，可以用来关闭连接。
3.它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。
finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的
39.sleep()和wait()有什么区别?
sleep是让线程指定休眠时间，然后继续工作
wait则是等待，直到有线程通知notify（）唤醒他才会重新工作。
40.Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
Override是重写：方法名称、参数个数，类型，顺序，返回值类型都是必须和父类方法一致的。它的关系是父子关系
Overload是重载:方法名称不变，其余的都是可以变更的。它的关系是同一个类，同一个方法名，不同的方法参数或返回值。
备注：它们都是是Java多态性的不同表现
Overloaded的方法是可以改变返回值的类型。
这句话是正确的，唯一区分方法重载的是方法的参数列表不同，当参数列表不同时就可改变其返回类型
41.error和exception有什么区别?
答：error是一种错误，程序员不能处理，并且也不需要程序员处理
exception是一种异常，它分为编译时异常和运行时异常，程序员可以自行处理
Exception表示程序需要捕捉和处理的的异常;
Error表示系统级别的错误和程序无需处理的。
41.同步和异步有何异同，在什么情况下分别使用他们？举例说明。
答：同步是一个进程执行某个请求时，只有返回信息时，进程才会执行下一步，否则会一直等待下去
异步是指不需要等待下去，继续执行下面的代码
42.abstract class和interface有什么区别?
答：用abstract修饰的是抽象类，不能被实例化，需要被子类实例化
可以有抽象方法和普通方法，抽象方法必须有子类实现
用class修饰的是普通类
用interface修饰的是接口 ，不能被实例化，需要子类实现，
43.heap和stack有什么区别。
heap：是栈 声明一个对象是在栈中 如：String str="傻"；
stack：是堆 new一个对象是在堆中 如：String str= new String("啪啪")
44.StaticNestedClass和InnerClass的不同。
class A{ 外部类
class B {内部类
}
}
StaticNestedClass静态内部类：静态内部类实例化不需要先实例化外部类
例子： A.B b= new A.B();通过类名来实例化
InnerClass叫做非静态内部类：需要先实例化外部类，然后通过外部类的对象实例化
例： A a= new A()先实例化A
A.B b=a.new B() 通过A来实例化B
45.GC是什么?为什么要有GC?
GC：垃圾回收机制
内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，
Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的
46.short s1=1;s1=s1+1;有什么错?short s1=1;s1+=1;有什么错?
1）、short s1=1;
s1=s1+1;
会报语法错误，因为s1+1会自动向上转成int类型
2）、short s1=1;
s1+=1;
没有错误
47.Java有没有goto?
答：有goto，但是是作为保留字，可能以后会启用
48.启动一个线程是用run()还是start()?
答：star()
49.给我一个你最常见到的runtimeexception。
答：NullPointerException 空指针异常
ArthmeticException 算术异常
ClassCastException 类型转换异常
ArrayIndexOutOfBoundsException 数组越界
IndexOutOfBoundsException索引越界
NumberFormatException 格式化异常
50.接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承实体类(concreteclass)?
答：接口可以继承接口，而且还可以多继承；
抽象类可以实现接口，但是抽象类中的抽象方法需要由子类继承重写
抽象类可以继承实体类(concreteclass)；但是抽象类需要其子类实例化
51.List,Set,Map是否继承自Collection接口?
答：List,Set是继承Collection接口，但是Map不是，Map和Collection相当于同级，Map是以键值作为储存单元的集合
52.abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
答：abstract中的方法如果全是普通方法，可以同时用static修饰，此时方法用类.方法名调用
如果有抽象方法，就不能同时用static修饰，因为抽象方法需要子类实现
使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。
如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象，因为该方法不是在该抽象类中实现的。是在其子类实现的。
所以。锁应该归其子类所有。所以。抽象方法也就不能用synchronized关键字修饰了；native，这个东西本身就和abstract冲突，
他们都是方法的声明，只是一个吧方法实现移交给子类另一个是移交给本地操作系统。如果同时出现，就相当于即把实现移交给子类，
又把实现移交给本地操作系统，那到底谁来实现具体方法呢？
53.数组有没有length()这个方法?String有没有length()这个方法？
答;数组没有length()这个方法;
String有length()这个方法;
54.Set里的元素是不能重复的，那么用什么方法来区分重复与否呢?是用==还是equals()?它们有何区别?
答：区分重复与否用equals()方法来区分
"=="是根据栈中引用类型的地址来判断是否相同
"equals"是根据堆中的内容是否相同来判断
55.构造器Constructor是否可被override?
答：不能被重写，因为构造器不能被继承，继承时只能调用父类的构造器
56.是否可以继承String类?
String类是用final修饰的，所以不能继承String类
57.swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?
答：swtich能作用在byte（向上转型）上，不能作用在long上，能作用在String上；
switch只能作用在int String enum上面
58.try{}里有一个return语句，那么紧跟在这个try后的finally{}里的code会不会被执行，什么时候被执行，在return前还是后?
答：会被执行
public static void main(String[] args) {
System.out.println(test());
}
public static int test(){
int i=3;
int j=1;
try {
int x=i/j;
return x;
} finally{
System.out.println("在return之前执行");
}
}
//在return之前执行 3
在return之前执行
59.当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
答：这是引用传递
60.当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
答：可以进入其他非synchronized的方法，synchronized的方法不可以的
61.编程题:写一个Singleton出来。
class A{//懒汉式
private static A a;//先创建一个对象
private A(){}; //把构造器私有化
public static A test(){ //判断对象是否实例化，没有的话就new一个
if(a==null){
a=new A();
}
return a;
}
}
class B{//饿汉式
private static B b= new B();//先创建一个对象并实例化
private B(){}; //把构造器私有化
public static B single(){//返回实例化了的对象
return b;
}
}
public class Arr_List {
public static void main(String[] args) {
A s=A.test();
System.out.println(s);
B bs=B.single();
System.out.println(bs);
}
}
63.Java中的异常处理机制的简单原理和应用。
答：Java中的异常处理机制的简单原理和应用 :
java中Throwable这个类可以被作为异常抛出的类,继承它的分为异常Exception和错误Error.
Exception表示程序需要捕捉和处理的的异常;
Error表示系统级别的错误和程序无需处理的。
我们所需要关心的是Exception. Execption可以分为java标准定义的异常和程序员自定义异常2种.
（1）一种是当程序违反了java语规则的时候,JAVA虚拟机就会将发生的错误表示为一个异常.这里语法规则指的是JAVA类库内置的语义检查。
（2）另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。
64.垃圾回收的优点和原理。并考虑2种回收机制。
答：Java语言中一个显著的特点就是引入了垃圾回收机制，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制
Java中的对象不再有”作用域”的概念，只有对象的引用才有”作用域”。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。
垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，
程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。
回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。
65.请说出你所知道的线程同步的方法。
答：用同步锁来实现，锁住方法、锁住代码块
66.你所知道的集合类都有哪些？主要方法？
答：Collection集合、Map集合
Collection集合下面主要分有序集合和无序集合
分别为List和Set集合
List下面有实现类
主要方法：add() remove() contain() size() get() clear() isEmpty() toArray() set(index,element)
Set下面有HashSet集合类
主要方法和有序集合差不多，因为Set是无序的，所以没有和索引有关的方法
67.描述一下JVM加载class文件的原理机制?
68.多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
同步的实现方面有两种，分别是synchronized,wait与notify wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
69.线程的基本概念、线程的基本状态以及状态之间的关系
答：线程是一个执行流，是进程的组成部分
状态：就绪，运行，synchronize阻塞，wait和sleep挂起，结束。
关系：调用线程的start方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状态，遇到synchronized语句时，由运行状态转为阻塞，
当synchronized获得锁后，由阻塞转为运行，在这种情况可以调用wait方法转为挂起状态，当线程关联的代码执行完后，线程变为结束状态。
70.简述位操作(&,|,^)与逻辑操作(&&,||)的区别。
&和&&都是且的意思，&&会短路，只要第一个条件不满足要求直接返回false，&不会短路，第一个条件不满足要求，会对后面进行判断
|和||都是且的意思，||会短路，只要第一个条件不满足要求直接返回false，|不会短路，第一个条件不满足要求，会对后面进行判断
^两个元素不同，返回true，否则返回false
71.简述synchronized和java.util.concurrent.locks.Lock的异同？
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，
并且必须在finally从句中释放（因为如果不在finally中释放的情况，当抛出异常时，线程直接死掉，但是没有释放锁，使得其他相关
线程无法执行。读者可以试试在定义一个数组，并访问越界区，使得程序抛出异常，但是释放锁并未在finally中）。
72.JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？
throws是获取异常
throw是抛出异常
把可能发生的异常代码块放在try块中，如果真的出现了异常就要在catch块里面返回异常的信息
finally块包裹的表示不管是否有异常，finally里面的代码都会执行
73.一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？
可以包含多个类，但是一个文件只能有一个public类，并且public类名必须与文件名相同
74.java中有几种方法可以实现一个线程？用什么关键字修饰同步方法?
3中：继承Thread，实现Runnable接口，实现Callable接口
synchronized同步
stop和suspend方法,stop用来直接终止线程
stop不安全，suspend容易死锁
75.java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
Java中的流分为两种，字节流和字符流，分别由四个抽象类来表示:
InputStream，OutputStream，Reader，Writer。
Java中其他多种多样变化的流均是由它们派生出来的.
76.java中会存在内存泄漏吗，请简单描述。
所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。
Java中有垃圾回收机制，它可以保证一对象不再被引用的时候
，即对象编程了孤儿的时候，对象将自动被垃圾回收器从内存中清除掉。由于Java 使用有向图的方式进行垃圾回收管理，可以消除引用循环的
问题，例如有两个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的。
java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长
生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景，通俗地说，就是程序员可能创建了一个对象，以后一直不再使
用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是java中可能出现内存泄露的情况，例如，缓存系统，
我们加载了一个对象放在缓存中(例如放在一个全局map对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。 检查java中
的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。
如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部
类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。
77.java中实现多态的机制是什么？
java中实现多态的机制是依靠父类或接口的引用指向子类。从而实现了一个对象多种形态的特性。其中父类的引用是在程序运行时动态的指向
具体的实例，调用该引用的方法时，不是根据引用变量的类型中定义的方法来运行，而是根据具体的实例的方法。
78.垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？
基本原理就是虚拟机每隔一段时间就会运行一次垃圾回收或是在虚拟机认为需要的时候。
主动调用是System.gc()。垃圾回收器运行了当然会收回内存。但悲剧的是，垃圾回收是任何程序员都无法自己控制的，
也就是说即使调用了System.gc()，也只是通知虚拟机要回收垃圾，至于虚拟机什么时候运行回收器就不知道了。
79.静态变量和实例变量的区别？
静态变量属于类，该类不生产对象，通过类名调用。
实例变量属于该类的对象，必须产生该类对象，通过对象调用。
80.什么是java序列化，如何实现java序列化？
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，
也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是
为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，
接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
81.在JAVA中，如何跳出当前的多重嵌套循环？
在java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的的break语句，即可跳出外层
循环。
82.List、Map、Set三个接口，存取元素时，各有什么特点？
list：存储： 有序的 可重复的
访问：可以for循环，foreach循环，iterator迭代器 迭代。
set：存储：无序的 不重复的
访问：可以foreach循环，iterator迭代器 迭代
map：存储：存储的是一对一对的映射 ”key=value“，key值 是无序，不重复的。value值可重复
访问：可以map中key值转为为set存储，然后迭代这个set，用map.get(key)获取value
也可以 转换为entry对象 用迭代器迭代
83.说出一些常用的类，包，接口，请各举5个
类:1.java.lang.Object
2.java.lang.String
3.java.lang.System
4.java.io.file
5.java.io.FileInputStream
包:1.java.lang包
2.java.io包
3.java.swt包
4.java.util包
5.java.sql包
接口:1.java.util.List<E>
2.java.util.Map<E>
3.java.util.Iterator<E>
4.java.sql.CallableStatement
5.java.lang.Comparable<T>
84.谈谈final, finally, finalize的区别
final是全局变量声明的时候使用，意思是这个变量不可被修改，不可被override，一般用于声明常量，或者系统设置的值。
例子：public static final String a = "123"
意思是： 公共的（所有范围可见），静态的（系统中只存在一个），final的（不可被更改） 变量a，值是123
finally是在try-catch-finally块中配套使用，作用是，不管代码执行了try还是catch，最后一定会执行finally里面的代码
85.String和StringBuffer 的区别
（1）String类对象为不可变对象，一旦你修改了String对象的值，隐性重新创建了一个新的对象，释放原String对象，StringBuffer类对象为可修改对象，可以通过append()方法来修改值
（2）String类对象的性能远不如StringBuffer类。
修饰符: 可见性作用域修饰符 (public, protected, 默认, private)
static(类, 方法, 属性, 静态块)
final(类, 方法, 属性)
类: 类不能被继承
方法: 方法不能被重写
属性: 基础类型属性值不能被修改; final修饰的基本数据类型为常量
对象类型属性值可以被修改; final修饰的对象表示地址不能改;
interface接口: 默认所有方法都是抽象的,并且public修饰的.
属性: 默认为public修饰的常量(public final修饰的)
abstract抽象类: 类名被abstract修饰的类; 里面可以有抽象方法, 也可以没有抽象方法; 实现接口类,可以重写也可以不重写接口中的方法;
子类创建的时候, 先调用父类中的构造器, 然后才调用子类的构造器
super: 调用父类的构造方法
this: 调用本类的对象(父类继承下来的)
native: 本地调用(跨语言调用)
volatile: 对变量同步
循环: for, do-while, while, 加强for循环(for in)
跳出循环: break; continue; return;
一维数组
多维数组
面向对象:
1.三大特性(封装, 继承,实现, 多态)
2.构造器限制,作用
创建类的实例
初始化变量
3.
包的作用(1.管理类的集合, 2.protected作用域范围同包下可访问此修饰符的变量和方法)
4.重写Override, 重载Overload
重写: 父子类之间, 方法名相同,返回值相同, 参数相同; 修饰符不同, 返回异常可以不一样;
重写的修饰符访问权限的范围只能大,不能小;
返回异常只能小不能大;
重载: 一个类之间; 只需要方法名相同, 返回值可以不同, 修饰符可以不同, 返回异常可以不同, 参数列表可以不同;
构造器;
5.抽象类和接口的区别:
相同点：都不能实例化，需要子类或实现类去继承或者实现
不同点：用abstract修饰的为抽象类，抽象类可以构造器，可以有抽象方法和普通方法
用interface修饰的是接口，接口不能有构造器，可以有常量属性，方法只能是抽象方法
抽象类的继承是单继承，接口可以实现多个接口
6.异常和错误的区别(Exception, Error)
Error:错误是一种故障，是程序员无法处理的也不需要程序员处理 如：内存溢出 虚拟机上出现的问题
Exception:异常是一种编译异常或者运行异常，程序员可以自行处理
编译异常：SQLException IOException
运行异常：
ArithmeticException 算术异常
NullPointerException空指针异常
ClassCastException 类型转换异常
NumberFormatException数字格式化异常
IndexOutOfBoundsException索引越界
ArrayIndexOutOfBoundsException数组越界
7.int和integer 的区别(基本数据类型和包装数据类型的区别)
char 和 character 的区别
long 和Long 的区别
初始值, 存放的地址
基本数据类型在栈中，直接储存数值
包装类型创建的是对象，拥有对象和字段，对象的调用都是通过引用对象的地址
8.io
io中有哪些流(字节流, 字符流, 对象流, 管道流, 缓冲流)
字节流: inputStream, outputstream
字符流: reader ,writer
对象流: 实现序列化接口, ObjectInputStream, ObjectOutputStream
管道流: PipedReader, PipedWrite
缓冲流: BufferedInputStream, BufferedOutputStream
9.静态内部类 和 内部类的区别
静态内部类可以访问外部的静态成员，不能访问非静态成员；静态内部类自身可以有静态成员
非静态内部类可以访问外部的非静态和静态成员；非静态内部类自身不能有静态成员
9. equals 和 hashcode 方法的联系:
两个方法都是Object下的子类;
equals等于true, hashcode一定相等;
equals等于false, hashcode不一定相等;
反过来说:
hashcode数据相同, equals不一定为true;
10.util
collection和collections的区别
collection是集合的父类, 是一个接口; Map不是collection下的子类;
collections是一个集合对象的工具类,里面提供了大量的静态方法(初始化, 置空, 排序, 反转, 最大最小值.....)
collection下的子类有哪些
List, Set, Queue, Deque
List集合下的ArrayList,Vector, LinkedList, Stack类的区别和特色
ArrayList 以object数组作为存储单元, 线程不安全;
Vector 以Object数组作为存储单元, 线程安全的;
LInkedList 以链表作为存储单元, 并且为双向链表;
Stack: 堆栈类; 是Vector类的子类; 所以以数组未做存储单元,并且为线程安全的;
Map 集合下的 HashMap, Hashtable, Properties 键值对作为存储单元;
key键, 不能重复; 根据equals和hashcode方法判断的; key的结构是Object数组+链表实现key检索的;
properties 是hashtable下的子类; 线程安全的, 不允许有null键值;
hashtable和hashMap的区别
1.hashMap是新集合, hashtable是老集合Dictionary
2.hashmap可以有null的key值, hashtable不允许有null的key值;
3.hashmap是线程不安全的, hashtable是线程安全的;
Set 集合 HashSet
值不能重复; 并且无序; Set的数据是存放在hashMap的key中的;
TreeSet, TreeMap 都有自然排序的功能; 实现了 Comparator 接口;
数组存储的优缺点: 线性存储结果, 以下标索引检索数据, 所以查询数据极快,便于查询和修改; 插入和删除效率极差(移位)
链表存储的优缺点: 线性存储结果, 每次都根据头数据检索数据, 所以查询数据效率极差; 插入和删除数据效率极高;
队列: 先进先出; 后进后出; (12306付款买票排队, 支付宝付款排队) + 线程池
堆栈: 先进后出; 后进先出; 具体的运用: 递归; java方法中的调用;
二叉树: 排序, 二叉查找;
-----------------java之api:
1.HashMap与Hashtable的比较：
答：1)、HashMap类比较新
2）、HashMap的key值可以为null，Hashtable的key值不能为null
3）、Hashable的线程比HashMap更安全
2.java.awt中常用的布局方式
3.实现线程通信的方法有哪些
答：线程同步，资源共享
Thread Runnable（共享资源）
4.String和StringBuffer, StringBulider的区别
答：String 是字符串常量
StringBuffer 、StringBulider是字符串变量
运行速度：StringBulider>StringBuffer>String
StringBuffer和StringBulider的区别：
StringBuffer线程是安全的
StringBulider线程是不安全的
但是我们一般是在单线程下面操作的，所以我们推荐用StringBulider
5.至少写出String中的10常用方法
6.重写clone方法的步骤
class CloneClass implements Cloneable{
public Object clone(){
CloneClass o = null;
try{
o = (CloneClass)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return o;
}
｝
7.Collection和Collections的区别
Collection:它是除Map集合外的其他集合的父接口
Collections:它是一个集合对象的工具类，里面包含大量的静态方法
8.Collection的三个子接口的特点：
List:是有序集合,元素可以重复
Set：无序集合，元素不能重复
Queue:队列类型的数据结构，遵循着先进先出的模式
9.创建线程的两个方法
Thread:继承Thread类
Runnable：实现Runnable接口
10.设置线程优先级的方法
12.在hashset中equals与hashcode之间的关系
《1》equals方法用于比较对象的内容是否相等（覆盖以后）
《2》hashcode方法只有在集合中用到
《3》当覆盖了equals方法时，比较对象是否相等通过覆盖后的equals方法进行比较（判断对象的内容是否相等）
《4》将对象放入到集合时，首先判断要放入对象的hashcode值与集合的任意一个元素的hashcode值是否相等，
如果不想等直接将该对象放入集合中。如果hashcode只想等，然后再通过equals方法判断要放入该对象与集合
中的任意一个对象是否相等，equals判断不相等，直接将该元素放入到集合中，否则不放入。
13.自然排序实现哪个接口，重写哪个方法
14.什么是对象序列化和对象反序列化：Serializable接口
答：主要用于存储对象状态为另一种通用格式，比如存储为二进制、xml、json等等，
把对象转换成这种格式就叫序列化，而反序列化通常是从这种格式转换回来。
使用序列化主要是因为跨平台和对象存储的需求，因为网络上只允许字符串或者二进制格式，
而文件需要使用二进制流格式，如果想把一个内存中的对象存储下来就必须使用序列化转换为xml（字符串）
、json（字符串）或二进制（流）
15.Strings="Helloworld!"声明了什么？
答：声明了一个字符串类型的引用s
s指向字符串常量"Hello world!"..
字符串常量是放在常量池中的~
常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。
它包括了关于类、方法、接口等中的常量，也包括字符串常量。Java会确保一个字符串常量只有一个拷贝。
17.File类在创建实例的时候会不会生成实际存在的文件？那要怎么样才能生成这么一个实例？如果不能，那么请说出一个能够生成的类。
答：不会，可以通过判断，如果该文件不存在，我们可以调用File的creatNewFile()的方
String path="E://08//a.txt";
File file= new File(path);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(file.exists());
法创建一个文件
可以通过FileWriter 类来生成文件
String path="E://08//b.txt";
try {
FileWriter fl= new FileWriter(path);
fl.write("写入");
fl.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
18.列出五个字节输出流类.
OutputStream 基类
FileOutputStream 访问文件
BufferOutputStream 缓存流
ObjectOutputStream 对象流
PrintStream 打印流
19.静态方法能不能调用非静态方法和访问非静态变量，说出理由。
答：静态方法不能调用非静态方法和防问非静态变量
原因：静态方法属于类的方法，调用的时候用类名.方法的方式调用
而非静态方法和非静态变量属于对象的，必须通过对象来调用
而且静态方法的生存期比非静态的长，如果非静态消亡，静态的该
该怎么存在
21.解析一下同步和异步的区别，分别在什么情况下使用?
《答》：如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，
或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，
就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
22.实现同步的方法有哪些？
《答》：实现同步有几种方法：例如：synchronized,wait,notify都可以实现同步。
23.构造方法必须满足哪些条件？
《答》：1.构造方法不能被子类继承，但可以被子类调用，可以重载（同一个类）。
2.方法名与类名相同
3.不能声明返回类型
4.不能被static、final、synchronized、abstarct修饰，不能有return语句返回值
5.有3种构造方法，分别为隐式无惨（默认构造方法）、显示无参、显示有参构造方法。
6.如果在类中自己编写了一个构造方法，编译器就不会提供那个默认无参构造方法，
如果还想调用那个无参构造方法创建实例，就必须明确添加这个默认构造方法。
24.当类被加载是，请简述一下类中的静态声明执行顺序
首先初始化静态属性值
然后执行静态块
最后执行类加载时的构造函数
25.error与exception的区别：
《答》：Exception：
1．可以是可被控制(checked) 或不可控制的(unchecked)
2．表示一个由程序员导致的错误
3．应该在应用程序级被处理
Error：
1．总是不可控制的(unchecked)
2．经常用来用于表示系统错误或低层资源的错误
3．如何可能的话，应该在系统级被捕捉
另一种：Error(错误)表示系统级的错误和程序不必处理的异常，
是java运行环境中的内部错误或者硬件问题，比如，内存资源不足等
，对于这种错误，程序基本无能为力，除了退出运行外别无选择。
Exception(违例)表示需要捕捉或者需要程序进行处理的异常，
它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题
，是程序必须处理的。
27.Strings tr=new String("miss")中有几个对象,分别为?
如果常量池中没有miss，那就创建了两个对象分别是new String () 、 miss
否则就是 new String()
28.集合类与数组的区别
集合长度是可变的，数组长度是不可变的
集合里面装的是对象，数组里面可以装对象和基本数据类型
数组运行速度比集合快
29.集合中的iterator()方法是用来做什么的;
Iterator()是迭代器，在集合中是循环遍历集合中的元素的
32.精灵线程和用户线程的区别：
答：精灵线程是运行在程序后台的线程，为其他线程提供服务，精灵线程不会单独运行，
如果非精灵线程停止运行，即使精灵线程在运行，程序也会关闭
33.流按功能可以分为哪几类？
1. 按流的方向分为：输入流和输出流 2. 按流的数据单位不同分为：字节流和字符流 3. 按流的功能不同分为：节点流和处理流
34.字节流的父类和字符类的父类分别是什么？
答：字节流父类：OutputStream InputStream
字符流父类：Writer Reader
35.缓冲流的有什么优点？
答：缓冲流就是先把数据读入或者写入一个缓冲区，待缓冲区满了再取出来，这样能够提高读或者写的效率
36.解释下死锁发生的原因，以及怎么样解决死锁
37.判断线程是否被中断并且写出来.
38.按钮应该添加什么事件,鼠标应该添加什么事件,获得焦点和失去焦点应该添加什么事件
《答》：按钮添加事件
<script type="text/javascript" src="js.js">
</script>
</head>
<body>
<input id="but1" type="button" value="全选" />
</body>
</html>搜索
鼠标添加事件
39.数组，LinkedList,Vector,ArrayList他们的性能差异
《答》：ArrayList,Vector底层是由数组实现，LinkedList底层是由双线链表实现，
从底层的实现可以得出它们的性能问题，ArrayList,Vector插入速度相对较慢，
查询速度相对较快，而LinkedList插入速度较快,而查询速度较慢。
再者由于Vevtor使用了线程安全锁，所以ArrayList的运行效率高于Vector。
40.jvm是如何加载类的?
《答》：(1)程序执行System.exit()
(2)程序正常结束
(3)程序抛出异常，一直向上抛出，没有try{}catch（）finally{}处理。
(4)由于操作系统的异常，导致JVM退出
类的加载过程主要包括三个部分：加载，连接（验证，准备，解析），初始化
简单介绍这几个环节的作用：
加载：就是将class二进制文件由类加载器加载到内存。
连接-验证：主要验证class文件的格式是否正确，语法是否正确，
字节码是否正确，二进制是否兼容。
连接-准备：为类的静态变量分配空间，且赋予默认的初始值。
连接-解析：将class文件中符号引用转变成直接引用。
初始化：为类的静态变量赋予正确的初始值，只有在类首次主动使用的时候，才会进行初始化。
41.jdk1.5 1.6的新特性;
《答》：jdk1.5新特性
1.泛型
2.foreach
3.自动拆箱装箱
4.枚举
5.静态导入（Static import）
6.元数据（Metadata）
7.线程池
8.Java Generics
jdk1.6新特性
1.Desktop类和SystemTray类
2.使用JAXB2来实现对象与XML之间的映射
3.StAX
4.使用Compiler API
5.轻量级Http Server API
6.插入式注解处理API(Pluggable Annotation Processing API)
7.用Console开发控制台程序
8.对脚本语言的支持
9.Common Annotations
jdk1.7新特性
1 对集合类的语言支持；
2 自动资源管理；
3 改进的通用实例创建类型推断；
4 数字字面量下划线支持；
5 switch中使用string；
6 二进制字面量；
7 简化可变参数方法调用。
42.线程的生命周期.
《答》：分为五个阶段 新建---就绪---运行---死亡---堵塞
1 新建（new Thread）
当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。
例如：Thread t1=new Thread();
2 就绪（runnable）
线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：t1.start();
3 运行（running）
线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。
4 死亡（dead）
当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。
自然终止：正常运行run()方法后终止
异常终止：调用stop()方法让一个线程终止运行
5 堵塞（blocked）
由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。
正在睡眠：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。
正在等待：调用wait()方法。（调用motify()方法回到就绪状态）
被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）
-----------java之面向对象:
1.重载与重写的区别：
答： 重写Override, 重载Overload
重写: 父子类之间, 方法名相同,返回值相同, 参数相同; 修饰符不同, 返回异常可以不一样;
重写的修饰符访问权限的范围只能大,不能小;
返回异常只能小不能大;
重载: 一个类之间; 只需要方法名相同, 返回值可以不同, 修饰符可以不同, 返回异常可以不同,
参数列表可以不同;
2.抽象类与接口的比较
接口和抽象类相同点：
都可以包含抽象方法，实现接口或抽象类的普通类必须实现这些抽象方法
(1) 都可以被继承
(2) 都不能被实例化
(3) 都可以包含方法声明
(4) 派生类必须实现未实现的方法
接口和抽象类的区别：
而接口只是一个行为的规范或规定，抽象类作为多个子类的共同父类，体现的是一种模板设计思想
1.类是对对象的抽象，可以把抽象类理解为把类当作对象，抽象成的类叫做抽象类
2. 接口基本上不具备继承的任何具体特点，它仅仅承诺了能够调用的方法；
3. 一个类一次可以实现若干个接口，但是只能扩展一个父类；
4. 接口可以用于支持回调，而继承并不具备这个特点；
5. 抽象类不能被密封；
(1)抽象类里面可以有非抽象方法但接口里只能有抽象方法 声明方法的存在而不去实现它的类被叫做抽像类（abstract class），它用于要创建一个体现某些基本行为的类，
并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽像类，并让它指向具体子类的一个实例。
不能有抽像构造函数或抽像静态方法。Abstract 类的子类为它们父类中的所有抽像方法提供实现，否则它们也是抽像类为。取而代之，在子类中实现该方法。
知道其行为的其它类可以在类中实现这些方法。
(2)接口（interface）是抽像类的变体。在接口中，所有方法都是抽像的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽像的，没有一个有程序体。
接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）
所有这种接口的方法。然后，它可以在实现了该接口的类的任何对像上调用接口的方法。由于有抽像类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。
引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口
3.抽象类和非抽象类的不同点？
使用abstract修饰的类即为抽象类，abstract修饰的方法即为抽象方法，有抽象方法的类只能定义为抽象类，抽象类里面可以没有抽象方法
4.链表的优点
答： 采用动态存储分配，不会造成内存浪费和溢出；另外，链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素。
5.循环有哪几种形式？
do{循环体}while(条件)------------先执行循环体，再判断条件，如果条件满足，继续执行，不满足，退出循环，最少执行一次
while（条件）{循环体}-------------先判断条件，满足就执行循环体，不满足退出
for(循环初始化语句; 循环条件; 迭代语句){循环体}
foreach--------遍历
6.Person person = new Person();执行的步骤
A：将Person.class文件加载到内存中。
B：在堆内存中创建一个对象Person。
C：把Person中的属性进行默认初始化。
D：把Person中的属性进行显示初始化。
E：调用构造代码块(如果没有，不执行这个操作)。
F：调用构造函数进行初始化。
G：在栈内存中声明Person类型的变量person
H：把堆内存的地址(引用)赋给了栈内存中person
7.8大基本类型以及其对应的封装类
数据类型 默认值 封装类(都在java.lang包下)
byte 字节型 (byte)0 Byte
short 短整形 (short)0 Short
int 整形 0 Integer
long 长整形 0L Long
float 浮点型 0.0f Float
double双精度浮点型 0.0d Double
char 字符型 \u0000 Character
boolean 布尔型 false Boolean
8.final的作用
1、final修饰类中的属性或者变量
无论属性是基本类型还是引用类型，final所起的作用都是变量里面存放的“值”不能变。
这个值，对于基本类型来说，变量里面放的就是实实在在的值，如1，“abc”等。
而引用类型变量里面放的是个地址，所以用final修饰引用类型变量指的是它里面的地址不能变，并不是说这个地址所指向的对象或数组的内容不可以变
2、final修饰类中的方法---------------可以被继承，但继承后不能被重写。
3、final修饰类-------------------------类不可以被继承。
关于final的重要知识点
final关键字可以用于成员变量、本地变量、方法以及类。
final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。
你不能够对final变量再次赋值。
本地变量必须在声明时赋值。
在匿名类中所有变量都必须是final变量。
final方法不能被重写。
final类不能被继承。
final关键字不同于finally关键字，后者用于异常处理。
final关键字容易与finalize()方法搞混，后者是在Object类中定义的方法，是在垃圾回收之前被JVM调用的方法。
接口中声明的所有变量本身是final的。
final和abstract这两个关键字是反相关的，final类就不可能是abstract的。
final方法在编译阶段绑定，称为静态绑定(static binding)。
没有在声明时初始化final变量的称为空白final变量(blank final variable)，它们必须在构造器中初始化，或者调用this()初始化。不这么做的话，编译器会报错“final变量(变量名)需要进行初始化”。
将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。
按照Java代码惯例，final变量就是常量，而且通常常量名要大写：
9.构造器Constructor是否可被override(重写)
答： Constructor不能被继承，所以Constructor也就不能被override,但是可以overload(重载),所以你可以看到有多个构造函数这种情况。
构造器不是方法，那么用来修饰方法特性的所有修饰符都不能用来修饰构造器（并不等与构造具备这些特性，虽然不能用static修饰构造器，但它却有静态特性）
构造器只能用 public private protected这三个权限修饰符，且不能有返回语句
10.子类继承父类的特点。
答： 子类将拥有父类所有的非私有的方法和属性，子类还可以拥有自己独有的方法和属性声明父类，实例化子类时，子类会自动向上转型为父类
①子类和父类在同一个包中时，子类可以继承父类的除private属性的所有方法和成员变量，当子类与 父类不在同一个包中时，
子类只能继承父类的protected和public属性的成员变量和方法。
②子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量；子类中定义一个方法，并且这个方法的名字、返回类型、参数个数
和类型与从父类继承的方法完全相同，子类就隐藏从父类继承来的方法（方法的重写）。
③在子类中允许有一个方法和父类的方法名字相同而类型不同。
11.throw throws的区别
(1)throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。-----throws 语句用在方法声明后面，表示再抛出异常，由该方法的调用者来处理。
(2)throws 主要是声明这个方法会抛出这种类型的异常，使它的调用者知道要捕获这个异常。-----throw 是具体向外抛异常的动作，所以它是抛出一个异常实例。
(3)throws 说明你有那个可能，倾向。-----throw 的话，那就是你把那个倾向变成真实的了。
13.equals()和==比较两个字符串是否相同有什么区别
(1) == 是比较两个字符串引用的地址是否相同，即是否指向同一个对象，而 equals 方法则比较字符串的内容是否相同。
(2) 1、string是一个特殊的引用类型。对于两个字符串的比较，不管是 == 和 Equals 这两者比较的都是字符串是否相同；
2、当你创建两个string对象时，内存中的地址是不相同的，你可以赋相同的值。所以字符串的内容相同。引用地址不一定相同，
（相同内容的对象地址不一定相同），但反过来却是肯定的；
3、基本数据类型比较(string 除外) == 和 Equals 两者都是比较值；
14.java的权限修饰符有哪几种，它们的可见性分别是什么
public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段。
包外 子类 包内 类内
public yes yes yes yes
protected no yes yes yes
default no no yes yes
private no no no yes
15.说出能用于switch()后的括号中的数据类型
答： byte、char、short、int四种基本类型以及它们的包装类（需要Java5.0/1.5以上版本支持） 都可以用于switch语句。
16.throw、throws、try、catch、finally他们在java异常机制中起到的作用
throws是获取异常,-----throw是抛出异常
try是将会发生异常的语句括起来，从而进行异常的处理，catch是如果有异常就会执行他里面的语句
finally不论是否有异常都会进行执行的语句。
throw 仅用于方法定义后面，指示该方法可能会抛出什么异常，使用该方法的方法必须处理该异常，或者再次抛出。
throws 用于当程序判断发生异常时，用该语句抛出异常，或处理异常时再次抛出异常。
try {
//这里放可能会发生异常的语句
} catch(Exception e) {
//这里处理异常
} finally {
//这里的语句必然会得到执行，不管异常发省与否，
//用于关闭数据库，关闭连接等收尾操作（非必要）
}
17.包的意义：
Package的作用就是把若干类按包结构进行分类管理。其中最重要的用途是为了解决同名但作用不同的类同时存在的问题
Java中提供的包主要有以下3种用途:
1) 将功能相近的类放在同一个包中，可以方便查找与使用。
2) 由于在不同包中可以存在同名类，所以使用包在一定程度上可以避免命名冲突。
3) 在Java中，某次访问权限是以包为单位的。
18.接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承实体类(concreteclass)?
1.接口可以继承接口..但是要使用extends~而不是用implements
如:interface a{}
interface b extends a{}
2.抽象类可以实现接口..
比如java.util中的AbstractCollection类就是实现的Collection接口
3.抽象类可以继承实体类
19.当类被加载是，请简述一下类中的静态声明执行顺序
首先初始化静态属性值
然后执行静态块
最后执行类加载时的构造函数
20.多态的好处
多态性：在程序中的体现。
就是：父类或者接口的引用指向自己的子类对象。
好处：提高了代码的扩展性。
弊端：前期建立父类的引用虽然可以接收后期所有该类的子类对象。
但是只能使用父类中的功能，不能使用子类中的特有功能，
因为前期的程序无法知道后期的子类的特有内容的。
但是前期的程序可以使用子类覆盖了父类的方法的内容。
前提：---1，必须存在着继承关系。-----2，通常要有覆盖操作。
21.类与对象的关系
类是拥有相同行为特征对象的一个抽象概念，而对象是类这个抽象概念中事实存在的个体。
打个比方：类;人，对象：你。人这个类可以是黄种人、黑种人、白种人等等，但是对象实实在在的
就是指类当中的一个个体..
22.静态方法注意事项
1，静态方法不能访问非静态的成员。
但是非静态可以访问静态成员的。
说明：静态的弊端在于访问出现局限性。好处是可以直接被类名调用。
2. 静态方法中不允许出现this，super关键字。
1，静态是随着类的加载就加载了。也是随着类的消失而消失了。
2，静态优先于对象存在，被对象共享。
3，因为静态先存在于内存中无法访问后来的对象的中的数据，所以静态无法访问非静态。 而且内部无法书写this。因为这时对象有可能不存在，this没有任何指向。
23.int和Integer有什么区别(基本数据类跟包装器类有什么区别?)
答：1. 数据类型和包装类型
2. 1.声明方式不同，基本类型不适用new关键字，而包装类型需要使用new关键字来在堆中分配存储空间；
2.存储方式及位置不同，基本类型是直接将变量值存储在堆栈中，而包装类型是将对象放在堆中，然后通过引用来使用；
3.初始值不同，基本类型的初始值如int为0，boolean为false，而包装类型的初始值为null
4.使用方式不同，基本类型直接赋值直接使用就好，而包装类型在集合如Collection、Map时会使用到。
24.子类与父类的生成顺序关系?
父类的静态代码块—>子类的静态代码块—>主方法（执行哪个程序就执行哪个程序的主方法）—>父类的非静态代码块—>父类的无参构造函数—>子类的非静态代码块
—>子类的无参构造函数（若实际子类执行的是有参构造函数，则不执行无参构造函数）
—>成员函数（指定执行哪个就执行哪个成员函数，若重写了父类成员函数，则只执行子类的成员函数）
25.两个对象值相同(x.equals(y)==true)，但却可有不同的hashcode，这句话对不对?
答：对的------每个对象都有自己的hashcode码，这是唯一的，当两个对象用==比较时，比较他们的内存地址是否一致，如果一致，他们的hashcode一定相同。
而用equals比较时 ，许多类都重载该方法，单比较值而已，他们的内存地址可能不一致。
26.float f=3.4这个表达式是否正确？
不正确。 3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，
因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;。
27.char a='晕';char能不能存放一个中文？为什么
可以。一个char是两个字节，而一个中文也是两个字节。java默认采用unicode，2个字节（16位）来表示一个字符， 无论是汉字还是数字字母，或其他语言。
28.instanceof是什么东东？
instanceof用来判断内存中实际对象属于那个类的，例如A nstanceof B，就是判断A是不是B类型.
instanceof是Java、php的一个二元操作符（运算符），和==，>，<是同一类东西。由于它是由字母组成的，所以也是Java的保留关键字。
它的作用是判断其左边对象是否为其右边类的实例，返回boolean类型的数据。可以用来判断继承中的子类的实例是否为父类的实现。
30.当类被加载是，请简述一下类中的静态声明执行顺序
首先初始化静态属性值
然后执行静态块
最后执行类加载时的构造函数
31.面向对象的特点,各有什么特点?
1、易维护
采用面向对象思想设计的结构，可读性高，由于继承的存在，即使改变需求，那么维护也只是在局部模块，所以维护起来是非常方便和较低成本的。
2、质量高
在设计时，可重用现有的，在以前的项目的领域中已被测试过的类使系统满足业务需求并具有较高的质量。
3、效率高
在软件开发时，根据设计的需要对现实世界的事物进行抽象，产生类。使用这样的方法解决问题，接近于日常生活和自然的思考方式，势必提高软件开发的效率和质量。
4、易扩展
由于继承、封装、多态的特性，自然设计出高内聚、低耦合的系统结构，使得系统更灵活、更容易扩展，而且成本较低。
32.String和StringBuffer的区别
就是一个变量和常量的关系。StringBuffer对象的内容可以修改；而String对象一旦产生后就不可以被修改，重新赋值其实是两个对象。
（1）String类对象为不可变对象，一旦你修改了String对象的值，隐性重新创建了一个新的对象，释放原String对象，
StringBuffer类对象为可修改对象，可以通过append()方法来修改值
（2）String类对象的性能远不如StringBuffer类。
33.运行时异常与一般异常有何异同？
运行时异常runtime exception和一般异常checked exception。checked 异常。对于后者这种异常，JAVA要求程序员对其进行catch。
所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。
运行时异常我们可以不处理。这样的异常由虚拟机接管。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。
如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。
34.说出ArrayList,Vector,LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，
但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，
Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，
而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
35.Collection和Collections的区别。
Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
36.&和&&的区别。&,|,~,>>,<< ,>>>
&是位运算符。&&是布尔逻辑运算符。
在运行上，&两边的条件都要判断（不管前面的是ture还是false），而&&先判断前面的，若为false，则后面的不再判断。
37.HashMap和Hashtable的区别。
1.hashMap去掉了HashTable 的contains方法，但是加上了containsValue（）和containsKey（）方法。
2.hashTable同步的，而HashMap是非同步的，效率上逼hashTable要高。
3.hashMap允许空键值，而hashTable不允许。
38.final,finally,finalize的区别。
1.final:凡是被final修饰过的类是不能被继承的，比如String，被final修饰过的熟悉是不能被更改的，被final修饰过的方法是不能被重写的。
2.finally:是在try{}catch{}组合中放在catch末尾的，不管有没捕获到异常finally都会执行。
在连接数据发生异常时，可以用来关闭连接。
3.它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。
finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的
39.sleep()和wait()有什么区别?
sleep是让线程指定休眠时间，然后继续工作
wait则是等待，直到有线程通知notify（）唤醒他才会重新工作。
40.Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
Override是重写：方法名称、参数个数，类型，顺序，返回值类型都是必须和父类方法一致的。它的关系是父子关系
Overload是重载:方法名称不变，其余的都是可以变更的。它的关系是同一个类，同一个方法名，不同的方法参数或返回值。
备注：它们都是是Java多态性的不同表现
Overloaded的方法是可以改变返回值的类型。
这句话是正确的，唯一区分方法重载的是方法的参数列表不同，当参数列表不同时就可改变其返回类型
41.error和exception有什么区别?
答：error是一种错误，程序员不能处理，并且也不需要程序员处理
exception是一种异常，它分为编译时异常和运行时异常，程序员可以自行处理
Exception表示程序需要捕捉和处理的的异常;
Error表示系统级别的错误和程序无需处理的。
41.同步和异步有何异同，在什么情况下分别使用他们？举例说明。
答：同步是一个进程执行某个请求时，只有返回信息时，进程才会执行下一步，否则会一直等待下去
异步是指不需要等待下去，继续执行下面的代码
42.abstract class和interface有什么区别?
答：用abstract修饰的是抽象类，不能被实例化，需要被子类实例化
可以有抽象方法和普通方法，抽象方法必须有子类实现
用class修饰的是普通类
用interface修饰的是接口 ，不能被实例化，需要子类实现，
43.heap和stack有什么区别。
heap：是栈 声明一个对象是在栈中 如：String str="傻"；
stack：是堆 new一个对象是在堆中 如：String str= new String("啪啪")
44.StaticNestedClass和InnerClass的不同。
class A{ 外部类
class B {内部类
}
}
StaticNestedClass静态内部类：静态内部类实例化不需要先实例化外部类
例子： A.B b= new A.B();通过类名来实例化
InnerClass叫做非静态内部类：需要先实例化外部类，然后通过外部类的对象实例化
例： A a= new A()先实例化A
A.B b=a.new B() 通过A来实例化B
45.GC是什么?为什么要有GC?
GC：垃圾回收机制
内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，
Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的
46.short s1=1;s1=s1+1;有什么错?short s1=1;s1+=1;有什么错?
1）、short s1=1;
s1=s1+1;
会报语法错误，因为s1+1会自动向上转成int类型
2）、short s1=1;
s1+=1;
没有错误
47.Java有没有goto?
答：有goto，但是是作为保留字，可能以后会启用
48.启动一个线程是用run()还是start()?
答：star()
49.给我一个你最常见到的runtimeexception。
答：NullPointerException 空指针异常
ArthmeticException 算术异常
ClassCastException 类型转换异常
ArrayIndexOutOfBoundsException 数组越界
IndexOutOfBoundsException索引越界
NumberFormatException 格式化异常
50.接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承实体类(concreteclass)?
答：接口可以继承接口，而且还可以多继承；
抽象类可以实现接口，但是抽象类中的抽象方法需要由子类继承重写
抽象类可以继承实体类(concreteclass)；但是抽象类需要其子类实例化
51.List,Set,Map是否继承自Collection接口?
答：List,Set是继承Collection接口，但是Map不是，Map和Collection相当于同级，Map是以键值作为储存单元的集合
52.abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
答：abstract中的方法如果全是普通方法，可以同时用static修饰，此时方法用类.方法名调用
如果有抽象方法，就不能同时用static修饰，因为抽象方法需要子类实现
使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。
如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象，因为该方法不是在该抽象类中实现的。是在其子类实现的。
所以。锁应该归其子类所有。所以。抽象方法也就不能用synchronized关键字修饰了；native，这个东西本身就和abstract冲突，
他们都是方法的声明，只是一个吧方法实现移交给子类另一个是移交给本地操作系统。如果同时出现，就相当于即把实现移交给子类，
又把实现移交给本地操作系统，那到底谁来实现具体方法呢？
53.数组有没有length()这个方法?String有没有length()这个方法？
答;数组没有length()这个方法;
String有length()这个方法;
54.Set里的元素是不能重复的，那么用什么方法来区分重复与否呢?是用==还是equals()?它们有何区别?
答：区分重复与否用equals()方法来区分
"=="是根据栈中引用类型的地址来判断是否相同
"equals"是根据堆中的内容是否相同来判断
55.构造器Constructor是否可被override?
答：不能被重写，因为构造器不能被继承，继承时只能调用父类的构造器
56.是否可以继承String类?
String类是用final修饰的，所以不能继承String类
57.swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?
答：swtich能作用在byte（向上转型）上，不能作用在long上，能作用在String上；
switch只能作用在int String enum上面
58.try{}里有一个return语句，那么紧跟在这个try后的finally{}里的code会不会被执行，什么时候被执行，在return前还是后?
答：会被执行
public static void main(String[] args) {
System.out.println(test());
}
public static int test(){
int i=3;
int j=1;
try {
int x=i/j;
return x;
} finally{
System.out.println("在return之前执行");
}
}
//在return之前执行 3
在return之前执行
59.当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
答：这是引用传递
60.当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
答：可以进入其他非synchronized的方法，synchronized的方法不可以的
61.编程题:写一个Singleton出来。
class A{//懒汉式
private static A a;//先创建一个对象
private A(){}; //把构造器私有化
public static A test(){ //判断对象是否实例化，没有的话就new一个
if(a==null){
a=new A();
}
return a;
}
}
class B{//饿汉式
private static B b= new B();//先创建一个对象并实例化
private B(){}; //把构造器私有化
public static B single(){//返回实例化了的对象
return b;
}
}
public class Arr_List {
public static void main(String[] args) {
A s=A.test();
System.out.println(s);
B bs=B.single();
System.out.println(bs);
}
}
63.Java中的异常处理机制的简单原理和应用。
答：Java中的异常处理机制的简单原理和应用 :
java中Throwable这个类可以被作为异常抛出的类,继承它的分为异常Exception和错误Error.
Exception表示程序需要捕捉和处理的的异常;
Error表示系统级别的错误和程序无需处理的。
我们所需要关心的是Exception. Execption可以分为java标准定义的异常和程序员自定义异常2种.
（1）一种是当程序违反了java语规则的时候,JAVA虚拟机就会将发生的错误表示为一个异常.这里语法规则指的是JAVA类库内置的语义检查。
（2）另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。
64.垃圾回收的优点和原理。并考虑2种回收机制。
答：Java语言中一个显著的特点就是引入了垃圾回收机制，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制
Java中的对象不再有”作用域”的概念，只有对象的引用才有”作用域”。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。
垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，
程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。
回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。
65.请说出你所知道的线程同步的方法。
答：用同步锁来实现，锁住方法、锁住代码块
66.你所知道的集合类都有哪些？主要方法？
答：Collection集合、Map集合
Collection集合下面主要分有序集合和无序集合
分别为List和Set集合
List下面有实现类
主要方法：add() remove() contain() size() get() clear() isEmpty() toArray() set(index,element)
Set下面有HashSet集合类
主要方法和有序集合差不多，因为Set是无序的，所以没有和索引有关的方法
67.描述一下JVM加载class文件的原理机制?
68.多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
同步的实现方面有两种，分别是synchronized,wait与notify wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
69.线程的基本概念、线程的基本状态以及状态之间的关系
答：线程是一个执行流，是进程的组成部分
状态：就绪，运行，synchronize阻塞，wait和sleep挂起，结束。
关系：调用线程的start方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状态，遇到synchronized语句时，由运行状态转为阻塞，
当synchronized获得锁后，由阻塞转为运行，在这种情况可以调用wait方法转为挂起状态，当线程关联的代码执行完后，线程变为结束状态。
70.简述位操作(&,|,^)与逻辑操作(&&,||)的区别。
&和&&都是且的意思，&&会短路，只要第一个条件不满足要求直接返回false，&不会短路，第一个条件不满足要求，会对后面进行判断
|和||都是且的意思，||会短路，只要第一个条件不满足要求直接返回false，|不会短路，第一个条件不满足要求，会对后面进行判断
^两个元素不同，返回true，否则返回false
71.简述synchronized和java.util.concurrent.locks.Lock的异同？
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，
并且必须在finally从句中释放（因为如果不在finally中释放的情况，当抛出异常时，线程直接死掉，但是没有释放锁，使得其他相关
线程无法执行。读者可以试试在定义一个数组，并访问越界区，使得程序抛出异常，但是释放锁并未在finally中）。
72.JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？
throws是获取异常
throw是抛出异常
把可能发生的异常代码块放在try块中，如果真的出现了异常就要在catch块里面返回异常的信息
finally块包裹的表示不管是否有异常，finally里面的代码都会执行
73.一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？
可以包含多个类，但是一个文件只能有一个public类，并且public类名必须与文件名相同
74.java中有几种方法可以实现一个线程？用什么关键字修饰同步方法?
3中：继承Thread，实现Runnable接口，实现Callable接口
synchronized同步
stop和suspend方法,stop用来直接终止线程
stop不安全，suspend容易死锁
75.java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
Java中的流分为两种，字节流和字符流，分别由四个抽象类来表示:
InputStream，OutputStream，Reader，Writer。
Java中其他多种多样变化的流均是由它们派生出来的.
76.java中会存在内存泄漏吗，请简单描述。
所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。
Java中有垃圾回收机制，它可以保证一对象不再被引用的时候
，即对象编程了孤儿的时候，对象将自动被垃圾回收器从内存中清除掉。由于Java 使用有向图的方式进行垃圾回收管理，可以消除引用循环的
问题，例如有两个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的。
java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长
生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景，通俗地说，就是程序员可能创建了一个对象，以后一直不再使
用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是java中可能出现内存泄露的情况，例如，缓存系统，
我们加载了一个对象放在缓存中(例如放在一个全局map对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。 检查java中
的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。
如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部
类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。
77.java中实现多态的机制是什么？
java中实现多态的机制是依靠父类或接口的引用指向子类。从而实现了一个对象多种形态的特性。其中父类的引用是在程序运行时动态的指向
具体的实例，调用该引用的方法时，不是根据引用变量的类型中定义的方法来运行，而是根据具体的实例的方法。
78.垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？
基本原理就是虚拟机每隔一段时间就会运行一次垃圾回收或是在虚拟机认为需要的时候。
主动调用是System.gc()。垃圾回收器运行了当然会收回内存。但悲剧的是，垃圾回收是任何程序员都无法自己控制的，
也就是说即使调用了System.gc()，也只是通知虚拟机要回收垃圾，至于虚拟机什么时候运行回收器就不知道了。
79.静态变量和实例变量的区别？
静态变量属于类，该类不生产对象，通过类名调用。
实例变量属于该类的对象，必须产生该类对象，通过对象调用。
80.什么是java序列化，如何实现java序列化？
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，
也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是
为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，
接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
81.在JAVA中，如何跳出当前的多重嵌套循环？
在java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的的break语句，即可跳出外层
循环。
82.List、Map、Set三个接口，存取元素时，各有什么特点？
list：存储： 有序的 可重复的
访问：可以for循环，foreach循环，iterator迭代器 迭代。
set：存储：无序的 不重复的
访问：可以foreach循环，iterator迭代器 迭代
map：存储：存储的是一对一对的映射 ”key=value“，key值 是无序，不重复的。value值可重复
访问：可以map中key值转为为set存储，然后迭代这个set，用map.get(key)获取value
也可以 转换为entry对象 用迭代器迭代
83.说出一些常用的类，包，接口，请各举5个
类:1.java.lang.Object
2.java.lang.String
3.java.lang.System
4.java.io.file
5.java.io.FileInputStream
包:1.java.lang包
2.java.io包
3.java.swt包
4.java.util包
5.java.sql包
接口:1.java.util.List<E>
2.java.util.Map<E>
3.java.util.Iterator<E>
4.java.sql.CallableStatement
5.java.lang.Comparable<T>
84.谈谈final, finally, finalize的区别
final是全局变量声明的时候使用，意思是这个变量不可被修改，不可被override，一般用于声明常量，或者系统设置的值。
例子：public static final String a = "123"
意思是： 公共的（所有范围可见），静态的（系统中只存在一个），final的（不可被更改） 变量a，值是123
finally是在try-catch-finally块中配套使用，作用是，不管代码执行了try还是catch，最后一定会执行finally里面的代码
85.String和StringBuffer 的区别
（1）String类对象为不可变对象，一旦你修改了String对象的值，隐性重新创建了一个新的对象，释放原String对象，StringBuffer类对象为可修改对象，可以通过append()方法来修改值
（2）String类对象的性能远不如StringBuffer类。
扫一扫
2073
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
