java 接口的概念
一:概念
接口是功能的集合。同样可以看做一种数据类型,是比抽象类更为抽象的“类”。
接口描述应该具备的方法,并没有具体的实现。具体实现由接口的实现类(相当于接口的子类来完成)。
好处:
使功能和实现分离,优化了程序设计。
二:语法
使用关键字interface关键字来定义。
定义的接口文件仍然是.java文件。虽然声明的时候使用interface关键字,编译之后仍然是.class
文件。接口我们可以把他看做是一种只包含了功能声明的特殊类。
定义格式:
public interface 接口名字{
抽象方法1(public abstract 返回值类型 方法名字(参数列表);)
抽象方法1(public abstract 返回值类型 方法名字(参数列表);)
抽象方法1(public abstract 返回值类型 方法名字(参数列表);)
.......
}
1 package com.company; 2 3 public interface Myinterface { 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 int myinter(); 14 }
注意:
在接口内的方法,必须是public修饰符,以及为抽象方法(abstract)。
三:接口的实现
我们把实现接口的类叫做接口的实现。
1 package com.company; 2 3 /** 4 * 接口的实现语法: 5 * 使用关键字implements. 6 * 修饰符 类名字 implements 接口名字{ 7 * public 返回值类型 抽象方法的名字{ 8 * 方法体. 9 * } 10 * } 11 * 类的名字 关键字 接口名字 12 * public class Myimple implements Myinterface 13 */ 14 15 16 17 public class Myimple implements Myinterface { 18 public int myinter(){ 19 return 2; 20 }; 21 }
注意:
在接口中默认方法都是抽象的(abstract),不管是否使用public abstract,都一样
抽象的方法重写,修饰符是public 注意访问权限 只能是public.而且是普通方法。(没有abstract,abstract是抽象方法的定义。)
类是接口的实现,类似于类是接口的子类,接口继承。但是实际上类是接口的实现。
如果接口中有多个抽象方法,实现类需要把接口的抽象方法都一一实现。
接口类的中的抽象方法和接口的成员变量访问权限都是public,写和不写都是这个权限,实现类中的方法的权限也必须是public。否则报错!!!
如果一个实现类中并没有实现接口的所有的抽象方法,如果依然是普通类,会报错,普通类需要实现所有的接口的方法,而实现类变为抽象类就不会报错。也就是说
实现部分接口的抽象方法,实现类是抽象类。
接口:
1 package com.company; 2 3 public interface Myinterface { 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 int myinter(); 14 public abstract void myinter1(); 15 }
实现类:
1 public abstract class Myimple implements Myinterface { 2 public int myinter(){ 3 return 2; 4 }; 5 }
调用:
通过初始化实现类对象来调用相应的方法:
1 package com.company; 2 3 public class Mytest { 4 public static void main(String ... arg){ 5 Myimple shixian=new Myimple(); 6 System.out.println(shixian.myinter()); 7 } 8 }
接口的多实现:
类的继承只能单继承,而接口不一样,可以同实现类实现多个接口,这个也是比抽象类更加灵活。
实现类C可以同时实现接口A和B。
接口A:
1 package com.company; 2 3 public interface Myinterface { 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 int myinter(); 14 15 }
接口B:
1 package com.company; 2 3 public interface Myinterfac_b { 4 public abstract int myinter(); 5 }
实现C:
1 public class Myimple implements Myinterface ,Myinterfac_b{ 2 public int myinter(){ 3 return 2; 4 }; 5 }
因为接口A 和B的抽象方法是一样,所以实现类C可以重写一个类即可。
但是前提:
1:重写方法 返回值一样。如果不一样的话,需要分别实现,不能一起实现。
2:如果方法的参数列表不一样。我们可以重载。
接口A:
1 package com.company; 2 3 public interface Myinterface { 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 int myinter(String a); 14 15 }
接口B:
1 package com.company; 2 3 public interface Myinterfac_b { 4 public abstract int myinter(); 5 }
实现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:
1 public interface Myinterface { 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 int myinter(String a); 12 13 }
接口B:
1 package com.company; 2 3 public interface Myinterfac_b { 4 public abstract int myinter(); 5 }
接口C:
1 package com.company; 2 3 public interface Myinter_c extends Myinterfac_b,Myinterface { 4 public abstract double myinter_c(); 5 }
实现:
1 public class Myimple implements Myinter_c{ 2 public int myinter(){ 3 return 2; 4 }; 5 6 @Override 7 public int myinter(String a) { 8 return 3; 9 } 10 public double myinter_c(){ 11 return 4; 12 } 13 }
调用:
1 package com.company; 2 3 public class Mytest { 4 public static void main(String ... arg){ 5 Myimple shixian=new Myimple(); 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 class Person_t { 4 public abstract void eat(); 5 public abstract void sleep(); 6 public String work(){ 7 return "make money"; 8 } 9 }
接口:
1 package com.company; 2 3 public interface Per_in { 4 public abstract void biancheng(); 5 }
实现类和实现抽象类的抽象方法:
1 package com.company; 2 3 4 5 public class Beav extends Person_t implements Per_in { 6 public void eat(){ 7 System.out.println("apple"); 8 } 9 public void sleep(){ 10 System.out.println("sleep at 500"); 11 } 12 public void biancheng(){ 13 System.out.println("java"); 14 } 15 }
调用类:
1 package com.company; 2 3 public class Per_Test { 4 public static void main(String ... args){ 5 Person_t new_Per=new Beav(); 6 new_Per.eat(); 7 new_Per.sleep(); 8 Beav new_be=new Beav(); 9 new_be.biancheng(); 10 } 11 }
注意:
抽象类中不一定只有抽象方法,也可以有普通方法。抽象类通过子类来调用和实现抽象方法和普通方法。
接口只有抽象方法和常量。没有普通方法。
接口需要实现(implements),抽象方法需要继承(extends),抽象是多态实现,而接口是功能和实现分离。
接口也可以这么写 接口 变量 =new 子类的构造器();这是接口的多态。
1 package com.company; 2 3 public class Per_Test { 4 public static void main(String ... args){ 5 Person_t new_Per=new Beav(); 6 new_Per.eat(); 7 new_Per.sleep(); 8 Per_in new_be=new Beav(); 9 new_be.biancheng(); 10 } 11 }
多态是指对象在不同的情形下,对应的类型不同。接口通过实现类来实现多态,类通过继承,子类实现多态。