java易混点小结（待补充）

1、final、finally、finalize的区别：

final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。

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

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等。

2、进程与线程的区别

进程：是一个正在执行的程序

每一个进程的执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元

线程：就是进程中的一个独立的控制单元

线程在控制着进程的执行

一个进程至少有一个线程

* 线程的四种状态：

* 被创建

* 运行状态：start()

* 冻结状态：放弃了执行资格 sleep(time) wait()/notify()

* 临时状态/阻塞状态：具备运行资格但没有执行权

* 消亡状态：stop() run方法结束

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。
1) 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
2) 线程的划分尺度小于进程，使得多线程程序的并发性高。
3) 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
4) 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
5) 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
3、sychronized 和 Lock

主要相同点:lock能完成synchronized所实现的所有功能

主要不同点:lock有比synchronized更精确的线程语义和更好的性能.synchronized会自动释放锁,而Lock一定要求程序员手工释放,并且必须在finally从句中释放.

使用：在java中，synchronized 包括两种用法，synchronized 方法和 synchronized

synchronized：在代码里，sychronized类似“面向对象“，修饰类、方法、对象

Lock：不作为修饰，类似”面向过程“，在方法中需要锁的时候lock，在结束的时候unlock（一般都在finally块里）

在并发高时，lock性能优势很明显，在低并发时，sychronized也能取得优势

4、单例模式的饿汉式和懒汉式

单例模式的概念：

单例模式的

关键点：

1）一个类只有一个实例 这是最基本的

2）它必须自行创建这个实例

3）它必须自行向整个系统提供这个实例

----------------------------------------------------------------------------------------------------------------------------------------------------

两种实现方式：

1 懒汉模式（类加载时不初始化）

package Singleton;

public class LazySingleton {
//懒汉式单例模式
//比较懒，在类加载时，不创建实例，因此类加载速度快，但运行时获取对象的速度慢

private static LazySingleton intance = null;//静态私用成员，没有初始化

private LazySingleton()
{
//私有构造函数
}

public static synchronized LazySingleton getInstance()    //静态，同步，公开访问点
{
if(intance == null)
{
intance = new LazySingleton();
}
return intance;
}
}

关键点：（代码注释上已给出）

1）构造函数定义为私有----不能在别的类中来获取该类的对象，只能在类自身中得到自己的对象

2）成员变量为static的，没有初始化----类加载快，但访问类的唯一实例慢，static保证在自身类中获取自身对象

3）公开访问点getInstance： public和synchronized的-----public保证对外公开，同步保证多线程时的正确性（因为类变量不是在加载时初始化的）

优缺点见代码注释。

2 饿汉式单例模式（在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快）

package Singleton;
public class EagerSingleton {
//饿汉单例模式
//在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快
private static EagerSingleton instance = new EagerSingleton();//静态私有成员，已初始化
private EagerSingleton()
{
//私有构造函数
}
public static EagerSingleton getInstance()    //静态，不用同步（类加载时已初始化，不会有多线程的问题）
{
return instance;
}
}

关键点：（代码注释已写）

1）私有构造函数

2）静态私有成员--在类加载时已初始化

3）公开访问点getInstance-----不需要同步，因为在类加载时已经初始化完毕，也不需要判断null，直接返回

优缺点见代码注释。

意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

5、静态类和非静态类的主要区别：

　　主要区别在于静态类不能实例化，静态类编译器能够执行检查确保不是偶然的添加实例成员，C#编译器会自动把它标记为sealed，静态类中不能创建非静态的方法，即静态方法中只能创建静态方法，但在非静态类中可以调用静态方法。

　　静态类的主要特性：

　　1：仅包含静态成员。

　　2：无法实例化。

　　3：是密封的。

　　4：不能包含实例构造函数。

　　5：非静态类可以包含静态的方法、字段、属性或事件；

　　6：静态方法和属性不能访问其包含类型中的非静态字段和事件

　　7：静态方法只能被重载，而不能被重写，因为静态方法不属于类的实例成员；

　　8：C# 不支持静态局部变量(在方法内部定义静态变量)。

　　静态类的主要特性：

　　1：仅包含静态成员。

　　2：无法实例化。

　　3：是密封的。

　　4：不能包含实例构造函数。

　　5：非静态类可以包含静态的方法、字段、属性或事件；

　　6：静态方法和属性不能访问其包含类型中的非静态字段和事件

　　7：静态方法只能被重载，而不能被重写，因为静态方法不属于类的实例成员；

　　8：C# 不支持静态局部变量(在方法内部定义静态变量)。

　　非静态类在使用时必须要实例化，每次使用时都要进行实例化，一般情况下使用比较频繁的类，可以使用静态类，比如LogClass,ConfigClass等等。

6、Java垃圾回收机制

Java垃圾回收机制是Java虚拟机提供的能力，用于在空闲时间以不定时的方式动态回收无任何引用的对象占据的空间。需注意：垃圾回收的是无任何引用对象占据的内存空间而不是对象本身。System.gc()   Runtime.getRuntime().gc()  方法调用时用于显式通知JVM可以进行一次垃圾回收，但真正垃圾回收机制具体在什么时间点发生动作，这个是不可预料的，这和抢占式的线程在发生作用时的原理一样。
在JVM垃圾回收器收集一个对象之前，一般要求程序调用适当的方法释放资源，但在没有明确释放资源的情况下，Java提供了缺省机制来终止对象释放资源，这个方法就是finalize(). 在finalize()方法返回之后，对象消失，垃圾收集开始执行。finalize()可用来释放“特殊”的内存区域，该内存区域无法被垃圾回收机制回收。

7、堆和栈的区别

（1）栈：由操作系统自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈

堆：一般由程序员分配释放，或垃圾回收机制来回收，分配方式类似于链表

（2）栈：使用的是一级缓存，他们通常都是被调用时处于存储空间中，调用完毕立即释放

堆：存放在二级缓存，声明周期由虚拟机的垃圾回收算法来决定，所以调用这些对象的速度要相对来的低一些

（3）栈：一种先进后出的数据结构

堆：可以被看成是一棵树