量化接口-抽象类和接口_ 股票程序化软件自动交易接口

抽象类

概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类

在上节课的打印形例子中,我们发现,父类Shape中的draw方法好像并没有什么实际工作,主要的绘制形都是由

Shape的各种子类的draw方法来完成的.像这种没有实际工作的方法,我们可以把它设计成一个抽象方法(abstract

metho,包含抽象方法的类我们称为抽象类(abstractclass).

抽象类语法

在Java中，一个类如果被abstract修饰称为抽象类，抽象类中被abstract修饰的方法称为抽象方法，抽象方法不用给出具体实现体

// 抽象类：被abstract修饰的类
public abstract class Shape {
    // 抽象方法：被abstract修饰的方法，没有方法体
    abstract public void draw();
    abstract void calcArea();
    
    // 抽象类也是类，也可以增加普通方法和属性
    public double getArea(){
        return area;
    } 
    
    p
rotected double area; // 面积
}

注意：抽象类也是类，内部可以包含普通方法，和属性，甚至构造方法

抽象类特性

抽象类不能直接实例化对象

Shape shape = new Shape();
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化

抽象方法不能是private

abstract class Shape {
    abstract private void draw();
} 
/
/ 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private

抽象方法不能被final和static修饰，因为抽象方法要被子类重写

public abstract class Shape {
    abstract final void methodA();
    abstract public static void methodB();
}
/
/ 编译报错：
// Error:(20, 25) java: 非法的修饰符组合: abstract和final
// Error:(21, 33) java: 非法的修饰符组合: abstract和static

抽象类必须被继承，并且继承后子类要重写父类的抽象方法，否则子类也是抽象类，必须要使用abstract修饰

抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

抽象类的作用

抽象类本身不能被实例化,要想使用,只能创建该抽象类的子类.然后让子类重写抽象类中的抽象方法.

有些同学可能会说了,普通的类也可以被继承呀,普通的方法也可以被重写呀,为啥非得用抽象类和抽象方法呢?

确实如此.但是使用抽象类相当于多了一重编译器的校验.

使用抽象类的场景就如上面的代码,实际工作不应该由父类完成,而应由子类完成.那么此时如果不小心误用成父类了,

使用普通类编译器是不会报错的.但是父类是抽象类就会在实例化的时候提示错误,让我们尽早发现问题.

很多语法存在的意义都是为了'预防出错',例如我们曾经用过的final也是类似.创建的变量用户不去修改,不就相当于常量嘛?但是加上final能够在不小心误修改的时候,让编译器及时提醒我们.充分利用编译器的校验,在实际开发中是非常有意义的

接口

在Java中，接口可以看成是：多个类的公共规范，是一种引用类型

语法规则

与类的格式基本相同：将class关键字换成interface关键字，就定义了一个接口

public interface 接口名称{
    //抽象方法
    public abstract void method();    //public abstract 是固定搭配，可以不写（默认）
    public void method2();
    abstract void method3();
    void method4();
    
    //注意：在接口中上述写法都是抽象方法，与推荐方式4相同，代码更简洁
}

提示：创建接口时，接口的命名一般以大写字母I开头接口的命名一般使用“形容词”词性的单词阿里编程规范中约定，接口中的方法和属性不要加任何修饰符号，保持代码的简洁性

接口使用

接口不能直接使用，必须要有一个“实现类”来实现接口，实现接口中的所有抽象方法。

public class 类名 implements 接口名称{
    //...
}

注意：子类和父类之间时extends继承关系，类与接口之间时implements实现关系

请实现笔记本电脑使用USB鼠标、USB键盘的例子USB接口：包含打开设备、关闭设备功能笔记本类：包含开机功能、关机功能、使用USB设备功能鼠标类：实现USB接口，并具备点击功能键盘类：实现USB接口，并具备输入功能

//usb 接口
public interface USB{
    void openDevice();
    void closeDevice();
}
//鼠标类，实现USB接口
public class Mouse implements USB{
    @Override
    public void openDevice() {
        System.out.println('打开鼠标');
    }
    @
Override
    public void closeDevice() {
        System.out.println('关闭鼠标');
    } 
    public void click(){
        System.out.println('鼠标点击');
    }
}
//键盘类似
//笔记本类，使用USB接口
public class Computer {
    public void powerOn(){
        System.out.println('打开笔记本电脑');
    } 
    p
ublic void powerOff(){
        System.out.println('关闭笔记本电脑');
    } 
    p
ublic void useDevice(USB usb){
        usb.openDevice();
        if(usb instanceof Mouse){
            Mouse mouse = (Mouse)usb;
            mouse.click();
        }else if(usb instanceof KeyBoard){
            KeyBoard keyBoard = (KeyBoard)usb;
            keyBoard.inPut();
        } 
        u
sb.closeDevice();
    }
}

public class TestUSB {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();
        // 使用鼠标设备
        computer.useDevice(new Mouse());
        // 使用键盘设备
        computer.useDevice(new KeyBoard());
        computer.powerOff();
    }
}

