接口(java)

已于 2022-10-11 13:41:16 修改
阅读量397 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
于 2022-10-06 14:08:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57385165/article/details/127219185
版权

1 为什么有接口

1664786322603

1.定义接口：有一系列的方法(规范)

public interface UsbInterface { //接口
    //规定接口的相关方法,老师规定的.即规范...
    public void start();
    public void stop();
}

2.使用接口的设备

//Phone 类 实现 UsbInterface
//解读1. 即 Phone类需要实现 UsbInterface接口 规定/声明的方法
public class Phone implements UsbInterface {

    @Override
    public void start() {
        System.out.println("手机开始工作...");
    }

    @Override
    public void stop() {
        System.out.println("手机停止工作.....");
    }
}
public class Camera implements UsbInterface {//实现接口,就是把接口方法实现

    @Override
    public void start() {
        System.out.println("相机开始工作...");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作....");
    }
}

3.电脑使用接口

1664787009385

public class Computer {
    //编写一个方法, 计算机工作
    //解读:
    //1. UsbInterface usbInterface 形参是接口类型 UsbInterface
    //2. 看到 接收 实现了 UsbInterface接口的类的对象实例
    public void work(UsbInterface usbInterface) {
        //通过接口，来调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}

4.测试

public class Interface01 {
    public static void main(String[] args) {
        //创建手机，相机对象
        //Camera 实现了 UsbInterface
        Camera camera = new Camera();
        //Phone 实现了 UsbInterface
        Phone phone = new Phone();
        //创建计算机
        Computer computer = new Computer();
        computer.work(phone);//把手机接入到计算机
        System.out.println("===============");
        computer.work(camera);//把相机接入到计算机

    }
}

2 基本介绍

1664857349285

public interface AInterface {
    //写属性
    public int n1 = 10;
    //写方法
    //在接口中，抽象方法，可以省略abstract关键字
    public void hi();

    //在jdk8后，可以有默认实现方法,需要使用default关键字修饰
    default public void ok() {
        System.out.println("ok ...");
    }
    //在jdk8后, 可以有静态方法
    public static void cry() {
        System.out.println("cry ....");
    }
}
1.如果一个类 implements实现 接口
2. 需要将该接口的所有抽象方法都实现
//class A implements AInterface {
//    @Override
//    public void hi() {
//        System.out.println("hi()....");
//    }
//}

3 什么时候使用接口呢？

1664857931457

1664857994113

1664893160091

编写接口

public interface DBInterface { //项目经理

    public void connect();//连接方法
    public void close();//关闭连接
}

编写类实现接口中的所有方法

//A程序
public class MysqlDB implements DBInterface {
    @Override
    public void connect() {
        System.out.println("连接mysql");
    }

    @Override
    public void close() {
        System.out.println("关闭mysql");
    }
}
//B程序员连接Oracle
public class OracleDB implements DBInterface{

    @Override
    public void connect() {
        System.out.println("连接oracle");
    }

    @Override
    public void close() {
        System.out.println("关闭oracle");
    }
}

体会接口带来的统一规范的便利性

将实现接口的类的对象作为参数传入某个方法中，而且该方法的参数就是类的对象所实现的接口。

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

        MysqlDB mysqlDB = new MysqlDB();
        t(mysqlDB);
        OracleDB oracleDB = new OracleDB();
        t(oracleDB);
    }

    public static void t(DBInterface db) {
        db.connect();
        db.close();
    }
}

4 注意事项和细节

1)接口不能被实例化;

2)接口中所有的方法是 public方法，接口中抽象方法，可以不用abstract修饰图示:

1664893282097

3)一个普通类实现接口,就必须将该接口中的所有方法都实现。

4)抽象类实现接口，可以不用实现接口的方法。

5)一个类同时可以实现多个接口。

6)接口中的属性,只能是final的，而且是 public static final修饰符。比如:int a=1;实际上是public static final int a=1;(必须初始化)

7)接口中属性的访问形式:接口名.属性名。

8)接口不能继承其它的类,但是可以继承多个别的接口。1664893964790

接口和接口之间是继承关系，用extends关键字；接口和类之间是实现关系，用implements关键字。

9)接口的修饰符只能是public 和默认，这点和类的修饰符是一样的。

public class InterfaceDetail01 {
    public static void main(String[] args) {
        //new IA();
    }
}

//1.接口不能被实例化
//2.接口中所有的方法是 public方法,  接口中抽象方法，可以不用abstract 修饰
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用alt+enter来解决
//4.抽象类去实现接口时，可以不实现接口的抽象方法
interface IA {
    void say();//修饰符 public protected 默认 private
    void hi();
}
class Cat implements IA{
    @Override
    public void say() {

    }

