接口
接口,是Java语言中一种引用类型,是方法的集合,如果说类的内部封装了成员变量、构造方法、成员方法,那么接口的内部主要就是封装了方法,包含了抽象方法(JDK1.7及以前),默认方法和静态的方法(JDK1.8),私有方法(JDK1.9)。
特点:
-
接口中,无法定义成员变量,但是可以定义常量,因为值不可变,默认使用 public static final 修饰的
-
接口中,没有构造方法,不能创建对象
-
接口中,没有静态代码块
接口的好处:
-
定义规则
-
降低耦合性 【高内聚,低耦合】
-
扩展原有类的功能
接口的定义格式:它与类的定义很相似,但是使用interface关键字,它也会被编译生成class文件,但一定要明确它不是类,而是另外一种引用数据类型。
我们目前接触到的引用数据类型有:
类、数组、接口
接口的使用:不能直接创建对象,但是可以被实现(implements关键字,类似于被继承),一个实现接口的类(可以看做是接口的子类),需要重写接口中的所有抽象方法,创建该类对象,就可以调用方法了。
public interface 接口名称{
//抽象方法 主要
//默认方法
//静态方法
//常量
//私有方法(JDK1.9)
}
含有抽象方法
抽象方法: 使用abstract关键字修饰,没有方法体内容,该方法主要是供子类使用。
public interface InterfaceDemo{
public abstract void method();
// public abstract 可以省略不写
}
含有默认方法和静态方法
默认方法:使用default关键字修饰的方法,我们成为默认方法,不可省略,供子类调用或者子类重写。
静态方法:使用static关键字修饰的方法,供接口直接调用。
含有私有方法和私有静态的方法
私有方法:使用private关键字,供接口中的默认方法或者静态方法调用。
代码如下:
public interface InerfaceName{
private void meth0d(){
//方法体内容
}
}
基本的实现
实现的概述
类与接口的关系为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类。实现动作类似于继承,格式相仿,只是关键字不同,实现使用implements关键字
非抽象类实现接口:
- 必须重写接口当中的所有抽象方法
- 继承了接口当中的默认方法,既可以直接调用,也可以重写。
实现格式:
public class 实现类 implements 接口名称{
//重写接口当中所有的抽象方法
//重写接口当中的默认方法【可选】
}
抽象方法的使用:
必须全部实现:
代码如下:
定义一个接口:
public interface Biological{
//生物
//定义一个吃东西的功能
public abstract void eat();
//定义一个休息的功能
public abstract void sleep();
}
//定义一个实现类
public class Animal implements Biological{
@Override
public void eat(){
System.out.println("恰");
}
@Override
public void sleep(){
System.out.println("睡觉");
}
}
//定义一个测试类
public class InterfaceDemo01{
public static void main(String[] args){
//创建子类对象
Animal ani = new Animal();
//调用重写之后的方法
ani.eat();
ani.sleep();
}
}
//输出结果
//恰
//睡觉
默认方法的使用
可以继承,可以重写,二选一,但是只能通过实现类的对象来调用
1.继承默认方法,代码如下
public interface Biological{
//生物
public default void fly(){
System.out.println("飞");
}
}
//定义实现类
public class Animal implements Biological{
//继承 什么也不写
}
//定义测试类
public class InterfaceDemo02{
public static void main(String[] args){
//创建子类对象
Animal ani = new Animal;
//调用默认方法
ani.fly();
}
}
//输出结果
//飞
2.重写默认方法
代码如下:
public interface Biological{
//生物
public default void fly(){
System.out.println("飞");
}
}
public class Animal implements Biological{
@Override
public void fly(){
System.out.println("自由自在的飞");
}
}
public class InterfaceDemo03{
public static void main(String[] args){
//创建子类对象
Animal ani = new Animal;
//调用重写方法
ani.fly();
}
}
3.静态方法的使用
静态的一般都是和类.class文件相关,【只能】使用【接口名】来调用,不可以通过实现类的类名或者实现类的对象来调用,代码如下:
public interface Biological{
//生物
public static void fly(){
System.out.println("跑起来");
}
}
public class Animal implements Biological{
//无法重写静态方法
}
//定义测试类
public class InterfaceDemo03{
public static void main(String[] args){
//Animal.run(); 错误操作,无法继承 ,也无法调用
Biological.fly();
}
}
//
4.私有方法的使用
私有方法:只有默认方法可以调用
私有静态方法:默认方法和静态方法都可以调用
如果一个接口中有多个默认方法,并且方法中有重复的内容,那么可以抽取出来,封装到私有方法中,供默认方法去调用。从设计的角度考虑,私有方法是对默认的方法和静态的方法的一种辅助
代码如下:
public interface Biological{
private void run1(){
System.out.println("跑起来");
}
public default void funMethod1{
// System.out.println("跑起来");
run1();
}
public default void funMethod2{
// System.out.println("跑起来");
run1();
}
}
接口的多实现
在继承体系中,一个类只能直接继承一个父类,而对于接口来说,一个类可以实现多个接口,这叫做接口的【多实现】。并且,一个类能直接继承一个父类同时还可以实现多个接口。
实现格式:
public class ClassName extends 父类 implements 接口名1,接口名2,.....{
//重写接口中的所有的抽象方法
//重写接口中的默认的方法【可选】
//抽象方法重名
}
抽象方法
接口中,有多个抽象方法,实现类必须重写所有的抽象方法,如果抽象方法有重名的,只需要重写一次即可,代码如下:
//定义多个接口
public interface Animal{
public abstract void eat();
public abstract void run();
}
public interface Human{
public abstract void eat();
public abstract void run();
}
//定义实现类
public class People implements Animal,Human{
@Override
public void eat(){
System.out.println("啥都吃");
}
@Override
public void run(){
System.out.println("??");
}
}
默认方法
接口中,有多个默认方法时,实现类都可以继承使用,如果默认方法有重名的,【必须重写一次】
public interface A {
public default void methodA(){}
public default void method(){}
}
public interface B {
public default void methodA(){}
public default void method(){}
}
//定义实现类
public class C implements A,B{
@Override
public void method(){
System.out.println("method方法被重写。。。。。");
}
}
静态方法
接口中,如果存在同名的静态方法并不会冲突,原因是只能通过各自的接口名访问静态方法。
优先级的问题
当一个类,即继承了一个父类,又同时实现了多个接口,父类中的成员方法与接口当中的默认方法重名,【子类就近选择父类的成员方法】。
代码如下:
public interface A{
public default void methodA(){
System.out.println("AAAAAAAAA");
}
}
//定义父类
public class D{
public void methodA(){
System.out.println("DDDDDDDD");
}
}
//定义子类
public class E extends D implements A{
//未重写methodA()方法
}
//定义测试类
public class TestInterfaceDemo06{
public static void main(String[] args){
//创建子类对象E
E e = new E();
e.methodA();
}
}
备注:子接口重写默认方法,default关键字保留.