2019-03-26

1 .java——接口定义：

接口是java中最重要的概念，接口可以理解为一种特殊的类，里边全都是由全局常量（static final声明 ）和公共的抽象方法组成
接口的定义格式：
interface 接口名称{
   全局常量
   抽象方法
}
例如：

interface {         //定义接口A
    public static final String AUTHOR = "GAOXIN";       //全局常量
    public abstract void print() ;      //抽象方法
    public abstract String getInfo() ;      //抽象方法
}
//public和static以及final课题省略，也可以写成下面的方式
interface A{
    String JAVA = "this is java" ;
    void print() ;
    String getInfo() ;
}

在接口的使用自必须有子类，子类必须覆写接口中的全部抽象方法，子类是通过implements关键字来实现接口，一个子类可以同时实现多个接口，则子类不是抽象类，需要覆写全部的抽象方法。

interface A{            //定义接口A
    public static final String AUTHOR = "GAOXIN";       //全局常量
    public abstract void print() ;      //抽象方法
    public abstract String getInfo() ;      //抽象方法
    
}
interface B{        //定义接口B
    public void say() ;     //定义抽象方法
}
class X implements A, B {       //x类同事实现A和B两个接口
    public void say() {
        System.out.println("Hello World");
    }
    public String getInfo() {
        return "HELLO";
    }
    public void print() {
        System.out.println("作者：" + AUTHOR);
    } 
}
public class interfaceDemo01 {
    public static void main(String args[]) {
        X x = new X() ;         //实例化子类对象
        x.say() ;
        x.print() ;
    }
}

2 .一个子类可以同时继承抽象类和实现接口，格式：

class 子类 extends 抽象类 implement 接口A, 接口B，……{}

interface A{            //定义接口A
    public static final String AUTHOR = "GAOXIN";       //全局常量
    public abstract void print() ;      //抽象方法
    public abstract String getInfo() ;      //抽象方法
    
}
abstract class B{       //定义抽象类 
    public abstract void say() ;        //定义抽象方法
}
class X extends B implements A {        //x类先继承B类 在实现A接口
    public void say() {
        System.out.println("Hello World");
    }
    public String getInfo() {
        return "HELLO";
    }
    public void print() {
        System.out.println("作者：" + AUTHOR);
    } 
}
public class interfaceDemo01 {
    public static void main(String args[]) {
        X x = new X() ;         //实例化子类对象
        x.say() ;
        x.print() ;
    }
}

在抽象类中，一个子类可以实现一个接口，那么对于抽象类的子类就必须全部覆写抽象类和接口中的抽象方法，接口不能继承抽象类，但抽象类可以实现接口

interface A{           //定义接口A
   public static final String AUTHOR = "GAOXIN";       //全局常量
   public abstract void print() ;      //抽象方法
   public abstract String getInfo() ;      //抽象方法
   
}
abstract class B implements A {     //定义抽象类 B ，实现接口A
   public abstract void say() ;        //定义抽象方法
}
class X extends B {     //x类先继承B类 在实现A接口
   public void say() {
       System.out.println("Hello World");
   }
   public String getInfo() {
       return "HELLO";
   }
   public void print() {
       System.out.println("作者：" + AUTHOR);
   } 
}
public class interfaceDemo01 {
   public static void main(String args[]) {
       X x = new X() ;         //实例化子类对象
       x.say() ;
       x.print() ;
   }
}

3 .一个接口虽然不能继承抽象类，但是在Java中 一个接口可以同时继承多个接口，实现接口的多继承 格式：

interface 子接口 extends 父接口A , 父接口B，…… {}

interface A{            //定义接口A
    public static final String AUTHOR = "GAOXIN";       //全局常量
    public void printA() ;      //抽象方法
}
interface B {
    public void printB() ;
    
}
interface C extends A, B{
    public void printC() ;
}
class X implements C {      //x类先继承B类
    public void printA() {
        System.out.println("A.Hello Word");
    }
    public void printB() {
        System.out.println("B：hello");
    } 
    public void printC() {
        System.out.println("C：此类");
    }
    
    
}
public class interfaceDemo01 {
    public static void main(String args[]) {
        X x = new X() ;         //实例化子类对象
        x.printA();
        x.printB();
        x.printC();
    }
}

举例，usb接口的使用:

在这里插入图片描述

4 .总结：

接口是一个特殊的类，只有全局常量和抽象方法
接口中的抽象方法可以不写abstract，而抽象类中的必须加入abstract关键字声明
一个类只能继承一个父类，但可以同时继承多个接口
一个接口可以同时继承多个接口，实现接口的多继承
接口和抽象类一样，都必须依靠子类
一个抽象类可以实现多个接口，一个接口不能继承一个抽象类