接口的基本概念

1.1 接口
接口是JAVA中最重要的概念，接口可以理解为一种特殊的类，里边全是由全局常量(static final声明)和公共的抽象方法组成。
接口的定义格式：

interface 接口名称
{
    全局常量 ;
    抽象方法 ;
}

以下定义两种抽象方法(void print())和(String getInfo*())，大多用第一种

interface A     //定义接口 A
{
    public static final String NAME = "IRONMAN" ;   //定义全局常量 都大写
    public abstract void print() ;                  //定义抽象方法
    public abstract String getInfo() ;                  //定义抽象方法
}

对于接口来说，因为其在定义的时候已经声明了其组成部分是全局常量和抽象方法，所以可以简化定义

interface A     //定义接口 A
{
    String NAME = "IRONMAN" ;   //定义全局常量 都大写
    void print() ;                  //定义抽象方法
    String getInfo() ;                  //定义抽象方法
}

1.2 实现接口
与抽象类一样，接口要使用也必须通过子类，子类通过implements关键字实现接口。
实现格式：

class 子类 implements 接口A,接口B{}

接口的使用中也必须有子类，子类必须覆写接口中抽象方法，一个子类可以同时实现多个接口。

interface A     //定义接口 A
{
    public String NAME = "IRONMAN" ;    //定义全局常量 都大写
    public void print() ;                   //定义抽象方法
    public String getInfo() ;               //定义抽象方法
}
interface B
{
    public abstract void run() ;
}
class X implements A,B
{
    public void print()
    {
        System.out.println("你好") ;
    }
    public String getInfo()
    {
        return "Hello World" ;
    }
    public void run()
    {
        System.out.println("世界") ;
    }
}
public class InterfaceDemo01
{
    public static void main(String[] args)
    {
        X x = new X() ;     //实例化X类对象
        x.print() ;
        x.getInfo() ;
        x.run() ;
    }
}

1.3 继承抽象类实现接口
一个子类可以同时继承抽象类和实现接口

class C extends 抽象类A implements 接口B{}

interface A     //定义接口 A
{
    public String NAME = "IRONMAN" ;    //定义全局常量 都大写
    public void print() ;                   //定义抽象方法
    public String getInfo() ;               //定义抽象方法
}
abstract class B    //定义抽象类
{
    public abstract void run() ;//因为在抽象类中，所以抽象方法不能简写
}
class X extends B implements A  //先继承抽象类 再实现接口A
{
    public void print()
    {
        System.out.println("你好") ;
    }
    public String getInfo()
    {
        return "Hello World" ;
    }
    public void run()
    {
        System.out.println("世界") ;
    }
}
public class InterfaceDemo02
{
    public static void main(String[] args)
    {
        X x = new X() ;     //实例化X类对象
        x.print() ;
        x.getInfo() ;
        x.run() ;
    }
}

interface A     //定义接口 A
{
    public String NAME = "IRONMAN" ;    //定义全局常量 都大写
    public void print() ;                   //定义抽象方法
    public String getInfo() ;               //定义抽象方法
}
abstract class B implements A   //定义抽象类 实现接口A
{
    public abstract void run() ;//因为在抽象类中，所以抽象方法不能简写
}
class X extends B   //定义子类继承抽象类B 
{
    public void print()     //覆写接口中抽象方法
    {
        System.out.println("你好") ;
    }
    public String getInfo()//覆写接口中抽象方法
    {
        return "Hello World" ;
    }   
    public void run()       //覆写抽象类中抽象方法
    {
        System.out.println("世界") ;
    }
}
public class InterfaceDemo03
{
    public static void main(String[] args)
    {
        X x = new X() ;     //实例化X类对象
        x.print() ;
        x.getInfo() ;
        x.run() ;
    }
}

1.4 接口的继承
一个接口不能继承一个抽象类，但是可以通过extends关键字继承多个接口，实现接口的多继承。

interface 子接口A extends 父接口B,父接口C{}

interface A     //定义接口A
{
    public String name = "IronMan" ;    //定义全局常量
    public void print1() ;      //定义抽象方法
}
interface B     //定义接口B
{
    public void print2() ;      //定义抽象方法
}
interface C extends A,B     //定义接口C继承接口A，B
{
    public void print3() ;      //定义抽象方法
}
class X implements C                //定义类X实现接口C
{
    public void print1()        //覆写方法
    {
        System.out.println("A, 你好") ;
    }
    public void print2()        //覆写方法
    {
        System.out.println("B, 世界") ;
    }
    public void print3()        //覆写方法
    {
        System.out.println("C, Hello World") ;
    }
}
public class InterfaceDemo04
{
    public static void main(String[] args)
    {
        X x = new X() ; //实例化X对象
        x.print1() ;    //对象.方法()
        x.print2() ;
        x.print3() ;
    }
}