abstract修饰符可以修饰类和方法。
（1）abstract修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型（见后面实例），也就是编译时类型。抽象类就相当于一类的半成品，需要子类继承并覆盖其中的抽象方法。
（2）abstract修饰方法，会使这个方法变成抽象方法，也就是只有声明而没有实现，需要子类继承实现。
（3）注意的地方：
A：有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。abstract修饰符在修饰类时必须放在类名前。abstract修饰方法就是要求其子类（实现）这个方法，调用时就可以以多态方式调用子类覆盖（实现）后的方法，除非子类本身也是抽象类。
B：父类是抽象类，其中有抽象方法，那么子类继承父类，并把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的实例的能力，否则子类也必须是抽象类。简单的例子下面有一个抽象类
- abstract class E{
- public abstract void show();
- }
- class F extends E{
- public void show(){
- System.out.print("test all FFFF \n");
- }
- }
- class G extends E{
- public void show(){
- System.out.print("test all GGGG \n");
- }
- }
- public class main
- {
- public static void main(String[] args)throws InterruptedException {
- E p = new F();
- p.show();
- E q = new G();
- q.show();
- }
- }
test all FFFF
test all GGGG
=============================================================================================================================
extends是继承父类，只要那个类不是声明为final就能继承。Java中不支持多重继承，但是可以用接口来实现，这样就要用到implements。继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了，比如 class A extends B implements C,D,E。
与extends的差别：extends 是继承某个类，继承之后可以使用父类的方法也可以重写父类的方法；implements 是实现多个接口，接口的方法必须重写才能使用。要注意以下几点：
A，接口中一般定义的是常量和抽象方法。抽象类中可以包含抽象方法，也可以有非抽象方法，但是有抽象方法的类一定是抽象类。抽象方法不能有方法体。
B，接口（interface）中，方法只能定义抽象方法而且默认是Public，常量则是public static final 修饰的（不管有没有这些修饰符，方法和常量默认具这种属性）。
C，一个类可以实现多个无关的接口（这点和继承要有所区别）。
D，接口可以继承其他的接口，并添加新的属性和抽象方法。
E，在类中实现接口的方法时必须加上public修饰符。
示例：
- interface W1{ //定义接口
- public final static int i = 3;
- void start();
- void run();
- void stop();
- }
- interface W2 extends W1{ //接口间可以继承，并添加新的属性方法
- public final static int j = 4; //常量的修饰
- void openMonth();
- void upAndDown();
- void goIn();
- }
- class TT implements W2{
- public void start(){ //实现接口的同时会继承接口的变量，实现接口的方法加上public
- System.out.println("----start()----");
- }
- public void run(){
- System.out.println("----run()----");
- }
- public void stop(){
- System.out.println("----stop()----");
- }
- public void openMonth(){
- System.out.println("----openMonth()----");
- }
- public void upAndDown(){
- System.out.println("----upAndDown()----");
- }
- public void goIn(){
- System.out.println("----goIn()----");
- }
- }
- public class main {
- public static void main(String[] args) {
- // TODO Auto-generated method stub
- W1 tt = new TT(); //实现对象指向接口引用的父类
- System.out.println(TT.i); //类名.静态变量
- System.out.println(tt.i); //实例.静态变量
- System.out.println(W1.i); //接口名.静态变量
- tt.start();
- W2 ee = new TT();
- System.out.println(TT.j); //类名.静态变量
- System.out.println(ee.j); //实例.静态变量
- System.out.println(W2.j); //接口名.静态变量
- ee.start();
- }
- }
3
3
3
----start()----
4
4
4
----start()----
得到这个结果，需要注意的几点：（1）静态变量（相当于常量）可以用类名.静态变量名直接使用，接口又是类的一种，所以接口名.静态变量名可用；（2）接口引用.静态变量是多态的体现。
==========================================================================================================================
这里需要谈到抽象类和Interface的差别，abstract class和interface是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的面向对象能力，两者的区别如下：
（1）相同点
A，两者都是抽象类，都不能实例化。
B，interface实现类及abstrct class的子类都必须要实现已经声明的抽象方法。
（2）不同点
A，interface实现，要用implements，而abstract class的实现，要用extends。
B，一个类可以实现多个interface，但一个类只能继承一个abstract class。
C，interface强调特定功能的实现，而abstract class强调所属关系。
D，尽管interface实现类及abstrct class的子类都必须要实现相应的抽象方法，但实现的形式不同。interface中的每一个方法都是抽象方法，都只是声明的(declaration, 没有方法体)，必须要实现。而abstract class的子类可以有选择地实现。
抽象类的这个选择有两点含义：一是Abastract class中并非所有的方法都是抽象的，只有那些冠有abstract的方法才是抽象的，子类必须实现。那些没有abstract的方法，在Abstrct class中必须定义方法体。二是abstract class的子类在继承它时，对非抽象方法既可以直接继承，也可以覆盖；而对抽象方法，可以选择实现，也可以通过再次声明其方法为抽象的方式，无需实现，留给其子类来实现，但此类必须也声明为抽象类。既是抽象类，当然也不能实例化。
E，interface是完全抽象的，只能声明方法，而且只能声明pulic的方法，不能声明private及protected的方法，不能定义方法体，也不能声明实例变量。
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
参考原文 http://blog.csdn.net/zhandoushi1982/article/details/8458081
///////////////////////////////////////////////////////////////////////////////////////////
区别
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。接口（interface）是抽象类的变体。新型多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，所有成员变量都是public static final 的。一个类可以实现多个接口，当类实现特殊接口时，它定义（即
将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。
