JAVA基础——接口(全网最详细教程)

概述

我们已经学完了抽象类,抽象类中可以用抽象方法,也可以有普通方法,构造方法,成员变量等。那么什么是接口呢?接口是更加彻底的抽象,JDK7之前,包括JDK7,接口中全部是抽象方法。接口同样是不能创建对象的

 

 把特有的方法(行为)写成接口,要用的时候调用接口就行了,除了狗和青蛙要用到游泳这个行为,当我们需要给多个类同时定义规则的时候,就需要用到接口

接口就是规则 

定义格式

//接口的定义格式:
interface 接口名称{
    // 抽象方法
}

// 接口的声明:interface
// 接口名称:首字母大写,满足“驼峰模式”

 

接口与抽象类的异同

抽象类作为父类的,他是表示动物这一类事物,接口侧重于行为,是对行为的抽象

练习

测试类

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

        Frog f = new Frog("小青",18);
        f.eat();
        f.swim();
        System.out.println(f.getAge()+" "+f.getName());
        System.out.println("------------------");
        Dog d = new Dog("小黑",5);
        d.eat();
        d.swim();
        System.out.println(d.getAge()+" "+d.getName());
        System.out.println("------------------");
        Rabbit r = new Rabbit("小白",6);
        r.eat();
        System.out.println(r.getAge()+" "+r.getName());
    }
}

接口

package jiekou.demo01;
//定义一个接口
public interface Swim {
    //定义一个规则
    public abstract void swim();
}

父类Animal

package jiekou.demo01;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

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

子类Dog

public class Dog   extends Animal implements Swim{

    @Override
    public void eat() {
        System.out.println("狗在吃骨头");
    }

    @Override
    public void swim() {
        System.out.println("狗刨");
    }

    public Dog() {
    }

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

子类Frog

public class Frog  extends Animal implements Swim{
    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");
    }

    public Frog() {
    }

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

子类兔子

public class Rabbit extends Animal {
    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜");
    }

    public Rabbit() {
    }

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

接口成分的特点

在JDK7,包括JDK7之前,接口中的只有包含:抽象方法和常量

抽象方法

注意:接口中的抽象方法默认会自动加上public abstract修饰程序员无需自己手写!! ​ 按照规范:以后接口中的抽象方法建议不要写上public abstract。因为没有必要啊,默认会加上。

常量  

在接口中定义的成员变量默认会加上: public static final修饰。也就是说在接口中定义的成员变量实际上是一个常量。这里是使用public static final修饰后,变量值就不可被修改,并且是静态化的变量可以直接用接口名访问,所以也叫常量。常量必须要给初始值。常量命名规范建议字母全部大写,多个单词用下划线连接。

 

案例演示

public interface InterF {
    // 抽象方法!
    //    public abstract void run();
    void run();

    //    public abstract String getName();
    String getName();

    //    public abstract int add(int a , int b);
    int add(int a , int b);


    // 它的最终写法是:
    // public static final int AGE = 12 ;
    int AGE  = 12; //常量
    String SCHOOL_NAME = "黑马程序员";

}

实现接口的概述

类与接口的关系为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类。实现的动作类似继承,格式相仿,只是关键字不同,实现使用 implements关键字。

实现接口的格式

/**接口的实现:
    在Java中接口是被实现的,实现接口的类称为实现类。
    实现类的格式:*/
class 类名 implements 接口1,接口2,接口3...{

}

类与接口基本实现案例

假如我们定义一个运动员的接口(规范),代码如下:

/**
   接口:接口体现的是规范。
 * */
public interface SportMan {
    void run(); // 抽象方法,跑步。
    void law(); // 抽象方法,遵守法律。
    String compittion(String project);  // 抽象方法,比赛。
}

接下来定义一个乒乓球运动员类,实现接口,实现接口的实现类代码如下:

package com.itheima._03接口的实现;
/**
 * 接口的实现:
 *    在Java中接口是被实现的,实现接口的类称为实现类。
 *    实现类的格式:
 *      class 类名 implements 接口1,接口2,接口3...{
 *
 *
 *      }
 * */
public class PingPongMan  implements SportMan {
    @Override
    public void run() {
        System.out.println("乒乓球运动员稍微跑一下!!");
    }

    @Override
    public void law() {
        System.out.println("乒乓球运动员守法!");
    }

    @Override
    public String compittion(String project) {
        return "参加"+project+"得金牌!";
    }
}

测试代码

public class TestMain {
    public static void main(String[] args) {
        // 创建实现类对象。
        PingPongMan zjk = new PingPongMan();
        zjk.run();
        zjk.law();
        System.out.println(zjk.compittion("全球乒乓球比赛"));

    }
}

//类和接口之间的关系
//实现类,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口

import jiekou.demo02.Inter;

//类和接口之间的关系
//实现类,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口
public class Interlmpl implements Inter1, Inter2 {
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }
}

//接口和接口之间的是继承关系,可以单继承,也可以多继承
//细节:如果实现类实现了最下面的子接口,那么就就需要重写所有的抽象方法