接口特性

接口类型是一种引用类型，但不能直接new接口对象接口中每一个方法都是public的抽象方法，即接口中的方法会被隐式的指定为publicabstract接口中的方法是不能在接口中实现的，只能有实现接口的类来实现重写接口中方法时，不能使用default访问权限修饰

public interface USB {
    void openDevice(); // 默认是public的
    void closeDevice(); // 默认是public的
} 
public class Mouse implements USB {
    @Override
    void openDevice() {
        System.out.println('打开鼠标');
    } 
    /
/ ...
} 
/
/ 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public

接口中可以含有变量，但是接口中的变量会被隐式的指定为publicstaticfinal变量接口中不能有静态代码块和构造方法接口虽然不是类，但接口编译完成后字节码文件的后缀名也是.class如果类没有实现接口中的所有抽象方法，则类必须设置为抽象方法jdk8中：接口中可以包含default方法，当然可以重写该方法，当引用多个接口时出现同名default抽象方法时会产生二义性，可以在实现类中重写该方法解决

public interface USB {
    default void openDevice(){
        System.out.println('USB打开！');    
    }
    void closeDevice(); // 默认是public的
}

实现多个接口

在Java中，类和类之间是单继承，即Java不支持多继承，但一个类可以实现多个接口

interface IFlying {
    void fly();
} 
interface IRunning {
    void run();
} 
interface ISwimming {
    void swim();
}

class Duck extends Animal implements IRunning, ISwimming, IFlying {
    public Duck(String name) {
        super(name);
    } 
    @
Override
    public void fly() {
        System.out.println(this.name + '正在用翅膀飞');
    } 
    @
Override
    public void run() {
        System.out.println(this.name + '正在用两条腿跑');
    } 
    @
Override
    public void swim() {
        System.out.println(this.name + '正在漂在水上');
    }
}

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类

先继承后接口

Java面向对象编程中最常见的用法:一个类继承一个父类,同时实现多种接口.

继承表达的含义是is-a语义,而接口表达的含义是具有xxx特性.

猫是一种动物,具有会跑的特性.青蛙也是一种动物,既能跑,也能游泳鸭子也是一种动物,既能跑,也能游,还能飞

这样设计有什么好处呢?

时刻牢记多态的好处,让程序猿忘记类型.有了接口之后,类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力

接口之间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

接口可以继承一个接口,达到复用的效果.使用extends关键字

interface IRunning {
    void run();
} 
interface ISwimming {
    void swim();
} 
/
/ 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {

} 
class Frog implements IAmphibious {
    ...
}

通过接口继承创建一个新的接口IAmphibious表示'两栖的'.此时实现接口创建的Frog类,就继续要实现run方法,也需要实现swim方法.

接口间的继承相当于把多个接口合并在一起.

接口使用

给对象排序

Comparable接口，实现其中的compareTo方法

权限修饰符 class 类名 implements Comparable<类名>{
    
}

class Student implements Comparable{
    public String name;
    public int age;
    public double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return 'Student{' +
                'name='' + name + ''' +
                ', age=' + age +
                ', score=' + score +
                '}';
    }

    /**
     * 比较方式
     * @param
     * @return
     */
    @Override
    public int compareTo(Student o) {
        /*if(this.age > o.age) {
            return 1;
        }else if(this.age == o.age) {
            return 0;
        }else {
            return -1;
        }*/
        //return this.age-o.age;    //名字
        //return (int)(this.score-o.score);//分数
        return this.name.compareTo(o.name);//名字,String类compareTo方法
    }
}

