java 接口的概念

一：概念

接口是功能的集合。同样可以看做一种数据类型，是比抽象类更为抽象的“类”。

接口描述应该具备的方法，并没有具体的实现。具体实现由接口的实现类（相当于接口的子类来完成）。

好处：

使功能和实现分离，优化了程序设计。

二：语法

使用关键字interface关键字来定义。

定义的接口文件仍然是.java文件。虽然声明的时候使用interface关键字，编译之后仍然是.class

文件。接口我们可以把他看做是一种只包含了功能声明的特殊类。

定义格式:

public   interface   接口名字{

    抽象方法1（public abstract 返回值类型 方法名字(参数列表);）

　 抽象方法1（public abstract  返回值类型 方法名字(参数列表);）

     抽象方法1（public abstract  返回值类型 方法名字(参数列表);）

      .......

}

package com.company;

public interface Myinterface {
    /**
     *接口定义：
     * 修饰符  interface  接口名字
     * 方法的定义:
     * public abstract  返回值类型 方法名字 (参数列表)
     * 其中 public 修饰符必须是 public  或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.
     * 成员的变量的定义:必须是常量且修饰符为public .
     */
    public static final  int  c=22;
    public abstract int  myinter();
}

注意：

在接口内的方法，必须是public修饰符，以及为抽象方法（abstract）。

三：接口的实现

我们把实现接口的类叫做接口的实现。

package com.company;

/**
 * 接口的实现语法：
 * 使用关键字implements.
 * 修饰符 类名字  implements 接口名字{
 *     public  返回值类型  抽象方法的名字{
 *         方法体.
 *     }
 * }
 *              类的名字   关键字      接口名字
 * public class Myimple  implements Myinterface
 */



public class Myimple  implements Myinterface {
    public int  myinter(){
        return 2;
    };
}

注意:

 在接口中默认方法都是抽象的（abstract）,不管是否使用public abstract，都一样

抽象的方法重写，修饰符是public  注意访问权限 只能是public.而且是普通方法。（没有abstract，abstract是抽象方法的定义。）

 类是接口的实现，类似于类是接口的子类，接口继承。但是实际上类是接口的实现。

如果接口中有多个抽象方法，实现类需要把接口的抽象方法都一一实现。

接口类的中的抽象方法和接口的成员变量访问权限都是public，写和不写都是这个权限，实现类中的方法的权限也必须是public。否则报错！！！

 如果一个实现类中并没有实现接口的所有的抽象方法，如果依然是普通类，会报错，普通类需要实现所有的接口的方法，而实现类变为抽象类就不会报错。也就是说

实现部分接口的抽象方法，实现类是抽象类。

接口:

package com.company;

public interface Myinterface {
    /**
     *接口定义：
     * 修饰符  interface  接口名字
     * 方法的定义:
     * public abstract  返回值类型 方法名字 (参数列表)
     * 其中 public 修饰符必须是 public  或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.
     * 成员的变量的定义:必须是常量且修饰符为public .
     */
    public static final  int  c=22;
    public abstract int  myinter();
    public abstract void myinter1();
} 

实现类:

public abstract class Myimple  implements Myinterface {
    public int  myinter(){
        return 2;
    };
}

调用：

通过初始化实现类对象来调用相应的方法：

package com.company;

public class Mytest {
    public static void  main(String ... arg){
        Myimple shixian=new Myimple();
        System.out.println(shixian.myinter());
    }
}

 接口的多实现：

类的继承只能单继承，而接口不一样，可以同实现类实现多个接口，这个也是比抽象类更加灵活。

实现类C可以同时实现接口A和B。

接口A：

package com.company;

public interface Myinterface {
    /**
     *接口定义：
     * 修饰符  interface  接口名字
     * 方法的定义:
     * public abstract  返回值类型 方法名字 (参数列表)
     * 其中 public 修饰符必须是 public  或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.
     * 成员的变量的定义:必须是常量且修饰符为public .
     */
    public static final  int  c=22;
    public abstract int  myinter();

}

 接口B：

package com.company;

public interface Myinterfac_b {
    public abstract int myinter();
}

 实现C：

public  class Myimple  implements Myinterface ,Myinterfac_b{
    public int  myinter(){
        return 2;
    };
}

因为接口A 和B的抽象方法是一样，所以实现类C可以重写一个类即可。

但是前提：

1：重写方法 返回值一样。如果不一样的话，需要分别实现，不能一起实现。

