Java-接口interface定义和使用

1.什么是接口

Java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩容子类能力。

即：Java中使用抽象类/父类表示通用属性时，每个类只能继承一个类，假如子类已经从一个父类继承了，就不能再继续继承另外的父类。但每个类可以实现多个接口，这样子类就拥有了更多的能力。

微观概念：接口是一种能力和约定。

接口的定义：代表了某种能力

方法的定义：能力的具体要求

2.接口的语法

API(应用程序编程接口): Application Program Interface

接口相当于特殊的抽象类，定义方式、组成部分与抽象类类似。

接口的定义语法：

interface 接口名 { }

接口的定义要求：

没有构造方法，不能创建对象

只能定义：公开静态常量、公开抽象方法

public interface MyInterface {

public static final String FIELD = "value";

public abstract void method();

}

//public 关键字仅限用于接口在于其同名文件中被定义

interface MyInterface {

// 公开静态常量(只能): public static final

public static final String A = "hello";

String D = "good"; // public static final 默认隐式存在、修饰

// 公开抽象方法(只能): public abstract

public abstract void method();

void m(); // public abstract 默认隐式存在、修饰

}

接口与抽象类的【相同】：

可编译为字节码文件(.class)

不能创建对象(接口不是类，也没有构造方法)

可以作为引用类型

具备Object类中所定义的方法

接口与抽象类的【不同】：

所有属性都只能且默认是公开静态常量，隐式使用public static final修饰

所有方法都只能且默认是公开抽象方法，隐式使用public abstract修饰

没有构造方法、没有动态/静态代码块

接口的使用语法：

// 增加/赋予1种/多种能力(逗号分隔) [约定]

calss Sub extends Super implements 接口名,接口名 {

@OverRide

public 返回值 method() { ... }

}

3.接口的规范

任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类。

实现接口中抽象方法，访问修饰符必须是public。

4.接口引用

同父类一样，接口也可声明为引用，并指向真实类对象。

注意：

使用接口引用作为方法形参，实现更自然的多态(只关注能力-具备能力的类对象均可传入)

仅可调用接口中所声明的方法，不可调用实现类中独有的方法

可强转回真实类本身类型，进行独有方法调用(注意判断真实类对象 instanceof)

接口引用的应用(伪代码示例-eclipse可编译运行)

/* (可编译通过的伪代码) */

// 使用接口引用作为方法形参，实现更自然的多态(只关注能力-具备能力的类对象均可传入)

public class TestApply {

public static void main(String[] args) {

// 接口应用伪代码

System.out.println("接口应用伪代码");

}

}

abstract class 船 implements 会漂浮的 {

public abstract void 漂浮(); // 子类去覆盖

}

class 小舟 extends 船 {

public void 漂浮() {}

}

class 游艇 extends 船 {

public void 漂浮() {}

}

class 木筏 extends 船 {

public void 漂浮() {}

}

class 纸壳 {}

class 纸壳箱 extends 纸壳 implements 会漂浮的 {

public void 漂浮() {

System.out.println("纸壳箱通过胶带多次山绕，具备了可以承载重量后，漂浮在水面上");

}

}

class 瓶子 {}

class 矿泉水瓶 extends 瓶子 implements 会漂浮的 {

public void 漂浮() { }

}

class 树 {}

class 大木头 extends 树 implements 会漂浮的 {

public void 漂浮() { }

}

class GameTeam {

// public void 过汉江 (船 boat) {

public void 过汉江 (会漂浮的 n) { // 使用接口引用作为方法形参，实现更自然的多态(关注行为、能力)

System.out.println("n可以传入具备 会漂浮的 能力的对象均可-多态");

}

}

interface 会漂浮的 {

public abstract void 漂浮();

}

接口引用指向实现类对象，以及强转回实现类对象

/* interface.java */

// 定义了一种能力：会跑的

interface Runnable {

public abstract void run();

}

// 定义了一种能力：会游的

interface Swimmable {

public abstract void swim();

}

// 定义了一种能力：会爬的

interface Climbable {

void climb();

}

// 定义了一种能力：会飞的

interface Flyable {

void fly();

}

/* TestApplyInterface.java */

public class TestApplyInterface {

public static void main(String[] args) {

Animal a = new Dog(); // 多态：父类引用指向子类对象

// 接口引用指向实现类对象，仅可调用接口中所声明的方法

Runnable r = new Dog(); // 指向一个会跑的xxx

r.run();

r = new Cat();

r.run();

r = new Bus();

r.run();

// 接口引用可强转回类的真实对象，进行独有的属性和方法的调用

if (r instanceof Bus) {

Bus b = (Bus)r;

System.out.println(b.seatNum);

}

}

}

class Animal{

String breed;

int age;

String sex;

public void eat() {}

public void sleep() {}

}

// implements 接口名 ： 增加/赋予一种能力 [约定]

class Dog extends Animal implements Runnable,Swimmable { // 实现--->落地

String furColor;

public void run() {

System.out.println("狗在奔跑...");

}

@Override

public void swim() {

System.out.println("狗在游泳...");

}

}

// implements 接口名,接口名 : 增加/赋予多种能力(逗号分隔) [约定]

class Cat extends Animal implements Runnable,Climbable{

String furColor;

public void run() {

System.out.println("猫在奔跑...");

}

public void climb() {

System.out.println("猫在爬树...");

}

}

class Fish extends Animal{

//public void swim() {}

}

class Bird extends Animal{

//public void fly() {}

}

class Bus implements Runnable{

int seatNum = 50;

@Override

public void run() {

System.out.println("公交车在跑...");

}

}

输出：

狗在奔跑...

猫在奔跑...

公交车在跑...

50