在sort方法中会自动调用compareTo方法.compareTo的参数是Object,其实传入的就是Student类型的对象

注意事项:对于sort方法来说,需要传入的数组的每个对象都是'可比较'的,需要具备compareTo这样的能力.通过重写compareTo方法的方式,就可以定义比较规则

student以名字排序，但这样对类的侵入性太强，以下为灵活的方式

Comparator接口，compare方法

class Student {
    public String name;
    public int age;
    public double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return 'Student{' +
                'name='' + name + ''' +
                ', age=' + age +
                ', score=' + score +
                '}';
    }
}
//年龄比较器
class AgeComparator implements Comparator {

    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;
    }
}
class ScoreComparator implements Comparator {

    @Override
    public int compare(Student o1, Student o2) {
        return (int)(o1.score-o2.score);
    }
}

通过Array.sort()

public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student('zhansan',18,89.9);
        students[1] = new Student('lisi',98,19.9);
        students[2] = new Student('ab',48,99.99);
        AgeComparator ageComparator = new AgeComparator();
        ScoreComparator scoreComparator = new ScoreComparator();
        System.out.println('排序前：'+Arrays.toString(students));
        
        Arrays.sort(students,scoreComparator);
        
        System.out.println('排序后：'+Arrays.toString(students));
}

Clonable接口和深拷贝

Object类中存在一个clone方法,调用这个方法可以创建一个对象的'拷贝'.但是要想合法调用clone方法,必须要先实现Clonable接口,否则就会抛出CloneNotSupportedException异常.

class Money implements Cloneable{
    public double money=10.2;

    //实现深拷贝
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    public int id;
    public Money m = new Money();

    public Person(int id) {
        this.id = id;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person personCopy = (Person)super.clone();
        personCopy.m = (Money)this.m.clone();
        return personCopy;
    }
}

public class TestDemo3 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person(110);
        System.out.println(person);

        Person person2 = (Person)person.clone();
        System.out.println(person2);

        System.out.println('修改一下money：');
        person2.m.money = 99.9;
        System.out.println(person.m.money);//99.9
        System.out.println(person2.m.money);//99.9
    }
}

浅拷贝VS深拷贝通过clone，我们只是拷贝了Person对象。但是Person对象中的Money对象，并没有拷贝。通过person2这个引用修改了m的值后，person1这个引用访问m的时候，值也发生了改变。这里就是发生了浅拷贝。那么同学们想一下如何实现深拷贝呢

抽象类和接口的区别

核心区别:抽象类中可以包含普通方法和普通字段,这样的普通方法和字段可以被子类直接使用(不必重写),而接口中不能包含普通方法,子类必须重写所有的抽象方法.

再次提醒:抽象类存在的意义是为了让编译器更好的校验,像Animal这样的类我们并不会直接使用,而是使用它的子类.万一不小心创建了Animal的实例,编译器会及时提醒我们

Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。

范例：使用Object接收所有类的对象

class Person{}
class Student{}
public class Test {
    public static void main(String[] args) {
        function(new Person());
        function(new Student());
    } 
    p
ublic static void function(Object obj) {
        System.out.println(obj);
    }
} 
/
/执行结果：
Person@1b6d3586
Student@4554617c

所以在开发之中，Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。如下

整个Object类中的方法需要全部掌握

本节掌握以下几个方法

toString()

直接重写，类和对象中有过介绍

// Object类中的toString()方法实现：
public String toString() {
    return getClass().getName() + '@' + Integer.toHexString(hashCode());
}

对象比较方法equals方法

在Java中，==进行比较时：

如果==左右两侧是基本类型变量，比较的是变量中值是否相同

如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同

如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的

// Object类中的equals方法
public boolean equals(Object obj) {
    return (this == obj); // 使用引用中的地址直接来进行比较
}

