关于Java开发中最常用的接口详解-通俗易懂-简单明了

接口：

1：接口也是一种数据类型
2：接口是完全抽象的。（抽象类是半抽象）或者也可以说接口是特殊的抽象类.
3:接口怎么定义?,语法是什么?

    修饰符列表 interface 接口名{
  	}

4:接口支持多继承,一个接口可以继承多个接口

//定义接口
interface A1{

}
//接口支持继承,并支持多继承
interface B1 extends A1{

}

5:接口中只包含两部分内容,常量+抽象方法.接口中没有其他内容
6:接口中所有元素都是public修饰的(公开的).
7:接口中的抽象方法定义时:public abstract修饰符可以省略.
8:接口中的方法都是抽象方法,所以接口中的方法不能有方法体.
9:接口中的常量 public static final 可以省略.看以下代码：

//我的数学接口
interface MyMath1{
    //常量 ,public static final 可以省略
    //public static final double PI = 3.1415926;
    double PI = 3.1415926;
    //抽象方法
    //public abstract int sum(int a,int b);
    //接口中既然都是抽象方法,那么在编写代码的时候,public abstract可以省略
    //相加的抽象方法
    int sum(int a,int b);

    //相减的抽象方法
    int sub(int a,int b);
}

接口的基础语法：

1:类和类之间叫做继承，类和接口之间叫做实现，"实现"可以看做"继承"
继承使用extends关键字完成
实现使用implements关键字完成
2:当一个类实现接口的话，必须将接口中的抽象方法全部实现。实现之后的抽象方法，修饰符是public

public class test021 {
    public static void main(String[] args) {
        //多态：父类型引用指向子类型对象
        MyMath mm = new MyMathImpl();
        //调用接口里的方法，(面向接口编程)，编译的时候找的是接口中的方法，运行的时候是底层对象的方法。
        int i = mm.sub(1,2);
        System.out.println(i);
    }
}

//我的数学接口
interface MyMath{
    //常量
    double PI = 3.1415926;

    int sum(int a,int b);

    int sub(int a,int b);
}

//编写一个类(非抽象类)
class MyMathImpl implements MyMath{

    //实现接口中的方法
    public int sum(int a,int b){
        return a + b;
    }
    public int sub(int a, int b) {
        return a - b;
    }
}

接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？
可以，但是必须将接口中的所有方法实现

public class test022 {
    public static void main(String[] args) {
        A a = new D();
        a.m1();
        //经过测试，接口和接口之间，在进行强制类型转换的时候，没有继承关系也可以强转
        //但是一定要注意，运行时可能会出现classCastException异常。
        //向下转型养成好习惯，使用instanceof 运算符来判断
        B b2 = new D();
        if (b2 instanceof C){
            C c = (C)b2;
            c.m3();
        }
    }
}
interface A{
    void m1();
}

interface B{
    void m2();
}

interface C{
    void m3();
}

interface E{
    void m3();
}

//实现三个接口
class D implements A,B,C{
    @Override
    public void m1() {

    }

    @Override
    public void m2() {
        System.out.println("m2....");
    }

    @Override
    public void m3() {
        System.out.println("m3....");
    }
}

继承和实现都存在的话，代码应该怎么写？
extends关键字在前，implements关键字在后

public class test023 {
    public static void main(String[] args) {
        Flyable am = new Cat();//多态：父类型引用指向子类型对象
        am.fly();
        //同一个接口
        Flyable pi = new Pig();
        //调用同一个fly()方法，最后执行效果不同。
        pi.fly();
    }
}

//动物类：父类
class Animal{

}

//可飞翔的接口(是一对翅膀)
//能插拔的就是接口。(没有接口怎么插拔)。内存条插到主板上，它们之间有接口，内存条可以更换
//接口通常提取的是行为动作
interface Flyable{
    void fly();
}

//猫类：动物类子类
//Flyable是一个接口，是一对翅膀的接口，通过接口插到猫的身上，让猫可以飞翔。
class Cat extends Animal implements Flyable{
    @Override //实现接口抽象方法
    public void fly() {
        System.out.println("我是会飞的猫！我想飞！！");
    }
}

//蛇类，如果你不想让它飞，可以不实现Flyable接口
//没有实现这个接口，表示你没有翅膀，你没有翅膀，肯定不能飞。
class Snake extends Animal{

}

class Pig extends Animal implements Flyable{
    @Override
    public void fly() {
        System.out.println("我是一只飞猪！");
    }
}

接口在开发中的作用
注意：接口在开发中的作用，类似于多态在开发中的作用。
多态：面向抽象编程，不要面向具体编程，降低程序的耦合度，提高程序的扩展力
接口：面向接口编程，可以降低程序的耦合度，提高程序的扩展力，符合ocp开发原则。
接口的使用离不开多态机制，(接口+多态才可以达到降低耦合度)
接口可以解耦合，解开的是谁和谁的耦合！
任何一个接口都有调用者和实现者。
接口可以将调用者和实现者解耦合。
调用者面向接口调用
实现者面向接口编写

抽象类和接口有什么区别？
抽象类是半抽象的。
接口是完全抽象的。

抽象类中有构造方法
接口中没有构造方法

接口和接口之间支持多继承
类和类之间只能单继承

一个类可以同时实现多个接口。
一个抽象类只能继承一个类（单继承）。

接口中只允许出现常量和抽象方法。

注意：以后接口使用的比抽象类多。一般抽象类使用的少，接口一般都是对"行为"抽象。