2：如果方法的参数列表不一样。我们可以重载。

 接口A：

package com.company;

public interface Myinterface {
    /**
     *接口定义：
     * 修饰符  interface  接口名字
     * 方法的定义:
     * public abstract  返回值类型 方法名字 (参数列表)
     * 其中 public 修饰符必须是 public  或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.
     * 成员的变量的定义:必须是常量且修饰符为public .
     */
    public static final  int  c=22;
    public abstract int  myinter(String a);

}

 接口B：

package com.company;

public interface Myinterfac_b {
    public abstract int myinter();
}

 实现C：

package com.company;

public class Mytest {
    public static void  main(String ... arg){
        Myimple shixian=new Myimple();
        System.out.println(shixian.myinter());
        System.out.println(shixian.myinter("ok"));
    }
}

 

注意：

决定方法的差异是方法的签名，方法的签名包含方法的名字和参数！

接口的多继承：

接口可以进行多继承，但是最后子接口，在被实现的时候，需要实现所有父接口的抽象方法。也就是说在java中有多继承的概念。

接口A：

public interface Myinterface {
    /**
     *接口定义：
     * 修饰符  interface  接口名字
     * 方法的定义:
     * public abstract  返回值类型 方法名字 (参数列表)
     * 其中 public 修饰符必须是 public  或者不写，不写该方法的访问权限也是public。方法为抽象方法,所以用abstract来修饰.
     * 成员的变量的定义:必须是常量且修饰符为public .
     */
    public static final  int  c=22;
    public abstract int  myinter(String a);

}

 接口B：

package com.company;

public interface Myinterfac_b {
    public abstract int myinter();
}

接口C：

package com.company;

public interface Myinter_c extends Myinterfac_b,Myinterface {
    public abstract double myinter_c();
}

实现：

public  class Myimple  implements Myinter_c{
    public int  myinter(){
        return 2;
    };

    @Override
    public int myinter(String a) {
        return 3;
    }
    public double myinter_c(){
        return 4;
    }
}

 调用：

package com.company;

public class Mytest {
    public static void  main(String ... arg){
        Myimple shixian=new Myimple();
        System.out.println(shixian.myinter());
        System.out.println(shixian.myinter("ok"));
        System.out.println(shixian.myinter_c());
    }
}

 注意：

最后实现：如果实现的C的接口时候，实现类中需要把各个抽象方法都要一一实现。这叫做接口的多继承。

抽象类和接口的区别：

抽象类：是事务共有的功能，但是功能由于具体的对象的不同导致实现内容不一样。

接口：是事务额外的功能，如果事务想具备这个功能，需要定义相应的接口，由实现类来实现。

人的共有的功能：吃和睡觉。但是每个吃什么和怎么睡觉是不一样的。但都属于人的共有的功能。人是否编程功能，不一定，属于人的额外功能。所以吃和睡是抽象，编程是接口。

 抽象类：

package com.company;

public abstract class Person_t {
    public abstract void  eat();
    public  abstract void sleep();
    public String work(){
        return "make money";
    }
}

接口：

package com.company;

public interface Per_in {
    public abstract void  biancheng();
}

实现类和实现抽象类的抽象方法：

package com.company;



public class Beav extends  Person_t implements Per_in {
    public void eat(){
        System.out.println("apple");
    }
    public void sleep(){
        System.out.println("sleep at 500");
    }
    public void  biancheng(){
        System.out.println("java");
    }
}

 调用类：

package com.company;

public class Per_Test {
    public  static void  main(String ... args){
        Person_t new_Per=new Beav();
        new_Per.eat();
        new_Per.sleep();
        Beav new_be=new Beav();
        new_be.biancheng();
    }
}

 注意：

抽象类中不一定只有抽象方法，也可以有普通方法。抽象类通过子类来调用和实现抽象方法和普通方法。

接口只有抽象方法和常量。没有普通方法。

接口需要实现（implements），抽象方法需要继承（extends），抽象是多态实现，而接口是功能和实现分离。

 接口也可以这么写  接口  变量 =new  子类的构造器();这是接口的多态。

package com.company;

public class Per_Test {
    public  static void  main(String ... args){
        Person_t new_Per=new Beav();
        new_Per.eat();
        new_Per.sleep();
        Per_in new_be=new Beav();
        new_be.biancheng();
    }
}

多态是指对象在不同的情形下，对应的类型不同。接口通过实现类来实现多态，类通过继承，子类实现多态。