[ Java学习基础 ] Java的抽象类与接口

一、抽象类

1. 抽象类

　　Java语言提供了两种类：一种是具体类；另一种是抽象子类。

2. 抽象类概念：

　　在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

　　由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

　　在[ Java学习基础 ] Java的继承与多态中介绍多态时，使用过几何图形类示例，其中Figure（几何图形）类中有一个onDraw（绘图）方法，Figure有两个子类Ellipse（椭圆形）和Triangle（三角形），Ellipse和Triangle覆盖onDraw方法。

　　作为父类Figure（几何图形）并不知道在实际使用时有多少个子类，目前有椭圆形和三角形，那么不同的用户需求可能会有矩形或圆形等其他几何图形，而onDraw方法只有确定是哪一个子类后才能具体实现。Figure中的onDraw方法不能具体实现，所以只能是一个抽象方法。在Java中具有抽象方法的类称为“抽象类”，Figure是抽象类，其中的onDraw方法是抽象方法。如下图所示类图中Figure是抽象类，Ellipse和Triangle是Figure子类实现Figure的抽象方法onDraw。

Tips：在UML类图抽象类和抽象方法字体是斜体的，如上图所示中的Figure类和onDraw方法都是斜体的。

3. 抽象类声明和实现

设计抽象方法目的就是让子类来实现的，否则抽象方法就没有任何意义，实现抽象类示例代码如下：

 1 //Ellipse.java文件
 2 package com.Kevin;
 3 
 4 //几何图形椭圆形
 5 public class Ellipse extends Figure {
 6 
 7     //绘制几何图形方法
 8     @Override
 9     public void onDraw() {
10         System.out.println("绘制椭圆形...");
11     }
12 }
13 
14 //Triangle.java文件
15 package com.Kevin;
16 
17 //几何图形三角形
18 public class Triangle extends Figure {
19 
20     // 绘制几何图形方法
21     @Override
22     public void onDraw() {
23         System.out.println("绘制三角形...");
24     }
25 }

上述代码声明了两个具体类Ellipse和Triangle，它们实现（覆盖）了抽象类Figure的抽象方法onDraw。

调用代码如下：

//HelloWorld.java文件
package com.Kevin;

public class HelloWorld {

    public static void main(String[] args) {

        // f1变量是父类类型，指向子类实例，发生多态
        Figure f1 = new Triangle();
        f1.onDraw();

        // f2变量是父类类型，指向子类实例，发生多态
        Figure f2 = new Ellipse();
        f2.onDraw();
    }
}

上述代码中实例化两个具体类Triangle和Ellipse，对象f1和f2是Figure引用类型。

声明抽象方法会造成以下两个结果：

如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

Tips:　抽象类不能被实例化,只有具体类才能被实例化。

4. 抽象类总结规定:

抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
构造方法，类方法（用static修饰的方法）不能声明为抽象方法。
抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

二、使用接口

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

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

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

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

1.接口声明和实现

在Java中接口的声明使用的关键字是interface，声明接口Figure示例代码如下：

 1 //Figure.java文件
 2 package com.Kevin;
 3 
 4 public interface Figure {                                 
 5     //接口中静态成员变量
 6     String name = "几何图形";//省略public static final    
 7 
 8     // 绘制几何图形方法
 9     void onDraw();            //省略public                
10 }

代码第4行是声明Figure接口，声明接口使用interface关键字，interface前面的修饰符是public或省略。public是公有访问级别，可以在任何地方访问。省略是默认访问级别，只能在当前包中访问。

代码第6行声明接口中的成员变量，在接口中成员变量都静态成员变量，即省略了public static final修饰符。代码第99行是声明抽象方法，即省略了public关键字。

某个类实现接口时，要在声明时使用implements关键字，当实现多个接口之间用逗号（,）分隔。实现接口时要实现接口中声明的所有方法。

实现接口Figure示例代码如下：

 1 //Ellipse.java文件
 2 package com.Kevin.imp;
 3 
 4 import com.Kevin.Figure;
 5 
 6 //几何图形椭圆形
 7 public class Ellipse implements Figure {
 8 
 9     //绘制几何图形方法
10     @Override
11     public void onDraw() {
12         System.out.println("绘制椭圆形...");
13     }
14 }
15 
16 //Triangle.java文件
17 package com.Kevin.imp;
18 
19 import com.Kevin.Figure;
20 
21 //几何图形三角形
22 public class Triangle implements Figure {
23 
24     // 绘制几何图形方法
25     @Override
26     public void onDraw() {
27         System.out.println("绘制三角形...");
28     }
29 }

