Java随笔记 接口 （2020.5.19）
（如有问题，欢迎各位大佬批评指正）
概述
- 接口就是一种公共的规范标准
定义一个接口
- 接口就是多个类的公共规范
- 接口是一种引用数据类型，最重要的内容就是其中的的抽象方法
- public interface 接口名{ 接口内容 }
备注：
接口包含的内容
- java7
- 常量
- 抽象方法
- java8
- 常量
- 抽象方法
- 默认方法
- 静态方法
- java9及以上
- 常量
- 抽象方法
- 默认方法
- 静态方法
- 私有方法
接口抽象方法
- 任何java版本中，接口都能定义抽象方法
- 格式
- public abstract 返回值类型 方法名(参数列表)
- 注意事项：
- 接口当中的抽象方法，修饰符必须是两个固定的关键字，public abstract
- 这两个关键字修饰符可以选择性省略
- 方法的三要素随意定义
package md.chenmo;
public interface MyInterFaceAbstract {
//这是一个抽象方法
public abstract void method1();
//这也是抽象方法
abstract void method2();
//这也是抽象方法
void method3();
}
接口使用
- 接口不能直接使用，必须要有一个“实现类”来“实现”改接口
- 格式
- public class 实现类名称 implements 接口名称{}
- 接口的实心类必须覆盖重写“实现“接口所有抽象方法
- 创建实现类的对象，进行使用
注意事项
- 如果实现类没有覆盖重写接口中所有的所有抽象方法，那么这个 类自己就必须是抽象类
package md.chenmo.demo01;
import md.chenmo.MyInterFaceAbstract;
public class MyInterFaceAbstractImpl implements MyInterFaceAbstract {
@Override
public void method1() {
System.out.println("这是第一个抽象方法");
}
@Override
public void method2() {
System.out.println("这是第二个抽象方法");
}
@Override
public void method3() {
System.out.println("这是第三个抽象方法");
}
}
package md.chenmo.demo01;
public class Demo01 {
public static void main(String[] args) {
MyInterFaceAbstractImpl myimpl = new MyInterFaceAbstractImpl();
myimpl.method1();
myimpl.method2();
myimpl.method3();
}
}
接口的默认方法
方法的定义
- 首先创建一个接口为MyInterFace
package md.chenmo.demo01;
public interface MyInterFace {
//接口的抽象方法
public abstract void method4 ();
//接口的默认方法
public default void method5() {
System.out.println("我是接口的默认方法");
}
default void method6(){
System.out.println("我也是结构默认方法");
}
}
- 再创建一个实现类
package md.chenmo.demo01;
public class MyInterFace1 implements MyInterFace {
@Override
public void method4(){
System.out.println("我是覆盖重写方法");
}
//接口的默认方法可以被实现类覆盖重写
@Override
public void method5(){
System.out.println("我是覆盖重写之后的接口方法");
}
}
- 实现接口默认方法的调用
package md.chenmo.demo01;
public class Demo02 {
public static void main(String[] args) {
MyInterFace1 myInterFace1 = new MyInterFace1();
myInterFace1.method4();
myInterFace1.method5();
myInterFace1.method6();
}
}
接口的静态方法
- 从java8开始，接口中就允许有静态方法。
- 格式
- public static 返回值类型 方法名称（参数列表）{}
提示： 就将abstract或者default换成abstract即可
注意事项
- 不能通过接口实现类的对象来调用接口中的方法。
- 通过接口名，直接调用其中的静态方法
调用接口的静态方法
- 创建一个接口MyInterFaceStatic
package md.chenmo.demo01;
public interface MyInterFaceStatic {
//定义接口的抽象方法
public abstract void method1();
//定义接口的静态方法
public static void method2(){
System.out.println("我是接口的静态方法");
}
}
- 创建接口的实现类
package md.chenmo.demo01;
public class MyInterFaceIm implements MyInterFaceStatic{
@Override
public void method1() {
System.out.println("我是接口实例类的覆盖重写方法");
}
}
- 调用接口静态方法
package md.chenmo.demo01;
public class Demo03Static {
public static void main(String[] args) {
MyInterFaceIm myInt = new MyInterFaceIm();
//通过类实例对象来调用实例类的覆盖重写方法
myInt.method1();
//通过类实例对象来调用接口的静态方法（错误）
// myInt.method2();
//直接通过接口调用接口的静态方法
MyInterFaceStatic.method2();
}
}
接口的私有方法
-
问题描述
- 我们定义一个共有方法，用来解决静态方法之间代码重复问题
- 但是这个共有方法不应该让除本类意外的访问
-
解决方法：
- 普通私有方法，解决默认方法之间代码重复问题，private 返回值类型 方法名 （参数列表）{}
- 静态私有方法：解决静态代码重复问题，private static 返回值类型 方法名 （参数列表）{}
-
定义一个接口
public interface MyInterFacePrivateA {
//定义接口的抽象方法
// public abstract void eat();
//定义接口的静态方法
public static void sleep(){
System.out.println("我是接口的睡觉静态方法");
}
//为什么要定义接口的私有方法
public static void methodA(){
System.out.println("我是静态方法A");
// System.out.println("AAAA");
// System.out.println("bbbb");
// System.out.println("cccc");
methodC();
}
public static void methodB(){
System.out.println("我是接口的静态方法B");
// System.out.println("AAAA");
// System.out.println("bbbb");
// System.out.println("cccc");
methodC();
}
private static void methodC(){
System.out.println("AAAA");
System.out.println("bbbb");
System.out.println("cccc");
}
}
访问尝试访问接口中的私有静态方法
package md.chenmo.demo01;
public class MyInterDefault{
public static void main(String[] args) {
MyInterFacePrivateA.methodA();
MyInterFacePrivateA.methodB();
// MyInterFacePrivateA.methodC();
}
}
接口中的常量
- 接口当中可以定义“成员变量”，但是必须使用 public static finial 三个关键字修饰
格式
pubilc static final 数据类型 常量名称 = 数据值
注意：
一旦使用了final关键字修饰，说明不可改变。
注意事项
- 接口中的常量：可以省略 public static final，注意：不写也默认添加
- 接口中的常量：必须进行赋值。
- 接口中的常量：使用完全大写的字母，用下划线分隔
创建一个接口定义一个常量
public interface MyInterfaceConst {
public static final int NUM = 10;
}
使用接口的常量
public class Demo04 {
public static void main(String[] args) {
//使用接口中的变量
System.out.println(MyInterfaceConst.NUM);
}
}
接口小结
在java9+版本中，接口可以有以下内容
- 成员边变量其实就是常量，格式：public static finial 数据类型 常量名称 = 数据值；
- 注意：
- 常量必须进行赋值，而且一旦赋值不能改变。
- 常量名称完全大写，用下划线分隔
- 注意：
- 接口中最重要的就是抽象方法，格式：public abstract 返回值类型 方法名称（参数列表）
- 注意：实现类必须覆盖重写接口的所有抽象方法，除非实现类是抽象类
- 从Java 8开始，接口里允许定义默认方法，格式：public default 返回值类型（参数列表）{方法体}
- 注意：默认的方法体是可以被覆盖重写的
- 从Java 8开始，接口中允许定义静态方法，格式：public static 返回值类型 方法名称（参数列表）{方法体}
- 注意：应该通过接口名称进行调用，不能通过实现类调用接口静态方法
- 从Java 9开始，接口中可以定义私有方法：
- 普通私有方法：private 返回值类型 方法名称（参数列表）{方法体}
- 静态私有方法：Privata static 返回值类型 方法名称（参数列表）{方法体}
- 注意：Privata 的方法只能接口内部调用，不能被接口之外其他者调用
继承父类和实现多接口的注意事项
- 接口是没有静态代码块或者构造方法的
- 一个类的直接父类是唯一的，但是接口可以同时实现多个
- public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {//覆盖重写所有抽象类方法}
- 如果实现类所实心的多个接口中，存在重复抽象方法，那么只会覆盖重写一次
- 如果实现类没有覆盖重写所有接口中的抽象方法，那么这个实现类必须是一个抽象类
- 如果实现类实现的多个接口中，存在默认方法，那么实现类一定要对冲突的的默认方法进行覆盖重写
- 一个类如果直接父类中的方法和接口当中的默认方法产生了冲突，优先使用父类方法
接口之间的多继承
- 类与类之间是单继承的。直接父类只能有一个
- 类与接口之间是多实现的
- 接口与接口之间是多继承的
- 多个父类接口中抽象方法重复，没关系
- 多个父类接口中默认方法重复，那么子接口必须进行默认方法的覆盖重写，而且需要带着default关键字。