首页 > 编程语言 >JAVA基础——接口（全网最详细教程）

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

时间：2024-06-20 19:32:22浏览次数：11  
标签：教程 JAVA void 全网 System 接口 println public out

概述

我们已经学完了抽象类，抽象类中可以用抽象方法，也可以有普通方法，构造方法，成员变量等。那么什么是接口呢？接口是更加彻底的抽象，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() {

    }
}

标签：教程,JAVA,void,全网,System,接口,println,public,out
From： https://blog.csdn.net/weixin_65752158/article/details/139819512

相关文章

  • 2024年 Java 面试八股文（20w字）
    第一章-Java基础篇1、你是怎样理解OOP面向对象   难度系数：⭐面向对象是利于语言对现实事物进行抽象。面向对象具有以下特征：继承：继承是从已有类得到继承信息创建新类的过程封装：封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口多态性：多态性是指允......
  • Java面试八股文2024最新版
    一、java基础1、java有哪几种数据类型？基本数据类型：byte（1），char（2），short（2），int（4），long（8），double（8），float（4），boolean（1）引用数据类型：各种类和接口，枚举，数组2、 面向对象和面向过程的区别？面向对象和面向过程都是一种开发思想。面向过程就是根据解决问题所需要的步骤，具体化的一步一步的去实现......
  • Python入门_基础理论_全网详细版
    （根据黑马教程整理）第二章01-字面量0.6数据的类型1.掌握字面量的含义代码中，被写在代码中的固定值，称之为字面量2.常见的字面量类型整数、浮点数、字符串3.基于print语句完成各类字面量的输出print(10)print("今天是23年2月22日")第二章02-注释1.单行注释：#2.......
  • 微信小程序源码-基于Java后端的教学质量评价系统的计算机毕业设计(附源码+论文)
    大家好！我是程序员一帆，感谢您阅读本文，欢迎一键三连哦。......
  • Java跳动爱心代码
    1.计算爱心曲线上的点的公式计算爱心曲线上的点的公式通常基于参数方程。以下是两种常见的参数方程表示方法，用于绘制爱心曲线：1.1基于(x,y)坐标的参数方程x=a*(2*cos(θ)-sin(θ))^3y=a*(2*sin(θ)-cos(θ))^3其中，a是一个常数，用于控制爱心的大小；θ是参......
  • EarMaster Pro\软件下载及安装教程
    ​简介来自丹麦皇家音乐学院的多媒体音乐教育软件EarMasterPro以问答的交互形式，寓教于乐的视听方法，给专业和非专业音乐人士以极大的音乐学习帮助。无论你是刚学音乐的儿童，还是一个音乐高手，都可以使用这个软件来增强你的听音能力。因为这个软件可以灵活的设置难度了级别。E......
  • PDFFactory&FinePrint软件安装包下载+详细安装教程
    简介：pdfFactoryPro(虚拟打印机)是一个无须Acrobat创建AdobePDF文件的打印机驱动程序。pdffactorypro虚拟打印机提供了比其他程序提供得更简单、更有效率和更少的花费的创建PDF文件的解决方案。用于需要安全的PDF(法律文档、公司信息等)和其他高级功能的用户。安......
  • Exposure X7 mac中文版安装包下载及安装教程
    简介：Exposure是专为摄影艺术设计的图像编辑器。新的ExposureX7结合了专业级的照片调整、庞大的华丽照片库和令人愉悦的高效设计。安装包获取地址：ExposureX7Win版：​​https://souurl.cn/AKHdBV​​ExposureX7Mac版：​​https://souurl.cn/tYdYWg​​功能特性：......
  • Pointnet++改进即插即用系列：全网首发FastKAN|即插即用，提升特征提取模块性能
    简介：1.该教程提供大量的首发改进的方式，降低上手难度，多种结构改进，助力寻找创新点！2.本篇文章对Pointnet++特征提取模块进行改进，加入FastKAN，提升性能。3.专栏持续更新，紧随最新的研究内容。目录1.理论介绍2.修改步骤2.1步骤一     2.2步骤二     2.3步......
  • 腾讯云部署的java服务，访问阿里云的mysql数据库，带宽异常偏高，可能是什么原因
    个人名片......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99