Java里的接口的interface 简单介绍.

怼烎@ 2022-08-24 14:11 214阅读 0赞

这是写给我自己和我这种初学者看的.

Java作为1个强面向对象语言,  基本上所有东西(成员和方法)都是写在class(类)里面的.

但是也存在一种与class平行的东西, 它就是interface , 中文译成接口.  本屌能力有限在这里这能写写Interface的一些语法规则与存在意义.

## 一, 什么是接口    ##

Java里的接口, 就是抽象方法和常量值的集合.

这里的定义相当表面, 就如java里的类是成员和方法的集合一样.

作为1个初学者, 可以简单理解为接口就是一种特殊的抽象类.  区别下面会详细提到.

## 二, Java里接口的定义和语法 ##

interface 的定义跟java有点类似.   大概如下:

**\[public\]  interace interface\_name \[extends <Superinterface\_list>\]\{**

**        //public static final members**

**          .....................**

**       //public abstract methods**

**       .......**

**\}**

下面是1个简单的例子:

interface It_1{ 
    	int i = 10;  //public static final
    
    	//int j;   //error all the members in a interface must be a const member 
    			  //& need assignment
    
    	//public abstract It_1();	  //error,  must without a constructor
    
    	void print(); //public abstract
    }

上面就简单定义了一个接口It\_1. 接下来讲下接口定义的一些关键点:

### 2.1 关于接口前面的修饰符(这里只讨论外部接口) ###

外部interface前面的修饰符有两种:

#### 2.1.1 public修饰接口 ####

接口可以用public修饰, 但是这个接口必须定义在同名字的java文件内.   这种情况下此接口就是所谓的公共接口, 可以被所有类访问.

这也是interface最常见的用法.

#### 2.1.2 没有任何修饰词修饰接口 ####

如果1个接口不是在同名字的java文件内定义的.   那么这个接口前面不能带有任何权限修饰符, 就如上面的例子.  关键字前面没有权限修饰符.

如果架上public 则通不过编译.

这种情况下, 这个接口只能被同1个包内的类访问. 其他类不能访问.

#### 2.1.3 不能用protected ,private 来修饰外部接口 ####

跟外部类一样, 外部接口不能private 和 protected 来修饰.

### 2.1 接口里所有成员都是公共静态常变量成员. ###

也就是说接口里所有成员都是有个修饰组合:   public  static final.

代表了这个成员首先是公共的(所有类都可以访问),   静态的(只属于接口本身),  而且是个常变量(只能而且必须赋值一次).

这个组合可以被省略.

例如上面例子中的

int i = 10; 就相当于  **public static final** int i =10;

但是你写成

**static final** int i =10;

**final** int i = 10;

都是可以通过编译的,  但是i这个成员实际上还是  public static final的, 性质没变.

但是不能用protected 或 private 来修饰成员, 否则编译失败.

### 2.2 接口里所有方法都是公共抽象方法 ###

也就是说接口里的方法都有个修饰词组合: public abstract

跟接口方法一样, 这两个修饰词也可以省略不写.

既然是抽象方法, 则不能包含方法体.

而且接口里不允许存在非抽象的方法, 这个也是接口和抽象类的明显区别之一.

### 2.3 接口里不能定义构造方法 ###

即使这个构造方法是抽象的...

## 三, 接口的实现和继承 ##

由于接口不是类, 所以接口没有实例化这个概念.  而且上面提到过接口类似1个抽象类.

而1个接口是可以继承另1个接口的(extends)

但是java里1个类也不能继承1个接口, 而有1个类似继承的概念,  就叫做实现( implements)

### 3.1 类可以实现接口 ###

看下面的例子:

class It_class1 implements It_1{  //implement an interface
    
    	void f(){
    		//i = 10;  error cannot do assignment for a const member
    		int j = this.i;
    	}
    
    	//void print(){  the signal of authority cannot smaller than super class's(interface)
    	public void print(){ // overwrite an the abstract method.
    
    	}
    }

这个类就实现了上面的接口It\_1.  接下来有几点要注意的.

#### 3.1.1 1个类要实现1个接口, 关键字是implements 而不是extends ####

extends是继承的关键字,  而1个类是不能继承1个接口的.

#### 3.1.2 类里面不能为接口的成员赋值 ####

类继承1个接口的话, 可以使用接口的成员, 但是不能为它们赋值, 因为接口的成员都是常量.

#### 3.1.3 如果1个非抽象类继承1个接口, 则必须重写接口里的所有方法. ####

原因也很简单, 因为接口的方法都是抽象的, 跟1个非抽象类继承1个抽象类一样, 都必须重写继承的所有方法.     非抽象类不允许有抽象方法.

### 3.2 接口的实现(implement)可以多态 ###

也就是说虽然接口不能被实例化, 但是1个接口的引用变量可以指向实现它的类的1个对象.

跟继承的多态类似

下面例子:

public class Interface_1{
    	public static void f(){
    		It_1 a = new It_class1(); // Poly
    		a.print();
    	}
    }

看f()函数,  它定义了 1个接口的引用a,  但是指向了1个类的对象(前提是这个类实现該接口)

并调用了类重写后的方法.

### 3.3 接口可以继承接口 ###

类可以继承类,  而接口也可以继承另1个接口.

下面例子:

package Interface_kng.Extend;
    
    interface Itf_1{
    	int i = 1;
    	void f();
    }
    
    interface Itf_3 extends Itf_1{
    	int j = 3;
    }
    
    class Itf_class1 implements Itf_3{
    	public void f(){ //overwrite
    		System.out.printf("i is %d, j is %d\n", this.i, this.j);
    	}	
    }
    
    public class Interface_3{
    	public static void f(){
    		Itf_class1  a = new Itf_class1();
    		a.f();
    	}
    }

