Java基础-面向接口（interface）编程

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

一.接口的概念

　　接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的“类”。

　　接口是抽象的一种机制，现实事物的共性抽取成类，将不同类中的同名方法抽象成抽象方法，形成抽象类，对类的成员变量和方法继续抽象的话，就形成接口，接口是类的最高级的抽象机制。接口中只有常量和抽象方法，接口是一种规范，实现一个接口，就需要实现其中的所有抽象方法。

　　接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类（相当于接口的子类）来完成。这样将功能的定义与实现分离，优化了程序设计。请记住：一切事物均为功能，即一切事物均为接口。

二.接口的定义

　　与定义class不同，接口定义时需要使用interface关键字。

　　定义接口所在的仍为".java"文件，虽然声明时使用的为interface关键字编译后仍然会产生“.class”文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。定义格式如下：

1 public interface 接口名{
2         抽象方法1；
3         抽象方法2；
4         抽象方法3；
5 }

　　使用interface代替了原来的class，其它步骤与定义类相同（接口中的方法均为公共访问的抽象方法，接口中无法定义普通的成员变量（成员变量均为常量，需要用关键字fanal修饰）），下面是定义一个接口的案例：

1 /*
2 @author :yinzhengjie
3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
4 EMAIL:y1053419035@qq.com
5 */
6
7 public interface MyInterface {
8     public abstract void function();
9 }

三.类实现接口

1>.类实现接口的格式

　　类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用关键字implements。其它类（实现类）实现接口后，就相当于声明：“我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。格式如下：

1 class 类 implements 接口名{
2      实现接口中的抽象方法；
3 }

2>.接口是功能的集合　　

　　在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。

　　　　a>.接口中定义功能，当需要具有该功能时，可以让类实现该接口，只声明了应该具备该方法，是功能的声明。

　　　　b>.在具体实现类中重写方法，实现功能，是方法的具体实现。

　　于是，通过以上两个动作将功能的声明与实现便分开了，此时请重写思考：类是实现事物的描述，而接口是功能的集合的含义。下面是我定义一个接口并用类去实现的简易代码：

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6
 7 interface MyInterface {
 8     public abstract void function();
 9 }
10
11 class MyInterfaceImpl implements MyInterface{
12     public void function(){
13         System.out.println("实现接口的子类，重写接口抽象方法！");
14     }
15 }
16
17 public class MyInterfaceDemo{
18     public static void main(String[] args){
19         MyInterfaceImpl m = new MyInterfaceImpl();
20         m.function();
21     }
22 }
23
24 /*
25 实现接口的子类，重写接口抽象方法！
26 */

四.接口中的成员变量的特点

1>.接口中成员变量的特点

　　a>.成员变量的特点，即没有变量，都是常量（固定格式：public static final 数据类型变量名 = 值）；

　　b>.注意，public static final 修饰符，在接口的定义中可以省略不写，但是，不写并不等于没有！

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6
 7 interface MyInterface {
 8
 9     public static final int x = 3;
10
11     //注意，public static final 修饰符，在接口的定义中可以省略不写，但是，不写并不等于没有！
12     y = 6;
13 }

2>.接口中成员方法的特点

　　接口中修饰方法的固定格式为：“public abstract 返回值类型方法名（参数列表）”。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6
 7 interface MyInterface {
 8
 9     public static final int x = 3;
10
11     public abstract void show1();
12
13     //public abstract 修饰符是选择性书写，不管你写不写，这个修饰符默认都是存在的！
14     void show2();
15 }
16
17 class MyInterfaceImpl implements MyInterface{
18     public void show1(){
19         System.out.println("show1()...");
20     }
21     public void show2(){
22         System.out.println("show2()...");
23     }
24 }
25
26 public class MyInterfaceDemo{
27     public static void main(String[] args){
28         MyInterfaceImpl m = new MyInterfaceImpl();
29         m.show1();
30         m.show2();
31     }
32 }
33
34 /*
35 以上代码执行结果如下：
36 show1()...
37 show2()...
38 */

3>.实现(implements)类还是一个抽象类

