java 接口概念_java 接口的概念

一：概念

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

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

好处：

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

二：语法

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

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

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

定义格式:

public   interface   接口名字{

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

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

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

.......

}

1 packagecom.company;2

3 public interfaceMyinterface {4 /**

5 *接口定义：6 * 修饰符 interface 接口名字7 * 方法的定义:8 * public abstract 返回值类型 方法名字 (参数列表)9 * 其中 public 修饰符必须是 public 或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.10 * 成员的变量的定义:必须是常量且修饰符为public .11 */

12 public static final int c=22;13 public abstract intmyinter();14 }

注意：

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

三：接口的实现

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

1 packagecom.company;2

3 /**

4 * 接口的实现语法：5 * 使用关键字implements.6 * 修饰符 类名字 implements 接口名字{7 * public 返回值类型 抽象方法的名字{8 * 方法体.9 * }10 * }11 * 类的名字 关键字 接口名字12 * public class Myimple implements Myinterface13 */

14

15

16

17 public class Myimple implementsMyinterface {18 public intmyinter(){19 return 2;20 };21 }

注意:

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

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

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

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

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

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

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

接口:

1 packagecom.company;2

3 public interfaceMyinterface {4 /**

5 *接口定义：6 * 修饰符 interface 接口名字7 * 方法的定义:8 * public abstract 返回值类型 方法名字 (参数列表)9 * 其中 public 修饰符必须是 public 或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.10 * 成员的变量的定义:必须是常量且修饰符为public .11 */

12 public static final int c=22;13 public abstract intmyinter();14 public abstract voidmyinter1();15 }

实现类:

1 public abstract class Myimple implementsMyinterface {2 public intmyinter(){3 return 2;4 };5 }

调用：

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

1 packagecom.company;2

3 public classMytest {4 public static voidmain(String ... arg){5 Myimple shixian=newMyimple();6 System.out.println(shixian.myinter());7 }8 }

接口的多实现：

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

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

接口A：

1 packagecom.company;2

3 public interfaceMyinterface {4 /**

5 *接口定义：6 * 修饰符 interface 接口名字7 * 方法的定义:8 * public abstract 返回值类型 方法名字 (参数列表)9 * 其中 public 修饰符必须是 public 或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.10 * 成员的变量的定义:必须是常量且修饰符为public .11 */

12 public static final int c=22;13 public abstract intmyinter();14

15 }

接口B：

1 packagecom.company;2

3 public interfaceMyinterfac_b {4 public abstract intmyinter();5 }

实现C：

1 public class Myimple implementsMyinterface ,Myinterfac_b{2 public intmyinter(){3 return 2;4 };5 }

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

但是前提：

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

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

接口A：

1 packagecom.company;2

3 public interfaceMyinterface {4 /**

5 *接口定义：6 * 修饰符 interface 接口名字7 * 方法的定义:8 * public abstract 返回值类型 方法名字 (参数列表)9 * 其中 public 修饰符必须是 public 或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.10 * 成员的变量的定义:必须是常量且修饰符为public .11 */

12 public static final int c=22;13 public abstract intmyinter(String a);14

15 }

接口B：

1 packagecom.company;2

3 public interfaceMyinterfac_b {4 public abstract intmyinter();5 }

实现C：

packagecom.company;public classMytest {public static voidmain(String ... arg){

Myimple shixian=newMyimple();

System.out.println(shixian.myinter());

System.out.println(shixian.myinter("ok"));

}

}

注意：

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

接口的多继承：

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

接口A：

1 public interfaceMyinterface {2 /**

3 *接口定义：4 * 修饰符 interface 接口名字5 * 方法的定义:6 * public abstract 返回值类型 方法名字 (参数列表)7 * 其中 public 修饰符必须是 public 或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.8 * 成员的变量的定义:必须是常量且修饰符为public .9 */

10 public static final int c=22;11 public abstract intmyinter(String a);12

13 }

接口B：

1 packagecom.company;2

3 public interfaceMyinterfac_b {4 public abstract intmyinter();5 }

接口C：

1 packagecom.company;2

3 public interface Myinter_c extendsMyinterfac_b,Myinterface {4 public abstract doublemyinter_c();5 }

实现：

1 public class Myimple implementsMyinter_c{2 public intmyinter(){3 return 2;4 };5

6 @Override7 public intmyinter(String a) {8 return 3;9 }10 public doublemyinter_c(){11 return 4;12 }13 }

调用：

1 packagecom.company;2

3 public classMytest {4 public static voidmain(String ... arg){5 Myimple shixian=newMyimple();6 System.out.println(shixian.myinter());7 System.out.println(shixian.myinter("ok"));8 System.out.println(shixian.myinter_c());9 }10 }

注意：

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

抽象类和接口的区别：

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

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

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

抽象类：

1 package com.company;2

3 public abstract classPerson_t {4 public abstract voideat();5 public abstract voidsleep();6 publicString work(){7 return "make money";8 }9 }

接口：

1 package com.company;2

3 public interfacePer_in {4 public abstract voidbiancheng();5 }

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

1 package com.company;2

3

4

5 public classBeav extends Person_t implements Per_in {6 public voideat(){7 System.out.println("apple");8 }9 public voidsleep(){10 System.out.println("sleep at 500");11 }12 public voidbiancheng(){13 System.out.println("java");14 }15 }

调用类：

1 package com.company;2

3 public classPer_Test {4 public static voidmain(String ... args){5 Person_t new_Per=newBeav();6 new_Per.eat();7 new_Per.sleep();8 Beav new_be=newBeav();9 new_be.biancheng();10 }11 }

注意：

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

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

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

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

1 package com.company;2

3 public classPer_Test {4 public static voidmain(String ... args){5 Person_t new_Per=newBeav();6 new_Per.eat();7 new_Per.sleep();8 Per_in new_be=new Beav();9 new_be.biancheng();10 }11 }

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