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