Java中的接口

Java中的接口

接口

狭义的定义:

关键字 : interface

interface 接口名{

}

广义的定义:

接口相当于定义了一个规则

要想使用这个接口 就必须遵循这个规则

public class Demo{
    public static void main(String[] args) {
        // 使用实现类(多态方法使用)
        InterA interA = new InterAImpl();
        interA.fun();
        // 直接调用num
        System.out.println(InterA.num);
    }
}

注意: JDK 1.8 以前的规则

1. 接口中只能声明抽象方法
2. 如果你声明一个方法 没写 abstract 系统会默认帮你加上

建议: 建议你先写上 等写熟了再说

1. 接口没有构造方法 不能直接实例化对象
2. 接口中定义的成员变量 默认的修饰词 是 public static final 是常量
   直接使用接口名 去调用

使用接口的关键字 implements(实现接口)

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

interface InterA{
    public static final int num = 10;
    public abstract void fun();
}
// 实现接口A
class InterAImpl implements InterA{

    // 重写接口中的方法
    @Override
    public void fun() {
        System.out.println(num);
        System.out.println("我是实现类的 fun方法");
    }

}

举例:

需求:
    动物 吃 叫
    猫  吃鱼 喵喵喵
     训练动物: 跳高
     会跳高的猫

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();
}

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

}

// 实现类
class InterImpl implements InterB , InterC{
    @Override
    public void fun2() {
    }
    @Override
    public void fun1() {
    }
}

类和类的关系:

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

---

类和接口的关系:

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

---

接口和接口的关系:

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

---

举例:

   经过国际主板研究协会讨论 
   最终要求 主板生产商 要按规则生产可插卡的主板
   所有的卡都要有 开始和停止的方法
   设计完成 生产 大力牌主板

   主板接口(插卡方法)
   抽象卡类(开始和停止的方法)
   声卡 继承抽象类
   大力牌 实现接口

public class Demo {
    public static void main(String[] args) {
         父类引用指向子类空间
        MainBoardInter dlBoard = new DLBoard();
         通过向下转型 来调用 子类特有的方法
        DLBoard dl = (DLBoard)dlBoard;
        dl.run();
         添加一张网卡
        dl.addCard(new NetCard());

    }
}

 接口
interface MainBoardInter{
     插卡方法 // Card card = new NetCard();
    public abstract void addCard(Card card);//规则
}

 主板类
abstract class Card{
    public abstract void start() ;
    public abstract void stop() ;
}

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

}



 大力牌
class DLBoard implements MainBoardInter{
     重写接口中的方法
    @Override
    public void addCard(Card card) {
        card.start();
        card.stop();
    }
     启动主板方法
    public void run() {
        System.out.println("主板启动");
    }
}

JDK 1.8 以后的新特性

接口中可以声明

1.抽象方法

2.静态方法

3.默认方法

---

分析思路:(如何使用的思路)

• 1.明确写法
• 2.明确如何在接口和实现类中调用
• 3.明确如何使用对象去调用
• 4.总结要注意什么

注意 :

抽象类和接口的区别 :

1.成员变量

抽象类: 可以是变量 可以是常量

接口: 只能是常量

2.成员方法

抽象类: 可以是抽象方法 也可以普通的成员方法

接口: 只能是抽象方法 静态方法 和 默认方法

3.构造方法(抽象类和接口 都不能实例化对象)

抽象类: 有构造方法 可以被继承

接口: 没有构造方法 只能被实现

public class Demo {
    public static void main(String[] args) {
         接口中静态方法的调用 可以直接使用接口名调用
        InterX.staticFun();
         创建一个接口的实现类的对象
        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 void fun() {
         调用接口中 默认方法
        InterX.super.defaultFun();
        System.out.println(" 我是实现类中的 特有方法 fun() ");
    }

     静态方法 又叫 类方法
    public static void staticFun() {
        System.out.println(" 我是实现类中 静态方法 staticFun() ");
    }
}

---

 需求:
                 计算一个程序的 运行时间

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

        /*
         获取1970.1.1日和当前系统时间的差值
         以毫秒为单位 1秒 == 1000毫秒
        long time = System.currentTimeMillis();
        System.out.println(time);
        */

        GetTime time = new Test();
        time.getTime();
    }
}

   创建一个 获取程序的时间
abstract class GetTime{
    public void getTime() {
           获取系统当前时间(程序执行前)
        long start = System.currentTimeMillis();
           写段程序
        fun();
           获取时间(执行后的)
        long stop = System.currentTimeMillis();
           打印程序的 时间差
        System.out.println("程序执行 : " + (stop - start ) + "毫秒");
    }
       把执行的程序声明为抽象方法
    public abstract void fun();
}
class Test extends GetTime{
       重写抽象方法 方法中就写 要计算执行时间的方法
    @Override
    public void fun() {
        for (int i = 0; i < 999; i++) {
            System.out.println(i);
        }
    }
}