　　接口是不可以创建对象的，子类必须覆盖掉接口所有的抽象方法后，子类才可以实例化。否则子类还是一个抽象类。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6
 7 interface MyInterface {
 8
 9     public abstract int getMax(int[] arr);
10
11     public abstract int getMin(int[] arr);
12
13 }
14
15 class MyInterfaceImpl implements MyInterface{
16     public int getMax(int[] arr){
17         int max = arr[0];
18         for(int i=0;i<arr.length;i++){
19             if(arr[i] > max){
20                 max = arr[i];
21             }
22         }
23         return max;
24     }
25     public int getMin(int[] arr){
26         int min = arr[0];
27         for(int i=0;i<arr.length;i++){
28             if(arr[i] < min){
29                 min = arr[i];
30             }
31         }
32         return min;
33     }
34 }
35
36 public class MyInterfaceDemo{
37     public static void main(String[] args){
38         MyInterfaceImpl m = new MyInterfaceImpl();
39         int[] arr = {1,2,3,4,5,6,7,8};
40         System.out.printf("数组中最大值是：%d,最小值是:%d\n",m.getMax(arr),m.getMin(arr));
41
42     }
43 }
44
45 /*
46 以上代码执行结果如下：
47 数组中最大值是：8,最小值是:1
48 */

五.接口的多实现(implements)

　　接口最重要的体验：解决多继承的弊端，将多继承这种机制在Java中通过多实现完成了。

1>.怎么解决多继承的弊端呢？

　　弊端：多继承时，当多个父类有相同功能时，子类调用会产生不确定性，其实核心原因就是在于多继承父类中功能有主题，而导致调用运行时，不确定运行哪个主体内容。

2>.为什么多实现能解决呢？

　　因为接口中的功能都没有方法体，由子类来明确。我们可以看下面这个案例：

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6
 7 interface A {
 8     public abstract void a();
 9     void d();
10 }
11
12 interface B {
13     public abstract void b();
14     void d();
15 }
16
17 class C implements A,B{
18     public void a(){
19         System.out.println("C.a()");
20     }
21     public void b(){
22         System.out.println("C.b()");
23     }
24     public void d(){
25         System.out.println("C.d()");
26     }
27 }
28
29
30 public class MyInterfaceDemo{
31     public static void main(String[] args){
32         C c = new C();
33         c.a();
34         c.b();
35         c.d();
36
37     }
38 }
39
40 /*
41 以上代码执行结果如下：
42 C.a()
43 C.b()
44 C.d()
45 */

六.类在继承类的同时实现(implements)多接口

　　接口和类之间可以通过实现产生关系，同时也学习了类与类之间可以通过继承产生关系。当一个类已经继承了一个父类，它又不需要扩展额外的功能，这时接口就派上了用场了。子类通过继承父类扩展功能，通过继承扩展的功能都是子类应该具备的基础功能。如果子类想要继续扩展其它类中的功能呢？这时通过实现接口来完成。

　　一个类在继承一个类的同时，还可以实现多个接口，代码如下：

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6
 7 interface A {
 8     public abstract void a();
 9 }
10
11 interface B {
12     public abstract void b();
13 }
14
15 abstract class C{
16     public abstract void d();
17 }
18
19 class D extends C implements A,B{
20     public void a(){
21         System.out.println("D.a()");
22     }
23     public void b(){
24         System.out.println("D.b()");
25     }
26     public void d(){
27         System.out.println("D.d()");
28     }
29 }
30
31
32 public class MyInterfaceDemo{
33     public static void main(String[] args){
34         D d = new D();
35         d.a();
36         d.b();
37         d.d();
38     }
39 }
40
41 /*
42 以上代码执行结果如下：
43 D.a()
44 D.b()
45 D.d()
46 */

七.接口的多继承

　　多个接口之间可以使用extends进行继承，在开发中如果多个接口中存在相同方法，这时若有个类实现了这些接口，那么就要实现接口中的方法，由于接口中的方法是抽象方法，子类实现后也不会发生调用的不确定性。以下是一个接口继承多个接口的案例：

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6
 7 interface A {
 8     public abstract void a();
 9 }
