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.java
public interface Prime{
boolean isPrime(int i);
}

// FenJie.java
public interface FenJie{
void print(int i);
}

// FenJieImpl.java 实现接口 FenJie

public 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 实现接口Prime

public 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；//看看是不是本类对象

......//根据本类设计。