java接口(interface)与抽象类(abstract class)的区别

最近学习PHP5接口的过程中遇到了困难
,书中说是实现多重继承的一种方式,但我依然不知道具体该如何实现。在网上查PHP接口的资料很少,就查了java的,其实基本上都差不多。看完《澄清Java》这篇文章才恍然大悟,原来我一开始理解就有误,所谓的多重继承是指接口继承类,而不是类继承接口。
文章中提到了OO的抽象,正如文章中的那句话――”抽象就是抽去像的部分”,很形象,以前想到抽象总是认为很难理解,抽象嘛,哈哈,现在就很容易理解了,这也正是接口和抽象类所要做的事情。
文章中还有很多观点也让我受益匪浅,罗列如下:
OO的精髓,我以为,是对对象的抽象。
接口的作用,一言以蔽之,就是标志类的类别。把不同类型的类归于不同的接口,可以更好的管理他们。
继承的意义也在于抽象,而不是代码重用。
看完这篇文章,现在基本上理解接口、抽象类、继承该如何应用了。

很久没有看到如此精辟的文章了!作者写得实在太好了!正在学JAVA或者想了解抽象类与接口的朋友,绝对不可错过!本人极力推荐!

原文如下: 澄清Java
计算机学院研二的兄弟与我讨论Java,一见面,几个问题全是关于接口,接口有什么用?为什么要用接口?什么时候该使用接口?很庆幸他们不是问我Java如何连接SQL
Server,或者是如何开发J2EE应用,这类问题有杀伤力,避之则吉。今年计算机学院本科有个毕业设计课题是做J2ME,选这个题目的学生在5月末都还在苦着脸研究java.util.*这个包,这个这个……唉。

  1. OOP中接口与抽象类的区别
  2. Java语言接口与继承的本质
  3. 深入理解接口和抽象类
     

大多数人认为,接口的意义在于顶替多重继承。众所周知Java没有c++那样多重继承的机制,但是却能够实作多个接口。其实这样做是很牵强的,接口和继承是完全不同的东西,接口没有能力代替多重继承,也没有这个义务。接口的作用,一言以蔽之,就是标志类的类别。把不同类型的类归于不同的接口,可以更好的管理他们。OO的精髓,我以为,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言,就是因为设计模式所研究的,实际上就是如何合理的去抽象。。

OOP中接口与抽象类的区别

设计模式中最基础的是工厂模式,在我最近的一个很简单的应用中,我想尽量的让我的程序能够在多个数据库间移植,当然,这涉及很多问题,单是如何兼容不同DBMS的SQL就让人头痛。我们不妨先把问题简单化,只考虑如何连接不同的数据库。

OOP中的INTERFACE和ABSTRACT CLASS是两个不同的概念

假设我有很多个类,分别是Mysql.java、SQLServer.java、Oracle.java、DB2.java,他们分别连接不同的数据库,统一返回一个Connection对象,并且都有一个close方法,用于关闭连接。只需要针对你的DBMS,选择不同的类,就可以用了,但是我的用户他会使用什么数据库?我不知道,我希望的是尽量少的修改代码,就能满足他的需要。我可以抽象如下接口:
package org.bromon.test; public interface DB { java.sql.Connection
openDB(String url,String user,String password); void close(); }

我们在使用的时候往往将两个混在一起使用,不做什么区别,大家可能在定义上对他们的区别有不少见解

这个接口只定义两个方法,没有任何有实际意义的代码,具体的代码由实作这个接口的类来给出,比如Mysql.java:

这里我不用什么专业术语什么的,一个字“烦”,我们就以最简单的白话来讨论.

