高级类特性----接口(intertface)

接 口

有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

接口(interface)是抽象方法和常量值的定义的集合。

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

接口定义举例

public interfaceRunner {
　　int id = 1;
　　public void start();
　　public void run();
　　public void stop();
}

 

接口的特点：

　　用 interface 来定义。
　　接口中的所有成员变量都默认是由public static final修饰的。
　　接口中的所有方法都默认是由public abstract修饰的。接口没有构造方法。
　　实现接口的类中必须提供接口中所有方法的具体实现内容。
　　多个无关的类可以实现同一个接口
　　一个类可以实现多个无关的接口
　　与继承关系类似，接口与实现类之间存在多态性
　　接口也可以继承另一个接口，使用extends关键字。

 

定义Java类的语法格式：

　　< modifier> class < name> [extends < superclass>]
　　[implements < interface> [,< interface>] ] {
　　　　< declarations>
　　}

 

接口应用举例

 

public interface Runner {
　　public void start();
　　public void run();
　　public void stop();
}
public class Person implements Runner {
　　public void start() {
　　　　// 准备工作：弯腰、蹬腿、咬牙、瞪眼 // 开跑
　　}
　　public void run() {
　　　　// 摆动手臂
　　　　// 维持直线方向
　　}
　　public void stop() {
　　　　// 减速直至停止、喝水。
　　}
}

 

一个类可以实现多个无关的接口

interface Runner {
　　public void run();
}
interface Swimmer {
　　public double swim();
}
class Animal {
　　public int eat(){
　　　　…
　　}
}
class Person extends Animal implements Runner,Swimmer{
　　public void run() {……}
　　public double swim() {……}
　　public int eat() {……}
}

 

与继承关系类似，接口与实现类之间存在多态性

public class Test {
　　public static void main(String args[]) {
　　　　Test t = new Test();
　　　　Person p = new Person();
　　　　t.m1(p);
　　　　t.m2(p);
　　　　t.m3(p);
　　}
　　public String m1(Runner f) { f.run(); }
　　public void m2(Swimmer s) {s.swim();}
　　public void m3(Animal a) {a.eat();}
}

 

如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类。 接口也可以继承另一个接口，使用extends关键字。

interface MyInterface {
　　String s=“MyInterface”;
　　public void absM1();
}
interface SubInterface extends MyInterface {
　　public void absM2();
}
public class SubAdapter implements SubInterface {
　　public void absM1() {
　　　　System.out.println(“absM1”);
　　}
　　public void absM2() {
　　　　System.out.println(“absM2”);
　　}
}

实现类SubAdapter必须给出接口SubInterface以及父接口MyInterface中所有方法的实现

 

---

 

 

 1 /** 2  * 接口: 抽象方法和常量的集合. 实际上接口更是一种规范! 3  *  4  * 关于接口的提示: 5  *  6  * 1. 实现接口的类中必须提供接口中所有方法的具体实现内容。 若该类为抽象类, 另当别论.  7  * 2. 多个无关的类可以实现同一个接口 8  * 3. 与继承关系类似, 接口与实现类之间存在多态性  9  */10 public class TestInterface {11     public static void main(String[] args) {12     13         System.out.println(Dao.DAO_NAME);14         15         Dao dao = new DaoImpl();16         17         ComparableCircle cc1 = new ComparableCircle(2);//练习题的测试18         ComparableCircle cc2 = new ComparableCircle(7);19         20         System.out.println(cc1.compareTo(cc2)); 21     }22 }23 //1. 用 interface 来定义。24 interface Dao{25     //2. 接口中的所有成员变量都默认是由 public static final 修饰的。 在声明变量时必须直接赋值.26     //常量标识符的书写要求: 字母都大写, 多个单词使用 _ 连接27     String DAO_NAME = "DAONAME";28     29     //3. 接口中的所有方法都默认是由public abstract修饰的。接口没有构造方法。30     void save(Object obj);31     32     Object get();33 }34 35 interface Test{}36 //5. 接口也可以继承另一个接口，使用extends关键字。37 interface Test2 extends Test{}38 39 class BaseDao{}40 41 //4. 实现接口使用 implements 关键字. 若一个类既实现接口, 有继承了父类, 需要把 extends 关键字放在前面,42 //即先继承父类, 后实现多个接口.一个类可以实现多个无关的接口, 若实现多个接口, 使用 , 分割. 43 class DaoImpl extends BaseDao implements Dao, Test{44 45     @Override46     public Object get() {47         return null;48     }49 50     @Override51     public void save(Object obj) {52     }53 }54 55 class DaoImpl2 implements Dao{56 57     @Override58     public void save(Object obj) {59     }60 61     @Override62     public Object get() {63         return null;64     }65 }

 

 

练习

定义一个接口用来实现两个对象的比较。

interface CompareObject {
　　public int compareTo(Object o);
　　//若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
}

 

定义一个Circle类。

 1 public class Circle { 2     protected double radius; 3  4     public double getRadius() { 5         return radius; 6     } 7  8     public void setRadius(double radius) { 9         this.radius = radius;10     }11 12     public Circle(double radius) {13         this.radius = radius;14     }15 }

 

定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口。在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的半径大小。

 1 /** 2  * 定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口。 3  * 在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的半径大小。 4  */ 5 public class ComparableCircle extends Circle implements CompareObject { 6  7     public ComparableCircle(double radius) { 8         super(radius); 9     }10 11     @Override12     public int compareTo(Object o) {13         14         //1. 检验 o 是否为 Circle 类型15         if(o instanceof Circle){16             Circle circle = (Circle) o;17             //2. 比较半径18             return (int)(this.radius - circle.radius);19         }21         return 0;22     }23 }

 

定义一个测试类TestInterface，创建两个ComaparableCircle对象，调用compareTo方法比较两个类的半径大小。

　　ComparableCircle cc1 = new ComparableCircle(3);　　ComparableCircle cc2 = new ComparableCircle(5);         　　System.out.println(cc1.compareTo(cc2));