上述代码声明了两个具体类Ellipse和Triangle，它们实现了接口Figure中的抽象方法onDraw。

调用代码如下：

 1 //HelloWorld.java文件
 2 import com.Kevin.imp.Ellipse;
 3 import com.Kevin.imp.Triangle;
 4 
 5 public class HelloWorld {
 6 
 7     public static void main(String[] args) {
 8 
 9         // f1变量是父类类型，指向子类实例，发生多态
10         Figure f1 = new Triangle();
11         f1.onDraw();
12         System.out.println(f1.name);         
13         System.out.println(Figure.name);     
14 
15         // f2变量是父类类型，指向子类实例，发生多态
16         Figure f2 = new Ellipse();
17         f2.onDraw();
18     }
19 }

上述代码中实例化两个具体类Triangle和Ellipse，对象f1和f2是Figure接口引用类型。接口Figure中声明了成员变量，它是静态成员变量，代码第12行和第13行是访问name静态变量。

Tips：　接口与抽象类一样都不能被实例化。

2.接口与多继承

　　在C++语言中一个类可以继承多个父类，但这会有潜在的风险，如果两个父类在有相同的方法，那么子类将继承哪一个父类方法呢？这就是C++多继承所导致的冲突问题。

　　在Java中只允许继承一个类，但可实现多个接口。通过实现多个接口方式满足多继承的设计需求。如果多个接口中即便有相同方法，它们也都是抽象的，子类实现它们不会有冲突。如下图所示是多继承类图，其中的有两个接口InterfaceA和InterfaceB，从类图中可以见两个接口中都有一个相同的方法void methodB()。AB实现了这两个接口，继承了Object父类。

接口InterfaceA和InterfaceB代码如下：

 1 //InterfaceA.java文件
 2 package com.Kevin;
 3 
 4 public interface InterfaceA {
 5 
 6     void methodA();
 7 
 8     void methodB();
 9 }
10 
11 //InterfaceB.java文件
12 package com.Kevin;
13 
14 public interface InterfaceB {
15 
16     void methodB();
17 
18     void methodC();
19 }

从代码中可见两个接口都有两个方法，其中方法methodB()完全相同。

实现接口InterfaceA和InterfaceB的AB类代码如下：

 1 //AB.java文件
 2 package com.Kevin.imp;
 3 
 4 import com.Kevin.InterfaceA;
 5 import com.Kevin.InterfaceB;
 6 
 7 public class AB extends Object implements InterfaceA, InterfaceB {    
 8 
 9     @Override
10     public void methodC() {
11     }
12 
13     @Override
14     public void methodA() {
15     }
16 
17     @Override
18     public void methodB() {            
19     }
20 }

在AB类中的代码第18行实现methodB()方法。注意在AB类声明时，实现两个接口，接口之间使用逗号（，）分隔，见代码第7行。

3.接口继承

　　Java语言中允许接口和接口之间继承。由于接口中的方法都是抽象方法，所以继承之后也不需要做什么，因此接口之间的继承要比类之间的继承简单的多。如下图所示，其中InterfaceB继承了InterfaceA，在InterfaceB中还覆盖了InterfaceA中的methodB()方法。ABC是InterfaceB接口的实现类，从下图中可见ABC需要实现InterfaceA和InterfaceB接口中的所有方法。

接口InterfaceA和InterfaceB代码如下：

 1 //InterfaceA.java文件
 2 package com.Kevin;
 3 
 4 public interface InterfaceA {
 5 
 6     void methodA();
 7 
 8     void methodB();
 9 }
10 
11 //InterfaceB.java文件
12 package com.Kevin;
13 
14 public interface InterfaceB extends InterfaceA {
15 
16     @Override
17     void methodB();
18 
19     void methodC();
20 }

InterfaceB继承了InterfaceA，声明时也使用extends关键字。InterfaceB 中的methodB()覆盖了InterfaceA，事实上在接口中覆盖方法，并没有实际意义，因为它们都是抽象的，都是留给子类实现的。

实现接口InterfaceB的ABC类代码如下：

 1 //ABC.java文件
 2 package com.Kevin.imp;
 3 
 4 import com.Kevin.InterfaceB;
 5 
 6 public class ABC implements InterfaceB {
 7 
 8     @Override
 9     public void methodA() {
10     }
11 
12     @Override
13     public void methodB() {
14     }
15 
16     @Override
17     public void methodC() {
18     }
19 }

