public interface 会飞的 { public void 起飞 (); public void 巡航飞行 (); public void 降落 (); }
接口不能直接使用，必须有对应的实现类
public class 飞机类 implements 会飞的 { // 共性是通过实现接口来表示的 private String name ; // 名称，这是类属的属性，这里可以定义字节类的成员，和接口无关//如果当前类不是抽象类，则必须实现接口中的所有抽象方法 @Override public void 起飞 () { System . out . println ( " 使劲的跑，一抬头就飞起来了 " ); } @Override public void 巡航飞行 () { System . out . println ( " 使劲的烧油 ..." ); } @Override public void 降落 () { System . out . println ( " 我对准 ..." ); } }
通过接口定义变量，使用具体类的实例，进行调用
会飞的 obj = new 飞机类 (); obj . 起飞 (); obj . 巡航飞行 (); obj . 降落 ();
引入接口的目的在于隔离实现
public void 出差 ( 飞机 obj ){} 这种写法当前类和飞机是耦合的，如果需要坐超人出差，则必须修改源代码 public void 出差 ( 会飞的 obj ){} 当前类只是和接口耦合，任何实现了接口的对象都可以作为参数进行传入
使用接口而不是使用具体的类，则可以实现在实现接口的多个具体实现类之间进行更换,例如定义出超人类
什么是接口 在 Java 中不直接支持多继承，因为会出现调用的不确定性，所以 Java 将多继承机制进行改良，在 Java 中变成了多实现。一个类可以实现多个接口，一个接口可以继承多个接口interface IA {} interface IB {} interface IC extends IA , IB {} 正确的，其中 IC 中的方法等于 IA + IB class A implements IA , IB {} IA a = new A (); IB b = new A ();
接口是一种特殊的抽象类，接口只能被abstract或者public修饰
没有构造器方法
public interface IA { public IA (){} // 语法报错 }
没有属性，只能定义常量
public class Test { public static void main ( String [] args ) { System . out . println ( IA . name ); // 常量可以直接使用 System . out . println ( B . name ); // 实现类也可以直接访问常量 } } interface IA { String name = "yanjun" ; // 接口中只能定义常量，不能定义属性，默认限定词 public static final，自定义限定词不能冲突 } class B implements IA {}
可以包含抽象方法，也可以没有抽象方法
接口中的方法只能被public、default、abstract、static修饰
1.一般情况下接口中只定义抽象方法
2.定义的方法默认为公开的抽象方法interface IA2 { int ee (); // 默认 public abstract int ee(); public void pp (); // 方法的限定词可以是 public, abstract, default, static, 前面的 public 可以省略，如果不写默认 public public abstract void cc (); // 这里 abstract 可以省略 , 默认就是 abstract // 在 JDK1.8 中引入特殊关键字 default ，允许提供默认实现 public default void dd (){ // 这个方法的调用必须有实现类 System . out . println ( "dddd...." ); } // 在 JDK1.8 中允许在接口中定义静态方法 public static void ff (){ // 这个静态方法可以通过接口名称直接调用 IA2.ff() System . out . println ( "ffffff" ); } }
抽象方法必须在实现类中提供实现
class A2Impl implements IA2 { // 在实现类中必须实现接口中的所有抽象方法，否则当前 类只能是抽象类 public int ee () { return 0 ; } public void pp () { System . out . println ( "A2Impl...." ); } public void cc () { System . out . println ( "A2Impl....." ); } //dd 方法由于在接口中有默认实现，所以可以不用重新定义，也允许重新定义 }
可以使用default关键字给抽象方法提供默认实现，有默认实现的方法在实现类中可以重新定义，也 可以不重新定义
报错原因：Java中不支持类的多重继承，一个类只能有一个双亲类
接口允许多重继承 一个类在继承另一个类的同时，还可以实现多个接口接口允许多重继承 interface IA1 { public void p1 (); } interface IA2 { public void p2 (); } interface IC extends IA1 , IA2 { public void p3 (); } // 可以继承多个父接口 , 此时 IC 中实际有 3 个抽象方法 类是单根继承 , 不允许继承多个父类
允许一个类实现多个接口,但是每个接口的抽象方法都必须提供实现，否则是抽象类。提供的实现也可以是继承
public class A1 { public void p1 (){} } public class A2 extends A1 implements IA1 , IA2 { public void p2 (){} } public abstract class A3 extends A1 implements IA1 , IA2 {} // 因为 p2 方法没有实现
接口的出现避免了单继承的局限性，这样定义C接口则拥有A+B的所有定义，可以使用A和B接口以及父类D声明变量类型，直接new T。但是约束时，用谁声明变量编译器系统识别就是谁这种类型，也就意味只能调用识别类型中的方法，不能调用其他方法
interface A { public void p1 (); } interface B { public void p2 (); } interface C extends A , B {} class D { public void abc (){} } class T extends D implements C { public void p1 (){} public void p2 (){} } D d = new T (); 这里只能调用 abc 方法，如果使用其他方法则需要进行类型转换 A a = new T (); 这里只能调用 A 接口中声明的方法 p1 B b = new T (); 这里只能调用 B 接口中声明的方法 p2
声明接口的语法
访问修饰符 interface 接口名{ } 一般建议接口名称使用形容词
如果定义public接口，则规则和定义public类一致，要求接口名称和文件名称一致
外部的接口只能使用 public 、默认这两个范围限定词；如果定义内部接口则可以使用 4 大范围限定 词 接口实际上提供了同一的操作界面（方法），如果是 JDK1.8- 版本则一个方法也不实现，等待某类 或某几个类去实现它的方法【接口中的所有方法必须是抽象的】。如果使用的是 JDK1.8+ 允许使用 default 在接口中定义默认实现，这个实现允许在实现类中重新定义覆盖public class Test1 { public static void main ( String [] args ) { IA2 a2 = new A2Impl (); a2 . pp (); } } interface IA2 { default void pp (){ System . out . println ( "this is pp...." ); this . ff (); } void ff (); } class A2Impl implements IA2 { public void ff () { System . out . println ( "this is ff..." ); } }default 默认方法实现使用的限制
public class Test1 { public static void main(String[] args) { IA2 a2 = new A2Impl(); a2.pp(); } } interface IA2 { default void pp() { System.out.println("this is No2 pp...."); } } interface IA3 { default void pp(){ System.out.println("this is No3 pp"); } } class A2Impl implements IA2, IA3 {// 如果 IA2 中有一个 default 实现的方法和 IA3 中 的方法一致，则必须在实现类中重新定义 public void pp() { IA2.super.pp();//调用IA2 接口中的 pp 方法的默认实现 IA3.super.pp(); } }
接口中没有属性，只能定义常量，它提供一些常量，实现它的类可以共享这些常量
接口可以给出访问控制符，用 public 修饰的是公共接口，到处可见；如果定义接口没有范围限定 词，则只能在同包中访问 接口中只能定义常量和抽象方法interface IA { String name = "yanjun" ; // 这里实际上是常量定义，不是属性，它的限定词是 public static final String name="yanjun", 必须在声明的同时进行赋值 } 在接口中不能定义静态块 static {} 接口中不能定义构造器
接口中只能定义公共的抽象方法, 只有在JDK1.8+中可以使用default关键字定义方法实现。接口中 的方法默认是public abstract类型的，而且必须是public abstract类型的。只有在JDK1.8+中可以 使用default关键字定义方法默认实现，同时允许在实现类中覆盖重新定义
接口不能被实例化，只能通过实现类所实现，但是可以用于声明变量的类型。 接口 变量名 =new 实现接口类 () ; 接口没有构造函数 接口中的抽象方法必须在非抽象子类中提供实现，这个实现可以是继承来的interface IA2 { public void pp (); } class A2 { public void pp () { } } class B2 extends A2 implements IA2 { // 这里的 pp 方法的实现是从父类中继承来的 }
一个类实现接口的语法
class 类名称 implements 接口名称 { }
接口抽象方法的默认修饰符为public，在实现接口时必须用public关键字在方法头上说明
interface IA2 { void pp (); } class B2 implements IA2 { void pp () { // 语法报错，因为 IA2 接口中的方法为 public abstract } }
一个接口可以被多个子类实现。一个子类还可以实现多个接口
类实现接口 一个类在实现某接口的抽象方法时，必须使用完全相同的方法头 public 如果一个类实现多接口，用逗号隔开 如果一个类实现了声明相同方法的两个接口，则被多个接口共用 public class Test1 { public static void main(String[] args) { IA2 a2=new B2(); a2.pp(); IA3 a3=new B2(); a3.pp(); } } interface IA2 { void pp(); } interface IA3{ void pp(); } class B2 implements IA2,IA3 { public void pp() { System.out.println("this is B2.pp()"); } }
类在实现接口时可以定义它自己的附加成员，这也是最常见的形式
public class Test1 { public static void main(String[] args) { IA2 a2=new B2(); a2.pp();//这里不能直接调用B2 实现类中的其它方法，如果需要调用则应该进行强制类型转换 ((B2)a2).dd(); } } interface IA2 { void pp(); } class B2 implements IA2 { public void pp() { System.out.println("this is B2.pp()"); } private int age=100; public void pp(int k){ System.out.println("this is pp(int)"); } public void dd(){ System.out.println("this is dd()"); } }
如果一个类不完全实现接口的所有方法，必须把类定义成abstract类型的类，任何继承该类的子类 必须实现该接口
