Tips:样式蚂蚁森林浇水get

java基础——day08-1 接口、多态

接口

概述

　　接口，是java中一种引用类型，是方法的集合。

　　类封装：成员变量、构造方法、成员方法

　　接口封装：方法（包含抽象方法[JDK7以前]；默认方法和静态方法[JDK8]；私有方法[JDK9]）

　　接口的定义，它与类的定义相似，但是关键字使用 interface。它会被编译成.class文件，但需明确它不是类，而是另外一种引用类型。

　　引用数据类型：数组、类、接口

　　接口的使用，不能创建对象，但是可以被实现（implements，类似与被继承）。一个实现接口的类(可以看做是接口的子类)，需要实现接口中的所有抽象方法，创建实现类的对象，就可以调用方法了。(若实现类不实现接口中的所有抽象方法，那么它必须是一个抽象类)

定义格式

package day08.demo01;

public interface interfaceDY {
    //抽象方法
    //默认方法
    //静态方法
    //私有方法
}

1.含抽象方法

package day08.demo01;
//定义接口 使用interface关键字
/**
 * 1、接口当中的抽象方法：修饰符必须是两个固定关键字：public abstract
 * 2、这两个关键字可选择性省略
 */
public interface interfaceClass {
    //抽象方法；
    public abstract void methodAbs(); //正确
    abstract void methodAbs1(); //正确
    public void methodAbs2(); //正确
    void methodAbs3(); //正确

}
接口--含抽象方法
package day08.demo01;

/**
 * 1.接口类的实现 需要一个“实现类”来“实现”该接口
 * 2.格式：public class 类名 implements 接口名{}
 * 3.接口的实现类必须覆盖重写（实现）接口中的所有抽象方法
 */
public class interfaceAbsImpl implements interfaceClass {
    @Override
    public void methodAbs() {
        System.out.println("第一个抽象方法");
    }

    @Override
    public void methodAbs1() {
        System.out.println("第二个抽象方法");
    }
    @Override
    public void methodAbs2() {
        System.out.println("第三个抽象方法");
    }
    @Override
    public void methodAbs3() {
        System.out.println("第四个抽象方法");
    }
}
接口--实现类
package day08.demo01;

public class demo {
    public static void main(String[] args) {
        //错误写法！不能直接new()接口方法
//        interfaceClass inter = new interfaceClass();
        //创建实现类的对象
        interfaceAbsImpl inter = new interfaceAbsImpl();
        //调用实现类中的方法
        inter.methodAbs();
        inter.methodAbs1();
        inter.methodAbs2();
        inter.methodAbs3();
    }
}
main

　　注意：

　　1.不能直接new()接口方法，而是需要通过实现类对象，再去调用接口中的方法。

　　2.接口类的实现，需要一个“实现类”来“实现”接口

　　3.实现类的格式：public class 类名 implements 接口名(){}

　　4.接口的实现类，要覆盖重写(实现)接口中的所有抽象方法。

2.含默认方法

package day08.demo01.demo02;
//定义含默认方法的接口

public interface interfaceDefault {
    //定义抽象方法
    public abstract void methodAbs();
    //定义默认方法
    public default void methodDef(){
        System.out.println("this is a default");
    }
}
接口--默认方法
package day08.demo01.demo02;

public class interfaceShiXianA implements interfaceDefault{
    //实现接口中的默认方法
    @Override
    public void methodAbs() {
        System.out.println("我实现了自接口的抽象方法");
    }
}
接口--实现类A
package day08.demo01.demo02;

public class interfaceShiXianB implements interfaceDefault{
    //实现接口中的默认方法
    @Override
    public void methodAbs() {
        System.out.println("我实现了自接口的抽象方法");
    }
    //覆盖重写接口中的默认方法

    @Override
    public void methodDef() {
        System.out.println("我是重写了默认方法---B");
    }
}
接口--实现类B
package day08.demo01.demo02;

public class demo {
    public static void main(String[] args) {
        //创建实现类A对象
        interfaceShiXianA a = new interfaceShiXianA();
        a.methodAbs(); //调用实现类A的抽象方法
        a.methodDef(); //调用接口中默认方法（此处实现类A没有 就向上找接口的）
        System.out.println("======================");
        interfaceShiXianB b = new interfaceShiXianB();
        b.methodAbs();
        b.methodDef();
    }
}
main

　　注意：

　　1.接口中的默认方法，在接口的实现类中可以覆盖重写，也可以不重写。

　　2.可以加强接口的稳定性（当接口需要定义新的方法，如果定义抽象方法，那实现类都要去实现，而默认方法不需要，谁用谁改）

　　3.定义格式：public default 返回值类型 方法名(参数列表){方法体}

