接口组成更新与方法引用

最新推荐文章于 2024-04-18 18:50:58 发布
最新推荐文章于 2024-04-18 18:50:58 发布
阅读量207 收藏 1
点赞数
分类专栏： Java 接口组成更新 方法引用 文章标签： java lambda 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53529114/article/details/114282833
版权

接口组成更新与方法引用

1.接口组成更新概述

1.1 接口组成

  1. 常量：public static final
  2. 抽象方法：public abstract
  3. 默认方法（Java8）
  4. 静态方法（Java8）
  5. 私有方法（Java9）

2.默认方法

2.1 格式

接口中默认方法的定义格式：

  1. 格式：public default 返回值类型 方法名（参数列表）{}
  2. 范例：public default void show(){}
public default void show3(){
    System.out.println("show");
}

2.2 注意事项

接口中默认方法的注意事项：

  1. 默认方法不是抽象方法，所以不被强制重写。但是可以被重写，重写时去掉default关键字
  2. public可以省略，default不能省略

需求：

  1. 定义一个接口MyInterface，里面有两个抽象方法
    1. void show1();
    2. void show2();
  2. 定义两个实现类：
    1. MyInterfaceImplOne
    2. MyInterfaceImplTwo
  3. 定义测试类：
    1. MyInterfaceDemo
    2. 在主方法中，按照多态方式创建对象并使用

MyInterface接口：

public interface MyInterface {
    void show1();
    void show2();
//    void show3();
//    public default void show3(){
//        System.out.println("show");
//    }
    default void show3(){
        System.out.println("show");
    }
}

MyInterfaceImplOne实现类：

public class MyInterfaceImplOne implements MyInterface {
    @Override
    public void show1() {
        System.out.println("one show1");
    }

    @Override
    public void show2() {
        System.out.println("one show2");
    }

    @Override
    public void show3() {
        System.out.println("one show3");
    }
}

MyInterfaceImplTwo实现类：

public class MyInterfaceImplTwo implements MyInterface {
    @Override
    public void show1() {
        System.out.println("two show1");
    }
    @Override
    public void show2() {
        System.out.println("two show2");
    }
}

MyInterfaceDemo测试类：

public class MyInterfaceDemo {
    public static void main(String[] args) {
        //多态方式创建对象
        MyInterface my = new MyInterfaceImplOne();
        my.show1();
        my.show2();
        my.show3();
    }
}

3.静态方法

3.1 格式

接口中静态方法的定义格式：

  1. 格式：public static 返回值类型 方法名（参数列表）{}
  2. 范例：public static void show(){}
static void show(){}

2.2 注意事项

接口中静态方法的注意事项：

  1. 静态方法只能通过接口名调用，不能通过实现类名或对象名调用
  2. public可以省略，static不能省略

需求：

  1. 定义一个接口Inter，里面有三个方法，一个抽象方法，一个默认方法，一个静态方法
    1. void show()
    2. default void method() {}
    3. public static void test(){}
  2. 定义接口的一个实现类：
    1. InterImpl
  3. 定义测试类：
    1. InterDemo
    2. 在主方法中，按照多态方式创建对象并使用

Inter接口：

public interface Inter {
    void show();
    default void method(){
        System.out.println("Inter中的默认方法method()执行了");
    }
    public static void test(){
        System.out.println("Inter中的静态方法test()执行了");
    }
}

Flyable接口：

public interface Flyable {
    static void test(){
        System.out.println("Flyable中的静态方法test()执行了");
    }
}

InterImpl实现类：

public class InterImpl implements Inter,Flyable {
    @Override
    public void show(){
        System.out.println("show()方法执行了");
    }
}

InterDemo测试类：

public class InterDemo {
    public static void main(String[] args) {
        //按照多态方式创建对象并使用
        Inter i = new InterImpl();
        i.show();//show()方法执行了
        i.method();//Inter中的默认方法method()执行了
        //i.test();//Static method may be invoked on containing interface class only

        Inter.test();//Inter中的静态方法test()执行了
        //InterImpl.test();//Static method may be invoked on containing interface class only
        Flyable.test();//Flyable中的静态方法test()执行了
    }
}

4.私有方法

4.1 必然性

Java9新增了带方法体的私有方法，这其实在Java8中就埋下了伏笔：Java8允许在接口中定义带方法体的默认方法和静态方法。

