Abstract class

抽象類。 一個類用abstract修飾，這就是一個抽象類。
抽象方法，一個方法用abstract修飾，這就是一個抽象方法。
抽象類裡面有抽象的方法（當然也可以有具體的方法也可以沒有抽象方法），但是不具體實現，留給子類去實現。抽象類最大的意義是作為父類存在，很好的體現面向物件的繼承和多型，抽象類自己是不能進行例項化的。
但是如果一個類中有抽象的方法，這個類就必須是抽象的（不然這個抽象類是不能參與建立物件啊）
abstract與final private native不能修飾同一個方法
看一個例子

public abstract class Animal {
    String type;
    Animal(String s){this
 
.type = s;}
    Animal(){};
    //下面都是抽象方法，沒有花括號的方法體，留給子類去實現
    public abstract void describe();
    public abstract void sound();
    public abstract void sleep();
    public abstract void move();

}

下面是一個子類：

public class Cat extends Animal {
    private String name;
    protected String breed; 
    Cat(){};
    Cat(String name){
        this
 
.name = name;
    }
    //這裡要注意的是，繼承自一個抽象類，那麼抽象類中所有抽象方法都要實現
    //實現的時候就不要加abstract關鍵字了
    public void sound()
    {
        System.out.println("miao miao miao");
    }
    public void move()
    {
        System.out.println("cat moves");
    }
    public void sleep()
    {
        System.out.println("Cat does sleep"
 
);
    }
    public void describe()
    {
        System.out.println("This is a cat");
    }

}

要是繼承字一個抽象類但不實現父類全部的抽象方法，除非這個子類還是一個抽象類
比如：

public abstract class Bird extends Animal {
    protected String breed;
    public void move()//只實現了一個
    {
        System.out.println("Birds fly");
    }
}

不過注意子類中如果還有抽象方法，不能和父類重名，因為要繼續繼承下去，比如：

public class Robin extends Bird {
    private String type;
    public  void describe()
    {
        System.out.println("Robin is a bird ");
    }
    public void sound()
    {
        System.out.println("robin sounds good");
    }

    public  void sleep()
    {
        System.out.println("Ronbin needs sleep");
    }
    //這個move在直接父類bird裡不是抽象的，所以可以不實現直接繼承，但是其他的必須還要在實現
//  public  void move()
//  {
//      System.out.println("Robin flies very fast all the time");
//  }
}

抽象類有個方便的應用，當我想要彙總一堆cat robinbird的時候，一個一個弄很麻煩，一個animal的陣列就可以了
比如：

Animal [] ani = new Animal[3];
        ani[0] = new Cat();
        ani[1] = new Robin();
        for(int i = 0;i<2;i++)
            ani[i].move();

會輸出：
cat moves
Birds fly

當然這個例子可能體現不出來優勢，但是換做其他的就比較明顯了。

interface

介面
這是一個跟抽象類很像但是真的不一樣的東西。

相似點包括，不能例項化，裡面是抽象的方法，留給後面的類來實現，而且要把抽象的方法全都實現

但是也很不一樣，
比如在eclipse裡抽象類是new一個class而介面是new一個interface。
再比如 interface裡面一般不會有成員變數，有的話也全部是常量。所有的方法都是抽象的（即只有方法頭和引數列表），並且全得是public的，而抽象類作為一個類可以有成員，可以沒有抽象函式可以有不抽象的函式，可以有多種許可權的函式
再比如 因為java的繼承，一個子類只能繼承一個父類，而一個類可以implemnet多個介面

介面中也沒有構造方法
介面甚至可以通過native關鍵字實現其他語言來寫
介面可以多重繼承，一個類也可以繼承多個介面
介面是用來實現類間多重繼承的結構，是一種特殊的“抽象類”（當然並不是類）通過結構可以實現不相關類的相同的行為，而不需要考慮這些類之間的層次關係。也就是繼承中，Cat is Animal ，但是Anima裡move的屬性汽車也有，但是汽車不 is Animal, 但是如果move在接口裡，這兩個不相關的類都可以實現。

舉個例子：

//這是一個介面
public interface StudentManageInterface {
public void setFee(int f);
public int getFee();
}

//另一個介面
public interface TeacherManageInterface {
public void setPay(int p);
public int getPay();
}

//實現介面的類，逗號隔開多個介面
public class Graduate implements StudentManageInterface,TeacherManageInterface {
    public String name;
    public char sex;
    public int age;
    public int fee;
    public int pay;
    Graduate(){};
    Graduate(String name){
        this.name = name;
    }
    public void setFee(int fee){
        this.fee = fee;
    }
    public void setPay(int pay){
        this.pay = pay*12;
    }
    public int getFee()
    {
        return fee;
    }
    public int getPay(){
        return pay;
    }
}

總結一下：
1、abstract修飾的類是抽象類，裡面的抽象方法由abstract修飾，沒有方法體，但是可以有其他成員變數，建構函式，非抽象方法
2、抽象類不能產生例項，必須要由子類去實現具體的方法，並且如果子類不是抽象類，要實現父類全部的抽象方法
3、一個類中有抽象方法，這個類就得是抽象類
4、一個類可以實現多個介面，用implements關鍵字，用逗號隔開多個介面
5、實現介面的類不是抽象類的話也要實現介面中所有的方法
6、介面中成員只能是常量，方法都是public的抽象函式
7、abstract類和interface的區別：一個類只能繼承一個抽象類但可以實現多個介面;介面中的所有方法都是抽象的，所有的變數都是靜態不可修改的