Java进阶总结——接口

楼主自己理解的接口是：接口就像是个师傅， 师傅只是把要学习的知识告诉徒弟，要怎么学，就是徒弟的事情。一个徒弟可以有多个师傅，师傅也可以有多个老师，师傅的每个徒弟都要按照师傅的规矩做事，如果有多个师傅，那就要遵守每个师傅的规矩。如果一个师傅不想自己定规矩，他可以继承他父亲的规矩，师傅的徒弟如果不是抽象的，那就得遵守师傅父亲的规矩，如果是抽象的可以不遵守，如果这个抽象的徒弟想要传承，他的孩子就还得遵守这个规矩。

写完之后发现好绕啊，如果看不懂那就向下看吧！~~~~~~

1.什么是接口？

 * 接口：表示一种规范协议
 *         主要是要类遵循这个规范，实现这个接口
 * 语法：
 *         修饰符  interface  接口{
 *             常量
 *             方法1;
 *             方法2;
 *         }
 * 特点：
 *         1.接口是一个特殊的类，不能直接实例化
 *         2.接口中不允许有构造方法
 *         3.接口中的方法都是抽象方法，默认的修饰符是public abstract
 *         4.接口中只能定义常量，使用public static final 进行修饰
 *         5.实现接口的类，必须重写当前接口中所有的方法

package day12.interface1;

public interface FirstInterface {
	//int a; //接口中只能定义常量
/*	public  FirstInterface() {
		接口中不允许有构造方法
	}*/
	//定义方法
	void lock();//上锁
	void unlock();//开锁
}

package day12.interface1;

public interface SecondInterface {
	//防火功能
	public void firePrevention();
}

package day12.interface1;

//定义接口
public interface ThirdInterface {
	//防老王功能
	public void guardWang() ;
}

package day12.interface1;
//锁类
public class Lock {
	//上锁
	public void lock() {
		System.out.println("关锁");
	}
	//开锁
	public void unlock() {
		System.out.println("开锁");
	}
}

package day12.interface1;
//父类
public abstract class Door {
	//开门
	public void openDoor() {
		System.out.println("芝麻开门");
	}
	//关门
	public void closeDoor() {
		System.out.println("芝麻关门");
	}
}

 * 实现类：实现某个接口的类
 * 语法：  修饰符  class extends 父类  implements  接口1,接口2...{
 *                     必须重写接口中所有方法
 *                 }

package day12.interface1;
//子类
/**
 * 防盗门
 * 		具有门的特点
 * 		有锁的功能
 * */
public class AntiTheftDoor extends Door implements FirstInterface,SecondInterface,ThirdInterface{
	@Override
	public void lock() {
		// TODO 自动生成的方法存根
		System.out.println("通过钥匙上锁");
	}
	@Override
	public void unlock() {
		// TODO 自动生成的方法存根
		System.out.println("通过钥匙解锁");
	}
	@Override
	public void firePrevention() {
		// TODO 自动生成的方法存根
		System.out.println("喷水防烟雾");
	}
	@Override
	public void guardWang() {
		// TODO 自动生成的方法存根
		System.out.println("提醒主人，小心绿帽子");
	}
}

package day12.interface1;
//实现类
public class AntiTheftDoor1 extends Door implements FirstInterface,SecondInterface{
	@Override
	public void lock() {
		// TODO 自动生成的方法存根
		System.out.println("通过指纹上锁");
	}
	@Override
	public void unlock() {
		// TODO 自动生成的方法存根
		System.out.println("通过指纹解锁");
	}
	@Override
	public void firePrevention() {
		// TODO 自动生成的方法存根
		System.out.println("喷泡沫、干粉，可以自动报警！");
	}
}

package day12.interface1;
/**
 * 
 * */
public class Windows implements ThirdInterface,FirstInterface{
	@Override
	public void guardWang() {
		// TODO 自动生成的方法存根
		System.out.println("此处有监控，实时监控！");
	}
	@Override
	public void lock() {
		// TODO 自动生成的方法存根
		System.out.println("窗户关闭");
	}
	@Override
	public void unlock() {
		// TODO 自动生成的方法存根
		System.out.println("窗户打开");
	}
}

package day12.interface1;
//测试类
public class TestDemo {
	//实现调用FirstInterface方法
	public static void method1(FirstInterface face) {
		face.lock();
		face.unlock();
	}
	//实现SecondInterface
	public static void method2(SecondInterface face) {
		face.firePrevention();
	}
	public static void method3(ThirdInterface face) {
		face.guardWang();
	}
	public static void main(String[] args) {
		/*// 初始化一个安全门
		AntiTheftDoor door=new AntiTheftDoor();
		//调用方法
		door.openDoor();
		door.closeDoor();
		door.lock();
		door.unlock();
		door.firePrevention();
		door.guardWang();
		//初始化另一个安全门
		AntiTheftDoor1 door1=new AntiTheftDoor1();
		door1.openDoor();
		door1.closeDoor();
		door1.lock();
		door1.unlock();
		door1.firePrevention();
		//初始化一个窗户
		Windows win=new Windows();
		win.guardWang();*/
		/*
		 * 以多态的方法初始化一个对象
		 * */
		//初始化一个对象，将对象赋值给父类类型
		/*FirstInterface face1=new AntiTheftDoor();//接口可以看成一个特殊的父类
		//调用方法
		face1.lock();
		face1.unlock();
		Door door=(Door)face1;
		door.openDoor();
		door.closeDoor();*/
		//初始化一个防盗门
		AntiTheftDoor face1=new AntiTheftDoor();
		//调用开锁、关锁
		method1(face1);
		method2(face1);
		method3(face1);
		//初始化一个窗户
		Windows win=new Windows();
		method3(win);
		method1(win);
	}

}