class A {
    public int id;
    public A(int id) {
        this.id = id;
    }
    public boolean equals(Object obj) {
        //根据你自己打规则 判断是不是一样的两个对象
        if (obj == null) {
            return false ;
        }
        if(this == obj) {
            return true ;
        }
        // 不是A类对象
        if (!(obj instanceof A)) {
            return false ;
        }
        A tmp = (A) obj ; // 向下转型，比较属性值
        return this.id == tmp.id ;
    }
    //重写 归 重写  不敢胡来  除非你的业务需求就是这个样子
    public boolean equalsError(Object obj) {
        return true;
    }


}

结论：比较对象中内容是否相同的时候，一定要重写equals方法

hashcode方法

回顾toString源码

public String toString() {
    return getClass().getName() + '@' + Integer.toHexString(hashCode());
}

hashCode()这个方法，他帮我算了一个具体的对象位置存在，这里面涉及数据结构，但是我们还没学数据结构，没法讲述，所以我们只能说它是个内存地址。然后调用Integer.toHexString()方法，将这个地址以16进制输出。

该方法是一个native方法，底层是由C/C++代码写的。我们看不到

我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法，我们可以来看示例代码

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
} 
public class TestDemo4 {
    public static void main(String[] args) {
        Person per1 = new Person('gaobo', 20) ;
        Person per2 = new Person('gaobo', 20) ;
        System.out.println(per1.hashCode());
        System.out.println(per2.hashCode());
    }
} 
/
/执行结果
460141958
1163157884

抽象类和接口

注意事项：两个对象的hash值不一样。

像重写equals方法一样，我们也可以重写hashcode()方法。此时我们再来看看。

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @
Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
} 
public class TestDemo4 {
    public static void main(String[] args) {
        Person per1 = new Person('gaobo', 20) ;
        Person per2 = new Person('gaobo', 20) ;
        System.out.println(per1.hashCode());
        System.out.println(per2.hashCode());
    }
} 
/
/执行结果
460141958
460141958

注意事项：哈希值一样

结论：

hashcode方法用来确定对象在内存中存储的位置是否相同

事实上hashCode()在散列表中才有用，在其它情况下没用。在散列表中hashCode()的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

接受引用数据类型

在之前已经分析了Object可以接收任意的对象，因为Object是所有类的父类，但是Obejct并不局限于此，它可以接收所有数据类型，包括：类、数组、接口。

范例：使用Object来接受数组对象

public static void main(String[] args) {
    // Object接收数组对象，向上转型
    Object obj = new int[]{1,2,3,4,5,6} ;
    // 向下转型，需要强转
    int[] data = (int[]) obj ;
    for(int i :data){
        System.out.println(i+'、');
    }
}

Object可以接收接口是Java中的强制要求，因为接口本身不能继承任何类

范例：使用Object接收接口对象

interface IMessage {
    public void getMessage() ;
} 

c
lass MessageImpl implements IMessage {
    @Override
    public String toString() {
        return 'I am small biter' ;
    } 
    public void getMessage() {
        System.out.println('比特欢迎你');
    }
}

public class Test {
    public static void main(String[] args) {
        IMessage msg = new MessageImpl() ; // 子类向父接口转型
        Object obj = msg ; // 接口向Obejct转型
        System.out.println(obj);
        IMessage temp = (IMessage) obj ; // 强制类型转换
        temp.getMessage();
    }
}

Object真正达到了参数的统如果一个类希望接收所有的数据类型，就是用Object完成，在Java中，泛型就是底层就是通过Object来实现的。

最难不过坚持！

文章为作者独立观点，不代表股票程序化软件自动交易接口观点

量化接口-抽象类和接口

量化接口-JPX Tokyo Stock Exchange Prediction总结篇无泄漏0.3分以上经验分享20220714

量化接口-饿了么平台最全开发API接口列表 elm接口 2019

量化接口-一个接口依赖另一个接口的三种方法非注释

量化接口-Uni App 接口第三方登录 H5+ APP Hcoder 版

量化接口-JPX Tokyo Stock Exchange Prediction总结篇无泄漏0.3分以上经验分享20220714

量化接口-饿了么平台最全开发API接口列表 elm接口 2019

量化接口-一个接口依赖另一个接口的三种方法 非注释

量化接口-Uni App 接口 第三方登录 H5+ APP Hcoder 版

量化接口-一个接口依赖另一个接口的三种方法非注释

量化接口-Uni App 接口第三方登录 H5+ APP Hcoder 版