1>. 接口是一个特殊的抽象类,里面的常量都是public,static,final的;里面的方法都是public的abstract的。既然都是这样,那么在定义接口时就可以直接省略这些修饰符。例如:

interface  N{   
      int num=3;//默认的是public static final
      int index=4;
      void eat();//默认的是public abstract
      void sleep();
   }


   

2>. 接口不能创建对象,但是可以声明一个接口类型的引用,
        接口存在的意义是被子类实现,用关键字implements
        如果不想让子类也抽象,就要实现接口里面的所有的抽象方法 ,
        实现过程中注意访问权限  。例如:

class E implements N{     
      public void eat(){}//注意这里的public必不可少!!!
      public void sleep(){}
   }
   public class TestInterface{    
       public static void main(String[] args){       
            N n=new E();   
            n.eat();
            n.sleep();    
            System.out.println(n instanceof N);//true
            System.out.println(n instanceof E);//true
       }
   }

   3>.接口和接口之间可以继承,并且接口本身支持多继承,继承了父接口里功能的定义。

interface  AA {    
      void aa1();
      void aa2();
   }                  
   interface BB{   
      void bb1();
   }     
   interface CC extends AA,BB{  
      void cc1();
   }

 

4>. 类可以同时继承一个父类,实现多个接口.     

interface DD{      
      void dd1();
   }     
   abstract class EE{    
      public abstract void ee1();
   }    
   class  FF  extends EE implements DD,CC{   
      public void ee1(){}
      public void dd1(){}   
      public void cc1(){}  
      public void bb1(){}
      public void aa1(){}
      public void aa2(){}
   }   
   public class TestInterface2{    
       public static void main(String[] args){       
           FF f=new FF();  // 一个对象有六种编译时类型
           EE e=f;
           DD d=f;
           CC c=f;
           AA a=f;
           BB b=f;   
           e.ee1(); //但是每种编译时类型可以调用的方法不一样
           d.dd1();
           c.cc1();
           c.aa1();
           c.aa2();
           c.bb1();
           a.aa1();
           a.aa2();
           b.bb1();
       }
   }

5>.接口没有构造方法,不能创建对象

class  FF  extends EE implements DD,CC{//在创建FF对象时会递归的创建EE的对象,而并不创建DD和CC的对象。   
   }


    

6>.接口的作用:
     1>). 实现多继承
        接口是对类的共性进行再次抽象,抽象出类的次要类型
        因为接口是次要类型,所以在类关系里不占一个节点,
        不会破坏类层次关系的树状结构   

abstract class Animal{ 
            public abstract void eat();
        }    
        interface Pet{//Pet接口是对Dog和Cat类的再抽象
            void play();
        }
        class Dog extends Animal implements Pet{ 
            public void eat(){  
                System.out.println("dog eat bone");
            }      
            public void play(){    
                System.out.println("dog play");
            }
        }
        class Cat extends Animal implements Pet{    
           public void eat(){  
                System.out.println("cat eat fish");
            }  
            public void play(){    
                System.out.println("cat play");
            }
        }
        class Tiger extends Animal{  
           public void eat(){  
                System.out.println("tiger eat human");
            }
        }
        public class TestInterface3{    
           public static void main(String[] args){ 
              Animal[] animal=new Animal[3];
              animal[0]=new Dog();
              animal[1]=new Cat();
              animal[2]=new Tiger();
              for(int i=0;i<animal.length;i++){    
                  animal[i].eat();
              }  
              for(int i=0;i<animal.length;i++){    
                  if(animal[i] instanceof Pet){  
                       Pet p=(Pet)animal[i];
                       p.play();
                  }
              }  
            }
         }

     2>). 标准(弱耦合)   
        一个接口就是一个标准。我们利用接口可以将标准的制定者,标准的实现者以及标准的使用者分离开,降低实现者和使用者的耦合。因此,接口是java里一种重要的降低耦合的工具。       
       
        接口可以屏蔽不同实现类的差异,当底层的实现类更换后,不会对上层的使用者产生影响,体现在参数和返回值。
        JDBC其实就是一套最典型的接口,它由“狡猾的”SUN公司制定,而由“可怜的”数据库厂商实现,其中的酸甜苦辣恐怕只有当事人能够体味得到。