Java接口

LKY030

已于 2023-04-08 19:00:21 修改

阅读量96

点赞数 1

文章标签： java 开发语言

于 2023-04-05 16:56:22 首次发布

本文链接：https://blog.csdn.net/LKY030/article/details/129801277

版权

理解接口：

根据课本学习接口的时候，课本上先给出了接口的相关语法，等我把语法学得七七八八了再来给我谈接口的概念和作用，导致我一开始学习接口的时候总是不太能理解接口的作用。这里提到书中的一个例子，假如轿车、货车、拖拉机、摩托车、客车都是机动车的子类，其中机动车是一个抽象类（abstract类相关语法在下面给出补充吧，就不另写一篇文章了）。假设机动车有两个抽象方法：“收取费用”以及“调节温度”，那么上述所有的子类都应该能实现这两种方法，也就是给出方法体，但是飞机和轮船需要有收费和调节温度功能可以理解，拖拉机可能就不需要这两个功能了。接口只关心功能而不会在意功能的具体实现过程，如客车类实现一个接口，这个接口有一个收取费用的方法，那么在这个客车类中你就要定义一个方法实现收费，给出客车中具体收费的方法，不同车都可以实现收费，但收费的手段可能不同。我个人的理解就是，你实现一个功能需要一种方法，但是这些方法藏在很多类里面，你需要一个东西来汇聚所有有这一种功能（方法）的类，然后这个东西就是接口。

接口的声明与使用：

接口的定义和类的定义很类似，分为接口的声明和接口体。

(1)接口声明

接口通过关键字interface来声明，格式：interface 接口的名字

(2)接口体

接口体中包含常量定义和方法定义两个部分，接口体中只进行方法的声明，不提供方法的实现，所以方法定义没有方法体，也就是说接口中方法都是abstract方法（默认public abstract），这里注意区别接口和abstract类，后者中可以有abstract方法也可以有实例方法。

eg.

interface Printable{
    finall int MAX=100;
    void add();
    float sum(float x,float y);
}

(3)接口的使用

一个类通过关键字implements来声明自己使用一个或多个接口。

eg.

class A implements Printable,Addable

要注意的是，如果一个类使用了某个接口，那么这个类必须实现这个接口的所有方法，同时在类中实现接口的方法时，方法的名字、返回类型、参数格类型及个数必须与接口中的完全一致。

此外，接口中的常量默认是public static常量，接口中的方法默认是public abstract方法，所以类在实现接口方法时必须用public修饰。

接口继承的时候一定一定记得方法加public，不然默认友好降低访问权限，然后继承的时候方法参数类型要一样，名字可以不一样。(错过了，特意来强调一下)

因为接口体中只有常量定义和public的abstract方法定义，在编写程序时，允许省略常量前的public、final和static，也允许省略方法前面的public和abstract。

类实现的接口方法以及接口中的的常量可以被类的对象调用，而且常量也可以用类名或者接口名直接调用。

接口声明时interface前加上public则称为public接口且可以被任何一个类使用，如果不加public则被称为友好接口类，只能被同一个包中的类使用。

接口也可以被继承，即通过关键字extend声明一个接口是另一个接口的子接口。同时由于接口中的方法和常量都是public的，子接口将继承父接口中的全部方法和常量。

eg.

package ceshi;

interface Computable {
	int Max = 100;

	int f(int x);
}

class China implements Computable {
	int number;

	public int f(int x) {
		int sum = 0;
		for (int i = 1; i <= x; i++) {
			sum = sum + i;
		}
		return sum;
	}
}

class Japan implements Computable {
	int number;

	public int f(int x) {
		return 44 + x;
	}
}

public class ceshi {
	public static void main(String args[]) {
		China zhang;
		Japan henlu;
		zhang = new China();
		henlu = new Japan();
		zhang.number = 991898 + Computable.Max;
		henlu.number = 991448 + Computable.Max;
		System.out.println("number:" + zhang.number + "求和" + zhang.f(100));
		System.out.println("number:" + henlu.number + "求和" + henlu.f(100));
	}
}

运行结果：。

如果一个类声明实现一个接口，但没有实现接口中的所有方法，那么这个类必须是abstract类。

eg.

interface Computable{
    final int MAX=100;
    void speak(String s);
    int f(int x);
}
abstract class A implements Computable{
    public int f(int x){
        int sum=0;
        for(int i=1;i<=x;i++){
            sum=sum+i
        }
    return sum;
    }
}

abstract类为什么可以不实现接口中的所有方法呢？我个人的理解是abstract类是不能创建对象的，他的所有方法必须交由子类继承后再创建对象实现，所以接口的方法也应该是被继承上述abstract类的子类所实现。

接口回调：

接口回调指把实现某一接口的类创建的对象引用赋给该接口声明的接口变量中。那么该接口变量就可以调用被类实现的接口中的方法。实际上，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法。下面的例子一看就懂：

package ceshi;

interface ShowMessage {
	void 显示商标(String s);
}

class TV implements ShowMessage {
	public void 显示商标(String s) {
		System.out.println(s);
	}
}

class PC implements ShowMessage {
	public void 显示商标(String s) {
		System.out.println(s);
	}
}

public class ceshi {
	public static void main(String args[]) {
		ShowMessage sm;//声明接口变量
		sm = new TV();//接口变量中存放对象的引用
		sm.显示商标("长城牌电视机");//接口回调
		sm = new PC();//接口变量中存放对象的引用
		sm.显示商标("联想5008PC");//接口回调
	}
}

运行结果:

接口做参数：

如果一个方法的参数是接口类型，就可以将任何实现该接口类的实例的引用传递给该接口参数，那么接口参数就可以回调类实现的接口方法，下面的例子中KindHello类中的lookHello方法的参数是接口类型：

package ceshi;

interface SpeakHello {
	void speakHello();
}

class Chinese implements SpeakHello {
	public void speakHello() {
		System.out.println("中国人习惯问候语：你好，吃饭了吗？");
	}
}

class English implements SpeakHello {
	public void speakHello() {
		System.out.println("英国人习惯问候语：你好，天气不错");
	}
}

class KindHello {
	public void lookHello(SpeakHello hello) {// 接口类型参数
		hello.speakHello();//接口回调
	}
}

public class ceshi {
	public static void main(String args[]) {
		KindHello kindHello = new KindHello();
		kindHello.lookHello(new Chinese());
		kindHello.lookHello(new English());
	}
}

运行结果：

abstract类和abstract方法：

用关键字abstract修饰的类称为抽象类，如

abstract class A{

...

}

abstract类有如下几个特点：

1.abstract类中可以有abstract方法，而abstract方法是只允许声明不允许实现的方法，所以这种方法只有方法声明没有方法体。（要注意的是并不是说abstract类中只能有abstract方法，它也可以没有抽象方法。）并且不允许用final修饰abstract方法，这个也很好理解，abstract方法要由这个类的子类实现，用final修饰就没有子类了。

2.abstract类不能用new运算符创建对象，而是需要产生子类由子类创建对象，如果一个类是abstract类的子类，那么它必须具体实现父类的abstract方法。