深入浅出：重温JAVA中接口与抽象的区别

抽象类：声明一个抽象类，就是在类的声明开头、在Class关键字的前面使用关键字abstract

下面定义一个抽象类，代码如下：

abstract class  A{
   abstract void callme();
   void callmetoo(){
       System.out.println("This is a concrete method.");
   }
}
class B extends A{
   void callme(){
       System.out.println("B‘s implementation of callme.");
   }
}
class AbstractDemo{
   public static void main(String args[]){
       B b = new B();
       b.callme();
       b.callmetoo();
   }
}

分析抽象类的代码，得出抽象类的一些特性：

1、  定义一个抽象类，必须使用关键字abstract；

2、  抽象类不存在对象，也就是说，不能使用new运算符直接实例化抽象类；

3、  抽象类不能声明抽象的构造方法，也不能声明抽象的静态（static）方法；

4、  抽象类的所有子类，要么实现父类中的所有抽象方法，要么自己也声明为抽象类；

5、  抽象类中的方法，可以定义为抽象方法（用abstract关键字），也可以为普通方法；[注意以上第3点中的区别]；

6、  抽象类只能继承（extends）使用，也就是说父类为抽象类时，它的直接子类只有一个，这也是继承的特性；

接口：声明一个接口，使用interface关键字，可以指定类必须执行哪些工作，但是只定义工作的模版（方法），不具体实现工作的内容。

下面定义一个接口，代码如下：

interface Callback{
    public void callback(String param);
}
class  InterfaceDemo implements Callback{

    public void callback(String who){
        System.out.println("callback called with "+who);
    }
    public static void main(String[] args)
    {
        InterfaceDemo ifd = new InterfaceDemo();
        ifd.callback("me");
    }
}

分析接口的代码，得出接口的一些特性：

1、  定义一个接口，必须使用关键字interface；

2、  接口不能直接实例化，并且它里面的方法是没有方法体的；[注意：实际上，它们是抽象方法，在接口中指定的所有方法都可以没有默认实现]

3、  实现接口的每个类，都必须实现接口中定义的所有方法；

4、  一旦定义了接口，任意数量的类都可以实现（implements）该接口，此外，一个类也可以实现任意数量的接口，使用逗号隔开；[注意：如果在类实现的两个接口中都声明了同一个方法，那么这两个方法的客户都将可以使用该方法]

5、  接口可以声明变量，它们被隐式地标识为final和static，这意味着实现接口的类不能修改它们，同时在接口必须初始化它们；

6、  在接口的实现类中，实现接口方法时，必须将方法声明为public；

7、  虽然接口不能直接实例化，但可以将变量声明为使用接口而不是类的对象引用；[代码如下：]

Callback c = new InterfaceDemo();
c.callback(“me”);
//注意：变量c被声明为接口类型Callback，此时，可以使用c访问callback()方法，但是c不能访问InterfaceDemo类中的其他任何成员，接口的引用变量只知道由接口声明的方法。

8、  如果一个类实现了一个接口，但没有实现该接口定义的全部方法，那么必须将该类声明为抽象类（abstrace）；

9、  在声明嵌套接口的类或接口之外，嵌套接口的名称必须是完全限定的；[代码如下：]

class A{
    //定义嵌套接口
    public interface NestedIF{
        boolean isNotNegative(int x);
    }
}
class B implements A.NestedIF{
    public boolean isNotNegative(int x){
        return x<0?false:true;
    }
}
class  NestedIFDemo{
    public static void main(String[] args)
    {
        A.NestedIF nif = new B();
        if(nif.isNotNegative(10)){
            System.out.println("10 is not nogative");
        }
        if(nif.isNotNegative(-10)){
            System.out.println("this won't be displayed");
        }
    }
}
//注意：类A定义了成员接口NestedIF，并且声明为public，B类通过指定接口名称完全限定来实现嵌套接口：implements A.NestedIF

10、  接口可以通过关键字extends继承另一个接口，语法和继承类相同；