抽象类与接口(二)

二,接口

1.概念

抽象类是从多个类中抽象出来的模板,如果将这种抽象进行的跟彻底,则可以提炼出一种更加特殊的“抽象类”——接口(interface),接口里不能含普通方法,接口里的所有方法都是抽象方法。Java 8 对接口进行了改进,允许在接口中定义默认方法,默认方法可以提供方法实现

接口,在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。

接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类,否则该类要定义接口中的所有方法。

接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。另外,在 Java 中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。

2.接口的定义

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

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

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

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

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

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

接口里不能包含构造器和初始化块定义;但可以包含成员变量(只能是静态常量)、方法(只能是抽象实例方法、类方法或默认方法)、内部类(包括内部接口、枚举)定义。接口里定义的是多个类共同的公共行为规范,因此接口里的所有成员,包括常量、方法、内部类和内部枚举类都是public访问权限。定义接口成员时 ,可以省略控制修饰符,如果指定访问控制修饰符,则只能使用public访问控制修饰符。

下面定义一个接口:

package lee;
public interface Output
{
    //接口里定义的成员变量只能是常量
    int MAX_CACHE_LINE=50;
    //接口里定义的普通方法只能是public的抽象方法
    void out();
    void getData (String msg);
    //在接口中定义默认方法,需要使用default修饰
    default void print(String...msgs)
    {
        for (String  msg : msgs)
        {
            System.out.println(msg);
        }
    }
    //接口中定义默认方法,需要使用default修饰
    default void test()
    {
        System.out.println("默认的test()方法") ;
    }
    //在接口中定义类方法,需要使用static修饰
    static String staticTest()
    {
        return "接口里的类方法";
    }
}

上面定义了一个Output接口,这个接口包含了一个成员变量:MAX_CSCHR_LINE,成员变量默认使用public static final修饰的。两个普通方法,普通方法只能是public修饰的抽象方法。Java允许在接口中定义默认方法,默认方法必须用default修饰,该方法不能使用static修饰。Java允许在接口中定义类方法,类方法必须使用static修饰,该方法不能使用default修饰。

我们在来看下怎么下面这个例子:

package yeeku;
public class OutputFieldTest
{
    public static void main(String [] args)
    {
        //访问另一个包中的Output接口的MAX_CACHE_LINE
        System.out.println(lee.Output.MAX_CACHE_LINE);
        //下面语句将引发“为final变量赋值”的编译异常
        //lee.Output.MAX_CACHE_LINE = 20;
        //使用接口来调用类方法
        System.out.println(lee.Output.staticTest());
    }
}

从上面main()方法中可以看出,OutputFieldTest与Output处于不同包下,但可以访问Output的常量。

3.接口的继承

接口的继承和类继承不一样,接口完全支持多继承,即一个接口可以有多个直接父接口。和类继承相似,子接口扩展某个父接口,将会获得父接口里定义的所有抽象方法、常量。

一个接口继承多个父接口时,多个父接口排在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);
    }
}

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

4.使用接口

接口不能用于创建实例,但接口可以用于声明引用变量。当使用接口来声明引用类型变量时,这个引用类型变量必须引用到其实现类的对象。所以,接口的主要用途就是呗实现类实现。归纳起来,接口主要有如下用途。

☆ 定义变量,也可用于进行强制类型转换。

☆ 调用接口中定义的常量。

☆ 被其他类实现。

我们来看类实现接口的语法格式:

[修饰符] class 类名 extends 父类 implements 接口1,接口2...
{
   类体部分
}

实现接口与继承父类相似,一样可以获得所实现接口里定义的常量、方法。

可以实现多个接口,需要逗号(,)隔开。

下面看一个实现接口的类。

//定义一个Product 接口
interface Product
{
    int getProduceTime();
}
//让Printer 类实现Output 和Product 接口
public class Printer implements Output ,Product
{
    private String[] printData = new String[MAX_CACHE_LINE] ;
    //用以记录当前需打印的作业数
    private int dataNum = 0;
    public void out()
    {
        //只要还有作业,就继续打印
        while (dataNum > 0)
        {
            System.out.println("打印机打印: "+ printData[0] );
            // 把作业队列整体前移一位,并将剩下的作业数减1
            System.arraycopy(printData,1,printData,0,--dataNum);
        }
    }
    public void getData(String msg)
    {
        if(dataNum >= MAX_CACHE_LINE)
        {
            System.out.printIn("输出队列已满,添加失败") ;
        }
        else
        {
            // 把打印数据添加到队列里,已保存数据的数量加1
            printData[dataNum++] = msg;
        }
    }
    public int getProduceTime()
    {
        return 45;
    }
    public static void main (String [] args)
    {
        // 创建一个Printer 对象,当成Output 使用
        Output o = new Printer();
        o.getData("轻量级Java EE 企业应用实战");
        o.getData("疯狂Java 讲义");
        o.out();
        o.getData("疯狂Android 讲义");
        o.getData("疯狂Ajax 讲义");
        o.out();
        //调用Output 接口中定义的默认方法
        o.print("孙悟空","猪八戒","白骨精");
        o.test();
        //创建一个Printer对象,当成Product使用
        Product P = new Printer();
        System.out.println(P.getProduceTime());
        //所有接口类型的引用变量都可直接赋给Object类型的变量,下面程序将不会报错
        Object obj =P;
    }
}

从上面程序中可以看出,Printer类实现了Output接口和Product接口,仿佛Printer类既是Output类的子类,也是Product类的子类,这就是java提供的模拟多继承。

三.接口与抽象类

我在这里总结一下接口与抽象类的异同。

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

☆ 接口和抽象类都不能被实例化,它们都位于继承树的首端,用于被其他类实现和继承

☆ 接口和抽象类都可以包含抽象方法,实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

但其实接口和抽象类差别非常大,这种差别主要体现在二者的设计目的上。

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

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

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

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

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

☆ 接口里只能定义静态常量,不能定义普通成员变量; 抽象类里则既可以定义普通成员变量,也可以定义静态常量。

☆ 接口里不包含构造器; 抽象类里可以包含构造器,抽象类里的构造器并不是用于创建对象,而是让其子类调用这些构造器来完成属于抽象类的初始化操作。

☆ 接口里不能包含初始化块; 但抽象类则完全可以包含初始化块。

☆ 一个类最多只能有一个直接父类,包括抽象类; 但一个类可以直接实现多个接口,通过实现多个接口可以弥补Java 单继承的不足。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值