Java复习

1.heap（堆）和stack（栈）有什么区别
1.Java对象分配在heap中，stack存放临时变量。
2.stack中对象或变量定义就可使用，应用程序结束自动释放。heap申请变量或者指针，new动态分配内存空间，free释放内存空间，Java垃圾回收机制自动释放内存。
3.Java自动管理stack和heap，不能直接设置。
4.stack存取速度比heap快。
5.stack线性集合，添加删除元素操作应在同一段完成。heap是stack的一个组成元素。

2.Java接口与C++的虚类的相同和不同之处
1.Java不支持多继承，接口具有更高的灵活性，接口属性默认public static，方法默认情况public，一个类可以实现多个接口。
2.C++虚类相当于Java抽象类，单一继承，多实现
3.抽象类具有构造方法，接口没有
4.抽象类权限全面，接口只有public default
5.都不能实例化！！！

3.Java异常处理机制的简单原理和应用
1.违反Java语义规则抛出异常，内置语义检查和自定义语义检查
2.异常都是java.lang.Throwable的子类
Error：错误
Exception：异常
3.try{
//可能发生异常代码
}catch(异常类型){
//发生异常处理方式
}finally{
//必须执行代码
}
4.常见异常：NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException、NumberFormatException、StringIndexOutOfBoundsException、IOException、RuntimeException

4.垃圾回收的优点和原理，并考虑两种回收机制
1.Java不需要考虑内存管理，拥有自动垃圾回收机制。
2.垃圾回收有效防止内存泄漏，合理分配使用内存。
3.垃圾回收器作为单独的低级的线程运行。
4.不可预知情况下对内存堆中已经死亡或者长时间没有使用的对象进行清除，回收。
5.程序员不能实时对某个对象或所有对象调用垃圾回收器进行垃圾回收。
分类：分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

5.集合类有哪些，主要方法是什么？
1.java.util包含一系列重要集合类，Collection根类型
2.Iterator模式实现遍历集合
for(Iterator it = collection.iterator(); it.hasNext();){……}
3.Set: 无序、不能重复
HashSet，散列码实现hashCode()
TreeSet，二叉树排序，先把元素添加到HashSet再把集合转换为TreeSet进行有序遍历更快。
4.List：有序，可重复
LinkedList，允许null元素，没有同步方法，可被用作堆栈，队列，双向队列。基于链表的数据结构。
ArrayList，可变大小数组，允许所有元素，包括null，ArrayList没有同步。动态数组。
Vector，线程同步
5.Map：不重复的键到值的映射。改变、查询和提供可选视图。
HashMap，在Map中插入、删除和定位元素，HashMap最好，非同步，明确定义hashCode（）。
TreeMap，适合顺序遍历键
HashTable，同步线程安全，key value不允许为null

6.JVM加载class文件的原理机制
1.JVM实现跨平台，内存存储
2.Class Loader，类加载器：加载类文件到内存，只负责加载，不判断是否能够运行，从硬盘读取到内存中。
3.Execution Engine，执行引擎：（解释器Interpreter）负责解释命令、提交操作系统执行。
4.Native Interface，本地接口，在Native Method Stack中登记native方法，在Execution Engine执行时加载native libraies
5.三大类加载器：
BootStrap Loader 负责加载系统类
ExtClass Loader 负责加载扩展类
AppClass Loader 负责加载应用类
BootstrapLoader <—(Extends)—-AppClassLoader <—(Extends)—-ExtClassLoader
6.Java编译 源文件转换为字节码文件；
通过Java虚拟机加载二进制码文件；
校验二进制码文件正确性；
解析二进制码文件；
分发给不同平台。

7.线程问题
反对使用stop（），不安全，它会解除由线程获取的所有锁定
suspend（）方法容易发生死锁。
标志指出线程应该挂起用wait（），进入等待状态
标志指出线程应该恢复，则用notify（）重新启动线程
sleep（）和wait（）的区别
sleep正在执行的线程主动让出cpu，去执行其他线程。sleep时间过后再继续执行
如果当前线程进入同步锁，sleep方法并不会释放锁。
wait进入同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，notify释放同步锁，但是notify后面的方法依旧执行。

8.面向对象的特征
1.继承：类可以在继承父类的方法和属性的情况下增加特有的属性和方法。
2.封装：类是相同属性和方法的封装体。
3.多态：定义为父类的对象可被赋值为其任何子类对象，并根据子类对象的不同而调用不同的方法。
4.抽象：将一类实体的共同特性抽象出来，封装在一个抽象类中。
9.This vs Super
1.this指当前的对象的引用，指向对象本身的一个指针。
2.super指父类成分，当前对象里面的父对象的引用。
3.在类的构造方法中通过this语句调用另一个构造方法
4.父类没有提供无参构造，super指导子类调用父类中的其他构造方法。
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法
10.单态模式
1.饿汉式：
利用static的特性，提前初始化，并且只是初始化一次，保存一份，永驻内存。

public class SingleOne{
    //使用的时static属性，初始化一次，永驻内存
    private static SingleOne singleone = new SingleOne();
    // 定义一个活的singleone的对象的方法--->提供给外部进行获得SingleOne类的对象。
    public static SingleOne getInstance(){
        return singleone;
    }
    // 手动定义一个private方法
    private SingleOne() {
    }
}

2.懒汉式：

public class SingleTwo{
    private static SingleTwo singletwo = null;
    // 提供一个对外可以获得当前这个类的对象的方法
    public synchronized static SingleTwo getInstance(){
        if(singletwo == null){
            singletwo = new SingleTwo();
                }
        return singletwo;
    }
    private SingleTwo(){
    }
}

11.return语句调用先于finally执行

public  class Test {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(new Test().test());;
    }

    int test()
    {
        try
        {
            return func1();
        }
        finally
        {
            return func2();
        }
    }

    int func1()
    {
        System.out.println("func1");
        return 1;
    }
    int func2()
    {
        System.out.println("func2");
        return 2;
    }   
}
-----------执行结果-----------------

func1
func2
2

try中的return语句调用的函数先于finally中调用的函数执行，return并不是让函数直接返回，而是return语句执行之后，将返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正返回。

线程死锁
引发死锁同时满足四个条件：
互斥：线程使用的资源至少有一个不能共享
持有与等待：至少有一个线程持有资源，并且等待获取其他线程持有的资源
非抢占式：如果一个线程已经持有一个资源，如果它不释放资源，其他资源不可获得
循环等待：第一个线程等待第二个线程持有资源，第二个线程等待第三个线程持有资源……第n个线程等待第一个线程持有资源，形成等待。

内存泄漏
定义：一个不再被程序使用的对象或变量一直被占据在内存中。
Java使用有向图的方式进行垃圾回收管理，可以消除引用循环问题。
Java内存泄露情况：长生命周期的对象持有短生命周期对象的引用。一个对象无用却无法被垃圾回收机制回收。