    @Override
    public void hi() {

    }
}
abstract class Tiger implements  IA {

}
public class InterfaceDetail02 {
    public static void main(String[] args) {
        //老韩证明 接口中的属性,是 public static final
        System.out.println(IB.n1);//说明n1 就是static
        //IB.n1 = 30; 说明n1 是 final
    }
}
interface IB {
    //接口中的属性,只能是final的，而且是 public static final 修饰符
    int n1 = 10; //等价 public static final int n1 = 10;
    void hi();
}
interface IC {
    void say();
}
//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {
}
//接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的
interface IE{}

//一个类同时可以实现多个接口
class Pig implements IB,IC {
    @Override
    public void hi() {
    }
    @Override
    public void say() {
    }
}

5 练习1

//public class InterfaceExercise01 {
//    public static void main(String[] args) {
//        B b = new B();//ok
//        System.out.println(b.a);  //23
//        System.out.println(A.a);  //23
//        System.out.println(B.a);  //23
//    }
//}
//
//interface A {
//    int a = 23; //等价 public static final int a = 23;
//}
//
//class B implements A {//正确
//}

6 实现接口 vs 继承类

实现接口这种机制是对java中单继承的一种补充

1665032839857

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey wuKong = new LittleMonkey("悟空");
        wuKong.climbing();
        wuKong.swimming();
        wuKong.flying();
    }
}

//猴子
class Monkey {
    private String name;

    public Monkey(String name) {
        this.name = name;
    }
    public void climbing() {
        System.out.println(name + " 会爬树...");
    }

    public String getName() {
        return name;
    }
}

//接口
interface Fishable {
    void swimming();
}
interface Birdable {
    void flying();
}

//继承
//小结:  当子类继承了父类，就自动的拥有父类的功能
//      如果子类需要扩展功能，可以通过实现接口的方式扩展.
//      可以理解 实现接口 是 对java 单继承机制的一种补充.
class LittleMonkey extends Monkey implements Fishable,Birdable {

    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName() + " 通过学习，可以像鱼儿一样游泳...");
    }

    @Override
    public void flying() {
        System.out.println(getName() + " 通过学习，可以像鸟儿一样飞翔...");
    }
}

小结：

  1. 继承的价值主要在于:解决代码的复用性和可维护性。
  2. 接口的价值主要在于:设计，设计好各种规范(方法)，让其它类去实现这些方法。即更加的灵活。
  3. 接口比继承更加灵活，继承是满足is - a的关系，而接口只需满足like - a的关系。
  4. 接口在一定程度上实现代码解耦[即:接口规范性+动态绑定机制]

7 接口的多态特性

1665035056599

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

        //接口的多态体现
        //接口类型的变量 if01 可以指向 实现了IF接口类的对象实例
        IF if01 = new Monster();
        if01 = new Car();

        //继承体现的多态
        //父类类型的变量 a 可以指向 继承AAA的子类的对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}

interface IF {}
class Monster implements IF{}
class Car implements  IF{}

class AAA {

}
class BBB extends AAA {}
class CCC extends AAA {}
public class InterfacePolyArr {
    public static void main(String[] args) {

        //多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        /*
        给Usb数组中，存放 Phone  和  相机对象，Phone类还有一个特有的方法call()，
        请遍历Usb数组，如果是Phone对象，除了调用Usb 接口定义的方法外，
        还需要调用Phone 特有方法 call
         */
        for(int i = 0; i < usbs.length; i++) {
            usbs[i].work();//动态绑定..
            //和前面一样，我们仍然需要进行类型的向下转型
            if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
                ((Phone_) usbs[i]).call();
            }
        }

    }
}

interface Usb{
    void work();
}
class Phone_ implements Usb {
    public void call() {
        System.out.println("手机可以打电话...");
    }

    @Override
    public void work() {
        System.out.println("手机工作中...");
    }
}
class Camera_ implements Usb {

    @Override
    public void work() {
        System.out.println("相机工作中...");
    }
}
/**
 * 演示多态传递现象
 */
public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果IG 继承了 IH 接口，而Teacher 类实现了 IG接口
        //那么，实际上就相当于 Teacher 类也实现了 IH接口.
        //这就是所谓的 接口多态传递现象.
        IH ih = new Teacher();
    }
}

interface IH {
    void hi();
}
interface IG extends IH{ }
class Teacher implements IG {
    @Override
    public void hi() {
    }
}

8 练习2

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

    }
}

interface A {  // 1min 看看
    int x = 0;
}  //想到 等价 public static final int x = 0;

class B {
    int x = 1;
} //普通属性

class C extends B implements A {
    public void pX() {
        //System.out.println(x); //错误，原因不明确x
        //可以明确的指定x
        //访问接口的 x 就使用 A.x
        //访问父类的 x 就使用 super.x
        System.out.println(A.x + " " + super.x);
    }