package jiekou.demo04;

public class Interlmpl  implements  Inter3{
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }
}

练习

测试类 

public class Test {
    public static void main(String[] args) {
        PingPangSproter p = new PingPangSproter("张三",18);
        p.study();
        p.SpeakEnglish();
        System.out.println(p.getName()+" "+p.getAge());
        System.out.println("-------------------");
        BasketballSproter b = new BasketballSproter("李四",20);
        b.study();
        System.out.println(b.getName()+" "+b.getAge());
        System.out.println("-------------------");
        PingPangCoath a = new PingPangCoath("王五",18);
        a.teach();
        a.SpeakEnglish();
        System.out.println(a.getName()+" "+a.getAge());
        System.out.println("-------------------");
        BasketballSporterCoath h = new BasketballSporterCoath("赵六",20);
        h.teach();
        System.out.println(h.getName()+" "+h.getAge());
    }
}

子类运动员

public abstract class Sporter extends Person {
    public Sporter() {
    }

    public Sporter(String name, int age) {
        super(name, age);
    }
    public abstract void study();
}

子类教练

public abstract class Coath  extends Person{
    public Coath() {
    }

    public Coath(String name, int age) {
        super(name, age);
    }
    public abstract void teach();
}

子子类乒乓球运动员

public class PingPangSproter extends Sporter implements English {
    @Override
    public void SpeakEnglish() {
        System.out.println("乒乓球运动员在说英语");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员在学打乒乓球");
    }

    public PingPangSproter() {
    }

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

子子类篮球运动员

public class BasketballSproter extends Sporter {
    @Override
    public void study() {
        System.out.println("篮球运动员在学打篮球");
    }

    public BasketballSproter() {
    }

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

子子类乒乓球教练

public class PingPangCoath  extends Coath implements  English{
    @Override
    public void teach() {
        System.out.println("乒乓球教练在教打乒乓球");
    }

    @Override
    public void SpeakEnglish() {
        System.out.println("乒乓球教练在说英语");
    }

    public PingPangCoath() {
    }

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

子子类篮球教练

public class BasketballSporterCoath extends Coath {
    @Override
    public void teach() {
        System.out.println("篮球教练在教打篮球");
    }

    public BasketballSporterCoath() {
    }

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

说英语接口


public interface English  {
    void SpeakEnglish();
}

结果

扩展:接口的细节

public interface Inter {
    /*
    接口中的默认方法的定义格式
    格式: public default 返回值类型 方法名(参数列表){ }
     */
    /*
    接口中的默认的注意事项:
    1.默认方法不是抽象方法,所以不强制被重写,但是如果被重写,重写的时候去掉default关键字
    2.public可以省略,default不能被省略
    3.如果实现了多个接口,多个接口中存在相同的名字的默认方法,子类就必须对该方法进行重写
     */
    public  abstract  void method();
    public default void show() {
        System.out.println("接口的默认方法-------show");
    }
}
public class Interlmpl  implements  Inter {
    @Override
    public void method() {
        System.out.println("实现类重写的抽象方法");
    }

    @Override
    public void show() {
        System.out.println("接口的默认方法-被重写------show");
    }
}
public class Test {
    public static void main(String[] args) {
        Interlmpl i=new Interlmpl();
        i.method();
        i.show();
    }
}

静态方法不能被重写

package jiekou.demo7;

public class Test {
    public static void main(String[] args) {
        //调用接口静态方法
        Inter.show();
        //调用实现类中的静态方法
        InterImpl.show();
    }
}
public class InterImpl  implements  Inter{

    @Override
    public void method() {
        System.out.println("InterImpl重写的抽象方法");
    }
    public  static void show(){
        System.out.println("InterImpl实现类里的静态方法-----show");
    }
}

public interface Inter {
    public static  void show(){
        System.out.println("Inter里的静态方法-----show");
    }
    public abstract void method();
}

子类把从父类继承下来的虚方法表里面的方法进行覆盖了,这才叫重写

第一个是默认的方法

第二个静态方法

接口可以理解为各种行为的规则,你想要某个javabean类拥有对应的行为,那就实现对应的接口

接口的多态

 

适配器原理

就是在实现类里面重写自己指定的方法

package jiekou.demo8;


public class Interlmpl  extends Temp{
    //我需要用到那个方法,就用哪个方法

    @Override
    public void method5() {
        System.out.println("主要用第五个");
    }
}

package jiekou.demo8;

public interface Inter {
    public abstract  void method1();
    public abstract  void method2();
    public abstract  void method3();
    public abstract  void method4();
    public abstract  void method5();
    public abstract  void method6();
    public abstract  void method7();
    public abstract  void method8();
    public abstract  void method18();
}

package jiekou.demo8;

public abstract class Temp  implements Inter {


    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }

    @Override
    public void method5() {

    }

    @Override
    public void method6() {

    }

    @Override
    public void method7() {

    }

    @Override
    public void method8() {

    }

    @Override
    public void method18() {

    }
}

  • 29
    点赞
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值