疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java学习笔记之接口


 

  一、接口的概念与定义

  首先考虑一个简单的接口的定义:

  public interface Output

  {

  int MAX_LINE = 40;

  void out();

  void getData(String msg);

  }

  定义接口使用关键字interface

  修饰符interface前面的public可以省略,如果省略,则采用默认访问控制,即只有在相同包结构的代码才可以访问此接口

  接口不可以有构造方法(区别于类中的构造方法)

  接口里面的所有成员,包括常量、方法等都是public访问权限,所以在定义接口里面的成员时,可以省略访问控制修饰符,非要修饰一下子,也只能用public

  接口里面的属性(即成员变量)只能是常量,而且全部具有public, static, final三种性质,因此,在接口里面,如下两行语句完全等价:

  int MAX_LINE = 40;

  public static final int MAX_LINE = 40;

  接口里面的方法只能是抽象方法,即只声明一下函数类型,名称和参数列表,但是不可以提供具体实现

  二、接口的继承

  考虑如下代码:

  

  1 interface A

  2 {

  3 int PROP_A = 5;

  4 void testA();

  5 }

  6 interface B

  7 {

  8 int PROP_B = 6;

  9 void testB();

  10 }

  11 interface C extends A, B

  12 {

  13 int PROP_C = 7;

  14 void testC();

  15 }

  16

  17 public class myJavaTest

  18 {

  19 public static void main(String[] args)

  20 {

  21 System.out.println(C.PROP_A);

  22 System.out.println(C.PROP_B);

  23 System.out.println(C.PROP_C);

  24

  25 }

  26 }

  复制代码

  输出:

  5

  6

  7

  接口的继承和类的继承不一样,接口支持多继承,多个父接口排在extends关键字之后,多个父接口之间用逗号隔开,如上面11行所示,子接口C继承了父接口A和B

  子接口继承类父接口之后,可以获得它们的成员常量的访问权限。如21 -23行通过子接口C可以访问父接口A,B的成员常量PROP_A和PROP_B

  三、接口的实现和定义

  考虑如下程序:

  

  1 interface Output

  2 {

  3 int MAX_LINE = 4;

  4 void out();

  5 void getData(String msg);

  6 }

  7

  8 interface Product

  9 {

  10 int getProductTime();

  11 }

  12

  13 //实现简单的打印作业

  14 public class Printer implements Output, Product

  15 {

  16 private String[] printData = new String[MAX_LINE];

  17 private int dataNum = 0; // 记录需要打印的作业数

  18

  19 public void out()

  20 {

  21 while (dataNum > 0)

  22 {

  23 System.out.println("打印机打印" + printData[0]);

  24

  25 //把作业队列整体前移一位,并将剩下的作业数减1

  26 System.arraycopy(printData, 1, printData, 0, --dataNum);

  27 }

  28

  29 }

  30

  31 @Override

  32 public int getProductTime() {

  33 // TODO Auto-generated method stub

  34 return 45;

  35 }

  36

  37 @Override

  38 public void getData(String msg)

  39 {

  40 if (dataNum >= MAX_LINE)

  41 {

  42 System.out.println("输出队列已满,添加失败");

  43 }

  44 else

  45 {

  46 //把打印数据添加到队列里,作业数加1

  47 printData[dataNum++] = msg;

  48 }

  49 }

  50 public static void main(String[] args)

  51 {

  52 //创建一个Printer对象,当成Output使用

  53 Output O = new Printer();

  54 O.getData("123");

  55 O.getData("456");

  56 O.getData("789");

  57 O.getData("ABC");

  58 O.getData("def");

  59 O.out();

  60 //创建一个Printer对象,当成Product使用

  61 Product P = new Printer();

  62 System.out.println(P.getProductTime());

  63 }

  64 }

  复制代码

  输出:

  输出队列已满,添加失败

  打印机打印123

  打印机打印456

  打印机打印789

  打印机打印ABC

  45

  接口不能用于实例化,但是接口可以声明引用类型的变量,如53行,接口Output声明了一个引用变量O的类型是Output,61行,接口Product声明了一个引用变量P的类型是Product.

  接口的实现需要用类,通常形式如下:

  [修饰符] class 类名 extends 父类 implements 接口1, 接口2..

  {

  类体部分

  }

  implements是表明这个类实现接口的关键字,一个类可以实现多个接口,多个接口之间用逗号隔开,如上述程序14行所示

  一个类可以继承一个父类,并同时实现多个接口,此时,implements部分必须放在extends部分之后

  一个类声明实现一个或者多个接口之后,则这个类必须完全实现这些接口里所定义的全部抽象方法(抽象方法就是那些只声明而没有实现的方法);否则该类将保留从父接口那里继承的抽象方法,于是该类也必须定义成抽象类。

  上述程序用类Printer实现了Output接口和Product接口,于是,Printer对象既可以赋给Output变量(53行)也可以赋给Product变量(61行),好像Printer类既是Output类的子类,也是Output类的子类,这就是传说中的Java的模拟多继承。