Java中的接口(基础详解)

接口

    接口的狭义的定义:
    是个关键词
    写法:
    interface 接口名{

    }

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

    例如:
    //声明一个接口
    interface InterA{
        int num = 10;
        //上面这种定义成员变量的方式与下面的相同
        (public static final int num = 10;)

    //接口定义的成员变量 默认的修饰词 是:
    //public static final 
    //说明接口中定义的成员变量是一个常量 不能被修改
    //要想调用 可以直接使用接口名去调用

    public abstract void fun();
    //上面这张声明方法的方式和下面的相同
    //如果你声明一个方法没写 abstract 系统会默认帮你加上
    //这里建议如果你刚开始学的话 就写上
    //因为如果你不写的话 在你还不是很熟练的时候
    //你会下意识以为 找个方法 不是抽象方法
    (public void fun();)
    }

    //使用接口的关键字 implements(实现接口)
    //在接口中一班说实现接口

    //一班来说 接口的实现类 都有后缀 Impl



    //实现接口InterA
    class InterAImpl implements InterA{
        //当你实现接口的时候
        //系统会强制你重写接口的方法
        //不然就会报错

        //重写 接口中的方法
        @Override
        public void fun(){
            //num = 15; 这里的num不能修改 因为是常量
            System.out.println(num);
            System.out.println("我是实现类的 fun 方法");
        }
    }

注意

    jdk1.8以前的规则:
        1.接口中只能声明抽象方法
        2.如果你声明一个方法 没写 abstract 系统会默认帮你加上
        3.接口没有构造方法(不能被继承) 不能直接实例化
        4.接口定义的成员变量 默认的修饰词 是 public static final 是常量
        直接使用接口名 去调用

    关于接口的小练习:

   /* 需求:
    * 动物 吃 叫
    * 
    * 猫 吃鱼 喵喵喵
    * 
    * 训练动物: 跳高 
    */

        public class Demo {
        public static void main(String[] args) {
            //创建一个cat对象
            Cat cat = new Cat();
            //调用cat对象里的 eat方法
            cat.eat();
            //调用cat对象里的 speak方法
            cat.speak();
            //创建一个对象 调用接口
            JumpCat jCat = new JumpCat();
            //调用接口中的方法
            jCat.jump();

        }
    }

        //动物类
    abstract class Animal{
        //抽象方法
        public abstract void eat();
        public abstract void speak();
    }

    //接口 训练猫
    interface CatJumpInter{
        //训练毛
        public abstract void jump();
    }

    //猫
    class Cat extends Animal{
        //重写抽象类的方法
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
        @Override
        public void speak() {
            System.out.println("猫叫 喵喵喵");
        }
    }

    //跳高猫
    //因为跳高猫有猫的全部特性
    //所以跳高猫可以直接继承猫类
    class JumpCat extends Cat implements CatJumpInter{
        //实现接口中的方法
        @Override
        public void jump() {
            System.out.println("拿棍子怼屁股 训练跳高的最好方法");
        }
    }

    类和类的关系:
        类和类是继承关系 只能单继承 可以多层继承

    类和接口的关系:
        类和接口是实现关系 可以单实现 可以多实现

    接口和接口的关系:
        是继承关系 可以单继承 也可以多继承


    //测试接口的多实现
    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{
        public abstract void fun3();
    }

    interface InterE{
        public abstract void fun4();
    }

    interface InterF extends InterD,InterC{

    }

    jdk1.8接口的新特性(暂时没什么应用场景)

    接口中可以声明:
        1.抽象方法
        2.静态方法
        3.默认方法

    抽象类 和 接口的区别
        1.成员变量
        抽象类: 可以是变量 可以是常量
        接口: 只能是常量
        2.成员方法
        抽象类:可以是抽象方法 也可以是普通的成员方法
        接口: 只能是抽象方法 静态方法 和 默认方法
        3.构造方法(抽象类和接口 都不能被实例化对象)
        抽象类: 有构造方法 可以被继承
        接口: 没有构造方法 只能被实现

        例如:
        //接口中的静态方法
        public class Demo{
            public static void main(String[] args) {
                //接口中 静态方法的调用 
                //可以直接使用 接口名 调用
                InterX.staticFun();
            }
        }
        //接口的实现类
        //实现类中 可以不去重写 (实现) 接口中的静态方法 和  默认方法
        interface Inter X{
            public static void staticFun() {
                System.out.println("我是接口中的静态方法staticFun()");
    }
}

    例如:
    //接口中的默认方法

     public class Demo{
            public static void main(String[] args) {
                //创建一个接口实现类的对象
                InterX XImpl = new InterXImpl();
                //调用接口中的默认方法
            }
        }

    interface InterX{
        //默认方法(使用default关键词)
        public default void defaultFun() {
            System.out.println("我是接口中的默认方法defaultFun()");
        }
    }

    //接口的实现类
    //实现类中 可以不去重写 (实现) 接口中的静态方法 和  默认方法
    class InterXImpl implements InterX{
    //重写接口中的默认方法
    @Override
    public void defaultFun() {
        //实现类中调用接口类中的默认方法 可以使用
        //实现父类中的default 方法
        // 接口名.super.方法名();
        InterX.super.defaultFun();
        System.out.println("我是实现类中 的 默认方法");
        }
    }

    public class Demo {
        public static void main(String[] args) {
        //创建一个接口实现类的对象
        InterXImpl interXImpl = new InterXImpl();
        //调用接口中的静态方法
        InterX.staticFun();
        //调用实现类中的静态方法
        interXImpl.staticFun();


    interface InterX{
        public static void staticFun() {
            System.out.println("我是接口中的静态方法staticFun()");
        }
    }
    //接口的实现类
    //实现类中 可以不去重写 (实现) 接口中的静态方法 和  默认方法
    class InterXImpl implements InterX{
            //静态方法又叫 类方法
        public static void staticFun() {
            System.out.println("我是实现类中 静态方法 staticFun()");
        }
    }

                                                                  Day.12