java基础

1. 抽象类和接口；
这是多态的一种体现，接口是函数方法名的集合，抽象类中可有方法体，子类继承抽象类必须实现抽象的方法，抽象类不可以被实例化。
接口中定义的方法，实现这个接口的类必须实现所有方法。抽象类中定义一个抽象方法，继承抽象类必须实现父类中的抽象方法。抽象类中定义的非抽象方法，可以被继承抽象类的子类得到。Java语言的单继承性决定了，一个类可以实现多个接口，但只能继承一个抽象类。抽象类中父类和之类间是继承关系，存在“is a”，父类和子类本质上应该是相同的。对接口这不是这样，接口和实现者间是实现了接口的契约而已，是“like a”。
面向对象程序设计的重点在于抽象，而Java中接口和抽象类就是设计的关键。接口和抽象类代表的就是抽象类型，就是需要提出的抽象层的具体表现。面向对象的编程，要提高程序的复用率，增加程序的可维护性、可扩展性，就必须面向接口编程，面向抽象的编程。
接口和抽象类结合，可实现适配器模式。Java接口在最上面，然后紧跟着抽象类，抽象类实现了接口。而其他属于这个抽象类的具体类可以实现Java接口或继承抽象类。Java语言API中采用了这种模式，并且遵循一定的命名规范：Abstract+接口名
接口
public interface InfaceTesting {
    public void checkInterface();   
    public String getStringValue();   
    public void checkNull();
}
public class ImplementInterface implements InfaceTesting {
    @Override
    public void checkInterface() {
        // TODO Auto-generated method stub
    }
    @Override
    public String getStringValue() {
        // TODO Auto-generated method stub
        return null;
    }
    @Override
    public void checkNull() {
        // TODO Auto-generated method stub  
    }
}
抽象类
public abstract class AbstractClass {
    public String resturnStringValue() {
        return "testing string";
    }   
    public void getString() {
    }   
    public abstract void getAbstractString();   
}
public class ImplementAbstract extends AbstractClass {
    @Override
    public void getAbstractString() {
        // TODO Auto-generated method stub       
    }
}
接口加抽象类
public interface InfaceTesting {
    public void checkInterface();
    public String getStringValue();
    public void checkNull();
}
public abstract class InterfaceAbstractClass implements InfaceTesting {
    public String getValue() {
        return null;
    }
    public abstract void checkValue();   
}
public class TestAbstractInterface extends InterfaceAbstractClass {
    @Override
    public void checkInterface() {
        // TODO Auto-generated method stub
    }
    @Override
    public String getStringValue() {
        // TODO Auto-generated method stub
        return null;
    }
    @Override
    public void checkNull() {
        // TODO Auto-generated method stub
    }
    @Override
    public void checkValue() {
        // TODO Auto-generated method stub      
    }
}

一个类继承抽象类，抽象类实现了抽象接口，这主要用于设计了一个接口，但实现这个接口的子类并不需要实现接口中的全部方法。例如JMS的JmsTemplate。
public class JmsTemplate extends JmsDestinationAccessor implements JmsOperations {}
JmsDestinationAccessor是一个抽象类，JmsOperations是一个抽象接口，JmsTemplate继承了JmsDestinationAccessor，而JmsDestinationAccessor又实现了JmsOperations这个抽象接口。

public abstract interface AbstractInfaceTest {

    public abstract String getReturnValue();
   
    public abstract void setReturnValue();
}
public abstract class TestAbstractClass {

    public void getValues() {
        System.out.println("AAA");
    }
   
    public abstract String getAbstractValues();
}
public class TestAbstractInfacterClass extends TestAbstractClass implements AbstractInfaceTest {

    @Override
    public String getAbstractValues() {
        // TODO Auto-generated method stub
        // come from TestAbstractClass
        return null;
    }

    @Override
    public String getReturnValue() {
        // TODO Auto-generated method stub
        // come from AbstractInfaceTest
        return null;
    }

    @Override
    public void setReturnValue() {
        // TODO Auto-generated method stub
        // come from AbstractInfaceTest
    }

}
http://www.jianshu.com/p/2b5a9bdcd25f
http://blog.csdn.net/trojanpizza/article/details/6556604
http://www.importnew.com/12399.html

2.覆写和重载
覆写是在一个类中，方法名相同，参数个数，顺序，类型不同。重载是子类对父类方法的重新定义，覆盖于被覆盖函数只有函数体内容不相同。
http://www.runoob.com/java/java-override-overload.html
http://fatkun.com/2010/07/java-overload-and-overrid.html

3.构造函数：
构造函数调用，如果子类继承父类，构造函数从父类开始执行。如果调用super构造函数，必须放在第一条语句。
public class Base {
    public Base() {
        System.out.println("Base");
    }
}
public class Checket extends Base {
    Checket() {
        super();
        System.out.println("Checket");
    }
    public static void main(String[] args) {
        Checket checket = new Checket();
    }
}
输出：
Base
Checket

4.面向对象的设计要遵循：
理解抽象类：如果一个类中没有足够的信息来描绘一个对象就是抽象类。面向对象设计最核心的一个原则就是开放关闭原则OCP（Open-Closed-Principle）,而抽象类是其中关键。OCP要求对扩展开放，对修改关闭。开闭原则说白了就是，应该在不修改现有代码的基础上，引入新功能。开闭原则是面向对象设计中“可复用设计”的基础，是面向对象设计中最重要的原则之一。实现开闭原则的关键是抽象化，并且从抽象化导出具体实现。开闭原则是面向对象设计的主要目标。
从语法定义层面看抽象类和接口的设计：接口是一种特殊像形式的抽象类。
从编程角度看抽象类和接口的设计：一个只能继承一个抽象类，却可以实现多个接口。
从设计理念层面理解：创建一个类时，最重要一点就是要考虑这个类发生变化会不会影响其他类。

5.强引用，软引用、弱引用和虚引用
http://www.kuqin.com/shuoit/20141019/342724.html
http://zhangjunhd.blog.51cto.com/113473/53092/

6.static
http://zhh9106.iteye.com/blog/2151495
http://ych0108.iteye.com/blog/2107180

7.JVM
http://renchx.com/jvm-data-area-lifecycle/
http://boy00fly.iteye.com/blog/1095263

8.