java_接口

接口——初体验

UsbInterface接口

package com.hspedu.interface_;

public interface UsbInterface { //接口
    //规定接口的相关方法
    public void start();
    public void stop();
}

Camera类

package com.hspedu.interface_;

public class Camera implements UsbInterface{ //实现接口,就是把接口方法实现
    @Override
    public void start() {
        System.out.println("相机开始工作...");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作...");
    }
}

Phone类

package com.hspedu.interface_;

//Phone 类 实现 UsbInterface
//1. Phone类需要实现 UsbInterface接口 规定/声明的方法
public class Phone implements UsbInterface{
    @Override
    public void start() {
        System.out.println("手机开始了工作...");
    }

    @Override
    public void stop() {
        System.out.println("手机结束了工作....");
    }
}

Computer类

package com.hspedu.interface_;

public class Computer {
    //编写一个方法,计算机工作
    //解读：
    //1.UsbInterface usbInterface 形参是接口类型 UsbInterface
    //2.看到 接收 实现了 UsbInterface 接口的类的对象实例
    public void work(UsbInterface usbInterface){
        //通过接口，来调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}

Interface01类

package com.hspedu.interface_;

public class Interface01 {
    public static void main(String[] args) {
        //创建手机，相机对象
        Camera camera = new Camera();
        Phone phone = new Phone();
        //创建计算机
        Computer computer = new Computer();
        computer.work(phone);//把手机接入到计算机
        System.out.println("==============");
        computer.work(camera);//把相机接入到计算机
    }
}

基本介绍

注意（！！！）：在接口中，可以有三种方法：

（1）抽象方法，可以省略abstract关键字
（2）在jdk8后，可以有 默认实现方法，需要使用default关键字修饰
（3）在jdk8后，可以有 静态方法
AInterface接口

	package com.hspedu.interface_;

public interface AInterface {
    //写属性
    public int n1 = 10;
    //在接口中，抽象方法，可以省略abstract关键字
    public void hi();
    //在jdk8后，可以有 默认实现方法，需要使用default关键字修饰
    default public void ok() {
        System.out.println("ok.......");
    }
    //在jdk8后，可以有 静态方法
    public static void cry(){
        System.out.println("cry....");
    }
}

Interface02

package com.hspedu.interface_;

public class Interface02 {
    public static void main(String[] args) {

    }
}
//1.如果一个类 implements 实现接口
//2.需要将接口的所有抽象方法都实现
class A implements AInterface {
    @Override
    public void hi() {
        System.out.println("hi.....");
    }
}

接口的应用场景

DBInterface接口

package com.hspedu.interface_;

public interface DBInterface {
    public void connect();
    public void close();
}

MysqlDB类

package com.hspedu.interface_;

public class MysqlDB implements DBInterface{
    @Override
    public void connect() {
        System.out.println("连接mysql..");
    }

    @Override
    public void close() {
        System.out.println("关闭mysql..");
    }
}

OracleDB类

package com.hspedu.interface_;

public class OracleDB implements DBInterface{
    @Override
    public void connect() {
        System.out.println("连接Oracle....");
    }

    @Override
    public void close() {
        System.out.println("关闭Oracle..");
    }
}

Interface03类

package com.hspedu.interface_;

public class Interface03 {
    public static void main(String[] args) {
        MysqlDB mysqlDB = new MysqlDB();
        t(mysqlDB);
        OracleDB oracleDB = new OracleDB();
        t(oracleDB);
    }
     public static void t(DBInterface db){
        db.connect();
        db.close();
     }
}

接口的使用细节

IA接口

package com.hspedu.interface_;

//1.接口不能被实例化
//2.接口中所有的方法是 public 方法, 接口中抽象方法，可以不用 abstract 修饰
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用 alt+enter 来解决
//4.抽象类去实现接口时，可以不实现接口的抽象方法
interface IA {
    void say();//修饰符 public protected 默认 private

    void hi();
}

class Cat implements IA {
    @Override
    public void say() {
    }

    @Override
    public void hi() {
    }
}

abstract class Tiger implements IA {

}

接口使用细节2

InterfaceDetail02类

package com.hspedu.interface_;

public class InterfaceDetail02 {
    public static void main(String[] args) {
//老韩证明 接口中的属性,是 public static final
        System.out.println(IB.n1);//说明 n1 就是 static
//IB.n1 = 30; 说明 n1 是 final
    }
}

interface IB {
    //接口中的属性,只能是 final 的，而且是 public static final 修饰符
    int n1 = 10; //等价 public static final int n1 = 10;

    void hi();
}

interface IC {
    void say();
}

//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB, IC {
}

//接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的
interface IE {
}

//一个类同时可以实现多个接口
class Pig implements IB, IC {
    @Override
    public void hi() {
    }

