Java_OOP-高级篇5（接口）

接口
接口的多态特性

接口

基本介绍

将没有实现的方法封装到一起，在某个类需要的时候，根据情况，把方法实现

语法

interface 接口名{
    //属性
    //方法
}
class 类名 implement 接口名{
    //自己的属性
    //自己的方法
    //必须实现接口的抽象方法
}

JDK7.0前接口的所有方法都没有结构体

JDK8.0后接口可以有静态方法、默认方法；也就是说可以有具体的方法实现

default public void show(){}(默认方法)

public static void show1(){}(静态方法)

使用场景

对代码规范有重要作用

统一编码风格

细节与注意

接口不能被实例化
接口中所有方法都是public修饰，可以省略abstract
普通类实现接口，需要实现其所有方法
抽象类实现接口，可以不用实现方法
同一个类可以实现多个接口
接口中的属性修饰符必须为：public static final；写成int n=10默认也会加上上述修饰符
接口中属性访问方式：接口名.属性
接口不能继承其他类，但是可以继承多个接口

interface A extends B,C{}
接口修饰符和类一样，只有public 、默认

package com.java_learn.oop_advanced.interface_;
//访问范围
public class Exercises {
    public static void main(String[] args) {
        D d=new D();
        System.out.println(D.a);
        System.out.println(S.a);
        System.out.println(d.a);
    }
}
interface S{
    int a=12;//默认前面有修饰符public static final
}
class D implements S{
}

接口VS继承

接口是对java单继承的一种扩充

继承价值：主要提高代码复用性可维护性

接口价值：主要设计规范，使用灵活；让其他类去实现。配合动态绑定机制实现代码解耦

package com.java_learn.oop_advanced.interface_;
public class ExtendsVsInterface {
    public static void main(String[] args) {
        /**
         * 当一个人继承了父类之后
         * 后天需要学习技能提升自己，使用接口便可以实现
         * 不必要求父类重新新增技能
         */
        Child_I og = new Child_I(21, "OG");
        og.study_java();
        og.talk();
        og.play_teen();
    }
}
class Father{
   private int age;
   private String name;
    public Father(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public void talk(){
        System.out.println("走路技能");
    }
}
interface Learn{
    //子类可通过接口学习技能
    void study_java();
}
interface  Play{
    //子类通过娱乐接口，正在打网球
    void play_teen();
}
/**
 * 此时继承父类，并且实现Learn接口提升java技能
 * 同时实现Play接口打网球
 */

class Child_I extends Father implements Learn,Play{
    public Child_I(int age, String name) {
        super(age, name);
    }
    @Override
    public void study_java() {
        System.out.println("子类在使用接口学习java");
    }

    @Override
    public void play_teen() {
        System.out.println("正在打网球。。。");
    }
}

接口的多态特性

多态参数

与继承的向上转型类似，接口类型变量也能指向实现了接口的类的实例对象

示例：Run r=new Usb()(前提是该类实现了接口Run)

package com.java_learn.oop_advanced.interface_;

public class InterfacePloy {
    public static void main(String[] args) {
        /**
         * 一个电脑有多个接口
         * 实现usb接入电脑
         * 相机接入电脑
         */
        Computer computer = new Computer();
        Usb usb = new Usb();
        Camera camera = new Camera();
        computer.work(usb);
        computer.work(camera);
    }
}
interface Run{
    void start();
    void stop();
}
class Computer{
    public void work(Run run_i){//此时实现多态参数
        run_i.start();
        run_i.stop();
    }
}
class Camera implements Run{
    @Override
    public void start() {
        System.out.println("相机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作");
    }
}
class Usb implements Run{
    @Override
    public void start() {
        System.out.println("usb开始工作");
    }

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

多态数组

package com.java_learn.oop_advanced.interface_;
//使用上述实现接口类：Camera和Usb
public class InterfacePloyArr {
    public static void main(String[] args) {
        Run[] runs=new Run[2];
        runs[0]=new Camera();
        runs[1]=new Usb();
        for (int i = 0; i < runs.length; i++) {
            runs[i].start();
            if(runs[i] instanceof Camera){
                ((Camera) runs[i]).pictures();
            }
        }
    }
}

多态传递

package com.java_learn.oop_advanced.interface_;

public class InterfacePloyPass {
    public static void main(String[] args) {
        /**
         * 若两个继承关系的接口中一个被实现，另一个接口也必须在该类实现
         * 间接实现的接口变量也可以指向该类
         */
        IG g=new OG();//IG没有被OG直接实现，但是可以指向OG对象
        IH h=new OG();
    }
}
interface IG{
    void ga();
}
interface IH extends IG{
    void ha();
}

class OG implements IH{
    public void ha(){}
    public void ga(){}
}

继承的父类和实现的接口有同名属性问题：

package com.java_learn.oop_advanced.interface_;

public class Exercise01 {
    public static void main(String[] args) {
        /*
        当继承的父类和实现的接口有同名属性时
         */
        Sub01 sub01 = new Sub01();
        sub01.showN();
    }
}
interface E01{
    int n=10;
}
class F01{
    public int n=20;
}
class Sub01 extends F01 implements E01{
    public void showN(){
//        System.out.println(x);此时会编译失败，不能分辨n
//        System.out.println(this.n);不能使用this
        //只能使用以下方法，明确指出
        System.out.println(super.n);
        System.out.println(E01.n);
    }
}