10
11 interface B {
12     public abstract void b();
13 }
14
15 interface C{
16     public abstract void c();
17 }
18
19 interface D extends A,B,C{
20     public abstract void d();
21 }

八.接口在开发中的好处

1>.接口的出现扩展了功能；

2>.接口其实就是暴漏出来的规则；

3>.接口的出现降低了耦合性，即设备与设备之间实现了解耦；

　　接口的出现方便后期使用和维护，一方是在使用接口（如电脑），一方在实现接口（如U盘）。

九.接口和抽象的区别

1>.相同点

　　a>.都位于继承的顶端，用于被其它类实现或继承；

　　b>.都不能直接实例化对象；

　　c>.都包含抽象方法，其子类都必须覆写这些抽象方；

2>.区别

　　a>.抽象类为部分方法提供实现，避免子类重复实现这些方法，提高代码复用性；接口只能包含抽象方法；

　　b>.一个类只能继承一个直接父类（可能是抽象类），却可以实现多个接口；接口弥补了Java的单继承；

　　c>.抽象类是这个事物中应该具备的内容，继承体系是一种“is....a”关系（比如，猫啊，虎啊，蛇啊，猪啊都是动物）；

　　d>.接口是这个事物中的额外内容，继承体系是一种“like...a”关系（就好比猫和蛇是宠物）；

3>.二者的选用

　　a>.优先选用接口，尽量少用抽象类；

　　b>.需要定义子类的行为，又要为子类提供共性功能时才选用抽象类；

Java基础-面向接口（interface）编程相关推荐

基础才是重中之重~再说面向接口的编程
回到目录之前在我的文章中有对接口进行过讲解,但感觉讲的还是不够清晰,不够利针见血,这次我把面向接口的编程里,自认为比较核心的两点说一下: 接口详细介绍请看我的这篇文章基础才是重中之重~为什么C#有 ...
Java基础教程：面向对象编程[2]
Java基础教程:面向对象编程[2] 内容大纲访问修饰符四种访问修饰符 Java中,可以使用访问控制符来保护对类.变量.方法和构造方法的访问.Java 支持 4 种不同的访问权限. default ...
JAVA面向接口的编程思想与具体实现
面向对象设计里有一点大家已基本形成共识,就是面向接口编程,我想大多数人对这个是没有什么觉得需要怀疑的. 问题是在实际的项目开发中我们是怎么体现的呢? 难道就是每一个实现都提供一个接口就 ...
Java中继承和面向接口的编程
继承是面向对象中很重要的概念.如果考虑到Java语言特性,继承分为两种:接口继承和实现继承.这只是技术层面的问题,即便C++中不存在接口的概念,但它的虚基类实际上也相当于接口.对于OO的初学者来说,他 ...
（31）Java基础语法 --接口
目录 1.接口的概述 2.接口的定义格式 3.在接口中定义抽象方法 4.定义接口的实现类 5.接口的使用接口练习 6.接口的特点 7.一个实现类可以同时实现多个接口 8.接口的继承 9.设计提示 ...
大数据 -- java基础8 接口特点和用法
1.接口:interface关键字 (1)语句定义格式: interface 接口名{} (2)接口是如何实现的呢? 接口不能直接实例化,需要一个关键字供其他类实现该接口:im ...
网上购物系统（Task100）——业务逻辑层BLL（面向接口的编程模式）
源代码:13033480群共享 [操作步骤] 一.新建类库IDAL,设置属性,添加引用→项目→Model 二.添加类ICategory.cs和IItem.cs 1.ICategory.cs using ...
Go语言基础之接口(面向对象编程下)
1 接口搜书 198200.com 1.1 接口介绍接口(interface)是Go语言中核心部分,Go语言提供面向接口编程,那么接口是什么? 现实生活中,有许多接口的例子,比如说电子设备上的充电 ...
第24天学习Java的笔记-接口Interface
接口 1.接口概述与生活举例 2.接口的定义基本格式.接口的抽象方法定义及使用接口使用步骤: 1.接口不能直接使用,必须有一个"实现类"来"实现"该接口. 格 ...

Java基础-面向接口（interface）编程

Java基础-面向接口（interface）编程相关推荐

最新文章

热门文章