上面定义了2个接口, 其中Itf\_3 继承了 Itf\_1. 所有Itf\_3 具有Itf\_1的所有成员和方法.

后面 类 Itf\_class1 实现了接口Itf\_3, 并重写了Itf\_3继承自 Itf\_1的方法f(), 输出了接口的两个成员值.

### 3.4 1个接口可以同时继承多个接口 ###

跟类的单继承不同, 接口的继承可以是多继承.

看回本文第二节的接口语法定义,  后面的extends 跟的是1个list. 也就暗示了这可能是1个多继承.

下面例子:

interface Itf_1{
            int i = 1;
            void f();
    }
    
    interface Itf_2{
            int k = 2;
            void g();
    }
    
    interface Itf_3 extends Itf_1, Itf_2{
            int j = 3;
    }
    
    class Itf_class2 implements Itf_3{
            public void f(){ //overwrite
                    System.out.printf("i is %d, k is %d, j is %d\n", this.i, this.k, this.j);
            }
    
            public void g(){
    
            }
    }
    
    public class Interface_3{
            public static void f(){
                    Itf_class2  a = new Itf_class2();
                    a.f();
            }
    }

上面的接口Itf\_3 同时继承了接口Itf\_1 和 Itf\_2. 所以Itf\_3 同时具有了两者的成员和方法

接着非抽象了类 Itf\_class2 实现了Itf\_3, 并重写了所有接口方法.

接口的多继承有时也会产生冲突. 下面有两种情况要注意的:

#### 3.2.1  假如1个接口A 继承另外两个接口B和C,  但是接口B,C 有相同名字的成员i ####

这种情况并不影响多继承,   但是当1个类实现了接口A时, 使用成员i时就不能用this.i了.

因为编译器会告诉你成员混扰.   需要告诉编译器你想调用那个成员, 毕竟这个成员是静态的, 前面可以加接口名字前缀.

例子:

interface Itf_1{
    	int i = 1;
    	void f();
    }
    
    interface Itf_2{
    	String i = "abc";
    	int k = 2;
    	void g();
    }
    
    interface Itf_3 extends Itf_1, Itf_2{
    	int j = 3;
    }
    
    
    class Itf_class2 implements Itf_3{
    	public void f(){ //overwrite
    		System.out.printf("i1 is %d, i2 is %s, k is %d, j is %d\n", Itf_1.i, Itf_2.i, this.k, this.j);
    	}	
    
    	public void g(){
    		
    	}
    }

例如上面的成员i, 如果在类中直接调用this.i, 编译失败..

#### 3.2.1  假如1个接口A 继承另外两个接口B和C,  但是接口B,C 有相同名字的方法f(). ####

这里还要分两种情况

**假如这两个方法具有相同的返回类型.**

这样的话则不影响继承.   在实现接口A时直接重写一次f() 就ok了.

编译器会将两个同名方法视为1个方法:

package Interface_kng.Extend;
    
    interface Itf_1{
    	int i = 1;
    	void f();
    }
    
    interface Itf_2{
    	String i = "abc";
    	int k = 2;  //same name with Itf_1
    	void f();   //same name with Itf_1
    	void g();
    }
    
    interface Itf_3 extends Itf_1, Itf_2{
    	int j = 3;
    }
    
    
    class Itf_class2 implements Itf_3{
    	public void f(){ //overwrite
    		System.out.printf("i1 is %d, i2 is %s, k is %d, j is %d\n", Itf_1.i, Itf_2.i, this.k, this.j);
    	}	
    
    	public void g(){
    		
    	}
    }

**假如这两个方法具有不同的返回类型.**

这种情况下就悲剧了,  一个非抽象类无法实现该接口

例如:

interface Itf_1{
    	int i = 1;
    	void f();
    }
    
    interface Itf_2{
    	String i = "abc";
    	int k = 2;  //same name with Itf_1
    	int f();   //same name with Itf_1, but diff return type
    	void g();
    }

原因也很简单, 因为1个非抽象类无法同时重写这两个方法.

**1个类中不允许有两个方法相同名字相同参数而返回值不同啊**.

假如在工作中遇到这种情况怎么办?    除了重构.. 个人建议只能分别用两个类来实现两个接口...

所以在编程中,  为接口的成员和方法命名时最好加上接口的标记..  避免将来可能发生的冲突...

### 3.5 1个类可以同时实现多个接口. ###

这个不难理解, 跟上面那点类似,  不过也可能会出现上面提到的冲突..

interface Itf_1{
    	int i = 1;
    	void f();
    }
    
    interface Itf_2{
    	String i = "abc";
    	int k = 2;  //same name with Itf_1
    	void f();   //same name with Itf_1
    	void g();
    }
    
    class Itf_class1 implements Itf_1, Itf_2{
    	public void f(){ //overwrite
    		System.out.printf("i1 is %d, i2 is %s, k is %d", Itf_1.i, Itf_2.i, this.k);
    	}	
    
    	public void g(){
    		
    	}
    }

### 3.6 1个类可以继承另一个类的同时实现1个或多个接口. ###

这个也不难理解.

但是要把 extends 写在前面,  implements 写在下面

语法:

**class Class\_name** **extends**  **Superclass\_name** ** implements <Superinterface\_list>\{**

**\}**

个人建议, 小心使用, 因为如果超类也实现了1个或多个相同的接口时就可能有冲突了..

## 四, Java接口的功能和意义 ##

说道这个, 很多java教材介绍接口时对会提到 电脑主板内存插槽 和 内存金手指的例子...

但是本人觉得这个例子不是很能体现java接口的意义

本人觉得, java里的接口更像是1个功能包或插件.

而java的类实现1个接口就相当于装备上了这个功能包或插件, 从而具有了这个功能包和插件的功能..