抽象类和接口

Author Avatar
stormjie 10月 13, 2018
  • 在其它设备中阅读本文章

我发现刷题有关接口和抽象类的知识点是常考点,也是易错点。今天来总结下,做个记录。

一、抽象类

1.抽象方法和抽象类

抽象方法和抽象类必须使用abstract 修饰符来定义,有抽象方法的类只能被定义成抽象类,抽象类里可以没有抽象方法。

抽象方法和抽象类的规则如下:

  • 抽象类必须使用abstract修饰符来修饰,抽象方法也必须使用abstract修饰符来修饰,抽象方法不能有方法体。

  • 抽象类不能被实例化,无法使用new关键字来调用抽象类的构造器创建抽象类的实例。即使抽象类里不包含抽象方法,这个抽象类也不能创建实例。

  • 抽象类可以包含成员变量、方法(普通方法和抽象方法都可以)、构造器、初始化块、内部类(接口、枚举)5种成分。抽象类的构造器不能用于创建实例,主要是用于被其子类调用。
  • 含有抽象方法的类(包括直接定义了一个抽象方法;或继承了一个抽象父类,但没有完全实现父类包含的抽象方法;或实现了一个接口,但没有完全实现接口包含的抽象方法三种情况)只能被定义成抽象类。

注意:

  • 定义抽象方法只需在普通方法上增加abstract 修饰符,并把普通方法的方法体(也就是方法后花括号括起来的部分)全部去掉,并在方法后增加分号即可。

  • 抽象方法和空方法体的方法不是同一个概念。例如,public abstract void test();是一个抽象方法,它根本没有方法体,即方法定义后面没有一对花括号;但public void test(){}方法是一个普通方法,它已经定义了方法体,只是方法体为空,即它的方法体什么也不做,因此这个方法不可使用abstract 来修饰。

当使用abstract修饰类时,表明这个类只能被继承;当使用abstract修饰方法时,表明这个方法必须由子类提供实现(即重写)。而final修饰的类不能被继承,final 修饰的方法不能被重写。因此final和abstract永远不能同时使用。

注意:

  • abstract不能用于修饰成员变量,不能用于修饰局部变量,即没有抽象变量、没有抽象成员变量等说法;abstract也不能用于修饰构造器,没有抽象构造器,抽象类里定义的构造器只能是普通构造器。

除此之外,当使用static修饰一个方法时,表明这个方法属于该类本身,即通过类就可调用该方法,但如果该方法被定义成抽象方法,则将导致通过该类来调用该方法时出现错误(调用了一个没有方法体的方法肯定会引起错误)。因此static和abstract不能同时修饰某个方法,即没有所谓的类抽象方法。

注意:

  • static和abstract并不是绝对互斥的,static 和abstract虽然不能同时修饰某个方法,但它们可以同时修饰内部类。
  • abstract关键字修饰的方法必须被其子类重写才有意义,否则这个方法将永远不会有方法体,因此abstract方法不能定义为private访问权限,即private和abstract不能同时修饰方法。
2.通过抽象类实现多态
package com.test;

//抽象Pet类
public abstract class Pet {

    public abstract void cry();

}

//Dog类继承实现抽象类Pet
public class Dog extends Pet {

    //实现父类抽象方法cry()
    public void cry() {
        System.out.println("汪汪汪");
    }
}

//Cat类继承实现抽象类Pet
public class Cat extends Pet {

    //实现父类抽象方法cry()
    public void cry() {
        System.out.println("喵喵喵");
    }
}

//测试类
public class TestAbstract {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Pet cat = new Cat();
        Pet dog = new Dog();
        cat.cry();
        dog.cry();
    }

}

上面main()方法中定义了两个Pet类型的引用变量,它们分别指向Cat对象和Dog对象。由于在Pet类中定义了cry()方法,所以程序可以直接调用cat变量和dog变量的cry()方法,无须强制类型转换为其子类类型。

利用抽象类和抽象方法的优势,可以更好地发挥多态的优势,使得程序更加灵活。

二、接口

1.接口的定义

和类定义不同,定义接口不再使用class关键字,而是使用interface关键字。接口定义的基本语法如下:

[修饰符] interface 接口名 extends 父接口1, 父接口2...
{
    零个到多个常量定义...
    零个到名个抽象方法定义...
    零个到多个内部类、接口、枚举定义...
    零个到多个默认方法或类方法定义...
}

对上面语法的详细说明如下:

  • 修饰符可以是public或者省略,如果省略了public访问控制符,则默认采用包权限访问控制符,即只有在相同包结构下才可以访问该接口。

  • 接口名应与类名采用相同的命名规则,即如果仅从语法角度来看,接口名只要是合法的标识符即可;如果要遵守Java可读性规范,则接口名应由多个有意义的单词连缀而成,每个单词首字母大写,单词与单词之间无须任何分隔符。接口名通常能够使用形容词。

  • 一个接口可以有多个直接父接口,但接口只能继承接口,不能继承类。

在上面语法定义中,只有在Java8以上的版本中才允许在接口中定义默认方法、类方法。

