Java进阶总结——接口

﹏ヽ暗。殇╰゛Y 2022-05-18 10:56 226阅读 0赞

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

# 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接口

![70][]

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.知识框架 #

![70 1][]

[70]: /images/20220518/b46f138a3b64403a8c58067a831a0d88.png
[70 1]: /images/20220518/fe93abd08ec04b45aa54d26d6e7dd787.png