接口

接口的基本定义：

如果一个类之中只是由抽象方法和全局常量所组成，那么在这种情况下不会将其定义为一个抽象类，而是将其定义为接口，所以所谓的接口严格来讲就属于一个特殊的类，而且这个类里面只有抽象方法和全局常量，连构造都没有。

要定义一个接口使用interface关键字完成。

范例：定义接口

interface A{ //定义了一个A接口
	 public abstract void print();//抽象方法
	 public static final String GOOD="BANG";
}

由于接口里面存在有抽象方法，所以接口对象不可能直接使用关键字new进行实例化的操作，那么所以接口的使用原则如下：

1.接口必须要有子类，但是此时一个子类可以使用implements关键字实现多个接口；

2.接口的子类（如果不是抽象类），那么必须要复写接口中的全部抽象方法；

3.接口的对象可以利用子类对象的向上转型来进行实例化操作；

范例：实现接口

interface A{	//定义了接口
	public static final String MGB="我草";
	 public abstract void fun();
}
interface B{
	 public abstract void fun2();//抽象方法
}
class X implements A,B{	//X实现了A和B两个接口
	  public void fun() {
		  System.out.println("哈哈哈哈哈");
	  }
	  public void fun2() {
		  System.out.println("呵呵呵呵");
	  }
}
public class TestDemo {       
	public static void main(String[] args) {
    	   X  x=new X();//实例化子类对象
    	   A a=x; 	//向上转型
    	   B b=x;	//向上转型
    	   a.fun();
    	   b.fun2();    	 
}   
       }  

上述代码结果分别为"哈哈哈哈哈" 和 "呵呵呵呵"。

以上的代码实例化X类对象。如果说现在由于X是A和B的子类，那么X类的对象可以变为A接口或B接口类的对象，当改为

A a =new X();
B b =(B) a;
  b.fun2();

时其结果为”呵呵呵呵“.当在后面增加如下代码时

          System.out.println(a instanceof A);
          System.out.println(a instanceof B);

其结果均为true。

在定义结构上来讲A和B接口没有任何的直接联系，但是这两个接口却同时拥有一个子类：X子类，不要被其名称和类型所迷糊，因为最终实例化的是X子类，而这个子类属于B类的对象，所以以上代码行得通。只不过从代码编写上来讲并不是很好。

但是要知道一点，对于子类而言除了接口之外，还有可能去继承抽象类，所以如果说一个子类既要继承抽象类又要去实现接口的话，那么请先使用extends继承，而后再使用implements实现。

abstract class C{
	public abstract void change();
}
class X extends C implements A,B{	//X实现了A和B两个接口
	  public void fun() {
		  System.out.println("哈哈哈哈哈");
	  }
	  public void fun2() {
		  System.out.println("呵呵呵呵");
	  }
	  public void change() {
		  System.out.println("C");
	  }
}

接口里面的public static final 和 public abstract修饰可以省略，且无影响。

public abstract void print();    //与 void print()；等价

public static final String MGB="我草";//与 String MGB="我草";等价

在接口里面没有写上public，其最终访问权限也是public ，绝对不是default。

一个抽象类可以去继承一个抽象类，但是一个接口却可以使用extends关键字继承多个接口（但是接口不能继承抽象类）。

范例：观察接口的多继承

interface A{	//定义了接口
	 void funA();
}
interface B{
	 void funB();
}
//C接口同时继承了A和B两个接口
interface C extends A,B{
	 void funC();
}
class X implements C{
	  public void funA() { }
	  public void funB() { }
	  public void funC() { }
}

从继承关系上讲抽象类的限制要比接口多了太多

   一个抽象类只能够继承一个抽象的父类，而接口没有这个限制。

    一个子类只能够继承一个抽象类，而却可以实现多个接口。

在Java中接口的主要功能是解决单继承局限问题，它实现了C++中多重继承的能力。

虽然从接口本身的概念来讲只能够由抽象方法和全局常量组成，但是所有的内部结构是不受到这些要求的限制，也就是说在接口里面可以定义普通内部类，抽象内部类和内部接口。

范例：在接口里定义抽象类

interface A{	//定义了接口
	 void funA();
	   abstract class B{
		 public abstract void fun();
	 }
}
class X implements A{
	  public void funA() { }{
		  System.out.println("-----");
	  }
   class Y extends B{
		public void fun() {}	  
       }
}

范例：在一个接口的内部如果使用static去定义一个内部接口表示是一个外部接口

interface A{	//定义了接口
	 void funA();
     static interface B{
        void  funB();
     }    
}
class X implements A.B{
    public void funB() {}
}

接口在实际的开发之中有三大核心作用：

1.定义不同层之间的操作标准。

2.表示一种操作的能力。

3.表示将服务器端的远程方法视图暴露给客户端。