Java 之接口详解

接口

接口
    狭义定义:
        interface 接口名{

        }
    广义定义:接口就相当于定义一个规则 要想使用这个接口  就必须遵循这个规则

注意: (jdk1.8以前的规则)
    1.接口中只能声明抽象方法
    2.如果你声明一个方法  没写 abstract 系统会默认帮你加上(建议先写上abstract)
    3.接口没有构造方法 不能直接实例化对象
    4.接口中定义的成员变量默认的修饰符是public static final 即是个常量 可以直接使用接口名去调用
    使用接口的关键字 implements(实现接口)
    一般来说 接口的实现类 都有后缀 Impl

代码示例:
        public class Demo01 {
            public static void main(String[] args) {
                // 使用实现类(多态方法使用)
                InterA interA = new InterAImpl();
                interA.fun();
            }
        }
        // 声明一个接口
        interface InterA{
            public static final int num = 10;
            public abstract void fun();
        }   
        //实现接口A
        class InterAImpl implements InterA {
            // 重写接口中的方法
            @Override
            public void fun() {
                //num = 15;
                System.out.println("我是实现类的 fun方法");
            }
        }

类和类的关系:类和类是继承关系,只能单继承,可以多层继承
类和接口的关系:类和接口是实现关系,可以单实现也可以多实现
接口和接口的关系
接口和接口是继承关系,可以单继承也可以多继承

测试代码:
        // 测试接口多实现
        interface InterB{
            public abstract void fun1();
        }
        interface InterC{
            public abstract void fun2();
        }

        // 实现类
        class InterImpl implements InterB, InterC {

            @Override
            public void fun1() {

            }

            @Override
            public void fun2() {

            }

        }

        // 测试接口和接口的关系
        interface InterD extends InterB, InterC {

        }

接口小练习:
    需求:
        /*
         * 经过国际主板研究协会讨论 
         * 最终要求 主板生产商 要按规则生产可插卡的主板
         * 所有的卡都要有 开始和停止的方法
         * 设计完成 生产 大力牌主板
         * 
         * 主板接口(插卡方法)
         * 抽象卡类(开始和停止方法)
         * 声卡  继承抽象类
         * 大力牌 实现接口
         */
        public class Demo03 {
            public static void main(String[] args) {
                DLMainBoard dlMainBoard = new DLMainBoard();
                dlMainBoard.run();
                // 添加一张网卡
                dlMainBoard.enterCard(new NetCard());
            }
        }

        // 卡类
        abstract class Card{
            public abstract void start();
            public abstract void stop();
        }

        // 主板接口
        interface CardInter {
            // 插卡方法
            public abstract void enterCard(Card card);
        }

        // 大力牌主板
        class DLMainBoard implements CardInter{
            // 重写接口中的方法
            @Override
            public void enterCard(Card card) {
                System.out.println("可插卡的主板");
                card.start();
                card.stop();
            }
            // 启动主板方法
            public void run() {
                System.out.println("主板启动");
            }
        }

        // 网卡类
        class NetCard extends Card{
            // 重写抽象类的方法
            @Override
            public void start() {
                System.out.println("开始上网");
            }

            @Override
            public void stop() {
                System.out.println("停止上网");
            }   
        }

JDK1.8后接口的新特性(暂时没什么应用场景)
接口中可以声明:
    1.抽象方法
    2.静态方法
    3.默认方法

学习新特性的思路:
    1.明确写法
    2.明确如何在接口和实现类中调用
    3.明确如何使用对象去调用
    4.总结要注意什么

抽象类和接口的区别
    1.成员变量
        抽象类:可以是变量也可以是常量
        接口:只能是常量
    2.成员方法
        抽象类:可以是抽象方法,也可以是普通的成员方法
        接口:只能是抽象方法 静态方法 和 默认方法
    3.构造方法(抽象类和接口都不能实例化对象)
        抽象类:有构造方法,可以被继承
        接口:没有构造方法,只能被实现
代码示例如下:
        public class Demo04 {
            public static void main(String[] args) {
                // 创建一个接口的实现类的对象
                InterX x = new InterXImpl();
                // 接口中默认方法的调用
                x.defaultFun();
                // 调用实现类中的特有方法 需要向下转型
                InterXImpl interXImpl = (InterXImpl)x;
                interXImpl.fun();
                // 接口中静态方法的调用 可以直接使用接口名调用
                InterX.staticFun();
                // 调用实现类中的静态方法
                InterXImpl.staticFun();
            }
        }

        // 声明一个接口
        interface InterX{
            // 抽象方法
            public abstract void print();
            // 静态方法
            public static void staticFun() {
                System.out.println("我是接口中 的静态方法 staticFun()");
            }
            // 默认方法(使用default关键字)
            public default void defaultFun() {
                System.out.println("我是接口中 的默认方法 defaultFun()");
            }
        }

        // 接口的实现类
        // 实现类中 可以不去重写 实现 接口中静态方法 和 默认方法
        class InterXImpl implements InterX{
            //  抽象方法
            @Override
            public void print() {
                System.out.println("我是实现类中 的抽象方法");
            }
            // 重写接口中默认方法
            @Override
            public void defaultFun() {
                // 实现类中调用 接口类中的 默认方法  可以使用
                // 接口名.super.方法名()
                InterX.super.defaultFun();
                System.out.println("我是实现类中 的默认方法");
            }
            // 接口中静态方法 又叫类方法  
            public static void staticFun() {
                System.out.println("我是实现类中 的静态方法 staticFun()");
            }
            // 实现类中特有方法
            public void fun() {
                // 调用接口中 默认方法
                InterX.super.defaultFun();
                System.out.println("我是实现类中的 特有方法 fun()");
            }
        }

模板设计模式 — (设计思想)

代码示例:
    需求:
        学习类 来xx学习 报名缴费 选择学科进行学习(Java H5 VR) 毕业找工作

        public class Demo05 {
            public static void main(String[] args) {
                YZP yzp = new YZP();
                yzp.lanOuStudy();
            }
        }

        // 学习类(相当于一个模板 可以适用选择不同学科的学生)目的想让学习类 适用于来蓝欧学习的每一个学生
        abstract class Study {
            // 来xx学习的方法
            public void lanOuStudy() {
                // 第一步和最后一步已经确定
                // 只有中间一部分不确定
                System.out.println("报名缴费");
                //System.out.println("选择Java学习");
                // 调用抽象方法
                chooseSubject();
                System.out.println("毕业找工作");
            }
            // 声明一个抽象方法
            public abstract void chooseSubject();
        }

        // YZP 来xx学习
        class YZP extends Study{
            @Override
            public void chooseSubject() {
                System.out.println("选择Java学习");
            }   
        }