JAVA基础——接口（全网最详细教程）

于 2024-06-20 19:21:17 发布
阅读量662 收藏 18
点赞数 29
分类专栏： JAVA 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65752158/article/details/139819512
版权

概述

我们已经学完了抽象类，抽象类中可以用抽象方法，也可以有普通方法，构造方法，成员变量等。那么什么是接口呢？接口是更加彻底的抽象，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
    评论
专栏目录
Java接口详解
qq_42006733的博客
08-18 619
定义 Java接口由Interface定义，他并不是类，但是和类是一个级别，与类有一些共性也有着很大的区别 接口的组成 在Java编程语言中接口是一个抽象类型，是抽象方法和全局常量的集合 定义一个接口 public interface IMessage{ public static final String MSG = "I am a student" ; // 全...
最适合小白的java接口教程
最新发布
2301_79987255的博客
05-03 966
1.接口用的关键字是interface，而不是class2.接口里面的方法只有声明，没有方法体，这种方法也叫做抽象方法（用abstract关键字修饰）3.接口里面的方法默认都是public因为暂时没有接口的实现类（方法都是空的），所以这边只是引用，不去new。先把原来的保存代码注释掉，然后依次调用接口的方法，顺便说一句，cstList做成static的，方便调用。">main方法源码：newLine(“欢迎使用兔子餐厅会员系统”);
Java 接口详解
liaofeifei_book的博客
06-15 258
接口详解 文章所涉及的资料来自互联网整理和个人总结，仅作为个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！ 1.1接口概述 接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法、成员方法，那么接口的内部主要就是封装了方法，包含抽象方法(JDK 7及以前)、默认方法和静态方法(JDK8)，私有方法(JDK9)。 1.2 定义格式 接口格式 public interface 接口名称 { // 抽象方法 // 默认方法 // 静态方法
Java接口（详解）
m0_52896041的博客
10-19 1999
Java接口（详解）
eclipse连接mysql全网最详细教程
05-30
java
java基础教程----精华版
09-22
这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**： - **变量**：在Java中，变量是存储...
Java 基础 —— 五阶段
05-02
Java 基础 —— 五阶段
Java面试宝典2021——java基础.pdf
04-30
面试题汇集，JAVA开发找工作时，尤其是实干派，明明都会做，但是面试总是不过，看java面试宝典，汇集现在java基础部分的面试题，可以高效的回顾
java接口详解
晓晓晓的打工日记
12-25 111
先介绍一下普通类、抽象类以及接口三者的区别： 普通类：只有具体实现 抽象类：具体实现和规范都有 接口：只有规范，自己无法写方法。接口是专业的约束，实现了约束和实现的分离。 接口定义的关键字是interface。**接口中的所有定义其实都是抽象的public abstract。**如果要在接口中定义方法，直接： 返回值类型+方法名即可 接口都需要有实现类。 我们先定义User接口如下，具有增删改查功能； public interface User { void add(String name);
Java 接口 详解
chenshun123的博客
09-29 415
接口中的默认方法 Java 8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default 关键字修饰 默认方法不能直接调用，可以通过其实现类调用这个默认方法，默认方法 接口中的默认方法 接口默认方法的” 类优先” 原则 若一个接口中定义一个默认方法，而另外一个父类或接口中又定义一个同名的方法时 1> 选择父类中的方法。如果一个父类提供了具体的实现，
java 接口详解
赵炳泉的博客
08-01 422
Java 接口 接口，在Java编程语言中是一个抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式。从而来继承接口的抽象方法。 接口并不是类，编写接口的方式和类很相似，但是属于不同的概念。类描述对象的所有方法。接口则包含类要实现的方法。 接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的属性和方法。否则就必须声明为抽象类。另外，在Java中，...
Java 接口
aldsot0997的博客
08-20 676
Java 接口 接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。 接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。 除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。...
Java语言历史与基础教程
"本资源是一份详细的Java基础教程，旨在帮助初学者掌握Java编程语言的基本概念和语法。教程涵盖Java语言的起源、发展历史以及其在互联网领域的应用。通过学习，读者将了解Java的起源——从Oak到Java的转变，以及Java...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值