接口
接口
概念
生活中的接口：usb vga hdmi dp type-c 雷电 灯泡 螺纹接口
usb : 1994年 IBM（服务器） 甲骨文 因特尔 联想 等 微软 共同制定的协议标准（数据交换协议）
java中接口： 就是一个特殊的抽象类 是接口使用者和接口实现者之间的规范
接口的定义
关键词：interface
语法：
interface 接口名{
}
特点：（特殊之处）
1.接口中的属性都是公开静态常量
2.接口中的方法都是公开抽象方法
3.接口没有构造方法，接口也没有对象，接口的对象是不存在的，但是可以声明引用
注意：
1.接口中的属性没有加修饰符默认是公开静态常量
2.接口中的方法没有加修饰符默认是公开抽象方法
案例：
package cn.wzx;
public class Demo {
}
interface IA{
public static final int a = 30;
public abstract void m1();
}
abstract class ClassA{
int a;
static int b;
public static final int C = 10;
public ClassA(){
}
public abstract void m1();
public void m2() {
System.out.println("成员方法");
}
public static void m3(){
System.out.println("静态方法");
}
public final void m4(){
}
}
接口的实现类
接口的实现类就是实现了接口的类
关键词： implements 实现
语法：
class 类名 implements 接口名{
}
特点：
1.当一个类实现了一个接口那么必须实现这个接口中所有的方法
2.接口的对象是不存在的 但是可以声明引用 引用可以指向实现类的对象，这样就存在多态了
案例：
package cn.wzx;
public class Demo {
public static void main(String[] args) {
IA a = new ClassA();
a.m1();
a.m2();
}
}
interface IA{
public static final int LIU_YANG = 30;
int a = 30;
void m1();
public abstract void m2();
}
class ClassA implements IA{
public void m1(){
System.out.println("实现类的m1");
}
public void m2() {
System.out.println("实现类的m2");
}
public void m3() {
System.out.println("实现类特有的m3");
}
}
类和接口之间的关系
类和类
java中类和类之间是单继承，可以多级继承
接口和接口之间的关系
接口和接口之间是多继承的关系，一个接口可以继承多个接口
语法：
interface 子接口 extends 父接口1，父接口2，父接口n..{
}
注意：
当一个类实现的接口有父接口时，这个实现类必须实现所有接口中的方法
案例：
package cn.wzx;
public class Demo {
public static void main(String[] args) {
IA a = new ClassA();
a.m1();
a.m2();
}
}
interface IA{
public static final int LIU_YANG = 30;
int a = 30;
public abstract void m1();
public abstract void m2();
}
interface IC{
public abstract void m3();
}
interface IB extends IA,IC{
public abstract void m4();
}
class ClassA implements IB{
@Override
public void m1() {
}
@Override
public void m3() {
}
@Override
public void m4() {
}
@Override
public void m2() {
}
}
类和接口之间的关系
一个类可以实现多个接口
语法：
class 类名 implements 接口1，接口2，接口n{
}
注意：当一个类实现了多个接口时，必须实现所有接口中的方法
一个类的最复杂的关系
注意事项：当一个类继承了一个父类的同时又实现了多个接口时，必须先继承后实现接口
接口的应用
可以扩展子类的功能
解耦合
使两个类之间的关系弱化
假设现在 没有螺纹接口
案例：
package cn.baizhi.day12;
public class TestLigth {
public static void main(String[] args) {
WhitePop whitePop = new WhitePop();
RedPop redPop = new RedPop();
GreenPop greenPop = new GreenPop();
Lamp lamp = new Lamp();
lamp.setLuoWen(greenPop);
lamp.powerOn();
}
}
class GreenPop implements LuoWen{
@Override
public void faGuang() {
System.out.println("发出绿光");
}
}
class WhitePop implements LuoWen{
@Override
public void faGuang() {
System.out.println("白光");
}
}
class RedPop implements LuoWen{
@Override
public void faGuang() {
System.out.println("红光");
}
}
class Lamp{
private LuoWen luoWen;
public void setLuoWen(LuoWen luoWen) {
this.luoWen = luoWen;
}
public void powerOn() {
luoWen.faGuang();
}
}
interface LuoWen{
void faGuang();
}
电脑：
属性： 鼠标 移动硬盘 键盘
方法： 电源开关
没有usb
案例：
package cn.wzx;
public class TestComputer {
public static void main(String[] args) {
Computer computer = new Computer();
Mouse mouse = new Mouse();
MovePan movePan = new MovePan();
KeyBoard keyBoard = new KeyBoard();
computer.setUsb(mouse);
computer.powerOn();
}
}
interface USB{
void start();
}
class Computer{
private USB usb;
public void setUsb(USB usb) {
this.usb = usb;
}
public void powerOn() {
usb.start();
}
}
class Mouse implements USB{
public void start() {
System.out.println("鼠标启动了");
}
}
class MovePan implements USB{
public void start() {
System.out.println("硬盘启动了");
}
}
class KeyBoard implements USB{
public void start() {
System.out.println("键盘启动了");
}
}
class U implements USB{
public void start() {
System.out.println("u盘启动了");
}
}
接口的回调
鼠标（usb接口的实现者） ---- usb ------电脑(usb接口的使用者)
就是接口的实现者必须按照接口中规定的方式为接口的使用者提供数据 。接口的使用者将这些数据进行处理,至于这些数据怎么处理，接口的实现者不用关心
百度地图：
滴滴车主：手机 gps（数据）----> 百度地图的api
案例：
package cn.wzx;
import java.util.Arrays;
public class Demo3 {
public static void main(String[] args) {
Student[] students = {
new Student("小周", 33, 45, 145.9),
new Student("小刘", 17, 100, 180),
new Student("小姜", 45, 56, 132.5),
new Student("小张", 88, 78, 45.67)
};
Arrays.sort(students);
for (int i = 0; i < students.length; i++) {
System.out.println(students[i]);
}
}
}
class Student implements Comparable<Student>{
String name;
int age;
double score;
double hight;
public Student(String name, int age,double score,double hight) {
super();
this.name = name;
this.age = age;
this.score = score;
this.hight = hight;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score
+ ", hight=" + hight + "]";
}
@Override
public int compareTo(Student o) {
return this.age-o.age;
}
}
