一、定义
/**
* @ Author HuQi
* @ Date 2020/2/1 17:05
* @ Version 1.0
* ---------------------------
*/
/*
* 1.接口的定义
* 2.java中，接口和类是并列结构
* 3.jdk8接口中可以定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
* 4.接口中不能定义构造器。意味着接口不可以实例化
* 5.接口通过让类去实现(implement)的方式来使用
* (1)如果实现类覆盖了接口中所有抽象方法，则此实现类就可以实例化
* (2)如果实现类没有覆盖了接口中所有抽象方法，则此实现类仍为一个抽象类
* 6.java类可以实现多个接口->弥补了java单继承行的局限性
* 7.接口和接口直接可以继承，而且可以多继承
* interface AA{}
* interface BB{}
* interface CC extends AA, BB{}
* */
public class InterfaceTest {
public static void main(String[] args) {
System.out.println(Flyable.Max_SPEED);
Plane plane = new Plane();
plane.fly();
}
}
interface Flyable{
//全局变量
public static final int Max_SPEED = 7990;
public static final int MIN_SPEED = 1;
public abstract void fly();
public abstract void stop();
}
//实现飞的功能，需要将所有抽象方法进行重写
class Plane implements Flyable{
@Override
public void fly() {
System.out.println("通过引擎起飞");
}
@Override
public void stop() {
System.out.println("驾驶员停止");
}
}
//如果未全部覆盖实现类方法，则需要加上abstract
abstract class Kite implements Flyable{
@Override
public void stop() {
System.out.println("放风筝");
}
}
二、示例
接口使用上提现多态性；
/**
* @ Author HuQi
* @ Date 2020/2/1 17:32
* @ Version 1.0
* ---------------------------
*/
public class USBTest {
public static void main(String[] args) {
Computer computer = new Computer();
//1.创建接口的非匿名实现类的非匿名对象
Flash flash = new Flash();
computer.transferData(flash);
System.out.println("----------------------");
//2.创建了接口的非匿名实现类的匿名对象
computer.transferData(new Printer());
System.out.println("----------------------");
//3.创建接口的匿名实现类的非匿名对象
USB phone = new USB() {
@Override
public void start() {
System.out.println("手机开始工作");
}
@Override
public void stop() {
System.out.println("手机停止工作");
}
};
computer.transferData(phone);
System.out.println("------------------");
//4.创建接口的匿名实现类的匿名对象
computer.transferData(new USB() {
@Override
public void start() {
System.out.println("电视开始工作");
}
@Override
public void stop() {
System.out.println("电视停止工作");
}
});
}
}
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("printer开启");
}
@Override
public void stop() {
System.out.println("printer关闭");
}
}
--------------------结果--------------------------
u盘开启
具体传输细节
u盘关闭
----------------------
printer开启
具体传输细节
printer关闭
----------------------
手机开始工作
具体传输细节
手机停止工作
------------------
电视开始工作
具体传输细节
电视停止工作
三、接口应用
>[package]Test
..>Circle.class
..>ComparableCircle.class
..>ComparableCircleTest.class
..>CompareObject.interface
1. Circle
package Test;
public class Circle {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
}
2. CompareObject
package Test;
public interface CompareObject {
/*
* 0：相等
* 正数：当前对象大
* 负数：当前对象小
* */
public int compareTo(Object obj);
}
3. ComparableCircle
package Test;
/**
* @ Author HuQi
* @ Date 2020/2/1 18:14
* @ Version 1.0
* ---------------------------
* 定义一个ComparableCircle类，继承Circle类并实现CompareObject接口
* 在ComparableCircle类中给出接口中方法compareTo的实现体用来比较两圆半径大小
*/
public class ComparableCircle extends Circle implements CompareObject {
//继承父类构造器
public ComparableCircle(double radius){
super(radius);
}
@Override
public int compareTo(Object obj) {
if (this == obj) {
return 0;
}
if (obj instanceof ComparableCircle) {
ComparableCircle c = (ComparableCircle) obj;
if (this.getRadius() > c.getRadius()) {
return 1;
} else if (this.getRadius() < c.getRadius()) {
return -1;
} else {
return 0;
}
} else {
throw new RuntimeException("传入的数据类型不匹配");
}
}
}
4. ComparableCircleTest
package Test;
public class ComparableCircleTest {
public static void main(String[] args) {
ComparableCircle comparableCircleOne = new ComparableCircle(10);
ComparableCircle comparableCircleTwo = new ComparableCircle(10);
int compareValue = comparableCircleOne.compareTo(comparableCircleTwo);
System.out.println(compareValue );
}
}
1.抽象类
类的一种，用 abstract 关键字修饰的类。不能直接创建对象，但可以有构造器，用于子类继承后使用。
2.抽象方法
用 abstract 关键字修饰的方法，没有方法体，必须给子类重写
3.final关键字
>修饰变量：变为常量，接口中必须在声明时进行赋值，后续无法修改。类中可以在构造器中赋值，后续无法修改
>修饰方法：变为最终方法，子类只能调用，不能重写
>修饰类：变为最终类，不能被其他类继承，可以创建对象。例如String
4.接口 - 它和类是统一级别的存在，都是引用类型。
>接口没有构造器，不能直接new对象
>接口中的变量都是公开的静态的常量，默认被 public static final 修饰
>接口中的方法都是抽象方法(不考虑1.8新特性)，默认被 public abstract 修饰
>使用接口时，需要提供一个类去实现接口。关键字 implements 。实现类必须要重写接口中所有的抽象方法
>一个接口可以有多个实现类，一个类可以实现多个接口