DemoInterdaceAbstract接口:
package demo19接口;
/*
接口就是多个公共类的规范,接口是一种引用数据类型,最重要的内容就是其中的抽象方法
接口的格式:
public interface 接口名称 {
//接口内容
}
接口编译生成的还是.claass文件
java7,接口中可以包含的内容有:
1.常量
2.抽象方法
如果是java8,接口中还可以包含
3.默认方法
接口中定义默认方法,可也以解决接口升级问题。
格式:
public default 返回值类型 方法名称(参数列表){
方法体
}
4.静态方法
如果是java9,还可以包含:
5.私有方法
在任何版本的java中,接口都能定义抽象方法.
格式:
public abstract 返回值类型 方法名称(参数列表);
接口当中的抽象方法,修饰符必须是两个固定的关键字:public abstract 这两个关键字可以选择性省略
接口的使用步骤:
1.接口不能直接使用,必须有一个实现类来实现改接口
public class 实现类名称 implements 接口名称 {
//...
}
2.接口的实现类必须覆盖重写(实现)接口中所有的额抽象方法
3.创建实现类对象进行使用
注意:
如果实现类并没有覆盖重写接口中所有的额抽象放,那么这个实现类自己必须是抽象类
*/
public interface DemoInterdaceAbstract {
//这是一个抽象方法
public abstract void methodAbs1();
//这是一个抽象方法
abstract void mathod2();
//这是一个抽象方法
public void method3();
//这是一个抽象方法
void method4();
//新添加的默认方法
public default void methodDefault(){
System.out.println("这是新添加的默认方法");
}
}
DemoInterface类:
package demo19接口;
/*
子类可以覆盖重写接口的默认方法
*/
public class DemoInterface implements DemoInterdaceAbstract {
@Override
public void methodAbs1() {
System.out.println("1");
}
@Override
public void mathod2() {
System.out.println("2");
}
@Override
public void method3() {
System.out.println("3");
}
@Override
public void method4() {
System.out.println("4");
}
//子类可以覆盖重写接口的默认方法
@Override
public void methodDefault() {
}
}
MyInterfaceStatic接口:
package demo19接口;
/*
java8 开始接口当中允许定义静态方法
格式:
public static 返回值类型 方法名称(参数列表){
方法体
}
提示:
注意不能通过实现类对象来调用接口当中的静态方法
正确使用:
接口名称.静态方法名(参数);
*/
public interface MyInterfaceStatic {
public static void methodStatic() {
System.out.println("这是接口的静态方法");
}
}
DemoInterfaceStatic类:
package demo19接口;
public class DemoInterfaceStatic implements MyInterfaceStatic {
}
MyInterfacePrivatrA接口:
package demo19接口;
/*
问题描述:
我们需要一个共有的方法,用来解决两个默认方法之间的重复代码的问题
但是这个共有的方法不应该让实现类使用,应该是私有的
解决方案:
从java9开始,接口中允许定义私有方法
1.普通私有方法,解决多个静态方法之间的重复代码问题
格式:
private 返回值类型 方法名称(参数列表){
方法体
}
*/
public interface MyInterfacePrivateA {
public default void methodDefault1(){
System.out.println("默认方法1");
//methodCommon();
}
public default void methodDefault2(){
System.out.println("默认方法2");
// methodCommon();
}
/* private void methodCommon(){
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}*/
}
MyInterfacePrivateB接口:
package demo19接口;
/*
静态私有方法,解决多个方法之间重复代码问题
格式:
private static 返回值类型 方法名称(参数列表){
方法体
}
接口当中可以定义成员变量,但是必须使用public static final三个关键字进行修饰,从效果上看就,这其实就是接口的常量
格式:
Public static final 数据类型 常量名称=值;
注意,一旦使用final关键字进行修饰,说明不可改变
1.接口当中的常量,可以省略public static final,不写也是这样
2.接口当中常量,必须进行赋值,不可以不赋值
3.接口中的常量名称完全大写字母,用下划线进行分隔
*/
public interface MyInterfacePrivateB {
//这是一个常量,一旦赋值,不可以改变
public static final int NUM_OF_MYCLASS=10;
public static void methodDefault1(){
System.out.println("默认方法1");
//methodCommon();
}
public static void methodDefault2(){
System.out.println("默认方法2");
// methodCommon();
}
/*private static void methodCommon(){
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}*/
}
Test类:
package demo19接口;
public class Test {
public static void main(String[] args) {
//不能直接new 接口对象使用,这是错误的
//DemoInterdaceAbstract inter=new DemoInterdaceAbstract();
//创建实现类的对象使用
DemoInterface impl=new DemoInterface();
impl.methodAbs1();
impl.mathod2();
impl.method3();
impl.method4();
//调用默认方法,如果实现类中没有,那么向上找接口
impl.methodDefault();
System.out.println("===================");
DemoInterfaceStatic imp=new DemoInterfaceStatic();
//注意不能通过实现类对象来调用接口当中的静态方法
//imp.methodStatic();错误
//
// 通过接口名称.静态方法名(参数);
MyInterfaceStatic.methodStatic();
System.out.println("常量");
//访问接口当中的常量
System.out.println(MyInterfacePrivateB.NUM_OF_MYCLASS);
}
}
MyInterface接口:
package demo20接口2;
/*
错误,接口没有静态代码块或者构造方法
static {
}
public MyInterface(){
}
1.类与类之间是继承的,直接父类只有一个
2.类与接口之间是实现的,一个类可以实现多个接口
3.接口与接口之间是多继承的
4.多个父接口当中的当中的抽象方法如果重复,没关系 多个接口当中的默认方法如果重复,那么子接口必须进行默认方法的覆盖重写
*/
public interface MyInterface {
public abstract void methodA();
}
1.接口是没有静态代码快,或者构造方法 2.一个类的直接父类是唯一的,但是一个类可以同时实现多个接口 3.如果实现类所实现的多个接口当中,存在重复的抽象方法,那么只需要覆盖重写一次即可 4.如果实现类没有覆盖重写所有接口当中的抽象方法,那么实现类必须是一个抽象类 5.如果实现类的多个接口当中,存在重复的默认方法,那么实现类一定要对冲突的默认方法进行覆盖重写 6.一个类如果直接继承父类当中的方法,和接口当中的默认方法产生冲突,优先用父类当中的方法