java 接口的概念

一：概念

接口是功能的集合。同样可以看做一种数据类型，是比抽象类更为抽象的“类”。

接口描述应该具备的方法，并没有具体的实现。具体实现由接口的实现类（相当于接口的子类来完成）。

好处：

使功能和实现分离，优化了程序设计。

二：语法

使用关键字interface关键字来定义。

定义的接口文件仍然是.java文件。虽然声明的时候使用interface关键字，编译之后仍然是.class

文件。接口我们可以把他看做是一种只包含了功能声明的特殊类。

定义格式:

public   interface   接口名字{

抽象方法1（public abstract 返回值类型 方法名字(参数列表);）

　 抽象方法1（public abstract  返回值类型 方法名字(参数列表);）

抽象方法1（public abstract  返回值类型 方法名字(参数列表);）

.......

}

 package com.company;

 public interface Myinterface {
     /**
      *接口定义：
      * 修饰符  interface  接口名字
      * 方法的定义:
      * public abstract  返回值类型 方法名字 (参数列表)
      * 其中 public 修饰符必须是 public  或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.
      * 成员的变量的定义:必须是常量且修饰符为public .
      */
     public static final  int  c=22;
     public abstract int  myinter();
 }

注意：

在接口内的方法，必须是public修饰符，以及为抽象方法（abstract）。

三：接口的实现

我们把实现接口的类叫做接口的实现。

 package com.company;

 /**
  * 接口的实现语法：
  * 使用关键字implements.
  * 修饰符 类名字  implements 接口名字{
  *     public  返回值类型  抽象方法的名字{
  *         方法体.
  *     }
  * }
  *              类的名字   关键字      接口名字
  * public class Myimple  implements Myinterface
  */

 public class Myimple  implements Myinterface {
     public int  myinter(){
         return 2;
     };
 }

注意:

在接口中默认方法都是抽象的（abstract）,不管是否使用public abstract，都一样

抽象的方法重写，修饰符是public  注意访问权限 只能是public.而且是普通方法。（没有abstract，abstract是抽象方法的定义。）

 类是接口的实现，类似于类是接口的子类，接口继承。但是实际上类是接口的实现。

如果接口中有多个抽象方法，实现类需要把接口的抽象方法都一一实现。

接口类的中的抽象方法和接口的成员变量访问权限都是public，写和不写都是这个权限，实现类中的方法的权限也必须是public。否则报错！！！

如果一个实现类中并没有实现接口的所有的抽象方法，如果依然是普通类，会报错，普通类需要实现所有的接口的方法，而实现类变为抽象类就不会报错。也就是说

实现部分接口的抽象方法，实现类是抽象类。

接口:

 package com.company;

 public interface Myinterface {
     /**
      *接口定义：
      * 修饰符  interface  接口名字
      * 方法的定义:
      * public abstract  返回值类型 方法名字 (参数列表)
      * 其中 public 修饰符必须是 public  或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.
      * 成员的变量的定义:必须是常量且修饰符为public .
      */
     public static final  int  c=22;
     public abstract int  myinter();
     public abstract void myinter1();
 } 

实现类:

 public abstract class Myimple  implements Myinterface {
     public int  myinter(){
         return 2;
     };
 }

调用：

通过初始化实现类对象来调用相应的方法：

 package com.company;

 public class Mytest {
     public static void  main(String ... arg){
         Myimple shixian=new Myimple();
         System.out.println(shixian.myinter());
     }
 }

接口的多实现：

类的继承只能单继承，而接口不一样，可以同实现类实现多个接口，这个也是比抽象类更加灵活。

实现类C可以同时实现接口A和B。

接口A：

 package com.company;

 public interface Myinterface {
     /**
      *接口定义：
      * 修饰符  interface  接口名字
      * 方法的定义:
      * public abstract  返回值类型 方法名字 (参数列表)
      * 其中 public 修饰符必须是 public  或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.
      * 成员的变量的定义:必须是常量且修饰符为public .
      */
     public static final  int  c=22;
     public abstract int  myinter();

 }

接口B：

 package com.company;

 public interface Myinterfac_b {
     public abstract int myinter();
 }

实现C：

 public  class Myimple  implements Myinterface ,Myinterfac_b{
     public int  myinter(){
         return 2;
     };
 }

因为接口A 和B的抽象方法是一样，所以实现类C可以重写一个类即可。

但是前提：

1：重写方法 返回值一样。如果不一样的话，需要分别实现，不能一起实现。

