12 接口

接口

接口

概念

生活中的接口：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("静态方法");
	}
	//final修饰的方法
	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() {
		// TODO Auto-generated method stub
		
	}

	

	@Override
	public void m3() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void m4() {
		// TODO Auto-generated method stub
		
	}



	@Override
	public void m2() {
		// TODO Auto-generated method stub
		
	}
	
}

类和接口之间的关系

一个类可以实现多个接口
语法：

class 类名 implements 接口1，接口2，接口n{
	
}
注意：当一个类实现了多个接口时，必须实现所有接口中的方法

一个类的最复杂的关系

注意事项：当一个类继承了一个父类的同时又实现了多个接口时，必须先继承后实现接口

接口的应用

可以扩展子类的功能

解耦合

使两个类之间的关系弱化 

假设现在 没有螺纹接口 

案例：
package cn.baizhi.day12;

public class TestLigth {
	public static void main(String[] args) {
		/*//买一个灯泡
		WhitePop whitePop = new WhitePop();
		//买一个台灯
		Lamp lamp = new Lamp();
		//安灯泡
		lamp.setWhitePop(whitePop);
		//打开开关
		lamp.powerOn();*/
		
		
		//买一个灯泡
		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();
		
	}
}

//定义一个USB接口
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) {
		//this当前对象的引用      o是传进来的对象的引用
		/*
		 * this.age <   o.age   返回的负数 
		 * this.age==  o.age 返回的0
		 * this.age>o.age  返回的正数
		 * 
		*/
		//System.out.println("我被调用了");
		return this.age-o.age;
		
	}
	
	//构造
	
}