javase面向对象编程06

接口
需求：需要飞到北京出差
飞机、鸟和超人不能归于一个类属，但是具备有相同的特性：会飞的。所以引入了一个新概念叫做接口，可以用于规范实现接口的类中必须实现接口中抽象方法。接口可以理解为一种契约
使用关键字interface定义接口
接口不能直接使用，必须有对应的实现类
通过接口定义变量，使用具体类的实例，进行调用
引入接口的目的在于隔离实现
使用接口而不是使用具体的类，则可以实现在实现接口的多个具体实现类之间进行更换,例如定义出超人类
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中变成了多实现。一个类可以实现多个接口，一个接口可以继承多个接口
接口是一种特殊的抽象类，接口只能被abstract或者public修饰
没有构造器方法
没有属性，只能定义常量
可以包含抽象方法，也可以没有抽象方法
接口中的方法只能被public、default、abstract、static修饰
一般情况下接口中只定义抽象方法
定义的方法默认为公开的抽象方法
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();
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{}
interface IA1 {
}// 这个接口中没有包含任何抽象方法
class A1Impl implements IA1 {
}
interface IA2{
int ee();//默认public abstract int ee();
public void pp();//方法的限定词可以是public, abstract, default,
static,前面的public可以省略，如果不写默认public
public abstract void cc();//这里abstract可以省略,默认就是abstract
抽象方法必须在实现类中提供实现
可以使用default关键字给抽象方法提供默认实现，有默认实现的方法在实现类中可以重新定义，也
可以不重新定义
报错原因：Java中不支持类的多重继承，一个类只能有一个双亲类
接口允许多重继承
一个类在继承另一个类的同时，还可以实现多个接口
允许一个类实现多个接口,但是每个接口的抽象方法都必须提供实现，否则是抽象类。提供的实现也可以是继承
//在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方法由于在接口中有默认实现，所以可以不用重新定义，也允许重新定义
}
接口允许多重继承
interface IA1{
public void p1();
}
interface IA2{
public void p2();
}
interface IC extends IA1,IA2{
public void p3();
}//可以继承多个父接口,此时IC中实际有3个抽象方法
类是单根继承,不允许继承多个父类
接口的出现避免了单继承的局限性，这样定义C接口则拥有A+B的所有定义，可以使用A和B接口以及父类D声明变量类型，直接new T。但是约束时，用谁声明变量编译器系统识别就是谁这种类型，也就意味只能调用识别类型中的方法，不能调用其他方法
声明接口的语法
如果定义public接口，则规则和定义public类一致，要求接口名称和文件名称一致
外部的接口只能使用public、默认这两个范围限定词；如果定义内部接口则可以使用4大范围限定词
接口实际上提供了同一的操作界面（方法），如果是JDK1.8-版本则一个方法也不实现，等待某类或某几个类去实现它的方法【接口中的所有方法必须是抽象的】。如果使用的是JDK1.8+允许使用default在接口中定义默认实现，这个实现允许在实现类中重新定义覆盖
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方法没有实现
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
1 访问修饰符 interface 接口名{ } 一般建议接口名称使用形容词
public class Test1 {
public static void main(String[] args) {
IA2 a2=new A2Impl();
a2.pp();
}
}
interface IA2 {
default void pp(){
default默认方法实现使用的限制
接口中没有属性，只能定义常量，它提供一些常量，实现它的类可以共享这些常量
接口可以给出访问控制符，用public修饰的是公共接口，到处可见；如果定义接口没有范围限定词，则只能在同包中访问
接口中只能定义常量和抽象方法
接口中只能定义公共的常量，接口中的属性默认是public static final类型的，必须是public static
final类型的
System.out.println(“this is pp…”);
this.ff();
}
void ff();
}
class A2Impl implements IA2{
public void ff() {
System.out.println(“this is ff…”);
}
}
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();
}
}
interface IA{
String name=“yanjun”;//这里实际上是常量定义，不是属性，它的限定词是public
static final String name=“yanjun”,必须在声明的同时进行赋值
} 在接口中不能定义静态块 static{}
接口