java interface实现_java笔记--接口interface与实现implements

格式：

interface{}

接口中的成员修饰符是固定的：

1 成员变量：publica static final

2 成员函数：publica abstract

3 发现接口中的成员都是public的

当一个抽象类的方法都是抽象的时候，这时可以将

该抽象类用另一种形式定义和表示，就是 接口 。

定义接口使用的关键字不是class，是interface。

对于接口当中常见的成员：而且这些成员都有固定的修饰符

1 全局常量：public static final

2 抽象方法，public abstract

interface Demo{

public static final int NUM=4;

public abstract void show1();

public abstract void show2();

}

由此得出结论，接口中的成员都是公共的权限。

类与类之间是继承关系，类与接口之间是实现关系implements。

接口不可以实例化，只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化，否则，这个子类就是一个抽象化。

实现例子：

//定义接口

interface Demo{

public static final int NUM=4;

public abstract void show1();

public abstract void show2();

}

//实现接口的子类并覆盖接口中所有的抽象方法

class DemoImpl implements Demo{

public void show1()

{}

public void show2()

{}

}

//将子类实例化，并调用NUM

public class InterfaceDemo {

public static void main(String[] args) {

DemoImpl d=new DemoImpl();

System.out.println(d.NUM);

System.out.println(DemoImpl.NUM);

System.out.println(Demo.NUM);

}

}

运行：

image.png

接口的出现将“多继承”通过另外一种形式体现出来，即“多实现”。

在java中不直接支持多继承，因为会出现调用的不确定性。所以java将多继承机制进行改良，在java中变成了多实现。

一个类可以实现多个接口。

多实现例子：

interface A{

public void show();

}

interface Z{

public void show();

}

interface M{

public int add(int a,int b);

}

public class MoreIamplements implements A,Z,M//多实现

{

public void show(){

System.out.print(add(1,2));

}

public int add(int a,int b){

return a+b;

}

}

public class InterfaceDemo {

public static void main(String[] args) {

MoreIamplements m=new MoreIamplements();

m.show();

}

运行：

image.png

一个类在继承另一个类的同时，还可以实现多个接口。

一个类在继承另一个类的同时，还可以实现多个接口，接口的出现避免了单继承的局限性：

//接口A,M的代码同上

class Q{

public void method(){

System.out.println("继承");

}

}

public class MoreIamplements extends Q implements A,M//继承先增加功能，多实现再扩展其他功能

{

public void show(){

super.method();

System.out.println("实现");

}

public int add(int a,int b){

return a+b;

}

public class InterfaceDemo {

public static void main(String[] args) {

MoreIamplements m=new MoreIamplements();

m.show();

}

}

运行：

image.png

接口与接口之间可以继承，是继承关系，而且接口可以多继承。原理就是方法体是否有存在。

interface CC{

void show();

}

interface MM{

void show();

}

interface QQ extends CC,MM{

void function();

}

class WW implements QQ{

//因为接口都是抽象的，所以实现要覆盖三个方法。

public void show(){}

public void method(){}

public void function(){}

}

总结：

接口的特点：

1 接口是对外暴露的规则

2 接口是程序的功能扩展

3 接口的出现降低耦合性(联系性)

4 接口可以用来多实现

5 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

6 接口与接口之间可以有继承关系

接口与抽象类的异同点：

相同点：

都是不断向上抽取而来的。

不同点：

1 抽象类需要被继承，而且只能单继承。接口需要被实现，而且可以多实现

2 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。

3 抽象类的继承，是 is a关系，在定义该体系的基本共性内容。接口的实现是 like a关系，在定义额外功能。

abstract class 犬{//基本功能

abstract void 吼叫();

}

//abstract class 导盲//会导盲的不止有导盲犬

interface 导盲{//额外功能

abstract void 导盲();

}

class 导盲犬 extends 犬 implements 导盲{

public void 吼叫(){}

public void 导盲(){}

}

接口的应用：

以笔记本为例，为了扩展笔记本的功能，但日后出现什么功能设备不知道。

定义一个规则，只要日后出现的设备符合这个规则就可以了。

规则在java中就是接口。

interface USB{//暴露的规则

public void open();

public void close();

}

public class BookPC {

public static void main(String[] args) {

useUSB(new UPan());//功能扩展

}

//使用规则

public static void useUSB(USB u){//接口类型的引用，用于接收(或者说指向)接口的子类对象 //这里是多态(后面讲)的使用即USB u=new UPan();

u.open();

u.close();

}

}

//一年后买了个U盘 必须得符合规则

//实现规则

//这些设备和电脑的耦合性降低了

class UPan implements USB{//符合规则

public void open(){

System.out.println("upan open");

}

public void close(){

System.out.print("upan close");

}

}

运行：

image.png