Java基础 第二节 第十四课
概述
接口, 是 Java 语言一种引用类型, 是方法的集合. 如果说类的内部封装了成员变量, 构造方法和成员方法, 那么接口的内部主要就是封装了方法. 包含抽象方法 ( JDK7 及以前 ), 默认方法和静态方法 ( JDK8 ), 私有方法 (JDK9 ).
接口的定义, 它与定义类方式相似, 但是使用 interface 关键字. 它与定义方式类似, 但是使用 interface 关键字. 它也会被编译成 .class 文件, 但一定要明确它并不是类, 而是另外一种数据类型.
引用数据类型：数组，类，接口。
- 1
接口的使用, 它不能创建对象, 但是可以被实现 ( implements, 类似于被继承 ). 一个实现接口的类 (可以看做是接口的子类), 需要实现接口中所有的抽象方法, 创建该类对象, 就可以调用方法了. 否则他必须是一个抽象类.
定义格式
public interface 接口名称 {
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
}
- 1
- 2
- 3
- 4
- 5
- 6
含有抽象方法
抽象方法: 使用 abstract 关键字修饰, 可以省略, 没有方法体. 该方供子类实现使用.
代码如下:
public interface InterFaceName {
public abstract void method();
}
- 1
- 2
- 3
含有默认方法和静态方法
默认方法: 使用 default 修饰, 不可省略, 供子类调用或者子类重写.
静态方法: 使用 static 修饰, 供接口直接调用.
代码如下:
public interface InterFaceName {
public default void method() {
// 执行语句
}
public static void method2() {
// 执行语句
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
含私有方法和私有静态方法
私有方法: 使用 private 修饰, 提供接口中的默认方法或者静态方法调用.
代码如下:
public interface InterFaceName {
private void method() {
// 执行语句
}
}
- 1
- 2
- 3
- 4
- 5
基本的实现
实现的概述
类与接口的关系为实现关系, 即类实现接口. 该类可以称为接口的实现类, 也可以称为接口的子类. 实现的动作类似继承, 格式相符, 知识关键字不同, 实现使用 implements 关键字.
非抽象子类实现接口:
- 必须重写接口中所有抽象方法
- 继承了接口的默认方法, 即可直接调用, 也可以重写
实现格式:
class 类名 implements 接口名 {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【可选】
}
- 1
- 2
- 3
- 4
抽象方法的使用
必须全部实现, 代码如下:
定义接口
public interface LiveAble {
// 定义抽象方法
public abstract void eat();
public abstract void sleep();
}
- 1
- 2
- 3
- 4
- 5
定义实现类
public class Animal implements LiveAble {
@Override
public void eat() {
System.out.println("吃东西");
}
@Override
public void sleep() {
System.out.println("睡觉觉");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
定义测试类
public class InterfaceDemo {
public static void main(String[] args) {
// 创建子类对象
Animal a = new Animal();
// 调用实现后的方法
a.eat();
a.sleep();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
执行结果:
默认方法的使用
可以继承, 可以重写, 二选一, 但是只能通过实现类的对象来调用.
继承默认方法
定义接口
public interface LiveAble2 {
public default void fly(){
System.out.println("天上飞");
}
}
- 1
- 2
- 3
- 4
- 5
定义实现类
public class Animal2 implements LiveAble2 {
// 继承, 什么都不用写
}
- 1
- 2
- 3
定义测试类
public class InterfaceDemo2 {
public static void main(String[] args) {
// 创建子类对象
Animal2 animal2 = new Animal2();
// 调用默认方法
animal2.fly(); // 输出结果: 天上飞
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
重写默认方法
定义接口
public interface LiveAble2 {
public default void fly(){
System.out.println("天上飞");
}
}
- 1
- 2
- 3
- 4
- 5
定义实现类
public class Animal3 implements LiveAble3 {
@Override
public void fly(){
System.out.println("自由自在的飞");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
定义测试类
public class InterfaceDemo3 {
public static void main(String[] args) {
// 创建子类对象
Animal3 animal3 = new Animal3();
// 调用默认方法
animal3.fly(); // 输出结果: 自由自在的飞
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
静态方法的使用
静态与 .class 文件相关, 只能使用接口名调用, 不可以通过实现类的类名或者实现类的对象调用.
代码如下:
定义接口
public interface LiveAble {
public static void run(){
System.out.println("嗨起来!");
}
}
- 1
- 2
- 3
- 4
- 5
定义实现类
public class Animal implements LiveAble {
// 无需重写静态方法
}
- 1
- 2
- 3
定义测试类
public class Animal implements LiveAble {
// 无需重写静态方法
}
- 1
- 2
- 3
私有方法的使用
私有方法: 只有默认方法可以调用.
私有静态方法: 默认方法和静态方法都可以调用.
如果一个接口有多个默认方法, 并且方法中有重复的内容. 那么可以抽取出来, 封装到私有方法中, 提供默认方法去调用. 从设计角度讲, 私有的方法是对默认方法和静态方法的辅助.
定义接口
public interface LiveAble2 {
default void func(){
func1();
func2();
}
private void func1(){
System.out.println("跑起来1");
}
private void func2(){
System.out.println("跑起来2");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
接口的多实现
之前学过, 在继承体系中, 一个类只能继承一个父类. 而对于接口而言, 一类是可以实现多个接口的, 这叫做接口的多实现. 并且, 一个类能继承一个父类, 同时实现多个接口.
实现格式:
class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
// 重写接口中抽象方法 (必须)
// 重写接口中默认方法 (不重名时可选)
}
- 1
- 2
- 3
- 4
抽象方法
接口中, 有多个抽象方法, 实现类必须重写所有抽象方法.
定义多个接口:
public interface A {
public abstract void showA();
public abstract void show();
}
- 1
- 2
- 3
- 4
public interface B {
public abstract void showB();
public abstract void show();
}
- 1
- 2
- 3
- 4
定义实现类:
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");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
默认方法
接口中, 有多个默认方法时, 实现类都可以继承使用. 如果默认方法有重名的, 必须重写一次.
代码如下:
public interface A {
public default void methodA(){
}
public default void method(){
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
public interface B {
public default void methadB(){
}
public default void methad(){
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
定义实现类:
public class C implements A,B {
@Override
public void method() {
System.out.println("method");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
静态方法
接口中, 存在同名的静态方法并不会冲突, 原因是只能通过各自接口访问静态方法.
优先级的问题
当一个类, 既继承一个父类, 又实现若干个接口时, 父类中的成员方法与接口中的默认方法重名, 子类就近选择执行父类的成员方法.
代码如下:
定义接口:
public interface A {
public default void methodA(){
System.out.println("AAAAAA");
}
}
- 1
- 2
- 3
- 4
- 5
定义父类:
public class D {
public void methodA(){
System.out.println("DDDDDD");
}
}
- 1
- 2
- 3
- 4
- 5
定义子类:
public class C extends D implements A {
// 未重写methodA方法
}
- 1
- 2
- 3
定义测试类:
public class Test {
public static void main(String[] args) {
C c = new C();
c.methodA(); // 输出结果: DDDDDD
}
}
- 1
- 2
- 3
- 4
- 5
- 6
接口的多继承
一个接口能继承另一个或者多个接口, 这和类之间的继承比较相似. 接口的继承使用 extends 关键字, 子接口继承父接口的方法. 如果父亲接口中的默认方法有重名的, 那么子接口需要重写一次.
代码如下:
定义父接口:
interface A {
public default void method(){
System.out.println("AAAAAA");
}
}
- 1
- 2
- 3
- 4
- 5
interface B {
public default void method(){
System.out.println("BBBBBB");
}
}
- 1
- 2
- 3
- 4
- 5
定义子接口:
interface D extends A,B{
@Override
public default void method() {
System.out.println("DDDDDD");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
注:
子接口重写默认方法时, default 关键字可以保留.
子类重写默认方法时, default 关键字不可保留.
其他成员特点
- 接口中, 无法定义成员变量, 但是可以定义常量, 其值不可以改变, 默认使用 public static final 修饰
- 接口中, 没有构造方法, 不能创建对象
- 接口中, 没有静态代码块
文章来源: iamarookie.blog.csdn.net，作者：我是小白呀，版权归原作者所有，如需转载，请联系作者。
原文链接：iamarookie.blog.csdn.net/article/details/110127500
- 点赞
- 收藏
- 关注作者
评论（0）