3.含静态方法

package day08.demo01.demo03;

public interface interfaceStatic {
    //定义默认方法
    public static void methodStic(){
        System.out.println("这是接口中的静态方法！");
    }
}
接口--静态方法
package day08.demo01.demo03;

public class interfaceStcImpl implements interfaceStatic {
    //此实现类可不写
}
接口--实现类(可省略)　
package day08.demo01.demo03;

public class demo {
    public static void main(String[] args) {
        //创建实现类对象
        interfaceStcImpl a= new interfaceStcImpl();
//        a.methodStc() 错误写法

        //注意：静态方法与类有关系 与对象无关系 所以不能直接通过实现类的对象调用接口

        //调用接口中的静态方法
        interfaceStatic.methodStic();
    }
}
main

 

　　注意：

　　1.因为静态方法的作用域是类，所以不可以通过实现类的对象去调用默认方法，实现类对象也无法调用。

　　2.定义格式：public static 返回值类型 方法名(参数列表){方法体}；

4.含私有方法(JDK9支持 没运行成功)

　　私有方法存在的意义：解决接口中代码重复的问题。

　　例如：我们需要抽取一个共有方法，解决两个默认方法之间代码重复问题，但此方法不可以让实现类使用。

　　解决方案：

　　1.使用普通私有方法，解决多个默认方法间代码重复问题。

　　格式：private 返回值类型 方法名(参数列表){方法体};

//定义接口
public interface interfacePrivateA {
//    例如
    public default void methodA(){
        System.out.println("默认方法1");
//        System.out.println("AAA");  //默认方法中的重复代码
//        System.out.println("BBB");  //默认方法中的重复代码
//        System.out.println("CCC");  //默认方法中的重复代码
        //调用私有方法
        methodComm();
    }
    public default void methodB(){
        System.out.println("默认方法2");
//        System.out.println("AAA");  //默认方法中的重复代码
//        System.out.println("BBB");  //默认方法中的重复代码
//        System.out.println("CCC");  //默认方法中的重复代码
        methodComm();
    }
    private void methodComm(){
        //若提示 modifier 'private' not allowed here 请升级jdk
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }

}
接口--私有方法(默认方法间)

　　2.使用静态私有方法，解决多个静态方法间代码重复问题。

　　格式：private static 返回值类型 方法名(参数列表){方法体};

5."成员变量"——常量

　　1.接口中的成员变量，指的是——常量(不可变的)

　　2.格式：public static final 常量名 = 数据值 //常量名，使用完全大写字母，用下划线分割(推荐命名)

　　3.一旦使用final关键字修饰，说明不可以变

　　4.就算public static final省略 常量还是不可变

　　5.接口中的常量，必须赋值

package day08.demo01.demo05;

public interface interfaceConst {
    //一旦赋值不可修改
    public static final int num = 10; //正确
    int a = 20;//正确
    // int a; 错误：必须赋值
}
接口--常量
package day08.demo01.demo05;

public class main {
    public static void main(String[] args) {
        //访问接口中的常量
        System.out.println(interfaceConst.num);
        System.out.println(interfaceConst.a);
    }
}
接口--常量调用

6.接口的多实现

　　在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类可以实现多个接口——接口的多实现。且一个类能继承一个父类，同时实现多个接口。

　　实现格式：

 

 　　[]：表示可选操作

小结

在java9+版本中，接口的内容可以有：

1、成员变量—常量

　　格式：[public][static][final] 数据类型 常量名称 = 数据值; // []中的关键字可省略

　　注意：

　　a、常量必须赋值，且一旦赋值后不能改变。

　　b、常量名称完全大写，用下划线分割(建议)

2、最重要的方法—抽象方法

　　格式：[public][abstract] 返回值类型 方法名称(参数列表); // []中的关键字可省略

　　注意：实现类必须覆盖重写（实现）接口中的所有抽象方法；除非实现类是抽象类

3、从java8开始，接口允许定义—默认方法

　　格式：[public] default 返回值类型 方法名称(参数列表){方法体};// []中的关键字可省略

　　注意：默认方法可以被重写，也可不重写直接调用

4、从java8开始，接口允许定义—静态方法

　　格式：[public] static 返回值类型 方法名(参数列表){方法体};// []中的关键字可省略

　　注意：应该通过接口名称调用，不能通过实现类对象进行调用

5、从java9开始，接口允许定义—私有方法

　　格式：private 返回值类型 方法名称(参数列表){方法体};

　　注意：private方法，只有在接口内部才能调用，不能被实现类调用

 

posted @ 2021-03-09 20:37  心岛未晴  阅读(70)  评论(0)    收藏  举报