Java--接口

一、接口语法

　　接口相当于特殊的抽象类，定义方式、组成部分与抽象类类似

　　用 interface 关键字来定义接口，接口没有构造方法，不能创建对象。(接口的名称一般以able结尾)

　　接口只能定义 公开静态常量和公开抽象方法

　　类与类的关系是继承，类与接口的关系是实现（用关键字 implements ）。

package com.monv.interface_1;
/**
 * 接口：只包括 公开的静态常量和公开的抽象方法
 * @author Administrator
 *
 */
public interface MyInterface {
    
//    public static final String NAME="接口";//公开的静态常量
//    一般情况下 可以不写public static final 直接定义常量 就会默认为 公开的静态常量
    String NAME="接口";
    
//    public abstract void method();//公开的抽象方法
//    一般情况下 可以不写public abstract 直接定义方法 默认的为 公开的抽象方法
    void method();
    
    
}
-----------------------接口与类的关系-------------------------------
package com.monv.interface_1;
/**
 * 实现类(类与类的关系是继承，类与接口的关系是实现)
 * @author Administrator
 *
 */
public class Impl implements MyInterface{
    //覆盖接口中的抽象方法
    @Override
    public void method() {
        System.out.println("接口实现。。");        
    }

}
----------------------------------------------------------------------
package com.monv.interface_1;

public class TestInterface {
    public static void main(String[] args) {
//        new MyInterface(); 接口不能创建对象 会报错
//        MyInterface myInterface1;//但是可以用接口定义变量
        MyInterface myInterface2 = new Impl();// 用接口创建变量 实例化成Impl对象 (多态)MyInterface相当于抽象类  Impl 相当于子类
        myInterface2.method();
    }
}
------------------------------------------------------------------------

 

二、接口和抽象类的异同

　　相同：

　　　　可编译成字节码文件

　　　　不能创建对象(接口没有构造方法无法创建对象，抽象类不能创建对象)

　　　　可以作为引用类型(接口和抽象类都可以创建变量)

　　　　具备Object类中所定义的方法

　　不同：

　　　　接口中所有属性都是公开静态常量，隐式使用 public static final 修饰。

　　　　接口中所有方法都是公开抽象方法，隐式使用 public abstract 修饰。

　　　　接口中没有构造方法 动态代码块 静态代码块

三、什么是接口

　　微观概念：接口是一种能力和约定

　　接口的定义：代表了某种能力。

　　方法的定义：能力的具体要求。

　　经验：Java为单继承，当父类的方法种类无法满足子类的需求时，可实现接口扩充子类能力。

　　接口支持多实现，可为类扩充多种能力。

　　实例：定义了一个person类，具有吃和睡的方法。当人类拥有了超能力(飞、喷火)后，person类就无法实现这个能力了，这个时候需要定义飞和喷火的接口，让person类来实现，然后人类对象就可以实现飞和喷火的超能力。

　　注意：在用接口创建变量的时候，变量只能调用接口中的方法和Object中的方法。其他的方法是不能被调用的

-----------------定义Person类----------------------
package com.monv.interface_2;
/**
 * person 拥有飞的能力 实现Flyable接口 类中必须重写接口中的方法
 * @author Administrator
 *
 */
public class Person implements Flyable,Fireable  {
    String name;
    int age;
    
    public Person() {
        // TODO Auto-generated constructor stub
    }
    
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    //吃的方法
    public void eat(){
        System.out.println(name+"正在吃东西...");
    }
    //睡的方法
    public void sleep(){
        System.out.println(name+"正在睡觉...");
    }
    @Override
    public void fly() {
        System.out.println(name+"拥有了飞的超能力...");
    }

    @Override
    public void fire() {
        System.out.println(name+"拥有了喷火的超能力...");
        
    }
}
----------------------------飞接口-----------------------------------
package com.monv.interface_2;
/**
 * 接口 飞的能力
 * @author Administrator
 *
 */
public interface Flyable {
    void fly();
}
----------------------------------喷火接口-----------------------------
package com.monv.interface_2;
/**
 * 喷火超能力
 * @author Administrator
 *
 */
public interface Fireable {
    void fire();
}
----------------------------------测试---------------------------------
package com.monv.interface_2;

public class TestPerson {
    public static void main(String[] args) {
        Person xm = new Person("小明",22);
        xm.fly();
        xm.fire();
        
        System.out.println("=====用多态=======");
        //在用接口创建变量的时候 变量只能调用接口中的方法和Object中的方法 不能调用person中eat和sleep方法
        Flyable xh = new Person("小红",20);
        xh.fly();
        Fireable xl= new Person("小李",21);
        xl.fire();
    }
}
------------------------------------------------------------------------
小明拥有了飞的超能力...
小明拥有了喷火的超能力...
=====用多态=======
小红拥有了飞的超能力...
小李拥有了喷火的超能力...

四、接口的规范

　　任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类

　　实现接口中的抽象方法时，访问修饰符必须是public。

五、接口引用

　　同父类一样，接口也可声明为引用(可以用接口创建变量，但是不能实例化对象)，并指向实现类对象。

　　注意：

　　　　仅可调用接口中所声明的方法，不可调用实现类中独有的方法。

　　　　可强转回实现类本身类型，进行独有方法调用

　　　　[特殊：可以通过接口调用Object中的公开方法]

六、接口的多态

 

 实例：动物类Animal类 有eat和sleep的方法；有两个接口Runable接口和Swimable接口，实现跑和游泳；狗狗类Dog 继承动物类，有自己独有的方法 shout，还有两个接口的实现。