    @Override
    public void say() {
    }
}

练习题

接口VS继承

ExtendsVSInterface类

package com.hspedu.interface_;

public class ExtendsVSInterface {
    public static void main(String[] args) {
        LittleMonkey wk = new LittleMonkey("悟空");
        wk.climbing();
        wk.swimming();
        wk.flying();
    }
}
class Monkey{
    private String name;

    public Monkey(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void climbing(){
        System.out.println(name + " 会爬树...");
    }
}
//接口
interface Fishable {
    void swimming();
}
interface Birdable {
    void flying();
}

//小结: 
//当子类继承了父类，就自动的拥有父类的功能
// 如果子类需要扩展功能，可以通过实现接口的方式扩展.
// 可以理解 实现接口 是 对 java 单继承机制的一种补充.

//继承
class LittleMonkey extends Monkey implements Fishable,Birdable{
    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName() + " 通过学习，可以像鱼一样游泳");
    }

    @Override
    public void flying() {
        System.out.println(getName() + " 通过学习，可以像小鸟一样飞翔");
    }
}

小结（！！！）：

1）当子类继承了父类，就自动的拥有父类的功能
2）如果子类需要扩展功能，可以通过实现接口的方式扩展.
3）可以理解 实现接口 是 对 java 单继承机制的一种补充.

接口多态特性

多态参数

InterfacePolyParameter类

package com.hspedu.interface_;

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口的多态体现
        //接口类型的变量 if01 可以指向 实现了IF接口类的对象实例
        IF if01 = new Monster();
        if01 = new Car();

        //继承体现的多态
        //父类类型的变量 a 可以指向 继承 AAA 的子类的对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}
//接口
interface IF {
}
class Monster implements IF {
}
class Car implements IF {
}
//继承
class AAA {
}
class BBB extends AAA {}
class CCC extends AAA {}

多态数组

InterfacePolyArr类

package com.hspedu.interface_;

public class InterfacePolyArr {
    public static void main(String[] args) {
        //多态数组-》接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();

        /*
        * 给 Usb 数组中，存放 Phone 和 相机对象，Phone 类还有一个特有的方法
        *  call（），请遍历 Usb 数组，如果是 Phone 对象，除了调用 Usb 接口定义的方法外，
        还需要调用 Phone 特有方法 call
        * */
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work(); //动态绑定
//            和前面一样，我们仍然需要进行类型的向下转型
            if (usbs[i] instanceof Phone_) {  //判断他的运行类型是Phone_
                ((Phone_) usbs[i]).call();
            }
        }
    }
}

interface Usb {
    void work();
}

class Phone_ implements Usb {
    public void call() {
        System.out.println("手机打电话.....");
    }

    @Override
    public void work() {
        System.out.println("手机工作中...");
    }
}

class Camera_ implements Usb {
    @Override
    public void work() {
        System.out.println("相机工作中...");
    }
}

多态传递

InterfacePolyPass类

package com.hspedu.interface_;

/**
 * 演示多态传递现象
 */
public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果 IG 继承了 IH 接口，而 Teacher 类实现了 IG 接口
        //那么，实际上就相当于 Teacher 类也实现了 IH 接口. 
        // 这就是所谓的 接口多态传递现象. 
        IH ih = new Teacher();
    }
}

interface IH {
    void hi();
}
interface IG extends IH {
}
class Teacher implements IG {
    @Override
    public void hi() {
    }
}

测试题

package com.hspedu.interface_;

public class InterfaceExcercise02 {
    public static void main(String[] args) {
    }
}

interface A {
    int x = 0;//想到 等价 public static final int x = 0;
}
class B {
    int x = 1;//普通属性
}
class C extends B implements A {
    public void pX() {
        //System.out.println(x); //错误，原因不明确 x
        //可以明确的指定 x
        //访问接口的 x 就使用 A.x
        //访问父类的 x 就使用 super.x
        System.out.println(A.x + " " + super.x);
    }

    public static void main(String[] args) {
        new C().pX();
    }
}