由浅到深认识Java语言（16）：接口

该文章Github地址：https://github.com/AntonyCheng/java-notes【有条件的情况下推荐直接访问GitHub以获取最新的代码更新】

在此介绍一下作者开源的SpringBoot项目初始化模板（Github仓库地址：https://github.com/AntonyCheng/spring-boot-init-template【有条件的情况下推荐直接访问GitHub以获取最新的代码更新】& CSDN文章地址：https://blog.csdn.net/AntonyCheng/article/details/136555245），该模板集成了最常见的开发组件，同时基于修改配置文件实现组件的装载，除了这些，模板中还有非常丰富的整合示例，同时单体架构也非常适合SpringBoot框架入门，如果觉得有意义或者有帮助，欢迎Star & Issues & PR！

上一章：由浅到深认识Java语言（15）：final关键字&抽象类

26.接口（interface）

**定义：**所谓的接口，就是一个极端的抽象类，接口中只能有抽象方法和常量（Java 1.7版本以前），描述一种规则，提高开发效率；

如何定义接口

接口和类是并行的概念，可以把接口看成类，但是接口的声明并不是 class ，而是 interface；

接口中的属性是全局常量；

定义格式：

public interface 接口名 {}

接口中属性和方法的格式：

public interface 接口名 {
	int MY_INT = 0;
	void method(){
	
	}
}

示例如下：

Person 类：

package top.sharehome.BagOne;

public interface Person {
	//接口中的全局常量
	int MY_INT = 0;
	//等效于 public static final int MY_INT = 0;
	String MY_STRING = " ";
	//等效于 public static final String MY_STRING = " ";
	
	//接口中的方法
	void sleep();
	//等效于 public abstract void sleep();
	void eat();
	//等效于 public abstract void sleep();
	void walking();
	//等效于 public abstract void sleep();
}

如何实现接口

类实现接口的基本格式：

class 类名 implements 接口名1,接口名2……{}

注意： 实现接口后，该类要重写接口中所有的抽象方法才能被实现，否则该类也得使用 abstract 修饰；

示例如下：

Person 类：

package top.sharehome.BagOne;

public interface Person {
	//接口中的全局常量
	int MY_INT = 0;
	//等效于 public static final int MY_INT = 0;
	String MY_STRING = " ";
	//等效于 public static final String MY_STRING = " ";
	
	//接口中的方法
	void sleep();
	//等效于 public abstract void sleep();
	void eat();
	//等效于 public abstract void sleep();
	void walking();
	//等效于 public abstract void sleep();
}

Student 类：

package top.sharehome.BagOne;

public class Student implements Person{
	public void sleep() {
		System.out.println("学生睡觉");
	}
	public void eat() {
		System.out.println("学生吃饭");
	}
	public void walking() {
		System.out.println("学生走路");
	}
}

Demo 类：

package top.sharehome.BagOne;

public class Demo {
	public static void main(String[] args) {
		Person p =new Student();
		p.sleep();
		p.eat();
		p.walking();
	}
}

打印效果如下：

使用接口进行开发的意义

意义

Java 中的继承是有局限的，一个类只能继承一个父类，但是 Java 中的接口是可以多实现的；

示例如下：

interface A{
	public void methodA();
}
interface B{
	public void methodB();
}
class c implements A,B{
    
}

关系

• 接口和接口：

  • 接口和接口之间既可以实现单继承，也可以实现多继承；

    示例如下：

    interface A{
    	void methodA();
    }
    interface B{
        void methodB();
    }
    interface C extends A,B{
        void methodC();
    }
    

• 类与类：

  • 继承关系只能单继承，不能多继承，但是可以多层继承；

  • 多层继承指的是子类继承父类，父类继承祖父类；

