java接口篇

一：概念

接口就是公共行为的规范，只要符合这个规范，都可以使用，可以看成是多个类的公共规范，

是一种引用数据类型。

二：语法

被interfac修饰的就是接口

public interfac 接口名 {

}

接口中的方法默认都是public abstract修饰的，

成员默认都是public static final修饰的。

三：接口的使用

public class 类名 implements 接口名 {

}

接口不能直接使用，是通过类继承来进行使用的

如果这个类继承了这个接口，那么这个类就要重写接口的所有抽象方法。

创建一个笔记本类

public class Computer {
    public void powerOn(){
        System.out.println("打开笔记本");
    }
    public void powerOff(){
        System.out.println("关闭笔记本");
    }

    public void usbDevice(IUsb usb){
        usb.openDevice();                      //使用接口中的打开
        if(usb instanceof Mouse) {
            Mouse mouse = (Mouse) usb;
            mouse.click();
        } else if (usb instanceof KeyBoard) {    //根据instanceof来判断属于哪个类，在去调用这个类特有的方法
            KeyBoard keyBoard = (KeyBoard) usb;
            keyBoard.input();
        }
        usb.closeDevice();                   //使用接口中的关闭
    }
}

创建一个接口，有有打开和关闭的动作

public interface IUsb {
    void openDevice();
    void closeDevice();
}

 

键盘有打开关闭和使用，那么我们就可以继承这个类

public class KeyBoard implements IUsb{
    @Override
    public void openDevice() {
        System.out.println("打开键盘");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭键盘");
    }

    public void input(){
        System.out.println("使用键盘");
    }
}

 鼠标也一样

public class Mouse implements IUsb{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }

    public void click(){
        System.out.println("使用鼠标");
    }
}

最后我们在这里进行最后的测试 

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();

        computer.usbDevice(new Mouse());
        computer.usbDevice(new KeyBoard());
        computer.powerOff();
    }
}

下面我们来看看测试结果。

这个就是一个很好的调用接口的例子。

四：接口特性

1.  使用interface来定义一个接口，开头要用大写的I，可以当成抽象类的抽象类、
2. 接口也不能通过关键子new来进行实例化
3. 接口中的方法默认是public abstract修饰的，不写也可以
4. 接口中默认成员变量是被public static final修饰的（静态常量）
5. 在接口中不能有具体实现的方法
6. 被default修饰的也可以实现{1.8开始引入的特性}
7. Static可以有具体的实现
8. 类通过关键字implements来进行关联
9. 一个类实现了一个接口后，就必须重写这个接口的抽象类方法
10. 当接口中存在default方法时，可以选择重写，也可以选择不重写
11. 当要判断一个类A是不是由类B向上转型得来的，可以使用instanceof来判断
12. 接口中不能有静态代码块和构造方法
13. 如果类没有完全实现接口中的抽象方法，那么这个类得设置为抽象类

 

五：实现多个接口

java中不能进行多继承，但是可以通过多接口的方式来实现。

比如狗子会跑，会走，鸭子会走会游，鸟会飞会走。

那么我们可以定义四个接口，分别是会走的，会游的，会飞的，会跑的

public interface IFly {
    void fly();
}

public interface IRun {
    void run();
}

public interface ISwim {
    void swim();
}

public interface IWalk {
    void walk();
}


public class Animal {
    private String name;

    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Bird extends Animal implements IWalk,IFly{

    public Bird(String name, int age) {
        super(name, age);
    }

    @Override
    public void fly() {
        System.out.println(this.getName()+"在用翅膀飞");
    }

    @Override
    public void walk() {
        System.out.println(this.getName() +"在用脚走");
    }
}


public class Dog extends Animal implements IWalk,IRun{

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void run() {
        System.out.println(this.getName()+"正在用四条腿跑");
    }

    @Override
    public void walk() {
        System.out.println(this.getName()+"正在用两条腿走");
    }
}

public class Duck extends Animal implements IWalk,ISwim{

    public Duck(String name, int age) {
        super(name, age);
    }

    @Override
    public void swim() {
        System.out.println(this.getName()+"用两只脚掌在游");
    }

    @Override
    public void walk() {
        System.out.println(this.getName()+"用头在走");
    }
}


public class Test {
    public static void walk1(IRun iRun) {
        iRun.run();
    }
    public static void walk2(IWalk iWalk) {
        iWalk.walk();
    }

    public static void walk3(ISwim iSwim) {
        iSwim.swim();
    }
    public static void walk4(IFly iFly) {
        iFly.fly();
    }
    public static void main(String[] args) {

        walk1(new Dog("小八嘎",1));
        walk2(new Duck("小坤子",2));
        walk3(new Duck("小坤子二号",1));
        walk4(new Bird("小坤子三号",1));
    }
}

 

我们可以通过不同接口的类型来分别调用这些方法。 

比如狗子会跑，那么就调用跑的接口..

好处牢记多态的好处，让程序员忘记类型，有了接口之后，类的使用者就不必关注具体的类型，只需要看这个类是否具有接口的属性。

六：接口的继承

接口是可以实现多个的，接口之间的继承也可以实现多个。

比如我们可以实现两个接口，一个跑，一个游，这都属于两栖动物，那么我们可以创建一个两栖动物接口，将跑和游都继承进去。

而当我们的类继承了这个两栖动物接口时，就要重写跑和游的抽象方法。

public interface IAmphibians extends IRun,ISwim{
}

public interface IRun {
    void run();
}

public interface ISwim {
    void swim();
}

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

    }
}
class Duck implements IAmphibians{

    @Override
    public void run() {

    }

    @Override
    public void swim() {

    }
}