ABC类实现了接口InterfaceB，事实上是实现InterfaceA和InterfaceB中所有方法，相当于同时实现InterfaceA和InterfaceB接口。

4.标记接口

　　最常用的继承接口是没有包含任何方法的接口。

　　标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

　　标记接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。

例如：java.awt.event 包中的 MouseListener 接口继承的 java.util.EventListener 接口定义如下：

package java.util;
public interface EventListener
{}

没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的：

建立一个公共的父接口：
正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。
向一个类添加数据类型：
这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

三、Java8新特性（默认方法和静态方法）

在Java 8之前，尽管Java语言中接口已经非常优秀了，但相比其他面向对象的语言而言Java接口存在如下不足之处：

不能可选实现方法，接口的方法全部是抽象的，实现接口时必须全部实现接口中方法，哪怕是有些方法并不需要，也必须实现。
没有静态方法。

针对这些问题，Java 8在接口中提供了声明默认方法和静态方法的能力。接口示例代码如下：

 1 //InterfaceA.java文件
 2 package com.Kevin;
 3 
 4 public interface InterfaceA {
 5 
 6     void methodA();
 7 
 8     String methodB();
 9 
10     // 默认方法
11     default int methodC() {
12         return 0;
13     }
14 
15     // 默认方法
16     default String methodD() {
17         return "这是默认方法...";
18     }
19 
20     // 静态方法
21     static double methodE() {
22         return 0.0;
23     }
24 }

在接口InterfaceA中声明了两个抽象方法methodA和methodB，两个默认方法methodC和methodD，还有声明了静态方法methodE。接口中的默认方法类似于类中具体方法，给出了具体实现，只是方法修饰符是default。接口中静态方法类似于类中静态方法。

实现接口示例代码如下：

 1 //ABC.java文件
 2 package com.Kevin.imp;
 3 
 4 import com.Kevin.InterfaceA;
 5 
 6 public class ABC implements InterfaceA {
 7 
 8     @Override
 9     public void methodA() {
10     }
11 
12     @Override
13     public String methodB() {
14         return "实现methodB方法...";
15     }
16 
17     @Override
18     public int methodC() {
19         return 500;
20     }
21 }

实现接口时接口中原有的抽象方法在实现类中必须实现。默认方法可以根据需要有选择实现（覆盖）。静态方法不需要实现，实现类中不能拥有接口中的静态方法。

上述代码中ABC类实现了InterfaceA接口，InterfaceA接口中的两个默认方法ABC只是实现（覆盖）了methodB。

调用代码如下：

 1 //HelloWorld.java文件
 2 package com.Kevin.imp;
 3 
 4 import com.Kevin.InterfaceA;
 5 
 6 public class HelloWorld {
 7 
 8     public static void main(String[] args) {
 9 
10         //声明接口类型，对象是实现类，发生多态
11         InterfaceA abc = new ABC();
12 
13         // 访问实现类methodB方法
14         System.out.println(abc.methodB());
15 
16         // 访问默认方法methodC
17         System.out.println(abc.methodC());               
18 
19         // 访问默认方法methodD
20         System.out.println(abc.methodD());               
21 
22         // 访问InterfaceA静态方法methodE
23         System.out.println(InterfaceA.methodE());        
24     }
25 }

运行结果：

实现methodB方法...
500
这是默认方法...
0.0

从运行结果可见，代码第17行调用默认方法methodC，是调用类AB中的实现。代码第20行调用默认方法methodD，是调用接口InterfaceA中的实现。代码第23行调用接口静态方法，只能通过接口名（InterfaceA）调用，不能通过实现类ABC调用，可以这样理解接口中声明的静态方法与其他实现类没有任何关系。

Tips：学习了接口默认方法后，有些读者还会有这样的疑问，Java 8之后接口可以声明抽象方法和具体方法，这就相当于抽象类一样了吗？在多数情况下接口不能替代抽象类，例如当需要维护一个对象的信息和状态时只能使用抽象类，而接口不行，因为维护一个对象的信息和状态需要存储在实例成员变量中，而接口中不能声明实例成员变量。

四、总结

1 接口与类的相似点：

一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

2 接口与类的区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

3 接口特性：

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

4 接口与抽象类的区别：

抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

5 什么时候使用抽象类和接口

如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

posted @ 2018-04-25 20:56 Kevin.ZhangCG 阅读(849) 评论(0) 编辑收藏举报

刷新页面返回顶部

Kevin_Zhang

[ Java学习基础 ] Java的抽象类与接口

四、总结

公告