1.接口的概述及特点

* A:接口概述

* 从狭义的角度讲就是指java中的interface

* 从广义的角度讲对外提供规则的都是接口

* B：接口的特点

* 接口用关键字interface表示

* interface 接口名{}

* 类实现接口用implements 接口名{}

* class 类名 implemts 接口名{}

* 接口不能实例化

* 那么，接口如何实例化呢？

* 按照多态的方式实例化。

* 接口的子类

* a:可以是抽象类，但是意义不大

* b:可以是具体类，但要重写接口中所有的抽象方法，（推荐方案）

* C: 案例演示

* 接口的特点

代码：

public class Demo09_polymorphic {
    public static void main(String[] args) {
        //Cannot instantiate the type Inter
        //Inter i = new Inter();//接口不能实例化因为调用抽象方法没有意义
        //按照多态的方式实例化。
        Inter i = new Demo1();   // 相当于是多态，（父类引用指向子类对象）
        i.print();     //编译看左边，运行看右边 成员方法

    }
}

// interface 接口名 {} 创建接口的方法
interface Inter {
    public abstract void print();   //接口中的方法都是抽象的
}

//b:可以是具体类，但要重写接口中所有的抽象方法，（推荐方案）
// 继承用extends  接口实现用implements
class Demo1 implements Inter {
    @Override
    // 重写接口print()的方法
    public void print() {
        System.out.println("printDemo");
    }
}

2  接口的成员特点

A：接口成员特点

* 成员变量：只能是常量，并且是静态的并公共的。

* 默认修饰符：public static final---这三个单词么有顺序

* 建议：自己手动给出

* 构造方法：接口没有构造方法。

* 成员方法：只能是抽象方法。

* 默认修饰符：public abstract

* 建议：自己手动给出。

* B：案例演示

* 接口成员特点 

代码：

public class Demo6_Interface {
    public static void main(String[] args) {
        InterSec interSec = new DemoSec();  // 父类引用指向子类的对象
        interSec.print();

    }
}

interface InterSec {
    //默认修饰符：public static final
    public static final int num = 10;  // 只能是常量  开发中建议这样写

    //public Inter() {}//接口没有构造方法。Interfaces cannot have constructors
    //只能是抽象方法。
   /*public void print() {//Abstract methods do not specify a body
      System.out.println("print");
   }*/
    public abstract void print();  // 抽象方法
}

class DemoSec implements InterSec {  //

    public void print() {        // 重写抽象方法

        System.out.println(num);
    }
}

3. 类与类、类与接口、接口与接口之间的关系

A：类与类，类与接口，接口与接口的关系

* a:类与类：

* 继承关系，只能单继承，可以多层继承

* b:类与接口

* 实现关系，可以单实现，也可以多实现。

* 并且还可以在继承一个类的同时实现多个接口。

* c: 接口与接口：

* 继承关系，可以单继承，也可以多继承。

代码：

public class Demo7_interface {
    public static void main(String[] args) {
        DemoA demoA = new DemoA();
        demoA.printA();
        demoA.printB();
        demoA.printC();
    }
}


// 第一个接口
interface InterA {
    public abstract void printA();  // 抽象的方法A
}

// 第二个接口
interface InterB {
    public abstract void printB();  // 抽象的方法B
}

//c: 接口与接口：
interface InterC extends InterA, InterB {    //可以多继承。
    public abstract void printC();
}


//class Demo implements InterA,implements InterB{
//b:类与接口
class DemoA extends Object implements InterA, InterB, InterC {
    // 重写接口InterA的方法
    @Override
    public void printA() {

        System.out.println("InterA");
    }

    // 重写接口InterB的方法
    @Override
    public void printB() {

        System.out.println("InterB");
    }

    // 重写接口InterC的方法
    @Override
    public void printC() {
        System.out.println("InterC");
    }

}

4.抽象类与接口的区别

*A：成员区别

    * 抽象类：

        * 成员变量：可以变量，也可以常量

        * 构造方法： 有

        * 成员方法：可以抽象，也可以非抽象

    * 接口：

        * 成员变量：只可以常量

        * 成员方法：只可以抽象

* B：关系区别

    * 类与类

        * 继承，单继承

    * 类与接口

        * 实现，单实现，多实现

    * 接口与接口

        * 继承，单继承，多继承

* C：设计理念区别

    * 抽象类 被继承体现的是：“is a "关系，抽象类中定义的是该继承体系的共性功能

    *  接口 被实现体现的是“is like" 的关系，接口中定义的是该继承体系的扩展功能