引言：
java中的接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个“是不是”的关系，二接口实现则是“能不能”的关系。接口的本质是契约，标准，规范。
接口的使用
接口使用interface来定义
Java中，接口和类是并列的两个结构
如何定义接口：定义接口中的成员
- JDK7及以前：只能定义全局常量和抽象方法
全局常量：public static final的。但是书写时，可以省略不写。注意：就算是省略不写，其也是全局静态常量。
抽象方法：public abstract的 - JDK8: 除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
- JDK7及以前：只能定义全局常量和抽象方法
接口中不能定义构造器的！意味着接口不可以实例化。接口只能用来被实现
Java开发中，接口通过让类去实现(implements)的方式来使用。
- 如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
- 如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
Java类可以实现多个接口。这弥补了Java单继承性的局限性
接口与接口之间可以继承，而且可以多继承
接口的具体使用，体现多态性
接口，实际上可以看做是一种规范
举例
public class InterfaceTest {
public static void main(String[] args) {
System.out.println(Flyable.MAX_SPEED);
System.out.println(Flyable.MIN_SPEED);
//Flyable.MIN_SPEED = 2;//报错，final属性不能修改
Plane plane = new Plane();
plane.fly();
}
}
/*定义Flyable接口*/
interface Flyable {
//全局静态常量
public static final int MAX_SPEED = 7900;
int MIN_SPEED = 1;//省略了public static final
//抽象方法
public abstract void fly();
void stop();//省略了public abstract
}
/*实现Flyable接口中的所有方法*/
class Plane implements Flyable {
@Override
public void fly() {
System.out.println("飞机通过引擎起飞");
}
@Override
public void stop() {
System.out.println("驾驶员控制减速");
}
}
/*实现Flyable接口中的所有方法*/
abstract class Rocket implements Flyable{
@Override
public void fly() {
System.out.println("火箭通过点火起飞");
}
}interface Flyable {
public static final int MAX_SPEED = 7900;
int MIN_SPEED = 1;
public abstract void fly();
void stop();
}
interface Attackable {
void attack();
}
class Plane implements Flyable {
@Override
public void fly() { System.out.println("飞机通过引擎起飞"); }
@Override
public void stop() {System.out.println("驾驶员控制减速");}
}
//类单继承，接口多实现。先继承，再实现。
class Bullet extends Object implements Flyable, Attackable {
@Override
public void fly() { }
@Override
public void stop() { }
@Override
public void attack() { }
}接口可以继承接口，并且可以多继承
interface A{
void method1();
}
interface B{
void method2();
}
interface C extends A, B {
void method3();
}
public class D implements C {
@Override
public void method1() {}
@Override
public void method2() {}
@Override
public void method3() {}
}接口使用上也满足多态性
public class USBTest {
public static void main(String[] args) {
Computer com = new Computer();
//1.创建了接口的非匿名实现类的非匿名对象
Flash flash = new Flash();
com.transferData(flash);
//2. 创建了接口的非匿名实现类的匿名对象
com.transferData(new Printer());
//3. 创建了接口的匿名实现类的非匿名对象
USB phone = new USB(){
@Override
public void start() {
System.out.println("手机开始工作");
}
@Override
public void stop() {
System.out.println("手机结束工作");
}
};
com.transferData(phone);
//4. 创建了接口的匿名实现类的匿名对象
com.transferData(new USB(){
@Override
public void start() {
System.out.println("mp3开始工作");
}
@Override
public void stop() {
System.out.println("mp3结束工作");
}
});
}
}
class Computer{
public void transferData(USB usb){//注意：此处体现多态
usb.start();
System.out.println("具体传输数据的细节");
usb.stop();
}
}
interface USB {
//常量：定义了长、宽、最大最小的传输速度等
void start();
void stop();
}
class Flash implements USB {
@Override
public void start() {
System.out.println("U盘开启工作");
}
@Override
public void stop() {
System.out.println("U盘结束工作");
}
}
class Printer implements USB{
@Override
public void start() {
System.out.println("打印机开启工作");
}
@Override
public void stop() {
System.out.println("打印机结束工作");
}
}注意以下情况
interface A {
int x = 0;//省略public static final
}
class B {
int x = 1;
}
class C extends B implements A {
public void px() {
//System.out.println(x);//编译不通过，x指向不明确
System.out.println(super.x);// 1
System.out.println(A.x);//0
}
public static void main(String[] args) {
new C().px();
}
}interface Playable {
void play();//省略public abstract
}
interface Bounceable {
void play();//省略public abstract
}
interface Rollable extends Playable, Bounceable {
Ball ball = new Ball("PingPang");//省略public static final
}
class Ball implements Rollable {
private String name;
public Ball(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public void play() {
//ball = new Ball("Football");//final关键字修饰的变量不能修改
System.out.println(ball.getName());
}
}