Package org.bromon.test; import java.sql.*; public class Mysql
implements DB { private String url=”jdbc:mysql:localhost:3306/test”;
private String user=”root”; private String password=””; private
Connection conn; public Connection openDB(url,user,password) {
//连接数据库的代码 }

其实这两个东西在使用上是有很大区别的,我自己郁闷了好半天才有所领悟

public void close() { //关闭数据库 } }

在我们对一个实体进行抽象的时候将他先分类处理,把他的属性跟主要方法划分为一个类,我们这时候就用到了ABSTRACT
CLASS,而INTERFACE则是用来增加功能的直接对外的。

类似的当然还有Oracle.java等等,接口DB给这些类归了个类,在应用程序中我们这样定义对象:

一般应用里边,接口是直接对外的,抽象类其次,最后才是具体实现方法的类。

org.bromon.test.DB myDB;

我们用一个简单的例子说明:

使用myDB来操作数据库,就可以不用管实际上我所使用的是哪个类,这就是所谓的“开-闭”原则。但是问题在于接口是不能实例化的,myDB=new
DB(),这样的代码是绝对错误的,我们只能myDB=new Mysql()或者myDB=new
Oracle()。麻烦了,我还是需要指定具体实例化的是哪个类,用了接口跟没用一样。所以我们需要一个工厂:

我们现在要分析“计算机”这个实体

package org.bromon.test; public class DBFactory { public static DB
Connection getConn() { Return(new Mysql()); } }

首先计算机部件有(主机,显示器)我们,然后分析部件的行为,主机可以(开机,关机),显示器也可以(打开,关闭),这些都是计算机的基本功能,也是必须的

所以实例化的代码变成:myDB=DBFactory.getConn();
这就是23种模式中最基础的普通工厂(Factory),工厂类负责具体实例化哪个类,而其他的程序逻辑都是针对DB这个接口进行操作,这就是“针对接口编程”。责任都被推卸给工厂类了,当然你也可以继续定义工厂接口,继续把责任上抛,这就演变成抽象工厂(Abstract
Factory)。

abstract Class jisuanji{

整个过程中接口不负责任何具体操作,其他的程序要连接数据库的话,只需要构造一个DB对象就OK,而不管工厂类如何变化。这就是接口的意义—-抽象。

String zhuji,xianshiqi;

继承的概念不用多说,很好理解。为什么要继承呢?因为你想重用代码?这绝对不是理由,继承的意义也在于抽象,而不是代码重用。如果对象A有一个run()方法,对象B也想有这个方法,所以有人就Class
B extends
A。这是不经大脑的做法。如果在B中实例化一个A,调用A的Run()方法,是不是可以达到同样的目的?如下:
Class B { A a=new A(); a.run(); }

abstract zj_on();

这就是利用类的聚合来重用代码,是委派模式的雏形,是GoF一贯倡导的做法。

abstract zj_off();

那么继承的意义何在?其实这是历史原因造成的,最开始的OO语言只有继承,没有接口,所以只能以继承来实现抽象,请一定注意,继承的本意在于抽象,而非代码重用,这是很多Java烂书最严重的错误之一,它们所造成的阴影,我至今还没有完全摆脱,坏书害人啊,尤其是入门类的,流毒太大。什么时候应该使用继承?只在抽象类中使用,其他情况下尽量不使用。抽象类也是不能实例化的,它仅仅提供一个模版而已,这就很能说明问题。

abstract xsq_on();

软件开发的万恶之源,一是重复代码而不是重用代码,二是烂用继承,尤以c++程序员为甚。Java中取缔多重继承,目的就是制止烂用继承,实是非常明智的做法,不过很多人都不理解。Java能够更好的体现设计,这是让我入迷的原因之一。

abstract xsq_off();

}

以上就是电脑这个实体的基本组成,但是我们的电脑不光有这些设备,我们还需要键盘,鼠标什么的,这些都是必须的,否则电脑这个东西将不能完成他的基本任务我们可以用继承来实现他

abstract class PC extends jisuanji{

String shubiao,jianpan;

abstract sb_click();

abstract sb_dblclack();

}

我们将计算机的完整部件基本上做好了,但是我们PC是一个多功能设备,不是每个人都用他来做基本的计算工作的,我们可以用他来看电影,听音乐什么的,这个时候我们就需要对他的功能进行扩充,这些设备不一定是电脑上需要的,这里就用到interface

我们的电脑现在只需要基本的功能和播放音乐的功能,我们用接口去实现他

interface music{

public void play();

}

这里我们播放音乐的功能也就生成了

将这些功能集成在一起

class Computer extends PC implements music{

<具体实现>

}

这里我们就将一个有音乐功能的电脑做成了,我们可能还需要其他功能,在这个时候我们就可以充分利用接口的优点来做到这些功能的随意增加。

说完了具体的例子,我们回过头来看接口跟抽象类在使用上的区别,抽象类在使用的时候是将主要功能封装起来,在主要部件上的增添(比如电脑的更新换代上)通过抽象类来实现,而接口则偏向于对附加功能的增删管理上。

这时候有人会问,为什么要那么复杂的去定义一个抽象类又去定义一个接口呢?将这些功能集中起来写在一个类里边多方便,有好理解。这种想法在解决小问题的时候显得得心应手,又好理解,又好写。

但是我们在解决复杂问题的时候采用这种方法就会暴露出很多的弊端:

我们在解决一个复杂问题的时候就需要先将他简单的分类,然后针对分类在进行细化,先考虑问题的解决顺序什么的,最后对问题的每个模块都有了掌握之后,我们再对其进行过程的编写。这样我们在面对一个复杂的问题时就会显得得心应手,而那种写在一起的方法则不能将问题考虑周全,即使勉强考虑周全了,估计代码也就没几个人能看懂了,使用起来也显得很烦琐,找不到个头绪。

事物不是一成不变的,他是在不断的发展,可能有很多变化,我们经常需要对一个已存在的程序进行功能的扩充和删除,使用这里我们分析的方法可以很有条理的去解决这个问题(将主要功能的增加用类的继承来实现,而将辅助功能的添加用接口去管理和分类,这样条理分明),在解决复杂问题和做很多修改的时候不必去大量更改代码。

OOP这种思想帮助我们解决了很多复杂的问题,这里不在一一列举,只说我们这里的重点。

 Java语言接口与继承的本质

大多数人认为,接口的意义在于顶替多重继承。众所周知Java没有c++那样多重继承的机制,但是却能够实作多个接口。其实这样做是很牵强的,接口和继承是完全不同的东西,接口没有能力代替多重继承,也没有这个义务。接口的作用,一言以蔽之,就是标志类的类别(type
of
class)。把不同类型的类归于不同的接口,可以更好的管理他们。OO的精髓,我以为,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++、java、c#等),就是因为设计模式所研究的,实际上就是如何合理的去抽象。(cowboy的名言是“抽象就是抽去像的部分”,看似调侃,实乃至理)。
  设计模式中最基础的是工厂模式(Factory),在我最近的一个很简单的应用中,我想尽量的让我的程序能够在多个数据库间移植,当然,这涉及很多问题,单是如何兼容不同DBMS的SQL就让人头痛。我们不妨先把问题简单化,只考虑如何连接不同的数据库。

  假设我有很多个类,分别是Mysql.java、SQLServer.java、Oracle.java、DB2.java,他们分别连接不同的数据库,统一返回一个Connection对象,并且都有一个close方法,用于关闭连接。只需要针对你的DBMS,选择不同的类,就可以用了,但是我的用户他会使用什么数据库?我不知道,我希望的是尽量少的修改代码,就能满足他的需要。我可以抽象如下接口:

  package org.bromon.test;
  public interface DB
  {
  java.sql.Connection openDB(String url,String user,String
password);
  void close();
  }

  这个接口只定义两个方法,没有任何有实际意义的代码,具体的代码由实作这个接口的类来给出,比如Mysql.java:

  Package org.bromon.test;
  import java.sql.*;
  public class Mysql implements DB
  {
  private String url=”jdbc:mysql:localhost:3306/test”;
  private String user=”root”;
  private String password=””;
  private Connection conn;
  public Connection openDB(url,user,password)
  {
    //连接数据库的代码
  }

  public void close()
  {
    //关闭数据库
  }
  }

  类似的当然还有Oracle.java等等,接口DB给这些类归了个类,在应用程序中我们这样定义对象:

  org.bromon.test.DB myDB;
使用myDB来操作数据库,就可以不用管实际上我所使用的是哪个类,这就是所谓的“开-闭”原则。但是问题在于接口是不能实例化的,myDB=new
DB(),这样的代码是绝对错误的,我们只能myDB=new Mysql()或者myDB=new
Oracle()。麻烦了,我还是需要指定具体实例化的是哪个类,用了接口跟没用一样。所以我们需要一个工厂:
  package org.bromon.test;
  public class DBFactory
  {
  public static DB Connection getConn()
  {
    Return(new Mysql());
  }
  }

  所以实例化的代码变成:myDB=DBFactory.getConn();

  这就是23种模式中最基础的普通工厂(Factory),工厂类负责具体实例化哪个类,而其他的程序逻辑都是针对DB这个接口进行操作,这就是“针对接口编程”。责任都被推卸给工厂类了,当然你也可以继续定义工厂接口,继续把责任上抛,这就演变成抽象工厂(Abstract
Factory)。

  整个过程中接口不负责任何具体操作,其他的程序要连接数据库的话,只需要构造一个DB对象就OK,而不管工厂类如何变化。这就是接口的意义—-抽象。

  继承的概念不用多说,很好理解。为什么要继承呢?因为你想重用代码?这绝对不是理由,继承的意义也在于抽象,而不是代码重用。如果对象A有一个run()方法,对象B也想有这个方法,所以有人就Class
B extends
A。这是不经大脑的做法。如果在B中实例化一个A,调用A的Run()方法,是不是可以达到同样的目的?如下:

  Class B
  {
  A a=new A();
  a.run();
  }

  这就是利用类的聚合来重用代码,是委派模式的雏形,是GoF一贯倡导的做法。

  那么继承的意义何在?其实这是历史原因造成的,最开始的OO语言只有继承,没有接口,所以只能以继承来实现抽象,请一定注意,继承的本意在于抽象,而非代码重用(虽然继承也有这个作用),这是很多Java烂书最严重的错误之一,它们所造成的阴影,我至今还没有完全摆脱,坏书害人啊,尤其是入门类的,流毒太大。什么时候应该使用继承?只在抽象类中使用,其他情况下尽量不使用。抽象类也是不能实例化的,它仅仅提供一个模版而已,这就很能说明问题。

  软件开发的万恶之源,一是重复代码而不是重用代码,二是烂用继承,尤以c++程序员为甚。Java中取缔多重继承,目的就是制止烂用继承,实是非常明智的做法,不过很多人都不理解。Java能够更好的体现设计,这是让我入迷的原因之一。

深入理解接口和抽象类

abstract
class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。abstract
class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于abstract
class和interface的选择显得比较随意。其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析,试图给开发者提供一个在二者之间进行选择的依据。

理解抽象类

abstract
class和interface在Java语言中都是用来进行抽象类(本文中的抽象类并非从abstract
class翻译而来,它表示的是一个抽象体,而abstract
class为Java语言中用于定义抽象类的一种方法,请读者注意区分)定义的,那么什么是抽象类,使用抽象类能为我们带来什么好处呢?

在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是这样。并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。比如:如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、三角形这样一些具体概念,它们是不同的,但是它们又都属于形状这样一个概念,形状这个概念在问题领域是不存在的,它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能够实例化的。

在面向对象领域,抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述,但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体,因此它可以是不允许修改的;同时,通过从这个抽象体派生,也可扩展此模块的行为功能。熟悉OCP的读者一定知道,为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed
Principle),抽象类是其中的关键所在。

从语法定义层面看abstract class和interface

在语法层面,Java语言对于abstract
class和interface给出了不同的定义方式,下面以定义一个名为Demo的抽象类为例来说明这种不同。

使用abstract class的方式定义Demo抽象类的方式如下:

abstract class Demo {
abstract void method1();
abstract void method2();

使用interface的方式定义Demo抽象类的方式如下:

interface Demo {
void method1();
void method2();

}

在abstract
class方式中,Demo可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface方式的实现中,Demo只能够有静态的不能被修改的数据成员(也就是必须是static
final的,不过在interface中一般不定义数据成员),所有的成员方法都是abstract的。从某种意义上说,interface是一种特殊形式的abstract
class。

对于abstract
class和interface在语法定义层面更多的细节问题,不是本文的重点,不再赘述,读者可以参阅参考文献〔1〕获得更多的相关内容。

从编程层面看abstract class和interface

从编程的角度来看,abstract class和interface都可以用来实现”design by
contract”的思想。但是在具体的使用上面还是有一些区别的。

首先,abstract
class在Java语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。也许,这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。

其次,在abstract
class的定义中,我们可以赋予方法的默认行为。但是在interface的定义中,方法却不能拥有默认行为,为了绕过这个限制,必须使用委托,但是这会增加一些复杂性,有时会造成很大的麻烦。

在抽象类中不能定义默认行为还存在另一个比较严重的问题,那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面(一般通过abstract
class或者interface来表示)以适应新的情况(比如,添加新的方法或者给已用的方法中添加新的参数)时,就会非常的麻烦,可能要花费很多的时间(对于派生类很多的情况,尤为如此)。但是如果界面是通过abstract
class来实现的,那么可能就只需要修改定义在abstract
class中的默认行为就可以了。

同样,如果不能在抽象类中定义默认行为,就会导致同样的方法实现出现在该抽象类的每一个派生类中,违反了”one
rule,one
place”原则,造成代码重复,同样不利于以后的维护。因此,在abstract
class和interface间进行选择时要非常的小心。

从设计理念层面看abstract class和interface

上面主要从语法定义和编程的角度论述了abstract
class和interface的区别,这些层面的区别是比较低层次的、非本质的。本小节将从另一个层面:abstract
class和interface所反映出的设计理念,来分析一下二者的区别。作者认为,从这个层面进行分析才能理解二者概念的本质所在。

前面已经提到过,abstarct
class在Java语言中体现了一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在”is
a”关系,即父类和派生类在概念本质上应该是相同的(参考文献〔3〕中有关于”is
a”关系的大篇幅深入的论述,有兴趣的读者可以参考)。对于interface
来说则不然,并不要求interface的实现者和interface定义在概念本质上是一致的,仅仅是实现了interface定义的契约而已。为了使论述便于理解,下面将通过一个简单的实例进行说明。

考虑这样一个例子,假设在我们的问题领域中有一个关于Door的抽象概念,该Door具有执行两个动作open和close,此时我们可以通过abstract
class或者interface来定义一个表示该抽象概念的类型,定义方式分别如下所示:

使用abstract class方式定义Door:

abstract class Door {
abstract void open();
abstract void close();
}

使用interface方式定义Door:

interface Door {
void open();
void close();
}

其他具体的Door类型可以extends使用abstract
class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract
class和interface没有大的区别。

如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢(在本例中,主要是为了展示abstract
class和interface反映在设计理念上的区别,其他方面无关的问题都做了简化或者忽略)?下面将罗列出可能的解决方案,并从设计理念层面对这些不同的方案进行分析。

解决方案一:

简单的在Door的定义中增加一个alarm方法,如下:

abstract class Door {
abstract void open();
abstract void close();
abstract void alarm();
}

或者

interface Door {
void open();
void close();
void alarm();
}

那么具有报警功能的AlarmDoor的定义方式如下:

class AlarmDoor extends Door {
void open() { … }
void close() { … }
void alarm() { … }
}

或者

class AlarmDoor implements Door {
void open() { … }
void close() { … }
void alarm() { … }

这种方法违反了面向对象设计中的一个核心原则ISP(Interface Segregation
Priciple),在Door的定义中把Door概念本身固有的行为方法和另外一个概念”报警器”的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为”报警器”这个概念的改变(比如:修改alarm方法的参数)而改变,反之依然。

解决方案二:

既然open、close和alarm属于两个不同的概念,根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有:这两个概念都使用abstract
class方式定义;两个概念都使用interface方式定义;一个概念使用abstract
class方式定义,另一个概念使用interface方式定义。

显然,由于Java语言不支持多重继承,所以两个概念都使用abstract
class方式定义是不可行的。后面两种方式都是可行的,但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。

如果两个概念都使用interface方式来定义,那么就反映出两个问题:1、我们可能没有理解清楚问题领域,AlarmDoor在概念本质上到底是Door还是报警器?2、如果我们对于问题领域的理解没有问题,比如:我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的,那么我们在实现时就没有能够正确的揭示我们的设计意图,因为在这两个概念的定义上(均使用interface方式定义)反映不出上述含义。

如果我们对于问题领域的理解是:AlarmDoor在概念本质上是Door,同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢?前面已经说过,abstract
class在Java语言中表示一种继承关系,而继承关系在本质上是”is
a”关系。所以对于Door这个概念,我们应该使用abstarct
class方式来定义。另外,AlarmDoor又具有报警功能,说明它又能够完成报警概念中定义的行为,所以报警概念可以通过interface方式定义。如下所示:

abstract class Door {
abstract void open();
abstract void close();
}
interface Alarm {
void alarm();
}
class AlarmDoor extends Door implements Alarm {
void open() { … }
void close() { … }
void alarm() { … }
}

这种实现方式基本上能够明确的反映出我们对于问题领域的理解,正确的揭示我们的设计意图。其实abstract
class表示的是”is a”关系,interface表示的是”like
a”关系,大家在选择时可以作为一个依据,当然这是建立在对问题领域的理解上的,比如:如果我们认为AlarmDoor在概念本质上是报警器,同时又具有Door的功能,那么上述的定义方式就要反过来了。

结论

abstract
class和interface是Java语言中的两种定义抽象类的方式,它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理,因为它们表现了概念间的不同的关系(虽然都能够实现需求的功能)。这其实也是语言的一种的惯用法,希望读者朋友能够细细体会

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图