java中接口

1、接口的分类

单方法接口

以下是引用片段：

public interface Actionlistener{     public abstract void actionPerformed(ActionEvent event);}

仅且只有一个方法，只有实现了这个接口(重写这个接口中的唯一一个方法)，你才有资格去事件监听器列表里注册(参数为Actionlistener类型)，当事件源变动时，自动调用这个唯一的actionPerformed方法。

标识接口

是没有任何方法和属性的接口。标识接口不对实现它的类有任何语意上的要求，它仅仅表明了实现它的类属于一个特定的类型(传递)。

不推荐过多的使用标识接口。

常量接口

用Java接口来声明一些常量，然后由实现这个接口的类使用这些常量(以前在做画板的时候这么干过)。建议不要模仿这种常量接口的做法。

2、定义接口

    

使用interface来定义一个接口。接口定义同类的定义类似，也是分为接口的声明和接口体，其中接口体由常量定义和方法定义两部分组成。

定义接口的基本格式如下：

[修饰符] interface 接口名 [extends 父接口名列表]{        [public] [static] [final] 常量;   //静态常量        [public] [abstract] 方法;   //抽象方法}

修饰符：可选，用于指定接口的访问权限，可选值为public。如果省略则使用默认的访问权限。
接口名：必选参数，用于指定接口的名称，接口名必须是合法的Java标识符。一般情况下，要求首字母大写。
extends 父接口名列表：可选参数，用于指定要定义的接口继承于哪个父接口。当使用extends关键字时，父接口名为必选参数。

方法：接口中的方法只有定义而没有被实现。

注意：实现接口时，在实现(覆盖)抽象方法时，注意必须要在方法的返回值类型前加public修饰符。如果没有完全实现接口中的方法，那么这个类就只能够是个抽象类，不能创建对象。接口的是实质就是特殊的抽象类。接口没有构造方法。

例如，定义一个用于计算的接口，在该接口中定义了一个常量PI和两个方法，具体代码如下：

public interface CalInterface {    final float PI=3.14159f;//定义用于表示圆周率的常量PI    float getArea(float r);//定义一个用于计算面积的方法getArea()    float getCircumference(float r);//定义一个用于计算周长的方法getCircumference()}

注意：

    与Java的类文件一样，接口文件的文件名必须与接口名相同。

3、实现接口
接口在定义后，就可以在类中实现该接口。在类中实现接口可以使用关键字implements，其基本格式如下：

[修饰符] class <类名> [extends 父类名] [implements 接口列表]{     类成员变量和成员方法；     为接口A中的所有方法编写方法体，实现接口A；     为接口B中的所有方法编写方法体，实现接口B；}

修饰符：可选参数，用于指定类的访问权限，可选值为public、abstract和final。
类名：必选参数，用于指定类的名称，类名必须是合法的Java标识符。一般情况下，要求首字母大写。
extends 父类名：可选参数，用于指定要定义的类继承于哪个父类。当使用extends关键字时，父类名为必选参数。
implements 接口列表：可选参数，用于指定该类实现的是哪些接口。当使用implements关键字时，接口列表为必选参数。当接口列表中存在多个接口名时，各个接口名之间使用逗号分隔。

    在类中实现接口时，方法的名字、返回值类型、参数的个数及类型必须与接口中的完全一致，并且必须实现接口中的所有方法。例如，编写一个名称为Cire的类，该类实现5.7.1节中定义的接口Calculate，具体代码如下：

public class Cire implements CalInterface {    public float getArea(float r)     {        float area=PI*r*r;//计算圆面积并赋值给变量area        return area;//返回计算后的圆面积    }    public float getCircumference(float r)     {        float circumference=2*PI*r;      //计算圆周长并赋值给变量circumference        return circumference;           //返回计算后的圆周长    }    public static void main(String[] args)     {        Cire c = new Cire();        float f = c.getArea(2.0f);        System.out.println(Float.toString(f));    }}

在类的继承中，只能做单重继承，而实现接口时，一次则可以实现多个接口，每个接口间使用逗号“,”分隔。这时就可能出现常量或方法名冲突的情况，解决该问题时，如果常量冲突，则需要明确指定常量的接口，这可以通过“接口名.常量”实现。如果出现方法冲突时，则只要实现一个方法就可以了。下面通过一个具体的实例详细介绍以上问题的解决方法。

Java接口和Java抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以，这大概就是Java抽象类唯一的优点吧，但这个优点非常有用。如果向一个抽象类里加入一个新的具体方法时，那么它所有的子类都一下子都得到了这个新方法，而Java接口做不到这一点，如果向一个Java接口里加入一个新方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每一个类都再实现这个方法才行，这显然是Java接口的缺点。

一个抽象类的实现只能由这个抽象类的子类给出，也就是说，这个实现处在抽象类所定义出的继承的等级结构中，而由于Java语言的单继承性，所以抽象类作为类型定义工具的效能大打折扣。在这一点上，Java接口的优势就出来了，任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型，而一个类可以实现任意多个Java接口，从而这个类就有了多种类型。

不难看出，Java接口是定义混合类型的理想工具，混合类表明一个类不仅仅具有某个主类型的行为，而且具有其他的次要行为。

在语法上，抽象类和接口有着以下不同：

1.abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。 继承抽象类使用的是extends关键字，实现接口使用的是implements关键字，继承写在前面，实现接口写在后面。如果实现多个接口，中间用逗号分隔。例：

public class Main extends JApplet

public class Main implements Runnable

public class Main extends JApplet implements ActionListener

public class Main extends JApplet implements ActionListener, Runnable

2.在abstract class中可以有自己的数据成员，也可以有非abstract的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。

3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。

4.实现接口的类必须实现其中的所有方法，继承自抽象类的子类实现所有的抽象方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

5.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。

6.抽象类中的变量默认具有 friendly权限，其值可以在子类中重新定义，也可以重新赋值。

7.接口中的方法默认都是 public abstract 类型的。

4、接口的意义：

1，接口可以实现多继承。
2，用接口可以实现混合类型（主类型，副类型），java中可以通过接口分出主次类型。主类型使用继承，副类型，使用接口实现。
3，接口进一步深化了标准的思想，接口本身就是一个标准，他起到了降低耦合性的作用，接口可以使方法的定义和实现相分离，也就是将接口的定义者和实现者相分离，接口也可以用于降低模块间或系统间的耦合性。针对接口编程可以屏蔽不同实现间的差异，看到的只是实现好的功能。

接口的使用说明：

接口：定义标准
接口的实现：实现标准
接口的使用：标准的使用

针对接口编程原则，也就是按照标准实现。
先有接口的定义，再有接口使用者，最后把接口的是先对象川入接口的使用者中，接口的使用者会通过接口来调用接口实现者的方法。

接口的定义者定义好了标准，接口的使用者先写好了使用代码，接口的实现者写好实现之后把实现对象传入接口的使用者中。他会回调接口中的方法。这种过程叫做接口的回调。

尽量使用接口类型作为编译时类型，尽量将抽取到的共性行为写在接口中。

用若干个小接口取代一个大接口。（接口隔离原则）

把一个类的功能作成接口，只暴露想暴露的方法，接口隔离原则可以实现更高层次的封装，针对的对象不同，暴露的方法也不同。

实例：

1、接口作为副类型

public class TestEmployee{       public static void main(String[] args){               Employee[] es=new Employee[4];               es[0]=new SalariedEmployee("Liucy",8,5000);               es[1]=new HourlyEmployee("Chenzq",2,40,200);               es[2]=new SalesEmployee("DuBin",8,0.03,80000);               es[3]=new BasePlusSalesEmployee("Winnie",10,0.08,150000,8000);               for(int i=0;i<es.length;i++){                       System.out.println(es[i].getName()+": "+es[i].getSalary(8));               }               //判断对象是否是Plusable对象，可以加班的对象               //强制转成Plusable，计算加班费               double d=0;               for(int i=0;i<es.length;i++){                       if (es[i] instanceof Plusable){                               Plusable p=(Plusable)es[i];                               d+=p.getPlusSalary();                       }               }               System.out.println(d);       }}class Employee{       private String name;       private int month;       public Employee(String name, int month) {               this.name = name;               this.month = month;       }       public String getName() {               return name;       }       //一般员工的共性部分，判断生日       public double getSalary(int month){               if(this.month==month) return 100;               else return 0;       }}interface Plusable{       double getPlusSalary();}class SalariedEmployee extends Employee implements Plusable{       private double salary;       //构造参数设置父类属性       public SalariedEmployee(String name, int month,double salary) {               super(name, month);               this.salary=salary;       }       public double getSalary(int month){               return salary+super.getSalary(month)+getPlusSalary();       }       public double getPlusSalary(){               return 1000;       }}class HourlyEmployee extends Employee{       private double salaryPerHour;       private int hours;       public HourlyEmployee(String name, int month, double salaryPerHour, int hours) {               super(name, month);               this.salaryPerHour = salaryPerHour;               this.hours = hours;       }       public double getSalary(int month){               double r=0;               if (hours>160){                       r=160*this.salaryPerHour+(hours-160)*1.5*this.salaryPerHour;               }               else {                       r=this.hours*this.salaryPerHour;               }               return r+super.getSalary(month);       }}class SalesEmployee extends Employee implements Plusable{       private double rate;       private int sales;       public SalesEmployee(String name, int month, double rate, int sales) {               super(name, month);               this.rate = rate;               this.sales = sales;       }       public double getSalary(int month){               return rate*sales+super.getSalary(month)+getPlusSalary();       }       public double getPlusSalary(){               return 100;       }}class BasePlusSalesEmployee extends SalesEmployee{       private double baseSalary;       public BasePlusSalesEmployee(String name, int month, double rate, int sales, double baseSalary) {               super(name, month, rate, sales);               this.baseSalary = baseSalary;       }       public double getSalary(int month){               return baseSalary+super.getSalary(month);       }}

2. 相当于一个标准,实现解藕合,把接口的使用者与实现者分开

//判断一个数是不是合数,是合数的打印出其质数积的形式// 定义了两个接口// Prime.javapublic interface Prime{       boolean isPrime(int i);}// FenJie.javapublic interface FenJie{       void print(int i);}//  FenJieImpl.java 实现接口 FenJiepublic class FenJieImpl implements FenJie{       Prime p;       public FenJieImpl(Prime p){               this.p=p;       }       public void print(int i){               for(int j=2;j<=i/2;j++){                       if (i%j==0 && p.isPrime(j)){                               int k=i/j;                               if (p.isPrime(k)){                                       System.out.println(j+"*"+k);                               }                               else{                                       System.out.print(j+"*");                                       print(k);                               }                               break;                       }               }       }}//PrimeImpl.java 实现接口Primepublic class PrimeImpl implements Prime{       public boolean isPrime(int i){               for(int j=2;j<i;j++){                       if (i%j==0) return false;               }               return true;       }}// Print.java 使用接口public class Print{       public static void main(String[] args){               Prime p=new PrimeImpl();               FenJie f=new FenJieImpl(p);               MyClass mc=new MyClass(p,f);               mc.business();       }}// 使用接口class MyClass{       Prime p;       FenJie f;       public MyClass(Prime p,FenJie f){               this.p=p;               this.f=f;       }       public void business(){               for(int i=2;i<=100;i++){                       if (!(p.isPrime(i))){                               System.out.print(i+"=");                               f.print(i);                       }               }       }}

3. 接口的回调

// WorldCupCountry.java 定义接口public interface WorldCupCountry{       void kaimushi();       void xiaozusai();       void taotaisai();       void juesai();}// WorldCupCountry.java 实现接口public class USA implements WorldCupCountry{       public void kaimushi(){               System.out.println("德国－玻利维亚");       }       public void xiaozusai(){               System.out.println("沙特黑马");       }       public void taotaisai(){               System.out.println("保加利亚");       }       public void juesai(){               System.out.println("巴西");       }}// Germany.java 实现接口public class Germany implements WorldCupCountry{       public void kaimushi(){               System.out.println("德国－哥斯达黎加");       }       public void xiaozusai(){               System.out.println("强者恒强");       }       public void taotaisai(){               System.out.println("四强全欧");       }       public void juesai(){               System.out.println("意大利");       }}// IFFO.java 使用接口public class FIFA{       public static void main(String[] args){               WorldCupCountry c=new USA();               act(c);       }       public static void act(WorldCupCountry c){               c.kaimushi();               c.xiaozusai();               c.taotaisai();               c.juesai();       }}

程序说明：

java中的根类Object

java中所有的类的父类或直接或间接的或隐含的都是Object类。

java不允许循环继承，也就是互相继承是不可以的。

Object类中的finalize()一个对象被垃圾收集的时候，

Object类中有一个String toString()方法，返回该对象的字符串表示。Object类中的toString()方法他返回的是类名加上他的地址的一个字符串。在子类中推荐覆盖toString()方法。

Object类中的boolean equals(Object o)方法是用来比较对象的内容是否相等，其返回值是boolean类型的值，相同为真，不同则为假。实际上还是比较对象地址是否相同。String类覆盖了equals()方法，他比较是对象中的内容是否相同。子类中也推荐覆盖Object类中继承的equals()方法

equals()的覆盖原则，

自反性 x.equals(x) 为true对称性 y.equals(x) 和 x.equals(y) 的值要相同，要么都为true，要么都为false。传递性 x.equals(y)为true， y.equals(z)也为true ，那么x.equals(z)一定也为true。

覆盖equals()方法的步骤

boolean equals(Object o){if(this==o) return true;//1,看看是不是一个对象if(o==null) return true;//2,看看对象是不是空if(!(o instanceof 本类类名)) return false；//看看是不是本类对象......//根据本类设计。