@[TOC] java个人自学博客-Qiao
Day09.01接口
接口的使用
- 接口的定义
- 【修饰符】 interface 【接口名称】{ }
- 接口的实现
//抽象方法:abstract
//默认方法:default
//静态方法:static
//私有方法:private- 【修饰符】class 【类名】 implements 【接口名】{ }
- 接口的多实现
- class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3
- 接口的多继承
- eg1.图片的不同格式保存
- eg2.为汽车增加GPS定位功能
接口的定义
接口,是Java语言中一种引用类型,是方法的集合,如果说类的内部封装了成员变量、构造方法和成员方法,那么 接口的内部主要就是封装方法:
抽象方法(JDK 7及以前)
默认方法
静态方法(JDK 8)
私有方法 (JDK 9)
【修饰符】 interface 接口名称【extends 父接口名列表】{
【public】【static】【final】变量
【public】【abstract】方法(有抽象、默认、静态、私有)
// 抽象方法:使用 abstract 关键字修饰,可以省略,没有方法体。该方法供子类实现使用。
// 默认方法:使用 default 修饰,不可省略,供子类调用或者子类重写。
// 静态方法:使用 static 修饰,供接口直接调用。
// 私有方法:使用 private 修饰,供接口中的默认方法或者静态方法调用。
}
public interface InterFaceName{
public abstract void method();
}
public interface InterFaceName2{
public default void method2() {
}//若其后没有大括号错的,封号是错的
}
public interface InterFaceName3{
public abstract void method3();
}
public interface InterFaceName4{
public abstract void method4();
}
接口的定义,它与定义类方式相似,但是使用 interface 关键字。它也会被编译成.class文件,但一定要明确它并 不是类,而是另外一种引用数据类型。
引用数据类型:数组,类,接口。
接口的使用,它不能创建对象,但是可以被实现( implements ,类似于被继承)。一个实现接口的类(可以看做 是接口的子类),需要实现接口中所有的抽象方法,创建该类对象,就可以调用方法了,否则它必须是一个抽象类。
接口的实现
【修饰符】class 类名【extends 父类名】 implements 接口名/接口列表 {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【可选】
}
- 抽象方法:使用 abstract 关键字修饰,可以省略,没有方法体。该方法供子类实现使用。
- 默认方法:使用 default 修饰,不可省略,供子类调用或者子类重写。
- 继承默认
- 重写默认
- 静态方法:使用 static 修饰,供接口直接调用。
- 静态与.class 文件相关,只能使用接口名调用,不可以通过实现类的类名或者实现类的对象调用
- 私有方法:使用 private 修饰,供接口中的默认方法或者静态方法调用。
- 私有方法:只有默认方法可以调用。
- 私有静态方法:默认方法和静态方法可以调用。
步骤:
- 创建好包package
- 创建class类:Demo01(定义测试类,上图是InterfaceDemo01)
- 定义接口:LiveAble
- 定义实现类:Animal
PS:笔者疲懒,将一种方法截图在一起。
- 抽象方法
//定义接口
public interface LiveAble1{
public abstract void eat();
public abstract void sleep();
}
//定义实现类
public class Animal1 implements LiveAble1{
@Override
public void eat() {
System.out.println("吃东西");
// TODO Auto-generated method stub
}
@Override
public void sleep() {
System.out.println("晚上睡");
// TODO Auto-generated method stub
}
}
//定义测试类
public class InterfaceDemo1{
public static void main(String[] args) {
//创建子类对象
Animal1 a=new Animal1();
//调用实现后的方法
a.eat();
a.sleep();
}
}
- 默认方法
* 继承默认方法
//定义接口
public interface LiveAble2{
public default void fly() {
System.out.println("天上飞");
}
}
//定义实现类
public class Animal2 implements LiveAble2{
//继承,什么都不写,直接调用
}
//定义测试类
public class InterfaceDemo2{
public static void main(String[] args) {
//创建子类对象
Animal2 a=new Animal2();
//调用默认方法
a.fly();
}
}
- 重写默认方法
//定义接口
public interface LiveAble3{
public default void fly() {
System.out.println("天上飞");
}
}
//定义实现类
public class Animal3 implements LiveAble3{
public void fly() {
System.out.println("自由自在的飞");
}
}
//定义测试类
public class InterfaceDemo3{
public static void main(String[] args) {
//创建子类对象
Animal3 a =new Animal3();
a.fly();
}
}
- 静态方法
//定义接口
public interface LiveAble4{
public static void run() {
System.out.println("跑起来");
}
}
//定义实现类
public class Animal4 implements LiveAble4{
//无法重写静态方法
}
//定义测试类
public class InterfaceDemo4{
public static void main(String[] args) {
// Animal4.run(); //【错误】无法继承方法,也无法调用
LiveAble4.run();
}
}
- 私有方法
//定义接口
public interface LiveAble5{
default void func() {
func1();
func2();
}
static void func1() {
System.out.println("走起来");
}
default void func2() {
System.out.println("走起来");
}
}
//定义实现类(1):继承
public class Animal5 implements LiveAble5{
//无法重写静态方法
//继承,什么都不写,直接调用
}
//定义实现类(2):重写
//静态+重写默认方法
public class Animal6 implements LiveAble5{
//无法重写静态方法
public void func2() {
System.out.println("自由自在的走");
}
}
//定义测试类(1)
public class InterfaceDemo5{
public static void main(String[] args) {
LiveAble15.func1();
//创建子类对象
Animal5 a=new Animal5();
//调用默认方法
a.func2();
}
}
//定义测试类(2)
public class InterfaceDemo5{
public static void main(String[] args) {
LiveAble15.func1();
//创建子类对象
Animal6 a=new Animal6();
//调用默认方法
a.func2();
}
}
运行结果:
- 吃东西
- 晚上睡
- 天上飞
- 自由自在的飞
- 跑起来
- 走起来
- 自由自在的走
接口的多实现
之前学过,在继承体系中,一个类只能继承一个父类。而对于接口而言,一个类是可以实现多个接口的,这叫做接 口的多实现。并且,一个类能继承一个父类,同时实现多个接口。
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 showB() {
System.out.println("showB");
// TODO Auto-generated method stub
}
@Override
public void showA() {
System.out.println("showA");
// TODO Auto-generated method stub
}
@Override
public void show() {
System.out.println("Show");
// TODO Auto-generated method stub
}
}
//定义测试类
public class Test{
public static void main(String[] args) {
C c=new C();
c.show();
c.showA();
c.showB();
}
}
输出结果:
Show
showA
showB
默认方法
接口中,有多个默认方法时,实现类都可继承使用。如果默认方法有重名的,必须重写一次。
//定义测试类
public class Test{
public static void main(String[] args) {
C c=new C();
c.method();
}
}
定义接口
public interface A{
public default void methodA() {
}
public default void methodB() {
}
}
public interface B {
public default void methodA() {}
public default void methodB() {}
}
//定义实现类
public class C implements A,B{
public void method() {
// TODO Auto-generated method stub
System.out.println("method");
}
@Override
public void methodA() {
// TODO Auto-generated method stub
A.super.methodA();
}
@Override
public void methodB() {
// TODO Auto-generated method stub
B.super.methodB();
}
}
输出结果:method
静态方法
接口中,存在同名的静态方法并不会冲突,原因是只能通过各自接口名访问静态方法。
优先级的问题
当一个类,既继承一个父类,又实现若干个接口时,父类中的成员方法与接口中的默认方法重名,子类就近选择执 行父类的成员方法。
定义测试类
//静态方法
public class Test {
public static void main(String[] args) {
C c=new C();
c.methodA();
}
}
定义接口
public interface A {
public default void methodA() {
System.out.println("AAAAAAAAAA");
}
}
定义子类
public class C extends D implements A{
//未重写methodA方法
}
定义父类
public class D {
public void methodA() {
System.out.println("DDDDDD");
}
}
输出结果:DDDDDD
接口的多继承
一个接口能继承另一个或者多个接口,这和类之间的继承比较相似。接口的继承使用 extends 关键字,子接口继 承父接口的方法。如果父接口中的默认方法有重名的,那么子接口需要重写一次。
public class Test{
public static void main(String[] args) {
C c=new C();
c.method();
}
}
//定义父接口
interface A{
public default void method() {
System.out.println("AAAAAAAAAAA");
}
}
//定义父接口
interface B{
public default void method() {
System.out.println("BBBBBBBBBBBB");
}
}
//多继承
public class C implements A{
}
//定义子接口
interface D extends A,B{
@Override
default void method() {
// TODO Auto-generated method stub
System.out.println("DDDDDDDDDDDD");
}
}
输出结果:DDDDDDDDDDDDD
子接口重写默认方法时,default关键字可以保留。
子类重写默认方法时,default关键字不可以保留。
其他成员特点
接口中,无法定义成员变量,但是可以定义常量,其值不可以改变,默认使用public static final修饰。
接口中,没有构造方法,不能创建对象。
接口中,没有静态代码块。