• 类与接口：

  • 类实现接口，可以单实现，也可以多实现，在继承类的同时，可以实现多个接口；

    示例如下：

    package top.sharehome.BagOne;
    
    public class Demo {
    	public static void main(String[] args) {
    	}
    }
    
    interface M {
    	void m1();
    }
    
    interface N {
    	void m2();
    }
    
    abstract class A {
    	public abstract void m3();
    }
    
    class B extends A implements M,N{  //在继承类的同时，实现了多个接口
    	@Override
    	public void m2() {
    		// TODO Auto-generated method stub
    	}
    	@Override
    	public void m1() {
    		// TODO Auto-generated method stub
    	}
    	@Override
    	public void m3() {
    		// TODO Auto-generated method stub
    	}
    }
    

  • 多个接口中出现了名称和参数列表相同的方法，但是返回值不同，会报错；

抽象类实例

实例一：

定义老师规则接口，定义老师类，讲课方法，辅导作业方法；

定义实现的子类，不同的老师有不同的讲课方法；

package top.sharehome.BagOne;

public class Demo {
	public static void main(String[] args) {
		Teacher java = new JavaTeacher();
		Teacher Chinese = new ChineseTeacher();
		java.Teach();
		java.checkHomework();
		Chinese.Teach();
		Chinese.checkHomework();
	}
}

interface Teacher{
	void Teach();
	void checkHomework();
}

class ChineseTeacher implements Teacher{
	@Override
	public void Teach() {
		System.out.println("讲语文");
	}
	@Override
	public void checkHomework() {
		System.out.println("检查语文作业");
	}
}

class JavaTeacher implements Teacher{
	@Override
	public void Teach() {
		System.out.println("讲Java");
	}

	@Override
	public void checkHomework() {
		System.out.println("检查Java作业");
	}
}

打印效果如下：

实例二：

具体事物：猫，狗；

共性：姓名，年龄，吃饭（抽象类中成员变量的使用和普通类一样）；

猫的特性：抓老鼠；

狗的特性：看家；

package top.sharehome.Bag;
import java.util.*;
public class Demo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		Animal a = new Cat();
		Animal b = new Dog();
		System.out.println("您家养的是小猫还是小狗？（猫/狗=1,2)");
		int select = sc.nextInt();
		if (select == 1) {
			System.out.println("您家小猫叫：");
			a.name = sc.next();
			System.out.println("您家小猫的年龄？");
			a.age = sc.nextInt();
			System.out.println("============================");
			System.out.println("你家小猫的具体情况如下:" + "\n" + "姓名:" + a.name + "\n" + "年龄" + a.age);
			System.out.println("有如下技能：");
			a.eat();
			Cat a1 = (Cat) a;
			a1.catchMouse();
		} else if (select == 2) {
			System.out.println("您家小狗叫：");
			b.name = sc.next();
			System.out.println("您家小狗的年龄？");
			b.age = sc.nextInt();
			System.out.println("============================");
			System.out.println("你家小狗的具体情况如下:" + "\n" + "姓名:" + b.name + "\n" + "年龄" + b.age);
			System.out.println("有如下技能：");
			b.eat();
			Dog b1 = (Dog) b;
			b1.lookHome();
		}
		sc.close();
	}
}

abstract class Animal {
	String name;
	int age;
	public abstract void eat();
}

class Cat extends Animal {
	@Override
	public void eat() {
		System.out.println("猫进食");
	}
	public void catchMouse() {
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	@Override
	public void eat() {
		System.out.println("狗进食");
	}
	public void lookHome() {
		System.out.println("看家");
	}
}

打印效果如下：

实例三：

汽车工厂已经将车的主体完成，汽车已经可以开动了，后期需要根据不同的用途安装不同的部件，例如货车需要安装货箱用来拉货，客车需要安装座椅用来拉人；

package top.sharehome.Bag;
public class Demo {
	public static void main(String[] args) {
		Car t = new Track();
		Car b = new Bus();
		t.tool();
		b.tool();
	}
}

abstract class Car{
	public abstract void tool();
}

class Track extends Car{
	public void tool() {
		System.out.println("拉货");
	}
}

class Bus extends Car{
	public void tool() {
		System.out.println("拉人");
	}
}

打印效果如下：

下一章：由浅到深认识Java语言（17）：内部类