zoukankan html css js c++ java

接口

一、接口的概念

Java接口是一系列方法的声明，是一些方法特征的集合，（如：“人”的“食、宿”问题。）一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

 1  //interface 定义的关键字 ，接口都需要实现类
 2  public interface UserService {
 3      //接口中所有的定义都是抽象的
 4  
 5      //常量    public static final
 6      public static final int age=99;
 7      /*public abstract*/ void add(String name);
 8      void delete(String name);
 9      void updete(String name);
10      void query(String name);
11  
12  }
13  
14  public interface TimeService {
15      void timer();
16  }
17  
18  
19  
20  //抽象类：extends
21  //一个类可以实现接口，imlements接口
22  //实现了接口的类，就需要重写接口中的方法
23  
24  //多继承~利用接口实现多继承~
25  public class UserServiceImp1 implements UserService,TimeService{
26      @Override
27      public void add(String name) {
28  
29      }
30  
31      @Override
32      public void delete(String name) {
33  
34      }
35  
36      @Override
37      public void updete(String name) {
38  
39      }
40  
41      @Override
42      public void query(String name) {
43  
44      }
45  
46      @Override
47      public void timer() {
48  
49      }
50  }

二、接口的使用

1、由于接口里面存在抽象方法，所以接口对象不能直接使用关键字new进行实例化。接口的使用原则如下：（1）接口必须要有子类，但此时一个子类可以使用implements关键字实现多个接口；（2）接口的子类（如果不是抽象类），那么必须要覆写接口中的全部抽象方法； （3）接口的对象可以利用子类对象的向上转型进行实例化。

范例：

 1  package com.wz.interfacedemo;
 2  
 3  interface A{//定义一个接口A
 4  
 5      public static final String MSG = "hello";//全局常量
 6  
 7      public abstract void print();//抽象方法
 8  }
 9  
10  interface B{//定义一个接口B
11  
12      public abstract void get();
13  }
14  
15  class X implements A,B{//X类实现了A和B两个接口
16  
17      @Override
18      public void print() {
19          System.out.println("接口A的抽象方法print()");
20      }
21  
22      @Override
23      public void get() {
24          System.out.println("接口B的抽象方法get()");
25      }
26  
27  }
28  
29  public class TestDemo {
30  
31      public static void main(String[] args){
32  
33          X x = new X();//实例化子类对象
34          A a = x;//向上转型
35          B b = x;//向上转型
36  
37          a.print();
38          b.get();
39      }
40  
41  }

运行结果：

 接口A的抽象方法print()
 接口B的抽象方法get()

以上的代码实例化了X类的对象，由于X类是A和B的子类，那么X类的对象可以变为A接口或者B接口对象。我们把测试主类代码改一下：

 public class TestDemo {
 
     public static void main(String[] args){
 
         A a = new X();
 
         B b = (B) a;
         b.get();
 
     }
 
 }

运行结果：

 接口B的抽象方法get()

