目录
接口
接口的概念
语法
接口使用
接口实现用例
接口特性
实现多个接口和实现用例
接口间的继承
接口
接口的概念
在现实生活中，接口的例子比比皆是，比如：笔记本上的
USB
口，电源插座等。
电脑的
USB
口上，可以插：
U
盘、鼠标、键盘
...
所有符合
USB
协议的设备
电源插座插孔上，可以插：电脑、电视机、电饭煲
...
所有符合规范的设备
通过上述例子可以看出：
接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用
。
在 Java 中，接口可以看成是：多个类的公共规范，是一种引用数据类型。
语法
接口在语法上和类相似
public interface 接口名称 {
......
}
提示: 创建接口时, 接口的命名一般以大写字母 I 开头
接口使用
接口不能直接使用，必须要有一个"实现类"来"实现"该接口，并实现接口中的所有抽象方法。
public class 类名称 implements 接口名称 {
...
}
注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。
接口实现用例
以笔记本电脑使用
USB
鼠标、
USB
键盘为例
USB接口 笔记本类 鼠标类 键盘类
//USB接口
public interface USB {
//方法，打开设备，关闭设备
void openEquipment();
void stopEquipment();
}
//定义鼠标类，使用接口
class Mouse implements USB {
//使用接口，就要重写USB接口的抽象方法
@Override
public void openEquipment() {
System.out.println("使用鼠标");
}
//自定义一个鼠标点击的功能
public void click(){
System.out.println("鼠标点击");
}
@Override
public void stopEquipment() {
System.out.println("关闭鼠标");
}
}
//定义键盘类，使用接口
class Keyboard implements USB{
@Override
public void openEquipment() {
System.out.println("使用键盘");
}
//自定义一个键盘输入的方法
public void inPut() {
System.out.println("键盘输入");
}
@Override
public void stopEquipment() {
System.out.println("关闭键盘");
}
}
//定义电脑类,使用设备
class Computer{
public void powerOn(){
System.out.println("打开电源");
}
public void useEquipment(USB usb){
//这里使用USB usb的原因是：为了传参并发生向上转型
usb.openEquipment();//这里会发生动态绑定
//这里，我们调用了使用设备的方法，但我们有鼠标和键盘，他们都要各自特有的方法click和inPut
//但usb是接口类型，直接用usb去调用他们的特有方法，不可行
//区分 引用的是谁的对象
if(usb instanceof Mouse){
Mouse mouse = (Mouse) usb;
mouse.click();
}else if(usb instanceof Keyboard){
Keyboard keyboard = (Keyboard) usb;
keyboard.inPut();
}
usb.stopEquipment();
}
public void powerOff(){
System.out.println("关闭电源");
}
}
class Test{
public static void main(String[] args) {
Computer computer = new Computer();
computer.powerOn();
System.out.println();
computer.useEquipment(new Keyboard());
System.out.println();
computer.useEquipment(new Mouse());
System.out.println();
computer.powerOff();
}
}
接口特性
- 接口类型是一种引用类型，不能直接 new 接口的对象
- 接口中的每一个方法都是默认被 public private 修饰
- 接口中的方法不能在接口中实现(因为抽象方法不能有具体的实现)，只能由实现接口的类来实现
- 重写接口中的方法时，不能使用默认的访问权限（因为接口的方法默认是public）
- 接口中可以拥有变量，但接口中的变量会默认被public static final 修饰
- 接口中不能有静态代码块和构造方法
- 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
- 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
实现多个接口和实现用例
在
Java
中，类和类之间是单继承的，一个类只能有一个父类，即
Java
中不支持多继承
，但是
一个类可以实现多个接
口
。
下面通过类来表示一组动物
创一个动物类
//动物类
class Animals{
private String name;
public Animals(String name) {
this.name = name;
}
}
创几个接口
//吃 接口
interface EAT{
void eat();
}
//跑 接口
interface RUN{
void run();
}
//飞 接口
interface FLY{
void fly();
}
//游泳 接口
interface SWIM{
void swim();
}创几个具体的动物类
小狗，可以吃和跑
class Dog extends Animals implements EAT,RUN{
public Dog(String name) {
super(name);
}
@Override
public void eat() {
System.out.println(this.name + "在吃");
}
@Override
public void run() {
System.out.println(this.name + "在跑");
}
}
小鱼，可以吃和游
class Fish extends Animals implements EAT,SWIM{
public Fish(String name){
super(name);
}
@Override
public void eat() {
System.out.println(this.name + "在吃");
}
@Override
public void swim() {
System.out.println(this.name + "在游");
}
}小鸭子，可以吃，飞，跑和游
class Duck extends Animals implements EAT,RUN,FLY,SWIM{
public Duck(String name){
super(name);
}
@Override
public void eat() {
System.out.println(this.name + "在吃");
}
@Override
public void run() {
System.out.println(this.name + "在跑");
}
@Override
public void fly() {
System.out.println(this.name + "在飞");
}
@Override
public void swim() {
}
}
上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口
继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性
以下是完整代码和执行结果
class Animals{
public String name;
public Animals(String name) {
this.name = name;
}
}
//吃 接口
interface EAT{
void eat();
}
//跑 接口
interface RUN{
void run();
}
//飞 接口
interface FLY{
void fly();
}
//游泳 接口
interface SWIM{
void swim();
}
class Dog extends Animals implements EAT,RUN{
public Dog(String name) {
super(name);
}
@Override
public void eat() {
System.out.println(this.name + "在吃");
}
@Override
public void run() {
System.out.println(this.name + "在跑");
}
}
class Fish extends Animals implements EAT,SWIM{
public Fish(String name){
super(name);
}
@Override
public void eat() {
System.out.println(this.name + "在吃");
}
@Override
public void swim() {
System.out.println(this.name + "在游");
}
}
class Duck extends Animals implements EAT,RUN,FLY,SWIM{
public Duck(String name){
super(name);
}
@Override
public void eat() {
System.out.println(this.name + "在吃");
}
@Override
public void run() {
System.out.println(this.name + "在跑");
}
@Override
public void fly() {
System.out.println(this.name + "在飞");
}
@Override
public void swim() {
}
}
public class Blog {
public static void main(String[] args) {
Dog dog = new Dog("小狗");
dog.eat();
dog.run();
Fish fish = new Fish("小鱼");
fish.eat();
fish.swim();
Duck duck = new Duck("小鸭子");
duck.eat();
duck.fly();
duck.run();
duck.swim();
}
}
接口间的继承
在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字
interface RUN{
void run();
}
//游泳 接口
interface SWIM{
void swim();
}
interface ICanDo extends RUN, SWIM {
}
class Frog implements ICanDo {
...
}
通过接口继承创建一个新的接口 ICanDo 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.
接口间的继承相当于把多个接口合并在一起
