一、抽象类
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. 抽象类总结规定:
二、使用接口
接口(英文: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
{}
没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的:
三、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 接口与类的相似点:
2 接口与类的区别:
3 接口特性:
4 接口与抽象类的区别:
5 什么时候使用抽象类和接口