--------------------父类-----------------------------
package com.monv.interface_3;

public abstract class Animal {
    
    public void eat(){
        System.out.println("正在吃东西...");
    }
    public void sleep(){
        System.out.println("正在睡觉...");
    }
}
-------------------接口1 跑---------------------------
package com.monv.interface_3;

public interface Runable {
    void run();
}
-------------------接口2 游泳-------------------------------
package com.monv.interface_3;

public interface Swimable {
    void swim();
}
--------------------子类 狗狗类----------------------------
package com.monv.interface_3;
/**
 * Dog类来实现跑和游的接口  implements(接口的实现，多个接口用逗号隔开) 要在extends(继承)之后
 * @author Administrator
 *
 */
public class Dog extends Animal implements Runable,Swimable{
    //子类独有的方法
    public void shout(){
        System.out.println("狗狗在叫....");
    }

    @Override
    public void swim() {
        System.out.println("狗狗在游泳...");
    }

    @Override
    public void run() {
        System.out.println("狗狗在奔跑...");
    }
}
--------------------------测试----------------------------------------
package com.monv.interface_3;

public class TestDog {
    public static void main(String[] args) {
        Dog kejiDog = new Dog();
        Animal a = kejiDog;
        Runable r = kejiDog;
        Swimable s = kejiDog;
        //kejiDog狗狗对象 可以调用Dog类中的方法 包括实现的方法
        kejiDog.eat();
        kejiDog.sleep();
        kejiDog.shout();
        kejiDog.swim();
        kejiDog.run();
        //a 父类对象 只能调用父类中的方法
        a.eat();
        a.sleep();
        //r 用接口定义的变量  只能调用 Runable中的方法
        r.run();
        //s 用接口定义的变量 只能调用Swimable中的方法
        s.swim();
    }
}
----------------------------------------------------------------------

七、常见关系

　　类与类： 1.单继承　　2.extends 父类名称

　　类与接口：1.多实现　　2.implements 接口名称1，接口名称2，接口名称n

　　接口与接口：1.多继承　　2.extends 父接口1，父接口2，父接口n

八、常量接口和标记接口

　　常量接口：将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统一管理，提高代码的可读性。

　　标记接口：接口中没有包含任何成员，仅仅用作标记。(如：Serializable(可以序列化的),Cloneable(可以克隆的))

九、什么是接口

　　宏观概念：接口是一种标准。

 

 

 

   示例：电脑连接USB设备

 

---------------------USB接口定义------------------------
package com.monv.interface_5;
/**
 * Usb接口
 * @author Administrator
 *
 */
public interface Usb {
    void service();
}
----------------------接口的实现-----------------------------
package com.monv.interface_5;
/**
 * U盘-接口的实现者
 * @author Administrator
 *
 */
public class UPan implements Usb{

    @Override
    public void service() {
        System.out.println("U盘连接电脑成功！");
    }

}

package com.monv.interface_5;
/**
 * 风扇-接口的实现者
 * @author Administrator
 *
 */
public class Feng implements Usb {

    @Override
    public void service() {
        System.out.println("风扇连接电脑成功！");
    }

}

package com.monv.interface_5;
/**
 * 鼠标-接口的实现者
 * @author Administrator
 *
 */
public class Mouse implements Usb{

    @Override
    public void service() {
        System.out.println("鼠标连接电脑成功！");
    }
  
}
------------------接口的使用者------------------------------
package com.monv.interface_5;
/**
 * 电脑-接口的使用者（电脑上3个USB接口）
 * @author Administrator
 *
 */
public class Computer {
    Usb usb1;
    Usb usb2;
    Usb usb3;
    
    public void run(){
        System.out.println("电脑开始工作。。。");
        if (usb1 != null){
            usb1.service();
        }
        if (usb2 != null){
            usb2.service();
        }
        if (usb3 != null){
            usb3.service();
        }
        
    }
}
------------------------测试---------------------------------
package com.monv.interface_5;

public class Test {
    public static void main(String[] args) {
        //定义电脑
        Computer huawei = new Computer();
        //3个USB设备
        Usb mouse = new Mouse();
        Usb feng  = new Feng();
        Usb upan  = new UPan();

        //把USB设备连接到电脑  Computer类中usb1是用接口定义的 没有用具体的类型来定义 所以可以把任何一个usb设备赋值给usb1
        huawei.usb1 = upan;
        huawei.usb2 = mouse;
        huawei.usb3 = feng;
        
        huawei.run();
    }
}
---------------------------------------------------------
电脑开始工作。。。
U盘连接电脑成功！
鼠标连接电脑成功！
风扇连接电脑成功！
--------------------------------------------------------

十、回调原理

 

十一、接口好处

• 程序的耦合度降低
• 更自然的使用多态
• 设计与实现完全分离
• 更容易搭建程序框架
• 更容易更换具体实现

十二、总结

• 什么是接口
• 微观：接口是一种能力和约定
• 宏观：接口是一种标准
• 接口与类的异同
• 接口没有构造方法，不能创建对象，仅可定义公开静态常量和公开抽象方法
• 接口的应用
• Java为单继承，当父类的方法无法满足子类需求时，可实现接口扩充子类能力。
• 接口的规范
• 任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类
• 实现接口中的抽象方法时，访问修饰符必须是public
• 什么是常量接口、标记接口
• 常量接口：将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统一管理
• 标记接口：接口中没有包含任何成员，仅仅用作标记。
• 什么是接口回调
• 先有接口的使用者，后有接口的实现者。