    public static void main(String[] args) {
        new C().pX();
    }
}

9 小结

类的五大成员

  1. 属性
  2. 方法
  3. 构造器
  4. 代码块
  5. 内部类(难点)
半路_出家ren
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CTP接口Java实现
05-15
借助SWIG实现的CTP-java接口，测试程序见org.hraink.futures.jctp.test.Test。参考了csdn上的相关资料，分享出来供大家参考。
支付宝单笔转账接口JAVA版本demo
04-09
提供支付宝开放平台的单笔转账到支付宝账户接口JAVA版本demo 望大家共同进步
【API接口工具】postman-变量定义、使用详解
lichong951的专栏
05-27 3733
百分之50时间在调试接口； 百分之50时间在写代码； 百分之30时间在扯皮，其中还包含了和API接口扯皮 所以使用一个方便快捷的API开发测试工具起码节省百分之30的调试和扯皮的时间。 呃！多了30哈！那是因为加班了嘿！
接口、Abstract类
sukyle的专栏
06-08 2598
<br /><br />http://hi.baidu.com/soxunyi/blog/item/3b01cf12bf98e0dbf6039ede.html<br />接口Interface<br />1. 接口中的成员变量默认都是public、static、final类型的，必须被显式初始化<br />2. 接口中的方法默认都是public、abstract类型的。<br />3. 接口中只能包含public、static、final类型的成员变量和public、abstract类型的成员方法。<br
Java学习笔记——使用接口类型声明对象（变量）
最新发布
2303_79232676的博客
03-20 488
的具体类型也是完全可以的，但使用接口作为引用类型通常是一个更好的做法，因为它提供了更大的灵活性和抽象性。：Java 中的多态性允许我们将一个子类的引用赋值给一个父类类型的变量。：将代码设计为依赖于接口而不是具体实现，可以使得代码更加解耦，更容易测试和维护。：使用接口作为引用类型可以增加代码的抽象性和灵活性。接口的类，只需要改变创建实例的那一行代码，而不需要修改引用。但在大多数情况下，使用接口作为类型是一个更好的选择。这样，在运行时就可以避免插入错误类型的对象。接口的一个子类（实现），所以我们可以将。
一文真正学懂Java接口
大河之犬的博客
07-16 476
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
Java-CTP.rar_CTP PHP接口_CTP接口java_Java-CTP_ctp java_ctp-java
09-19
上期CTP接口Java封装 可以使用该封装进行期货交易，并且可以搭建自己的程序化交易平台
农业银行接口Java-Demo-V3.1.6
03-20
农业银行TrustPayClient-Java接口文档， 2019年，V3.1.6，接口demo
实验接口java
07-03
java实验，java接口实验小程序，课程实习作业代码
Java中类，变量，方法，接口的修饰…
Working...
11-25 3002
1.类的修饰符 （1）定义类的顺序：访问修饰符 修饰符 class 类名 extends 父类名称 implements 接口名。（在这访问修饰符和修饰符可以调换位置） （2）类的访问修饰符： public 说明：可以被所有的类访问和使用，并且public类必须定义在与该类名相同的文件中。 package 说明：可以被同一个包中的类使用，默认的访问权限可以省略该关键字，可以定义在和publ
Java(接口作为成员变量类型、接口作为方法的参数和或返回值)
Valentino112358的博客
04-05 3552
接口作为成员变量类型 执行结果： 我叫艾希，开始施放技能： Biu~Pia~Biu~Pia~ 施放技能完成。 Process finished with exit code 0 接口作为方法的参数和或返回值 package cn.itcast.day11.demo07; import java.util.ArrayList; i...
JAVA接口作为成员变量类型
Milk的博客
10-24 2434
首先创建一个接口Skill public interface Skill { public abstract void use();//施放技能的抽象方法 } 接口的实现类SkillImpl public class SkillImpl implements Skill { @Override public void use() { System.ou...
为什么java接口中的成员变量必须被static关键字和final关键字修饰
袁小龙的飘渺之旅
01-04 3394
对待这个问题，我建议用辩证的角度去看待！首先我们来看只有final没有static的情况，也就是说每个实现类里面都会有一个名字和值都一样的变量（final强调不准改变引用地址），那么在初始化相关实现类的时候，都会单独为这个属性开辟一个存储空间，这个时候问题就来了--》不觉得很浪费内存吗？如果我用static关键字修饰了，不管你创建多少个实现类实例，他们都共享这个成员属性并且内存中也只会开销紧够存储
通达信数据接口 java版
12-23
通达信数据接口Java版是一个用于与通达信财经软件进行数据交互的接口。通过该接口，用户可以方便地获取通达信财经软件中的股票、期货、指数等金融市场数据，实现数据的查询、下载、更新等功能。该接口基于Java语言...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值