【Java入门】接口与实现 & 抽象类

接口与实现

一.1Interface 接口

准确的来讲，接口是一个规范。它并不包含任何具体的实现，他只是规定了一个规程，提供了一个大致的方向。

追女朋友 约出来看电影 ==》 约出来吃饭 ==》 表白

只要你满足这个流程，你就能够找到女朋友

学霸忙着学习，没空请女孩看电影和吃饭，也就是不符合这个流程，于是学霸也就找不到女朋友

接口中不包含任何实例成员，也不能再接口中实现函数。默认所有函数的访问权限都是public

接口不包含具体的实例成员，也就无法被实例化，但是你可以声明一个接口的变量，但是只能接受实现该接口所有函数的类的对象。

/*
@author Juston
@date 2020-10-03 09:58
*/

//如果要实现网络通信那么必须实现这个接口
public interface NetInterface {

//链接
boolean connection(String ip, int port);

//断开链接
boolean disConnection();

//写入数据 从offset开始，写入长度为length
void write(byte[] data, int offset, int length);

//读取数据 从offset开始，读取长度为length，然后返回一个byte[]F
byte[] readData(int offset, int length);
}

一.2Implements 实现

接口定义了一种规范，不是无意义的，是要为实践服务的。

通过implements关键字引入接口，然后实现所有函数，否则该类只能成为抽象类。

实现了接口所有函数后，该类就是符合该接口也就是该规范的类，这时可以通过new关键字创建实例。

public class TCPImp implements NetInterface {

private String ip;
private int port;
private boolean status;
private byte[] data;

public TCPImp() {
ip = "0.0.0.0";
port = 0;
status = false;
data = new byte[1024];
}

@Override
public boolean connection(String ip, int port) {
if (!status) {
System.out.format("链接到%s:%d\n", ip, port);
this.ip = ip;
this.port = port;
status = true;
return true;
} else {
System.out.println("已经链接！");
return false;
}
}

@Override
public boolean disConnection() {
if (status) {
ip = "0.0.0.0";
port = 0;
status = false;
return true;
} else
return false;
}

@Override
public void write(byte[] data, int offset, int length) {
if (status) {
if ((length + offset) < this.data.length) {
System.out.format("从%d开始写入 写入长度%d\n", offset, length);
for (int i = 0; i < length; i++) {
// System.out.print("offset " + offset + " i " + (i) + "\n");
this.data[offset + i] = data[i];
}
} else {
System.out.println("写入溢出");
}
} else {
System.out.println("写入失败");
}
}

@Override
public byte[] readData(int offset, int length) {
if (status) {
if ((length + offset) < this.data.length) {
System.out.format("从%d开始读取 读取长度%d\n", offset, length);
byte[] res = new byte[offset + length];
for (int i = 0; i < length; i++) {
res[i] = this.data[offset + i];
}
return res;
} else {
System.out.println("读取长度过长");
return null;
}
} else {
System.out.println("未链接！");
return null;
}
}
}

一.3回调

鸿门宴内，项羽与众将士约定，以摔杯为令，全体将士冲出来杀死刘邦，否则按兵不动。

如果让你写一个程序，你会怎么写？写个while循环让将士们一直检测有没有摔杯？

其实有一个东西叫做回调。就像他的名字一样，做完了一件事回过头来调用函数。

问题是，怎么让它知道调用哪个函数，或者说怎么把函数的指针传递给它。

下面写一个简单的程序

public interface ActionListener {
void kill();
}

public class XiangXu {
private ActionListener actionListener = null;

public void addActionListener(ActionListener listener) {
this.actionListener = listener;
}

void DropTheCup() {
System.out.println("Drop THE Cup");
if (actionListener != null)
actionListener.kill();
}

}

public class Test2 {
public static void main(String[] args) {
XiangXu xx = new XiangXu();
xx.addActionListener(new ActionListener() {
@Override
public void kill() {
System.out.println("冲啊！！！！！！！ \n士兵们从四面八方冲了出来");
}
});

try {
System.out.println("喝酒中。。。。");
Thread.sleep(10000);
xx.DropTheCup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

只要实现ActionListener接口，然后传递给XiangXu，当XinagXu调用的时候顺便调用一下。

就实现了一旦做了某人某事然后我就做某事的效果。

第二章抽象类

二.1Abstract

与接口是类似的，但是又有一点不同。

接口中所有的函数都是空的，等待子类实现。

接口是一个规范，是一个协议。

抽象类是一个快要完成的具体的协议，只不过只有某些函数没有实现，这些没有实现的函数我们称为抽象函数。 抽象函数用abstract修饰，抽象类也是.

public abstract class Person {
private String name;

public Person(String name) {
this.name = name;
}

public String getName() {
return name;
}

abstract void introduce();
}

二.2Extends

抽象类与普通类类似，通过extends继承，不过抽象类无法被实例化，因为它存在未实现的函数。只有子类继承后实现所有的抽象函数，并且这个类不存在自己的抽象函数，那么这个类才可以被实例化。

抽象类变量可以接受子类对象。

public class Student extends Person {
private String from;
private int studentID;

public Student(String name, String from, int studentID) {
super(name);
this.from = from;
this.studentID = studentID;
}

public int getStudentID() {
return studentID;
}

public String getFrom() {
return from;
}

@Override
void introduce() {
System.out.println(String.format("我是%s，学号；%d，来自%s", this.getName(), this.getStudentID(), this.getFrom()));
}
}