量化私募交易接口关闭:2022Java学习笔记三十七面向对象加强进阶：接口interface 接口的实现接口多继续接口的新增方法

实例代码定义SportMan接口

package com.zcl.d11_interface_implements;

public interface SportMan {
    void run();
    void competition();
}

接口是用来实现的，实现接口的类称为实现类，实现类可以理解成所谓的子类接口可以被单实现，也可以被类多实现

定义实现类

package com.zcl.d11_interface_implements;
/*
    实现接口类
 */
public class PingPongMan implements SportMan,Law{
    private String Name;
    public PingPongMan(String name){
        this.Name = name;
    }
    // Alt + 回车重写所有方法

    @Override
    public void rule() {
        System.out.println(Name+'要遵守规则');
    }

    @Override
    public void run() {
        System.out.println(Name+'必须跑步训练');
    }

    @Override
    public void competition() {
        System.out.println(Name+'需要比赛');
    }
}

一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类

接口的新增方法第一种方法：默认方法类似于之前的普通方法：必须用default修饰默认会public修饰，需要用接口的实现类的对象来调用格式：

default void run(){
	System.out.println('---开始跑---');
}

接口就是体现规范的，其中用抽象方法定义的一组行为规范，接口是更加彻底的抽象

规范合并：整合多个接口为同一个接口，便于子类实现接口

定义Test测试类

package com.zcl.d11_interface_implements;
/*
    测试类
 */
public class Test {
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan('张继科');
        p.run(); // 张继科必须跑步训练
        p.rule(); // 张继科要遵守规则
        p.competition(); // 张继科需要比赛
    }
}

接口

定义Law接口

实例代码：继承两个接口Law,SportMan

package com.zcl.d12_interface_extends;
/*
    实现接口多继承
 */
public interface People extends Law,SportMan{
    void eat();
}

子类实现接口只需要实现一个People接口，也可以重写所有方法

package com.zcl.d12_interface_extends;
/*
    实现接口
 */
public class Test implements People{

    @Override
    public void rule() {

    }

    @Override
    public void eat() {

    }

    @Override
    public void run() {

    }

    @Override
    public void competition() {

    }
}

JDK8之前接口中只能是抽象方法和常量，没有其他成分了接口不能实例化接口中的成员都是public修饰的，写于不写都是，因为规范的目的就是为了公开化

package com.zcl.d10_interface;
/*
    定义接口关键字：interface
    接口不能创建对象
 */
public interface SportManInterface {
    // 接口中的成员：jdk1.8之前只有常量和抽象方法

    // public static final 可以不写，接口默认会为你加上
    String SCHOOL_NAME = '张三'; // 常量：要被初始化

    // 2、抽象方法
    // public abstract 可以省略不写
    public abstract void run();
    void eat();
}

实例代码

package com.zcl.d13_interface_jdk8;

import com.zcl.d12_interface_extends.SportMan;

public interface SportManinter {
    /*
        1、jdk8开始，默认方法（实例方法）
        必须用 default修饰，默认用public修饰
        默认方法，接口不能创建对象，这个方法只能通过实现类的对象调用
     */
    public default void run(){
        System.out.println('---跑的很快---');
        //  -- 必须在接口内部才能被访问
        go(); // 开始跑了哦
    }

    /*
        2、静态方法
        必须使用static修饰，默认用public修饰
        --接口的静态方法，必须接口名自己调用
     */
    static void inAddr(){
        System.out.println('---跑的很快了---');
    }

    /*
        3、私有方法，jsk1.9开始
        -- 必须在接口内部才能被访问
     */
    private void go(){
        System.out.println('开始跑了哦');
    }
}

// 实现接口
class PingPongMan implements SportManinter{
}

// 测试类
class Test{
    public static void main(String[] args) {
        // 创建实现接口对象
        PingPongMan p = new PingPongMan();
        p.run();

        // --接口的静态方法，必须接口名自己调用
        SportManinter.inAddr();
    }
}

2022Java学习笔记三十七面向对象加强进阶：接口interface 接口的实现接口多继续接口的新增方法

接口的定义格式：

接口用关键字interface来定义
public interface 接口名{
	// 常量
	// 抽象方法
}

第三种方法：私有方法就是私有的实例方法：必须使用private修饰，从jdk9才开始有只能在本类中被其他的默认方法或私有方法访问

private void go(){
	System.out.println('---开始跑了哦---');
}

接口不能创建对象一个类实现了多个接口，多个接口中有同样的静态方法不冲突接口静态方法不能子类调用，只能父类调用自己的方法一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的继承在前实现在后一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承

接口的基本使用：被实现

接口与接口的关系：多继续

实现类的格式：

// 实现关键字 implements
修饰符 class 实现类 implements 接口1,接口2,...{

}

第二种方法：静态方法默认会public修饰，必须static修饰接口的静态方法必须用本身的接口名称来调用

static void inAddr(){
	System.out.println('---开始跑了---');
}

文章为作者独立观点，不代表股票交易接口观点