由于接口定义的是一种规范,因此接口里不能包含构造器和初始化块定义。接口里可以包含成员变量(只能是静态常量)、方法(只能是抽象实例方法、类方法或默认方法)、内部类(包括内部接口、枚举)定义。
对比接口和类的定义方式,不难发现接口的成员比类里的成员少了两种,而且接口里的成员变量只能是静态常量,接口里的方法只能是抽象方法、类方法或默认方法。
前面已经说过了,接口里定义的是多个类共同的公共行为规范,因此接口里的所有成员,包括常量、方法、内部类和内部枚举都是public访问权限。定义接口成员时,可以省略访问控制修饰符,如果指定访问控制修饰符,则只能使用public访问控制修饰符。
对于接口里定义的静态常量而言,它们是接口相关的,因此系统会自动为这些成员变量增加static和final两个修饰符。也就是说,在接口中定义成员变量时,不管是否使用public static final 修饰符,接口里的成员变量总是使用这三个修饰符来修饰。而且接口里没有构造器和初始化块,因此接口里定义的成员变量只能在定义时指定默认值。

接口里定义成员变量采用如下两行代码的结果完全一样。

//系统自动为接口里定义的成员变量增加public static final修饰符

int MAX_SIZE = 50;

public static final int MAX_SIZE = 50;

接口里定义的方法只能是抽象方法、类方法或默认方法,因此如果不是定义默认方法,系统将自动为普通方法增加abstract修饰符;定义接口里的普通方法时不管是否使用public abstract修饰符,接口里的普通方法总是使用public abstract来修饰。接口里的普通方法不能有方法实现(方法体);但类方法、默认方法都必须有方法实现(方法体)。

注意:

  • 接口里定义的内部类、内部接口,内部枚举默认都采用public static两个修饰符,不管定义时是否指定这两个修饰符,系统都会自动使用public static对它们进行修饰。
2.接口的继承

接口的继承和类继承不一样,接口完全支持多继承,即一个接口可以有多个直接父接口。和类继承相似,子接口扩展某个父接口,将会获得父接口里定义的所有抽象方法、常量。
一个接口继承多个父接口时,多个父接口排在extends关键字之后,多个父接口之间以英文逗号(,)隔开。下面程序定义了三个接口,第三个接口继承了前面两个接口。

interface interfaceA {
    int PROP_ A = 5;
    void testA();
}

interface interfaceB {
    int PROP_ B = 6;
    void testB();
}

interface interfaceC extends interfaceA, interfaceB {
    int PROP_ C = 7;
    void testC();
}

public class InterfaceExtendsTest {
    public static void main(String[] args) {
        System.out.println(interfaceC.PROP_ A);
        System.out.println(interfaceC.PROP_ B);
        System.out.println(interfaceC.PROP_ C);
    }
}

上面程序中的itetfaceC接口继承了interfaceA和interfaceB,所以interfaceC中获得了它们的常量,因此在main()方法中看到通过interfaceC来访问PROP_ A、PROP_ B和PROP_C常量。

三、抽象类和接口

接口和抽象类很像,它们都具有如下特征。

  • 接口和抽象类都不能被实例化,它们都位于继承树的顶端,用于被其他类实现和继承。
  • 接口和抽象类都可以包含抽象方法,实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

但接口和抽象类之间的差别非常大,这种差别主要体现在二者设计目的上。下面具体分析二者的差别。

接口作为系统与外界交互的窗口,接口体现的是一种规范。对于接口的实现者而言,接口规定了实现者必须向外提供哪些服务(以方法的形式来提供);对于接口的调用者而言,接口规定了调用者可以调用哪些服务,以及如何调用这些服务(就是如何来调用方法)。当在一个程序中使用接口时,接口是多个模块间的耦合标准;当在多个应用程序之间使用接口时,接口是多个程序之间的通信标准。

从某种程度上来看,接口类似于整个系统的“总纲”,它制定了系统各模块应该遵循的标准,因此一个系统中的接口不应该经常改变。一旦接口被改变,对整个系统其至其他系统的影响将是辐射式的,导致系统中大部分类都需要改写。

抽象类则不一样, 抽象类作为系统中多个子类的共同父类,它所体现的是一种模板式设计。 抽象类作为多个子类的抽象父类,可以被当成系统实现过程中的中间产品,这个中间产品已经实现了系统的部分功能(那些已经提供实现的方法),但这个产品依然不能当成最终产品,必须有更进一步的完善, 这种完兽可能有几种不同方式。

除此之外,接口和抽象类在用法上也存在如下差别:

  • 接口里只能包含抽象方法、静态方法和默认方法,不能为普通方法提供方法实现;抽象类则完全可以包含普通方法。

  • 接口里不能定义静态方法(Java8之前);抽象类里可以定义静态方法。

  • 接口里只能定义静态常量,不能定义普通成员变量;抽象类里则既可以定义普通成员变量,也可以定义静态常量。
  • 接口里不包含构造器;抽象类里可以包含构造器,抽象类里的构造器并不是用于创建对象,而是让其子类调用这些构造器来完成属于抽象类的初始化操作。
  • 接口里不能包含初始化块;但抽象类则完全可以包含初始化块。
  • 一个类最多只能有一个直接父类, 包括抽象类;但一个类可以直接实现多个接口,通过实现多个接口可以弥补Java单继承的不足。

好了,关于抽象类和接口的总结我就写这么多了,还想理解的可以看看这两篇帖子Java 接口和抽象类区别(写的很好,转了)深入理解Java的接口和抽象类

参考资料:《Java疯狂讲义》