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的区别：一个类只能继承一个抽象类但可以实现多个接口;接口中的所有方法都是抽象的，所有的变量都是静态不可修改的