这样就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要别人使用的，因此用私有给隐藏起来，这就是Java9增加私有方法的必然性

4.1 格式

接口中私有方法的定义格式：

  1. 格式1： private 返回值类型 方法名（参数列表）{}
  2. 范例1： private void show(){}
  3. 格式2： private static 返回值类型 方法名（参数列表）{}
  4. 范例2： private static void method(){}

4.2 注意事项

接口中私有方法的注意事项：

  1. 默认方法可以调用私有的静态方法和非静态方法
  2. 静态方法只能调用私有的静态方法

需求：

  1. 定义一个接口Inter，里面有四个方法，两个默认方法，两个静态方法
    1. default void show1(){}
    2. default void show2(){}
    3. static void method1(){}
    4. static void method2(){}
  2. 定义接口的一个实现类：
    1. InterImpl
  3. 定义测试类：
    1. InterDemo
    2. 在主方法中，按照多态方式创建对象并使用

Inter接口：

package com.advanced.myinterface.demo03private;

public interface Inter {
    default void show1(){
        System.out.println("show1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
//        show();
        method();
        System.out.println("show1结束执行");
    }

    default void show2(){
        System.out.println("show2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
//        show();
        method();
        System.out.println("show2结束执行");
    }

    private void show(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");

    }

    static void method1(){
        System.out.println("method1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        method();
        System.out.println("method1结束执行");
//        show();
    }

    static void method2(){
        System.out.println("method2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        method();
        System.out.println("method2结束执行");
    }

    private static void method(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }
}

InterImpl实现类：

public class InterImpl implements Inter {}

InterDemo测试类：

public class InterDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        i.show1();
        System.out.println("==========(@ _ @)==========");
        i.show2();
        System.out.println("==========(@ _ @)==========");
        Inter.method1();
        System.out.println("==========(@ _ @)==========");
        Inter.method2();
    }
}

5.方法引用

5.1 体验方法引用

在使用Lambda表达式的时候，我们实际上传递进去的参数代码就是一种解决方案：拿参数做操作

那么考虑一种情况，如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？

答案肯定是没有必要的

那么我们又是如何使用已经存在的方案的呢？

这就是我们要将的方法引用，我们是通过方法的引用来使用已经存在的方案

需求：

  1. 定义一个接口(Printable)：里面定义一个抽象方法：void printString(String s);
  2. 定义一个测试类(PrintableDemo)，在测试类中有两个方法
    1. 一个方法是：usePrintable(Printable p)
    2. 一个方法是主方法，在主方法中调用usePrintable()方法

Printable接口：

public interface Printable {
    void printString(String s);
}

PrintableDemo测试类：

public class PrintableDemo {
    public static void main(String[] args) {
        //匿名内部类
//        usePrintable(new Printable() {
//            @Override
//            public void printString(String s) {
//                System.out.println(s);
//            }
//        });

        //Lambda
        usePrintable(s -> System.out.println(s));

        System.out.println("hello,world");

        //方法引用符： ::
        usePrintable(System.out::println);

        //可推导的就是可省略的
    }

    private static void usePrintable(Printable p){
        p.printString("hello,world");
    }
}

5.2 方法引用符

方法引用符

  • ::该符号为引用运算符，而它所在的表达式被称为方法引用

回顾以下我们在‘体验方法引用’中的代码

  1. Lambda表达式：usePrintable(s -> System.out.println(s));

    分析：拿到参数s之后通过Lambda表达式，传递给System.out.println方法去处理

  2. 方法引用：usePrintable(System.out::println);

    分析：直接使用System.out中的println方法来取代Lambda，代码更加简洁

推导与省略

  1. 如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
  2. 如果使用方法引用，也是同样可以根据上下文进行推导
  3. 方法引用是Lambda的孪生兄弟

需求：

  1. 定义一个接口(Printable)：里面定义一个抽象方法：void printString(int i);
  2. 定义一个测试类(PrintableDemo)，在测试类中有两个方法
    1. 一个方法是：usePrintable(Printable p)
    2. 一个方法是主方法，在主方法中调用usePrintable()方法

Printable接口：

public interface Printable {
    void printString(int i);
}

PrintableDemo测试类：

public class PrintableDemo {
    public static void main(String[] args) {
        //在主方法中调用usePrintable()方法
        usePrintable(i -> System.out.println(i));

        //方法引用
        usePrintable(System.out::println);
    }

    private static void usePrintable(Printable p) {
        p.printString(666);
    }
}

5.3 Lambda表达式支持的方法引用

常见的引用方式：

  1. 引用类方法
  2. 引用对象的实例方法
  3. 引用类的实例方法
  4. 引用构造器

5.4 引用类方法

引用类方法，其实就是引用类的静态方法

  1. 格式：类名::静态方法
  2. 范例：Integer::parseInt
    1. Integer类的方法：public static int parseInt(String s)将此String转换为int类型数据

练习：

  1. 定义一个接口(Converter)，里面定义一个抽象方法：int convert(String s);
  2. 定义一个测试类(ConverterDemo)，在测试类中提供两个方法
    1. 一个方法是：useConverter(Converter c)
    2. 一个方法是主方法，在主方法中调用useConverter()方法

Converter接口：

public interface Converter {
    int convert(String s);
}

ConverterDemo测试类：

public class ConverterDemo {
    public static void main(String[] args) {
        //在主方法中调用useConverter()方法
        useConverter(s -> Integer.parseInt(s));

        //方法引用
        useConverter(Integer::parseInt);

        //Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
    }
    private static void useConverter(Converter c) {
        int num = c.convert("666");
        System.out.println(num);
    }
}

5.5 引用对象的实例方法

引用对象的实例方法，其实就是引用类中的成员方法

  1. 格式：对象::成员方法
  2. 范例：“HelloWorld”::toUpperCase
    1. String类的方法：public String toUpperCase()将此String所有字符转换为大写

练习：

  1. 定义一个类(PrintString),里面定义一个方法
    1. public void printUpper(String s)：把字符串参数变为大写形式，然后在控制台输出
  2. 定义一个接口(Printer)，里面定义一个抽象方法
    1. void printUpperCase(String s)
  3. 定义一个测试类(PrinterDemo)，在测试类中提供两个方法
    1. 一个方法是：usePrinter(Printer p)
    2. 一个方法是主方法，在主方法中调用usePrinter方法

PrintString类：

public class PrintString {
    //把字符串参数变为大写形式，然后在控制台输出
    public void printUpper(String s) {
        String result = s.toUpperCase();
        System.out.println(result);
    }
}

Printer接口：

public interface Printer {
    void printUpperCase(String s);
}

PrinterDemo测试类：

public class PrinterDemo {
    public static void main(String[] args) {
        //在主方法中调用usePrinter方法
//        usePrinter(s -> {
            String result = s.toUpperCase();
            System.out.println(result);
//            System.out.println(s.toUpperCase());
//        });

        usePrinter(s -> System.out.println(s.toUpperCase()));

        //引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);

        //Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数
    }
    private static void usePrinter(Printer p) {
        p.printUpperCase("HelloWorld");
    }
}

5.6 引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

  1. 格式：类名::成员方法
  2. 范例：String::toUpperCase
    1. String类的方法：public String substring(int beginIndex,int endIndex)
    2. 从beginIndex开始，到endIndex结束，截取字符串。返回一个新的字符串，长度为endIndex-beginIndex

练习：

  1. 定义一个接口(MyString)，里面定义一个抽象方法
    1. String muSubString(String s,int x,int y);
  2. 定义一个测试类(MyStringDemo)，在测试类中提供两个方法
    1. 一个方法是：useMyString(MyString my)
    2. 一个方法是主方法，在主方法中调用useMyString方法

MyString接口：

public interface MyString {
    String muSubString(String s,int x,int y);
}

MyStringDemo测试类：

public class MyStringDemo {
    public static void main(String[] args) {
        //在主方法中调用useMyString方法
        useMyString((s, x, y) -> s.substring(x, y));//llo

        //引用类的实例方法
        useMyString(String::substring);//llo

        //Lambda表达式被类的实例方法替代的时候
        //第一个参数作为调用者
        //后面参数全部传递给该方法作为参数
    }

    private static void useMyString(MyString my) {
        String s = my.muSubString("helloworld", 2, 5);
        System.out.println(s);
    }
}

5.7 引用构造器

引用构造器，其实就是引用类中的构造方法

  1. 格式：类名::new
  2. 范例：Student::new

练习：

  1. 定义一个类(Student),里面定义两个成员变量(name,age)
    1. 并提供无参和带参构造方法，以及成员变量对应的set和get方法
  2. 定义一个接口(StudentBuilder)，里面定义一个抽象方法
    1. Student build(String name,int age);
  3. 定义一个测试类(StudentDemo)，在测试类中提供两个方法
    1. 一个方法是：useStudentBuilder(StudentBuilder s)
    2. 一个方法是主方法，在主方法中调用useStudentBuilder方法

Student类：

public class Student {
    private String name;
    private int age;

    public Student() {}

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {	return name;    }

    public void setName(String name) {        this.name = name;    }

    public int getAge() {        return age;    }

    public void setAge(int age) {        this.age = age;    }
}

StudentBuilder接口：

public interface StudentBuilder {
    Student build(String name,int age);
}

StudentDemo测试类：

public class StudentDemo {
    public static void main(String[] args) {
        //在主方法中调用useStudentBuilder方法
//        useStudentBuilder((name,age) -> {
//           return new Student(name,age);
//        });

        useStudentBuilder(((name, age) -> new Student(name, age)));//林青霞,30

        //引用构造器
        useStudentBuilder(Student::new);//林青霞,30

        //Lambda表达式被构造器替代的时候，它的形式参数全部传递给该方法作为参数
    }

    private static void useStudentBuilder(StudentBuilder s) {
        Student student = s.build("林青霞", 30);
        System.out.println(student.getName() + "," + student.getAge());
    }
}
qq_53529114
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python web接口开发与测试
06-08
综合以上知识点，我们可以了解Python基础学习、Django框架的搭建与应用、Django的视图和模型开发、模板的使用和管理、单元测试的编写以及Web接口的开发与测试。这些内容构成了使用Python进行Web接口开发与测试的完整...
Java中接口的编写与实现
憩园幽幽的专栏
07-10 1898
Java中接口的编写与实现1）  接口中所有的方法都是public abstract。2）  在接口中声明方法时，不能使用native、static 、final 、synchronized 、private 、protected等修饰符。3）  和public类一样，public接口也必须定义在与接口同名的文件中。4）  一般，接口中的每个类都要实现，且在实现中为public类型
【Java】JavaSE学习笔记
qq_30130205的博客
04-26 344
java学习
Java基础接口详解
qq_53325717的博客
08-07 602
接口学习
接口 Interface
好好学习
07-05 869
接口概述 接口就是一种公共的规范标准，只要符合规范标准，就可以大家通用。 接口就是多个公共的规范 接口是一种引用数据类型，最重要的内容就是其中的，抽象方法 如何定义一个接口 public interface 接口名称{ //接口内容 } 备注：.java–>.class 换成了关键字interface之后，编译生成的字节码文件仍然是.java–> 如果是java7，那么接口中可以包含的内容有： 1、常量 2、抽象方法 如果是Java8，还可以额外包含有： 3、默认方法 4、静态方法 如果是Jav
JAVA面向对象（下）
weixin_34414650的博客
03-16 3882
实验三 面向对象（下） 实验3-1 类的继承 一、实验描述 1、考核知识点 名称：类的继承 2、练习目标 了解类继承的意义和作用 掌握如何实现类的继承 3、需求分析 在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。 为了让初学者熟悉类的继承，本实验将演示类的继承并编写测试类验证子类是否拥有父类的可继承成员。 4、设计思路...
Python Web接口开发与测试
02-26
Python Web接口开发与测试是一个涵盖了从基础的Python学习到Web接口测试的完整过程。本书首先介绍了Python语言的基础知识，包括如何在不同的操作系统上安装Python，如何安装和使用扩展库，以及如何选择合适的Python...
C#抽象类与接口方法
04-13
【C#抽象类与接口方法】在C#编程语言中，抽象类和接口是两种用于实现多态性和封装的关键概念，它们允许我们设计灵活、可扩展的代码结构。 抽象类是一种特殊的类，它不能被实例化，而是作为其他类的基类使用。抽象类...
day12_函数式接口、方法引用_每日作业卷-答案1
08-08
本题涉及的知识点主要包括函数式接口的定义、Lambda 表达式的使用以及方法引用的应用。 首先，函数式接口是指只有一个抽象方法的接口，Java 8 为了支持 Lambda 表达式引入了 `@FunctionalInterface` 注解。这个注解...
设计模式--题目
The Tech-Dragon
12-09 1610
 编写一个接口MyInterface,包含方法sayHello（），两个实现类MyInterfaceImpl1、MyInterfaceImpl2，分别实现sayHello方法，并在主程序中通过调用这两个类的方法。要求：   另外创建一个类UseMyInterface来使用MyInterface接口，在主程序中决定实际调用的实现类。 interface MyInterface...{  vo
头歌平台Java实验：Java面向对象高级
最新发布
jing13_13的博客
04-18 4136
2.实现Demo接口，完善接口中的show方法，打印输出 “实现了接口中的show方法”System.out.println("实现了接口中的show方法");1.编写MyInterface接口，含一个抽象方法sayHi，返回值为void。System.out.println("接口定义完成");根据提示，在右侧编辑器补充代码，完成接口的书写和接口的实现。实现了接口中的show方法。
java基础--接口多态 （IDEA版）
xiaohan0010的博客
02-28 746
接口 接口是java中的一种引用数据类型 接口就是多个类的公共规范。 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。 如何定义一个接口的格式： public interface 接口名称 { // 接口内容 } 备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class。 如果是Java 7，那么接口中可以包含的内容有： 常量 抽象方...
java匿名内部类
qq_38763885的博客
06-12 319
*A:匿名内部类 * 就是局部内部类的简化写法。* B:前提：存在一个类或者接口 * 这里的类可以是具体类也可以是抽象类。* C:格式：*   new 类名或者接口名(){   重写方法;  }* D:本质是什么呢? * 是一个继承了该类或者实现了该接口的子类匿名对象。interface Inter { void show(); } class Outer { private int num=...
interface Inter { void show()；  }         class Outer {  //请在此处补齐代码 }         class OuterDem
Today_He的博客
09-04 2720
interface Inter { void show();  }         class Outer {  //请在此处补齐代码 }         class OuterDemo {            public static void main(String[] args) {                 Outer.method().show();              }       }           需求：要求在控制台输出”HelloW
java内部类相关知识的学习笔记
Wangdiankun的博客
04-10 231
内部类、成员内部类、局部内部类、匿名内部类以及匿名内部类在开发中的使用进行总结介绍。 一、内部类 （1）概述：内部类就是在一个类定义一个类，例如：在一个类A的内部定义一个类B，类B就被称为内部类。 （2）格式 （3）内部类的访问特点 ①内部类可以直接访问外部类的成员，包括私有。 ②外部类访问内部类的成员，必须创建对象。 （4）举例 如上图所示，Inner类就是Quter类的内部类，Outer类中...
Java的Interface-笔记
XXXXX的专栏
03-20 554
Java - Interfaces本文参考oracle_interface 和 tutorialspoint_interfaceinterface是一种特殊的abstract类，描述的是一种“契约”。 The interface keyword produces a completely abstract class, one that provides no implementation at
java接口实现
一些测开知识和java代码的的分享，感兴趣的可以关注，留言想看什么，然后我来发布文章
08-09 896
主要做一些简单基础理论的总结
java基础——匿名内部类
weixin_46848251的博客
07-22 681
匿名内部类： 内部类的简化写法 前提： 存在一个接口或者类，这里的类可以是一个具体的类或者抽象类 格式： new 类名或者接口名{ 重写方法； } 匿名内部类的本质：是一个继承了该类或者实现该接口的子类匿名对象 例： interface Inter{ public abstract void show(); public abstract void show2(); } class Outer { pu...
Java实验九-1 接口与实现
m0_47708813的博客
05-18 2823
小狗在不同的条件下可呈现不同的状态表现，要求用接口封装小狗的状态： 编写一个接口DogState，其中有一个void showState()方法，呈现小狗的不同状态； 编写一个Dog类，通过show()方法回调showState()； 编写若干个实现DogState接口的类，负责刻画小狗不同的状态； 编写主类，测试小狗不同状态。
Java Stream流与方法引用解析
总结来说，Java的Stream和方法引用是现代Java编程的重要组成部分，它们帮助开发者以更优雅、高效的方式处理数据，提升了代码质量和开发效率。对于任何Java开发者而言，熟练掌握这两个特性都是非常有益的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值