目录

说明接口概述定义格式抽象方法默认方法静态方法私有方法和私有静态方法 接口的多实现抽象方法默认方法静态方法优先级接口的多继承其他成员特点 多态概述多态的优点引用类型转换为什么要转型转型的异常 综合示例

说明

本文根据个人理解以及学习记录撰写，如有不对或者理解不到之处请指正。

接口

概述

接口是Java中的一种引用类型，是方法的集合，内部主要封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法 （JDK 9）。 接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。¹ 接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

定义格式

public interface 接口名称 { // 抽象方法 // 默认方法 // 静态方法 // 私有方法 }

抽象方法

抽象方法使用关键字abstract修饰，关键字可省，没有方法体，需要子类实现。 代码示例：

//定义接口 ublic interface MyInterface { void work(); public abstract void sleep(); ｝ //定义实现类 public class MyInterfaceImpl implements MyInterface{ @Override public void work() { //方法体 } @Override public void sleep() { //方法体 } } //定义测试类 public class MyInterfaceDemo { public static void main(String[] args) { MyInterfaceImpl myInterface = new MyInterfaceImpl(); myInterface.sleep(); myInterface.work(); } }

默认方法

默认方法使用关键字default修饰，不可省，供子类调用或者重写。 代码示例：

//定义接口 public interface MyInterface { default void work(){ System.out.println("正在工作"); } //定义实现类 public class MyInterfaceImpl implements MyInterface { //可重写可不重写 } //定义测试类 public class MyInterfaceDemo { public static void main(String[] args) { MyInterfaceImpl myInterface = new MyInterfaceImpl(); myInterface.work(); } }

静态方法

静态方法使用关键字static修饰，不可省，供接口直接调用。² 代码示例：

//定义接口 public interface MyInterface { static void eat(){ //方法体 } } //定义实现类 public class MyInterfaceImpl implements MyInterface { //无法重写静态方法 } //定义测试类 public class MyInterfaceDemo { public static void main(String[] args) { MyInterface.sleep(); } }

私有方法和私有静态方法

私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。³ 代码示例：

public interface MyInterface{ default void life(){ sleep(); play(); ｝ public static void sleep(){ // 方法体 } private static void play() //方法体 } ｝

接口的多实现

在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类在继承一个父类的同时可以实现多个接口。 实现格式：

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... { // 重写接口中抽象方法【必须】 // 重写接口中默认方法【不重名时可选】 } 注：[ ]中内容为可选操作。

抽象方法

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。 代码示例：

//定义多个接口 interface A { public abstract void showA(); public abstract void show(); } interface B { public abstract void showB(); public abstract void show(); } //定义实现类 public class C implements A,B{ @Override public void showA(){ System.out.println("showA"); } @Override public void showB() { System.out.println("showB"); } @Override public void show() { System.out.println("show"); } }

默认方法

接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。

//定义多个接口 interface A { public default void methodA(){ } public default void method(){ } } interface B { public default void methodB(){ } public default void method(){ } } //定义实现类 public class C implements A,B{ @Override public void method() { System.out.println("method"); } }

静态方法

接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

优先级

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执 行父类的成员方法。代码如下：

//定义接口 interface A { public default void methodA(){ System.out.println("AAAAAAAAAAAA"); } } //定义父类 class D { public void methodA(){ System.out.println("DDDDDDDDDDDD"); } } //定义子类 class C extends D implements A { // 未重写methodA方法 } //定义测试类 public class Test { public static void main(String[] args) { C c = new C(); c.methodA(); } } 运行结果: DDDDDDDDDDDD

接口的多继承

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。继承多个接口的时候，如果父接口们中的默认方法有重名的，那么子接口需要重写一次重名的方法。

注意： 子接口重写默认方法时，default关键字可以保留。 子类重写默认方法时，default关键字不可以保留。

其他成员特点

接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。接口中，没有构造方法，不能创建对象。接口中，没有静态代码块（static{ //执行语句 }）。

多态

概述

多态是继封装、继承之后，面向对象的第三大特性。 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。

格式 父类类型 变量名 = new 子类对象； 变量名.方法名();

注意： 当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

多态的优点

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利 示例代码

//父类 public abstract class Animal { public abstract void eat(); } //子类 public class Cat extends Animal { @Override public void eat() { System.out.println("吃鱼"); } } //子类 public class Dog extends Animal{ @Override public void eat() { System.out.println("吃骨头"); } } //测试示例 public class Test { public static void main(String[] args) { Cat c = new Cat(); c.eat(); Dog d = new Dog(); d.eat(); showCatEat(c); showDogEat(d); showAnimalEat(c); showAnimalEat(d); } private static void showDogEat(Dog dog) { dog.eat(); } private static void showCatEat(Cat cat) { cat.eat(); } //展示多态的优点，不需要分别创建子类，就能调用子类中的方法 private static void showAnimalEat(Animal a) { a.eat(); } } 运行结果： 吃鱼 吃骨头 吃鱼 吃骨头

首先写了一个父类Animal，然后写了两个子类Cat和Dog分别继承了父类，并重写了其中的方法。接着在测试用例中分别创建了Cat类型的变量和Dog类型的变量以及它们的对象。然后又写了三个方法，类型分别是之前创建的三个类。 由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。 当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致， 所以showAnimalEat完全可以替代以上两方法 不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用 showAnimalEat都可以完成。 所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

引用类型转换

多态的转型分为向上转型与向下转型两种：

向上转型 多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。 当父类引用指向一个子类对象时，便是向上转型。 使用格式： 父类类型 变量名 = new 子类类型(); 如：Animal a = new Cat();

向下转型 父类类型向子类类型向下转换的过程，这个过程是强制的。 一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。 使用格式： 父类类型 变量名 = new 子类类型(); 如：Animal a = new Cat();

为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥 有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子 类特有的方法，必须做向下转型。

// public abstract class Animal { public abstract void eat(); } // public class Cat extends Animal { @Override public void eat() { System.out.println("吃鱼"); } public void catchMouse(){ System.out.println("抓老鼠"); } } // public class Dog extends Animal{ @Override public void eat() { System.out.println("吃骨头"); } public void watchHouse(){ System.out.println("看家"); } } // public class Test public static void main(String[] args) { // 向上转型 Animal a = new Cat(); a.eat(); // 调用的是 Cat 的 eat // 向下转型 Cat c = (Cat)a; c.catchMouse(); // 调用的是 Cat 的 catchMouse } }

转型的异常

public class Test { public static void main(String[] args) { // 向上转型 Animal a = new Cat(); a.eat();// 调用的是 Cat 的 eat // 向下转型 Dog d = (Dog)a; d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】 } }

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了 Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。 为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下： 变量名 instanceof 数据类型 如果变量属于该数据类型，返回true。 如果变量不属于该数据类型，返回false。

所以，转换前，我们好先做一个判断，代码如下：

public class Test { public static void main(String[] args) { //向上转型 Animal a = new Cat(); a.eat(); //调用的是 Cat 的 eat //向下转型 if (a instanceof Cat) { Cat c = (Cat) a; c.catchMouse(); //调用的是 Cat 的 catchMouse } else if (a instanceof Dog) { Dog d = (Dog) a; d.watchHouse(); //调用的是 Dog 的 watchHouse } } }

综合示例

进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘： USB接口，包含开启功能、关闭功能； 笔记本类，包含运行功能、关机功能、使用USB设备功能 ； 鼠标类，要实现USB接口，并具备点击的方法； 键盘类，要实现USB接口，具备敲击的方法 。

//创建USB接口 public interface Usb { public abstract void open(); public abstract void close(); } //创建实现类鼠标 public class Mouse implements Usb{ @Override public void open() { System.out.println("插入鼠标"); } @Override public void close() { System.out.println("拔出鼠标"); } public void click(){ System.out.println("鼠标输入"); } } //创建实现类键盘 public class Keyboard implements Usb{ @Override public void open() { System.out.println("插入键盘"); } @Override public void close() { System.out.println("拔出键盘"); } public void print(){ System.out.println("键盘输入"); } } //创建类电脑 public class Laptop { public void run(){ System.out.println("电脑开机"); } public void Usb(Usb usb){ if (usb != null){ usb.open(); if (usb instanceof Mouse){ Mouse mouse = new Mouse(); mouse.click(); }else if (usb instanceof Keyboard){ Keyboard keyboard = new Keyboard(); keyboard.print(); } usb.close(); } } } /* * 实现电脑和接口之间的互动 * */ public class DemoTest { public static void main(String[] args) { Laptop laptop = new Laptop(); laptop.run(); Usb m = new Mouse(); laptop.Usb(m); Usb k = new Keyboard(); laptop.Usb(k); } } 运行结果： 电脑开机 插入鼠标 鼠标输入 拔出鼠标 插入键盘 键盘输入 拔出键盘

---

引用数据类型：数组，类，接口。 ↩︎

被static修饰的方不可以创建对象调用，而是通过类名调用。同时，该方法不能被重写 ↩︎

private关键字不可省，被该关键字修饰的方法和变量只能在本类当中使用。除了成员变量外不建议使用。 ↩︎