【JavaLearning】接口与抽象类的比较（The comparison of Interface and Abstract Class ）

Love The Way You Lie 2022-08-22 04:45 7阅读 0赞

**【Section one】Abstract**

近来，在学习Java的过程中遇到了一个新的概念（本人有C/C++开发基础）——接口（Interface），这个概念在C++中并不存在，因此，不由得一阵困惑，感觉所谓接口似乎与抽象类有很多共同之处，故，在深入理解并通过编程验证之后，写下这篇文章，浅析Java中接口与抽象类的异同。

**【Section two】**Interface

在Java语言中，接口的官方定义是：接口不是类，而是对类的一组需求的描述，这些类要遵循接口描述的统一格式进行定义。读起来云里雾里的，不接地气。我们先来看一个例子：Java中的一个接口Comparable的定义：

public interface Comparable<T> 
    {
        /**
         * Compares this object with the specified object for order.  Returns a
         * negative integer, zero, or a positive integer as this object is less
         * than, equal to, or greater than the specified object.
         */
        public int compareTo(T o);
    }

注释部分太多，我删掉了一些，Comparable接口里面只定义了一个方法CompareTo(T o)，但并没有实现，我们知道，一个方法要能够被使用，实现是前提，而从接口的定义来看，显然它是不能够使用的。根据注释，Comparable接口可以实现两个对象的比较，根据比较结果返回不同的标记值（正数、负数和零）。

在实际应用中，当我们需要对一个对象数组按照某个域进行排序时，我们就需要对这个域进行比较，如：对100个员工对象按年龄进行排序，我们就需要比较每个员工的年龄；对100个码农按工号进行排序，我们就需要比较这些码农的工号；...

这里有一个特点：这些排序本质上是一样的，因此采用的算法完全可以一样，只是具体的操作对象不同，事实上，Java中对数组元素进行排序采用的都是Arrays类的静态方法Arrays.sort(),根据比较对象的不同，有sort(int\[\] a)、sort(double\[\] a)、sort(byte\[\] a)、sort(Object\[\] a)等诸多重载。int、char、double等基本类型的排序很容易实现，但是，待排序对象为类对象数组时sort(Object\[\] a)就有一个问题：比较什么呢？？？一个对象可能有多个数据域，年龄、工号、薪资、出生日期等，为了保证封装性，这些域一般都是私有的，因此，对其中任何一个域的比较所需的操作都是有差异的，显然，没有一个公共的方法能够覆盖所有这些极为“具体”的操作的需求。即便如此，这些操作的“框架”或者说本质却是一样的。

如上所述，接口的存在极具意义，如Comparable接口，提供了一个compareTo()方法来满足类对象排序中比较的需求。实际中，不同类的对象、同一类不同对象所需比较的域并不一定相同，因此，对于接口来讲，实现compareTo()方法并没有意义，因此，接口提供的不是具体的方法实现，而是一组需求的描述！！！当然，需求的描述主要依靠方法。在具体应用中再将其进行具体实现。

如，我们需要对100员工按薪资进行排序，员工类为Employee，排序依据为员工的私有域salary，排序中需要比较的是员工对象私有域double型数据salary，Employee的定义如下，它需要实现Comparable接口:

1.将Employee类声明为实现Comparable接口，采用关键字implements；

2.对接口中所有的方法进行定义，这里Comparable接口只有一个方法，故定义它即可。

class Employee implements Comparable<Employee>
    {
    	private String name;
    	private int age;
    	private double salary;
    	
    	public Employee(String aname,int aage,double salary)
    	{
    		name=aname;
    		age=aage;
    		this.salary=salary;
    	}
    	public double getSalary()
    	{
    		return salary;
    	}
    	//实现接口中的所有方法，也就是compareTo()方法
    	public int compareTo(Employee other)
    	{
    		return Double.compare(salary, other.salary);
    	}
    }

接下来对100个员工按薪资进行排序：程序中以3个员工为例

public static void main(String[] args) 
    	{
    		Employee[] p=new Employee[3];
    		p[0]=new Employee("Calvin",44,32345.9);
    		p[1]=new Employee("jim",34,45367.9);
    		p[2]=new Employee("Gavin",54,23389.9);
    		Arrays.sort(p);
    		for(Employee e:p)
    		System.out.println(e.getSalary());
    	}

