JAVA：接口

转自：http://www.cnblogs.com/zxl-jay/archive/2011/09/24/2189740.html

有所修改

Java中在接口的应用中，要注意一下几点：

<1>接口一般定义的是常量和一些抽象方法。抽象类中可以包含抽象方法，也可以有非抽象方法，但是有抽象方法的类一定是抽象类。抽象方法不能有方法体。

<2>在引用接口时，接口的引用指向实现的对象，尽量定义为接口或父类的引用。这其中有可能用到多态的知识。引用接口用implements。

<3>接口（interface）只能定义抽象方法而且默认为是Public。常量是public static final 修饰的

<4>通过implements来引用接口。例：Class runnrtmp inplements runner.

<5>多个无关类可以实现一个接口，!!!!接口的引用指向实现的对象。

<6>一个类可以实现多个无关的接口（这点和继承要有所区别）

<7>和继承一样，接口与实现类之间存在多态性。

<8>接口可以继承其他的接口，并添加新的属性和抽象方法。

<9>在类中实现接口的方法时必须加上public修饰符

下面通过一个例子来对上面的要点进行下说明

接口的应用1：

 1 interface Runner //定义接口
 2 {
 3         int i=3;
 4         public void start();
 5         void run();
 6         void stop();
 7 }
 8 interface Eater extends Runner //接口间可以继承
 9 {
10         public final static int j=4;
11         void openMouth();
12         void upAndDown();
13         void goIn();
14 }
15 class TT implements Eater //引用接口
16 {
17         public void start()
18         {
19                 System.out.println("---------start()-------");
20         }
21         public void run()
22         {
23                 System.out.println("---------run()-------");
24         }
25         public void stop()
26         {
27                 System.out.println("---------stop()-------");
28         }
29         public void openMouth()
30         {
31                 System.out.println("---------openMouth()-------");
32         }
33         public void upAndDown()
34         {
35                 System.out.println("---------upAndDown()-------");
36         }
37         public void goIn()
38         {
39                 System.out.println("---------goIn()-------");
40         }
41 }
42 public class TestInterface
43 {
44         public static void main(String[] args)
45         {
46                 Runner tt=new TT();//接口的引用指向实现的对象
47                 System.out.println(tt.i);
48                 System.out.println(Runner.i);
49                 tt.start();
50                 Eater ee=new TT();
51                 System.out.println(ee.j);
52                 System.out.println(Eater.j);
53                 ee.start();
54         }
55 }

接口的应用2：

 1 public class TestInterface {
 2         
 3         public static void main(String[] args){
 4                 
 5                 CareAnimalable c = new Worker();
 6                 //Worker w = (Worker)c;
 7                 TestInterface t = new TestInterface();
 8                 t.t(c); //多态
 9 
10                 c = new Farmer();
11                 t.t(c); 
12 
13                 
14         }
15 
16         public void t(CareAnimalable c){//尽量定义为接口或父类的引用
17                 c.feed();
18                 c.play();
19         }
20 }
21 
22 
23 interface CareAnimalable{
24         public void feed();
25         public void play();
26 }
27 
28 class Worker implements CareAnimalable{
29         
30         public void feed(){
31                 System.out.println("-----feed()----");
32         }
33 
34         public void play(){
35                 System.out.println("-----play()----");
36         }
37 }
38 
39 class Farmer implements CareAnimalable{
40         
41         public void feed(){
42                 System.out.println("-----Farmer feed()----");
43         }
44 
45         public void play(){
46                 System.out.println("-----Farmer play()----");
47         }
48 }

接口的应用3：

interface PCI
{
   public void use();
   public void close();
}
class NetCard implements PCI
{
   public void use()
   {
       System.out.println("run NetCard");
    }
   public void close()
   {
       System.out.println("close NetCard");
    }
}
class MainBoard
{
   public void run()
   {
       System.out.println("run MainBoard");
    }
   public void usePCI(PCI p)
   {
       p.use();
       p.close();
    }
}
public class TestMainBoard
{
   public static void main(String[] args)
   {
       MainBoard mb = new MainBoard();
       mb.run();
       mb.usePCI(new NetCard());
    }
}

注意：

接口定义中，数据和方法的默认定义方式为：

数据：public static final 

方法: public abstract 

在类中，重写接口中的方法时，务必加上修饰符public

 

例子：

interface InterA
{
   public static final int OKA = 1;
   public abstract void showA();
}
interface InterB
{
   public abstract void showB();
}
interface InterC extends InterA,InterB//JAVA可支持接口的多继承，但不支持类的多继承
{
   public abstract void showC();
}
interface InterD
{
   public abstract void showD();
}
class TextInter implements InterC,InterD//JAVA可实现接口的多实现
{
   public void showA()
   {
       System.out.println("showA");
    }
    public void showB()
   {
       System.out.println("showB");
    }
    public void showC()
   {
       System.out.println("showC");
    }
    public void showD()
    {
        System.out.println("showD");
    }
}
public class TestInterface
{
   public static void main(String[] args)
   {
       TextInter textInter = new TextInter();
       textInter.showA();
       textInter.showB();
       textInter.showC();
        textInter.showD();
       System.out.println(textInter.OKA);
       System.out.println(TextInter.OKA);
       System.out.println(InterA.OKA);
    }
}