面向对象——接口

在 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{}

可以包含抽象方法，也可以没有抽象方法

interface IA1{
}//这个接口中没有包含任何抽象方法
class A1Impl implements IA1{
}

接口中的方法只能被 public 、 default 、 abstract 、 static 修饰

• 一般情况下接口中只定义抽象方法
• 定义的方法默认为公开的抽象方法

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个抽象方法
类是单根继承,不允许继承多个父类

允许一个类实现多个接口 , 但是每个接口的抽象方法都必须提供实现，否则是抽象类。提供的实现也可以是继承

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{
    defalut 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 修饰的是公共接口，到处可见；如果定义接口没有范围限定

词，则只能在同包中访问

接口中只能定义常量和抽象方法

接口中只能定义公共的常量，接口中的属性默认是 public static final 类型的，必须是 public static

final 类型的

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 类型的类，任何继承该类的子类

必须实现该接口