好，没任何问题，我们再来做个验证：

 public class TestDemo {
 
     public static void main(String[] args){
 
         A a = new X();
 
         B b = (B) a;
         b.get();
 
         System.out.println(a instanceof A);
         System.out.println(a instanceof B);
 
     }

运行结果：

 接口B的抽象方法get()
 true
 true

我们发现，从定义结构来讲，A和B两个接口没有任何直接联系，但这两个接口却拥有同一个子类。我们不要被类型和名称所迷惑，因为实例化的是X子类，而这个类对象属于B类的对象，所以以上代码可行，只不过从代码的编写规范来讲，并不是很好。

2、对于子类而言，除了实现接口外，还可以继承抽象类。若既要继承抽象类，同时还要实现接口的话，使用一下语法格式：

 class 子类 [extends 父类] [implemetns 接口1,接口2,...] {}1

范例：

 1 interface A{//定义一个接口A
 2 
 3     public static final String MSG = "hello";//全局常量
 4 
 5     public abstract void print();//抽象方法
 6 }
 7 
 8 interface B{//定义一个接口B
 9 
10     public abstract void get();
11 }
12 
13 abstract class C{//定义一个抽象类C
14     public abstract void change();
15 }
16 
17 class X extends C implements A,B{//X类继承C类，并实现了A和B两个接口
18 
19     @Override
20     public void print() {
21         System.out.println("接口A的抽象方法print()");
22     }
23 
24     @Override
25     public void get() {
26         System.out.println("接口B的抽象方法get()");
27     }
28 
29     @Override
30     public void change() {
31         System.out.println("抽象类C的抽象方法change()");
32 
33     }
34 
35 }

对于接口，里面的组成只有抽象方法和全局常量，所以很多时候为了书写简单，可以不用写public abstract 或者public static final。并且，接口中的访问权限只有一种：public，即：定义接口方法和全局常量的时候就算没有写上public，那么最终的访问权限也是public，注意不是default。以下两种写法是完全等价的：

interface A{
    public static final String MSG = "hello";
    public abstract void print();
}

等价于

interface A{
    String MSG = "hello";
    void print();
}

但是，这样会不会带来什么问题呢？如果子类子类中的覆写方法也不是public，我们来看：

package com.wz.interfacedemo;

interface A{

    String MSG = "hello";

    void print();
}

class X implements A{

    void print() {
        System.out.println("接口A的抽象方法print()");
    }

}

public class TestDemo {
    public static void main(String[] args){

        A a = new X();
        a.print();
    }
}

运行结果：

Exception in thread "main" java.lang.IllegalAccessError: com.wz.interfacedemo.X.print()V
    at com.wz.interfacedemo.TestDemo.main(TestDemo.java:22)12

这是因为接口中默认是public修饰，若子类中没用public修饰，则访问权限变严格了，给子类分配的是更低的访问权限。所以，在定义接口的时候强烈建议在抽象方法前加上public ，子类也加上：

interface A{

    String MSG = "hello";

    public void print();
}

class X implements A{

    public void print() {
        System.out.println("接口A的抽象方法print()");
    }

}

3、在Java中，一个抽象类只能继承一个抽象类，但一个接口却可以使用extends关键字同时继承多个接口（但接口不能继承抽象类）。

范例：

interface A{
    public void funA();
}

interface B{
    public void funB();
}

//C接口同时继承了A和B两个接口
interface C extends A,B{//使用的是extends
    public void funC();
}

class X implements C{

    @Override
    public void funA() {


    }

    @Override
    public void funB() {


    }

    @Override
    public void funC() {


    }

}

由此可见，从继承关系来说接口的限制比抽象类少：（1）一个抽象类只能继承一个抽象父类，而接口可以继承多个接口；（2）一个子类只能继承一个抽象类，却可以实现多个接口（在Java中，接口的主要功能是解决单继承局限问题）

4、从接口的概念上来讲，接口只能由抽象方法和全局常量组成，但是内部结构是不受概念限制的，正如抽象类中可以定义抽象内部类一样，在接口中也可以定义普通内部类、抽象内部类和内部接口（但从实际的开发来讲，用户自己去定义内部抽象类或内部接口的时候是比较少见的），范例如下，在接口中定义一个抽象内部类：

interface A{
    public void funA();

    abstract class B{//定义一个抽象内部类
        public abstract void funB();
    }
}

在接口中如果使用了static去定义一个内接口，它表示一个外部接口：

interface A{
    public void funA();

    static interface B{//使用了static，是一个外部接口
        public void funB();
    }
}
class X implements A.B{

    @Override
    public void funB() {

    }

}

三、接口的用法

1、精简程序结构，免除重复定义

比如，有两个及上的的类拥有相同的方法，但是实现功能不一样，就可以定义一个接口，将这个方法提炼出来，在需要使用该方法的类中去实现，就免除了多个类定义系统方法的麻烦。

举例：鸟类和昆虫类都具有飞行的功能，这个功能是相同的，但是其它功能是不同的，在程序实现的过程中，就可以定义一个接口，专门描述飞行。

下图是分别定义鸟类和昆虫类，其都有飞行的方法。

下图定义了接口，其类图如下：

实现代码如下：

 1 interface   Flyanimal{   
 2    void fly();
 3 }
 4 class   Insect {   
 5    int  legnum=6;
 6 }
 7 class  Bird {   
 8   int  legnum=2;
 9   void egg(){};
10 }
11 class Ant extends Insect implements Flyanimal {
12    public void fly(){
13        System.out.println("Ant can  fly");
14    }
15 }
16 class Pigeon extends Bird implements Flyanimal {
17    public void fly(){
18        System.out.println("pigeon  can fly");
19    }
20    public void egg(){
21        System.out.println("pigeon  can lay  eggs ");
22    }
23 }
24 public classInterfaceDemo{
25    public static void main(String args[]){
26      Ant a=new Ant();
27      a.fly();
28      System.out.println("Ant's legs are"+ a.legnum);
29      Pigeon p= new Pigeon();
30     p.fly();
31      p.egg();
32   }
33 }

程序运行结果：

Ant can fly

Ant'slegs are 6

pigeon can fly

pigeon can lay eggs

二、拓展程序功能，应对需求变化。

假设一个学校接待方面的程序，招待不同身份的人的食宿问题，其对应规则如下：

身份	食	宿
学生	食堂	宿舍
教师	教师食堂	学校公寓
学生家长	招待所	招待所

理论上，当然可以对每个不同身份的人各定义一个对应的类，并实现各自的方法，但是观察这写类，可以归纳出其有一个共同的模板，即“人”的“食、宿”问题。这时候，就可以发挥接口的功能了。实现代码如下：

 1 interface Person{
 2     void eat();
 3     void sleep();
 4 }
 5  
 6 class Student implements Person{
 7     public void eat(){
 8        System.out.println("学生去食堂吃饭！");
 9     }
10     public void sleep(){
11        System.out.println("学生回寝室睡觉！");
12     }
13 }
14  
15 class Teacher implements Person{
16     public void eat(){
17        System.out.println("教师去教工餐厅吃饭！");
18     }
19     public void sleep(){
20        System.out.println("教师回学校公寓睡觉！");
21     }
22 }
23  class Parents implements Person{
24     publicvoid eat(){
25        System.out.println("家长去招待所饭馆吃饭！");
26     }
27     public void sleep(){
28        System.out.println("家长回招待所睡觉！");
29     }
30 }
31  
32 public class PersonInterface{
33          public static void main(String[] args)
34          {
35                    Person p=new Student();
36                    p.eat();
37                    p.sleep();
38                    p=new Teacher();
39                    p.eat();
40                    p.sleep();
41                    p=new Parents();
42                    p.eat();
43                    p.sleep();
44          }
45 }

程序执行结果：

学生去食堂吃饭！

学生回寝室睡觉！

教师去教工餐厅吃饭！

教师回学校公寓睡觉！

家长去招待所饭馆吃饭！

家长回招待所睡觉！

现在需要添加一些功能，即现在需要添加“外宾、上级领导”两类角色，并且以后工具需要还要添加相应的身份角色的人进来，此时，只需要根据需要添加“外宾”类、“领导”类，而主类仍然可以拿来就用，无需进行更多的修改。此时就可以显示出接口的作用了。

在上面的程序中添加如下两个类即可。

 1 class Foreign implements Person{
 2     publicvoid eat(){
 3        System.out.println("外宾去酒店吃饭！");
 4     }
 5     public void sleep(){
 6        System.out.println("外宾回酒店睡觉！");
 7     }
 8 }
 9  
10 class Leader implements Person{
11     publicvoid eat(){
12        System.out.println("领导去宾馆吃饭！");
13     }
14     public void sleep(){
15        System.out.println("外宾回宾馆睡觉！");
16     }
17 }

而主函数中用法仍然一样。

下面给出完整的代码：

 1 interfacePerson{
 2     void eat();
 3     void sleep();
 4 }
 5  
 6 class Studentimplements Person{
 7     public void eat(){
 8        System.out.println("学生去食堂吃饭！");
 9     }
10     public void sleep(){
11        System.out.println("学生回寝室睡觉！");
12     }
13 }
14  
15 class Teacherimplements Person{
16     public void eat(){
17        System.out.println("教师去教工餐厅吃饭！");
18     }
19     public void sleep(){
20        System.out.println("教师回学校公寓睡觉！");
21     }
22 }
23  class Parents implements Person{
24     publicvoid eat(){
25        System.out.println("家长去招待所饭馆吃饭！");
26     }
27     public void sleep(){
28        System.out.println("家长回招待所睡觉！");
29     }
30 }
31 class Foreign implements Person{
32     publicvoid eat(){
33        System.out.println("外宾去酒店吃饭！");
34     }
35     public void sleep(){
36        System.out.println("外宾回酒店睡觉！");
37     }
38 }
39  
40 class Leader implements Person{
41     publicvoid eat(){
42        System.out.println("领导去宾馆吃饭！");
43     }
44     public void sleep(){
45        System.out.println("领导回宾馆睡觉！");
46     }
47 }
48  
49 public class PersonInterface{
50          public static void main(String[] args)
51          {
52                    Person p=new Student();
53                    p.eat();
54                    p.sleep();
55                    p=new Teacher();
56                    p.eat();
57                    p.sleep();
58                    p=new Parents();
59                    p.eat();
60                    p.sleep();
61                    p=new Foreign();
62                    p.eat();
63                    p.sleep();
64                    p=new Leader();
65                    p.eat();
66                    p.sleep();
67          }
68 }

程序执行结果：

学生去食堂吃饭！

学生回寝室睡觉！

教师去教工餐厅吃饭！

教师回学校公寓睡觉！

家长去招待所饭馆吃饭！

家长回招待所睡觉！

外宾去酒店吃饭！

外宾回酒店睡觉！

领导去宾馆吃饭！

领导回宾馆睡觉！

举例二：

用来计算每一种交通工具运行1000公里所需的时间，已知每种交通工具的参数都是3个整数A、B、C的表达式。现有两种工具：

Car 和Plane，其中Car 的速度运算公式为：A*B/C

Plane 的速度运算公式为：A+B+C。

如果增加第3种交通工具的时候，比如火车（Train）不必修改以前的任何程序，只需要编写新的交通工具的程序。

import java.lang.*;
 interface Common {
      double runTimer(doublea, double b, double c);
           String getName(); //获取交通工具的名称
}
 
 class Plane implementsCommon  {
      public doublerunTimer(double a, double b, double c)  {
            return (a+ b + c);
      }
           public String getName(){
                   return"Plane";
           }
}
 class Car implements Common {
      public doublerunTimer(double a, double b, double c) {
            return ( a*b/c );
      }
            public String getName(){
                   return"Car";
           }
}
 
public class ComputeTime {
     
      public static void main(Stringargs[])  {
            double A=3;
            double B=5;
            double C=6;
            double v,t;
                            Commond=new Car();
           v=d.runTimer(A,B,C);
            t=1000/v;
           System.out.println(d.getName()+"的平均速度: "+v+" km/h");
           System.out.println(d.getName()+"的运行时间："+t+" 小时");
                            d=newPlane();
                            v=d.runTimer(10,30,40);
                            t=1000/v;
           System.out.println(d.getName()+"的平均速度: "+v+" km/h");
            System.out.println(d.getName()+"的运行时间："+t+" 小时");
      }
}

程序运行结果；

Car的平均速度: 2.5 km/h

Car的运行时间：400.0 小时

Plane的平均速度: 80.0 km/h

Plane的运行时间：12.5 小时

查看全文

相关阅读:
毕设(五)ListView
毕设(四)ListBox
毕设(三)NotifyIcon
hdu 1.2.3
ZOJ 1789 The Suspects
ZOJ 2833 Friendship
git
yum wget rpm
上传绕过
 LAMP 和 LNMP

原文地址：https://www.cnblogs.com/FettersLove/p/13741938.html