**   输出：**

23389.9  
            32345.9  
            45367.9

对员工薪资进行排序，调用的是Arrays类的静态方法sort(Object\[\] a),表面上看，sort()方法并不知道我们需要排序的是什么，sort()方法的输入仅仅是员工对象数组名p而已，为了解释其中原理，我们来看一下sort()的定义：

public static void sort(Object[] a) {
            Object[] aux = (Object[])a.clone();
            mergeSort(aux, a, 0, a.length, 0);
        }

sort()方法排序采用的是mergeSort算法，这个方法同样属于Arrays类，我们进一步来看这个方法：

private static void mergeSort(Object[] src,
    				  Object[] dest,
    				  int low,
    				  int high,
    				  int off) {
    	int length = high - low;
    
    	// Insertion sort on smallest arrays
            if (length < INSERTIONSORT_THRESHOLD) {
                for (int i=low; i<high; i++)
                    for (int j=i; j>low &&
    			 ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                        swap(dest, j, j-1);
                return;
            }
    
            // Recursively sort halves of dest into src
            int destLow  = low;
            int destHigh = high;
            low  += off;
            high += off;
            int mid = (low + high) >>> 1;
            mergeSort(dest, src, low, mid, -off);
            mergeSort(dest, src, mid, high, -off);
    
            // If list is already sorted, just copy from src to dest.  This is an
            // optimization that results in faster sorts for nearly ordered lists.
            if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
                System.arraycopy(src, low, dest, destLow, length);
                return;
            }
    
            // Merge sorted halves (now in src) into dest
            for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
                if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
                    dest[i] = src[p++];
                else
                    dest[i] = src[q++];
            }
        }

其中有两句：

((Comparable) dest[j-1]).compareTo(dest[j])>0
    ((Comparable)src[mid-1]).compareTo(src[mid]) <= 0

前面分析已经说过，对具体的对象进行排序，即便算法结构完全一样，具体的操作也不可能相同，对员工按薪资进行排序，那么，需要比较的数据就是员工的薪资，因此，sort()方法在排序中也需要对员工的薪资进行比较。如上面两行程序，sort()中调用了Comparable接口的compareTo()方法，由于dest\[\]是Employee类对象，因此，dest\[j-1\].compareTo(dest\[j\])调用的自然是Employee类的public方法compareTo(Employee other)。

**【Section Three】**

到这里，接口的运作方式已经明了了，接口其本质是类的一组“群体性”需求，我们将这组需求以统一的格式进行定义，便成了接口（Interface）。其意义在于，统一的格式为其深入操作提供了便利，如sort()方法中调用compareTo()方法，如果compareTo()方法格式不统一，则，对不同类对象的排序就需要定义不同的sort()方法，这显然是不合理的！！！

鉴于此，我们将类的一组“群体性”需求用接口来描述，从而为一些深入的操作提供统一的格式，从而简化程序的设计。

**【Section four】**

到目前为止，接口的作用和抽象类(Java，C++)的作用都基本一致，抽象类中，我们也只是声明方法而不具体实现，其实现在其子类中完成。其作用也是为一些“群体性”需求提供描述。但是，在Java中，每个类只能扩展于一个父类，而不能多继承，和C++是很不一样的，C++可以实现多继承，也正是这个原因，C++并不需要接口。

**【Section five】**

接口的一些特性：

1、接口不是类，不能用new方法实例化，这和抽象类完全一致；

2、可以声明接口变量，如Comparable temp；抽象类也可以；

3、接口变量必须引用实现了该接口的类对象，temp=new Employee("Jim",32,5000)；

4、抽象类变量必须引用其非抽象子类对象，这个和接口基本一致；

5、接口可以扩展，具有较高通用性接口可以扩展为较高专用性的接口，抽象程度根据实际的应用对象降低；

6、抽象类本身也是通用性极强的需求抽象，可以通过继承来走向专用性；

7、接口中除了可以包含方法外（非静态），还可以包含常量；

8、抽象类可以包含实例域、抽象方法和具体方法，约束不如接口多；

9、一个类可以实现多个接口；

10、一个类只能够继承于一个超类；