2：如果方法的参数列表不一样。我们可以重载。

接口A：

 package com.company;

 public interface Myinterface {
     /**
      *接口定义：
      * 修饰符  interface  接口名字
      * 方法的定义:
      * public abstract  返回值类型 方法名字 (参数列表)
      * 其中 public 修饰符必须是 public  或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.
      * 成员的变量的定义:必须是常量且修饰符为public .
      */
     public static final  int  c=22;
     public abstract int  myinter(String a);

 }

接口B：

 package com.company;

 public interface Myinterfac_b {
     public abstract int myinter();
 }

实现C：

package com.company;

public class Mytest {
    public static void  main(String ... arg){
        Myimple shixian=new Myimple();
        System.out.println(shixian.myinter());
        System.out.println(shixian.myinter("ok"));
    }
}

注意：

决定方法的差异是方法的签名，方法的签名包含方法的名字和参数！

接口的多继承：

接口可以进行多继承，但是最后子接口，在被实现的时候，需要实现所有父接口的抽象方法。也就是说在java中有多继承的概念。

接口A：

 public interface Myinterface {
     /**
      *接口定义：
      * 修饰符  interface  接口名字
      * 方法的定义:
      * public abstract  返回值类型 方法名字 (参数列表)
      * 其中 public 修饰符必须是 public  或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.
      * 成员的变量的定义:必须是常量且修饰符为public .
      */
     public static final  int  c=22;
     public abstract int  myinter(String a);

 }

接口B：

 package com.company;

 public interface Myinterfac_b {
     public abstract int myinter();
 }

接口C：

 package com.company;

 public interface Myinter_c extends Myinterfac_b,Myinterface {
     public abstract double myinter_c();
 }

实现：

 public  class Myimple  implements Myinter_c{
     public int  myinter(){
         return 2;
     };

     @Override
     public int myinter(String a) {
         return 3;
     }
     public double myinter_c(){
         return 4;
     }
 }

调用：

 package com.company;

 public class Mytest {
     public static void  main(String ... arg){
         Myimple shixian=new Myimple();
         System.out.println(shixian.myinter());
         System.out.println(shixian.myinter("ok"));
         System.out.println(shixian.myinter_c());
     }
 }

注意：

最后实现：如果实现的C的接口时候，实现类中需要把各个抽象方法都要一一实现。这叫做接口的多继承。

抽象类和接口的区别：

抽象类：是事务共有的功能，但是功能由于具体的对象的不同导致实现内容不一样。

接口：是事务额外的功能，如果事务想具备这个功能，需要定义相应的接口，由实现类来实现。

人的共有的功能：吃和睡觉。但是每个吃什么和怎么睡觉是不一样的。但都属于人的共有的功能。人是否编程功能，不一定，属于人的额外功能。所以吃和睡是抽象，编程是接口。

抽象类：

 package com.company;

 public abstract class Person_t {
     public abstract void  eat();
     public  abstract void sleep();
     public String work(){
         return "make money";
     }
 }

接口：

 package com.company;

 public interface Per_in {
     public abstract void  biancheng();
 }

实现类和实现抽象类的抽象方法：

 package com.company;

 public class Beav extends  Person_t implements Per_in {
     public void eat(){
         System.out.println("apple");
     }
     public void sleep(){
         System.out.println("sleep at 500");
     }
     public void  biancheng(){
         System.out.println("java");
     }
 }

调用类：

 package com.company;

 public class Per_Test {
     public  static void  main(String ... args){
         Person_t new_Per=new Beav();
         new_Per.eat();
         new_Per.sleep();
         Beav new_be=new Beav();
         new_be.biancheng();
     }
 }

注意：

抽象类中不一定只有抽象方法，也可以有普通方法。抽象类通过子类来调用和实现抽象方法和普通方法。

接口只有抽象方法和常量。没有普通方法。

接口需要实现（implements），抽象方法需要继承（extends），抽象是多态实现，而接口是功能和实现分离。

 接口也可以这么写  接口  变量 =new  子类的构造器();这是接口的多态。

 package com.company;

 public class Per_Test {
     public  static void  main(String ... args){
         Person_t new_Per=new Beav();
         new_Per.eat();
         new_Per.sleep();
         Per_in new_be=new Beav();
         new_be.biancheng();
     }
 }

多态是指对象在不同的情形下，对应的类型不同。接口通过实现类来实现多态，类通过继承，子类实现多态。