股票自动化交易软件接口-抽象类与接口 JAVA

接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

public interface USB {
void openDevice();
// 编译失败：因为接口中的方式默认为抽象方法
// Error:(5, 23) java: 接口抽象方法不能带有主体
void closeDevice(){
System.out.println('关闭USB设备');
}
}

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

// 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('关闭鼠标');
} p
ublic void click(){
System.out.println('鼠标点击');
}
} /
/ 键盘类，实现USB接口
public class KeyBoard implements USB {
@Override
public void openDevice() {
System.out.println('打开键盘');
} @
Override
public void closeDevice() {
System.out.println('关闭键盘');
} p
ublic void inPut(){
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();
}
}

提示:创建接口时,接口的命名一般以大写字母I开头.接口的命名一般使用'形容词'词性的单词.阿里编码规范中约定,接口中的方法和属性不要加任何修饰符号,保持代码的简洁性1接口使用接口不能直接使用，必须要有一个'实现类'来'实现'该接口，实现接口中的所有抽象方法

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

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

// 矩形类
public class Rect extends Shape {
private double length;
private double width;
Rect(double length, double width){
this.length = length;
this.width = width;
} p
ublic void draw(){
System.out.println('矩形: length= '+length+' width= ' + width);
} p
ublic void calcArea(){
area = length * width;
}
} /
/ 圆类：
public class Circle extends Shape{
private double r;
final private static double PI = 3.14;
public Circle(double r){
this.r = r;
} p
ublic void draw(){
System.out.println('圆：r = '+r);
} p
ublic void calcArea(){
area = PI * r * r;
}
} /
/ 三角形类：
public abstract class Triangle extends Shape {
private double a;
private double b;
private double c;
@Override
public void draw() {
System.out.println('三角形：a = '+a + ' b = '+b+' c = '+c);
} /
/ 三角形：直角三角形、等腰三角形等，还可以继续细化
//@Override
//double calcArea(); // 编译失败：要么实现该抽象方法，要么将三角形设计为抽象类
}

重写接口中方法时，不能使用default访问权限修饰

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

接口使用实例给对象数组排序

class Student {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
} @
Override
public String toString() {
return '[' + this.name + ':' + this.score + ']';
}
}
再给定一个学生对象数组, 对这个对象数组中的元素进行排序(按分数降序).
Student[] students = new Student[] {
new Student('张三', 95),
new Student('李四', 96),
new Student('王五', 97),
new Student('赵六', 92),
};
按照我们之前的理解, 数组我们有一个现成的 sort 方法, 能否直接使用这个方法呢?
Arrays.sort(students);
System.out.println(Arrays.toString(students));
// 运行出错, 抛出异常.
Exception in thread 'main' java.lang.ClassCastException: Student cannot be cast to
java.lang.Comparable
仔细思考, 不难发现, 和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确. 而两个学生对象的大小关系怎
么确定? 需要我们额外指定.
让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法
class Student implements Comparable {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
} @
Override
public String toString() {
return '[' + this.name + ':' + this.score + ']';
} @
Override
public int compareTo(Object o) {
Student s = (Student)o;
if (this.score > s.score) {
return -1;
} else if (this.score < s.score) {
return 1;
} else {
return 0;
}
}
}
在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象.
然后比较当前对象和参数对象的大小关系(按分数来算).
如果当前对象应排在参数对象之前, 返回小于 0 的数字;
如果当前对象应排在参数对象之后, 返回大于 0 的数字;
如果当前对象和参数对象不分先后, 返回 0;
再次执行程序, 结果就符合预期了.
// 执行结果
[[王五:97], [李四:96], [张三:95], [赵六:92]]
注意事项: 对于 sort 方法来说, 需要传入的数组的每个对象都是 '可比较' 的, 需要具备 compareTo 这样的能力. 通过
重写 compareTo 方法的方式, 就可以定义比较规则.
为了进一步加深对接口的理解, 我们可以尝试自己实现一个 sort 方法来完成刚才的排序过程(使用冒泡排序)
public static void sort(Comparable[] array) {
for (int bound = 0; bound < array.length; bound++) {
for (int cur = array.length - 1; cur > bound; cur--) {
if (array[cur - 1].compareTo(array[cur]) > 0) {
// 说明顺序不符合要求, 交换两个变量的位置
Comparable tmp = array[cur - 1];
array[cur - 1] = array[cur];
array[cur] = tmp;
}
}
}
}
再次执行代码
sort(students);
System.out.println(Arrays.toString(students));
// 执行结果
[[王五:97], [李四:96], [张三:95], [赵六:92]]

接口中每一个方法都是public的抽象方法,即接口中的方法会被隐式的指定为publicabstract（只能是publicabstract，其他修饰符都会报错

public interface USB {
// Error:(4, 18) java: 此处不允许使用修饰符private
private void openDevice();
void closeDevice();
}

抽象类与接口 JAVA

接口特性接口类型是一种引用类型，但是不能直接new接口的对象

public class TestUSB {
public static void main(String[] args) {
USB usb = new USB();
}
} /
/ Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化

接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类jdk8中：接口中还可以包含default方法。3实现多个接口在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。下面通过类来表示一组动物.

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

class Cat extends Animal implements IRunning {
public Cat(String name) {
super(name);
} @
Override
public void run() {
System.out.println(this.name + '正在用四条腿跑');
}
}

class Fish extends Animal implements ISwimming {
public Fish(String name) {
super(name);
} @
Override
public void swim() {
System.out.println(this.name + '正在用尾巴游泳');
}
}

class Frog extends Animal implements IRunning, ISwimming {
public Frog(String name) {
super(name);
} @
Override
public void run() {
System.out.println(this.name + '正在往前跳');
} @
Override
public void swim() {
System.out.println(this.name + '正在蹬腿游泳');
}
}

注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法抽象类不能直接实例化对象Shapeshape=newShape();//编译出错Error:(30,2java:Shape是抽象的;无法实例化

注意：抽象方法没有加访问限定符时，默认是public抽象方法不能被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

接口中可以含有变量，但是接口中的变量会被隐式的指定为publicstaticfinal变量

public interface USB {
double brand = 3.0; // 默认被：final public static修饰
void openDevice();
void closeDevice();
} p
ublic class TestUSB {
public static void main(String[] args) {
System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的
// 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
USB.brand = 2.0; // 说明brand具有final属性
}
}

抽象类与接口 JAVA

抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量3抽象类的作用抽象类本身不能被实例化,要想使用,只能创建该抽象类的子类.然后让子类重写抽象类中的抽象方法.有些同学可能会说了,普通的类也可以被继承呀,普通的方法也可以被重写呀,为啥非得用抽象类和抽象方法呢?确实如此.但是使用抽象类相当于多了一重编译器的校验.使用抽象类的场景就如上面的代码,实际工作不应该由父类完成,而应由子类完成.那么此时如果不小心误用成父类了,使用普通类编译器是不会报错的.但是父类是抽象类就会在实例化的时候提示错误,让我们尽早发现问题.很多语法存在的意义都是为了'预防出错',例如我们曾经用过的final也是类似.创建的变量用户不去修改,不就相当于常量嘛?但是加上final能够在不小心误修改的时候,让编译器及时提醒我们.充分利用编译器的校验,在实际开发中是非常有意义的接口

接口中不能有静态代码块和构造方法

public interface USB {
// 编译失败
public USB(){
} {
} // 编译失败
void openDevice();
void closeDevice();
}

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。接口的定义格式与定义类的格式基本相同，将class关键字换成interface关键字，就定义了一个接口。

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

抽象方法不能是private的

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

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