练习题

用程序描述USB接口

package day12.interface2;

public interface UsbInterface {
	//加载驱动
	public void loadDrive();
	//工作
	public void doWork();
}

package day12.interface2;
//实现类  U盘
public class UsbDrive implements UsbInterface{
	@Override
	public void loadDrive() {
		// TODO 自动生成的方法存根
		System.out.println("U盘加载驱动");
	}
	@Override
	public void doWork() {
		// TODO 自动生成的方法存根
		System.out.println("存储等功能");
	}
}

package day12.interface2;
//实现类  风扇
public class UsbFan implements UsbInterface{
	@Override
	public void loadDrive() {
		// TODO 自动生成的方法存根
		System.out.println("风扇加载驱动");
	}
	@Override
	public void doWork() {
		// TODO 自动生成的方法存根
		System.out.println("吹风");
	}
}

package day12.interface2;
//实现类  鼠标
public class UseMouse implements UsbInterface{
	@Override
	public void loadDrive() {
		// TODO 自动生成的方法存根
		System.out.println("鼠标加载驱动");
	}
	@Override
	public void doWork() {
		// TODO 自动生成的方法存根
		System.out.println("鼠标可以工作了！");
	}
}

​
package day12.interface2;

public class TestDemo {
	//加载驱动
	public static void load(UsbInterface face) {
		face.loadDrive();
		face.doWork();		
	}
	public static void main(String[] args) {
		// 初始化对象  调用方法
		UsbFan fan=new UsbFan();
		load(fan);
		UsbDrive drive=new UsbDrive();
		load(drive);
		UseMouse mouse=new UseMouse();
		load(mouse);
	}

}

​

2.接口的继承

 * 接口继承语法：
 *         修饰符 Interface 接口 extends 接口1,接口2....{
 *         }
 * 特性：
 *         1.接口可以继承接口
 *         2.接口可以多继承，只能继承接口中的抽象方法
 *         3.接口只能继承接口，不能继承类

package day12.interface3;

interface SecondInterface{
	public void method3();
}
interface ThirdInterface{
	public void method2();
}
interface FourInterface extends SecondInterface,ThirdInterface{
	
}
public interface FirstInterface {
	public void method1() ;
}

package day12.interface3;

public class Demo implements FirstInterface,SecondInterface,ThirdInterface{
	@Override
	public void method1() {
		// TODO 自动生成的方法存根
		
	}
	@Override
	public void method2() {
		// TODO 自动生成的方法存根
		
	}
	@Override
	public void method3() {
		// TODO 自动生成的方法存根
		
	}
}
//Demo1实现FourInterface
class Demo1 implements FourInterface{
	@Override
	public void method2() {
		// TODO 自动生成的方法存根
		
	}
	@Override
	public void method3() {
		// TODO 自动生成的方法存根
		
	}
}
/**
 * 抽象类实现一个接口后，可以不对接口中的方法进行重写。抽象类中可以包含抽象方法
 * 如果一个类继承了这个抽象类，必须对接口方法进行重写
 * */
abstract class Demo2 implements FourInterface{}

练习题

package day12.Test1;
//求面积的规范
public interface GetAreaInterface {
	public double getArea();
}

package day12.Test1;

public class Circle implements GetAreaInterface{
	// 半径
	private double r;	
	public double getR() {
		return r;
	}
	public void setR(double r) {
		this.r = r;
	}
	public Circle() {
		// TODO 自动生成的构造函数存根
	}
	public  Circle(double r) {
		this.setR(r);
	}
	@Override
	public double getArea() {		
		//求面积
		double area=3.14*Math.pow(this.r, 2);
		return area;
	}
}

package day12.Test1;
//长方形
public class Rectangle implements GetAreaInterface{
	private double length;
	private double width;
	
	public double getLength() {
		return length;
	}

	public void setLength(double length) {
		this.length = length;
	}

	public double getWidth() {
		return width;
	}

	public void setWidth(double width) {
		this.width = width;
	}
	public Rectangle() {
		// TODO 自动生成的构造函数存根
	}
	public  Rectangle(double length,double width) {
		this.setLength(length);
		this.setWidth(width);
	}
	@Override
	public double getArea() {
		// TODO 自动生成的方法存根
		double area=this.getLength()*this.getWidth();
		return area;
	}
}

package day12.Test1;

public class TestDemo {
	public static void getAreas(GetAreaInterface face) {
		if (face instanceof Circle) {
			System.out.println("圆的面积是"+face.getArea());
		}else if (face instanceof Rectangle) {
			System.out.println("长方形的面积是"+face.getArea());
		}		
	}
	public static void main(String[] args) {
		// 初始化对象  调用方法
		Circle circle=new Circle(2);
		getAreas(circle);
		Rectangle rect=new Rectangle(2,3);
		getAreas(rect);
	}

}

3.知识框架