AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

JavaSE 面向对象程序设计高级 方法引用 2024详解

2024-06-24 22
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： JavaSE 面向对象程序设计高级 方法引用 2024详解

在编程中，方法引用（Method Reference）是一种技术，它让你能够直接引用一个现有的函数或方法，而无需通过对象实例来调用。这种方法在函数式编程和高阶函数中非常有用，因为它提供了简洁的方式来传递函数行为，使代码更加灵活和可复用。

以下是方法引用的一些特点和用法：

  1. 直接引用：你可以创建一个方法引用，它直接指向某个类的静态方法或实例方法。例如，std::sort(myVector.begin(), myVector.end(), std::greater<int>()) 中的 std::greater<int>() 就是一个函数指针类型的引用，它直接指向 greater 函数。
  2. 类型参数化：方法引用可以接收类型参数，如 [](const T& t) -> void { ... }，这是一种通用的方法引用，适用于任何接受 T 类型参数的函数。
  3. Lambda表达式：Java和C++11引入了lambda表达式，它们本质上就是方法引用的简化形式，可以直接定义并使用匿名函数。
  4. 作为函数参数或返回值：方法引用可以被用作其他函数的参数，或者作为函数的返回值，这样可以使接口设计更加简洁。

 

方法 ：以前学习的方法

引用 ：把已经有的反复拿过来用，当做函数式接口中的抽象方法的方法体

引用处必须是函数接口

被引用的方法必须是已经存在的

被应用的方法的形参和返回值必须要和抽象方法保持一致

被引用的方法的功能要满足当前需求

改写

import java.util.Arrays;
import java.util.Comparator;
 
public class Main {
    public static void main(String[] args) {
        Integer arr[]={3,3,4,5,6,7};
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}

只有函数式接口能用Lambda表达式简化

import java.util.Arrays;
 
public class Main {
    public static void main(String[] args) {
        Integer arr[]={3,3,4,5,6,7};
        Arrays.sort(arr, (Integer o1,Integer o2) -> {
            return o2-o1;
        });
        System.out.println(Arrays.toString(arr));
    }
}
import java.util.Arrays;
 
public class Main {
    public static void main(String[] args) {
        Integer arr[]={3,3,4,5,6,7};
        Arrays.sort(arr, (o1,o2) -> o2-o1);
        System.out.println(Arrays.toString(arr));
    }
}

方法引用改写条件

1.引用处需要是函数式接口

2.被引用的方法需要已经存在

3.被引用的方法的形参各返回值需要和抽象方法的形参和返回值保持一致

4.被引用的方法的功能需要满足当前需求

import java.util.Arrays;
 
public class Main {
    public static void main(String[] args) {
        Integer arr[]={3,3,4,5,6,7};
        //表示引用Main类里的subtraction方法
        //把这方法作为抽象方法的方法体
        Arrays.sort(arr, Main::subtraction);
        System.out.println(Arrays.toString(arr));
    }
    public static int subtraction(int num1,int num2){
        return num2-num1;
    }
}

小结

引用静态方法

格式

类名::静态方法

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.util.function.Function;
 
public class Main {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"1","2","3","4","5","6");
        //先写匿名内部类
        //自动生成方法体
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                int i=Integer.parseInt(s);
                return i;
            }
        }).forEach(s -> System.out.println(s));
    }
}

方法引用简化

import java.util.ArrayList;
import java.util.Collections;
 
public class Main {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"1","2","3","4","5","6");
        list.stream().map(Integer::parseInt).forEach(s -> System.out.println(s));
    }
}

引用成员方法

import java.util.ArrayList;
import java.util.Collections;
 
public class Main {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"张三","张思锐","3","4","5","6");
        list.stream().filter(s -> s.startsWith("张")).filter(s ->s.length()==3).forEach(s -> System.out.println(s));
    }
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;
 
public class Main {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"张三","张思锐","张三丰","多多","李四","王五");
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张")&&s.length()==3;
            }
        }).forEach(s -> System.out.println(s));
    }
}

方法引用

1.写在其他类当中

public class Judge {
    public boolean judge(String s){
        return s.startsWith("张")&&s.length()==3;
    }
}
import java.util.ArrayList;
import java.util.Collections;
 
public class Main {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"张三","张思锐","3","4","5","6");
        //普通的成员方法要对象来调用
        //这里也可以先创建对象再去调用
        list.stream().filter(new Judge()::judge).forEach(s-> System.out.println(s));
    }
}

2.写在本类当中

静态方法中是没有this关键字的

因为Main默认是静态的

所以要创建本类的对象

格式 对象::成员方法

import java.util.ArrayList;
import java.util.Collections;
 
public class Main {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"张三","张思锐","3","4","5","6");
        //普通的成员方法要对象来调用
        //这里也可以先创建对象再去调用
        list.stream().filter(new Judge()::judge).forEach(s-> System.out.println(s));
    }
    public static boolean judge(String s){
        return s.length()==3&&s.startsWith("张");
    }
}

引用处不能是静态方法

import java.util.ArrayList;
import java.util.Collections;
 
public class Main {
    public void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"张三","张思锐","3","4","5","6");
        //普通的成员方法要对象来调用
        //这里也可以先创建对象再去调用
        list.stream().filter(this::judge).forEach(s-> System.out.println(s));
    }
    public boolean judge(String s){
        return s.length()==3&&s.startsWith("张");
    }
}

引用构造方法

为什么要引用构造方法

是为了创建对象

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
 
public class Main {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"张三,12","李四,13","王五,15");
        //封装成Student类对象,并且放到集合里面去、
        List<Student>newlist=list.stream().map(new Function<String, Student>() {
            @Override
            public Student apply(String s) {
                String arr[]=s.split(",");
                return new Student(arr[0],Integer.parseInt(arr[1]));
            }
        }).collect(Collectors.toList());
        System.out.println(newlist);
    }
}

构造方法运行完后对象就已经有了

在javabean类里写方法

注意参数类型要和调用处一致（new处）

所以在javabean类里要写一个只有一个形参的方法

Student::new

表示使用了Student类里的构造方法并获得了对象

用类名引用成员方法

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
 
public class Main {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"aaa","bbb","ccc","ddd");
        list.stream().map(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        }).forEach(s -> System.out.println(s));
    }
}

用类名引用成员方法改写

import java.util.ArrayList;
import java.util.Collections;
 
public class Main {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"aaa","bbb","ccc");
        list.stream().map(String::toUpperCase).forEach(s -> System.out.println(s));
    }
}

被引用方法的形参和返回值要和抽象方法中的形参和返回值一致

方法引用的规则 是类名引用成员方法独有的

需要有函数式接口

被引用的方法必须已经存在

被引用方法的形参需要和抽象方法的第二个形参到最后一个形参保持一致，返回值需要保持一致

拿着流中的每一个数据去调用String类中的toUpperCase方法

方法的返回值就是转换之后的结果

局限性

不能引用所有类中的成员方法

是跟抽象方法的第一个参数(形参)有关，这个参数是什么类型的，就只能引用这个类中的方法

引用数组的构造方法

数组是没有构造方法的

但是有一个专门描述数组的类，有构造方法

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
 
public class Main {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        Collections.addAll(list,"张三","李四","王五");
        String[] array = list.stream().toArray(String[]::new);
        for(String s:array)System.out.println(s);
    }
}

总结

文章标签：
Java
多多!
目录
相关文章
CaojunjiaOnly
|
6月前
|
Java 程序员 编译器
【详识JAVA语言】面向对象程序三大特性之二：继承
【详识JAVA语言】面向对象程序三大特性之二：继承
CaojunjiaOnly
67 2
遇事问春风乄
|
Java 编译器
【javaSE】 面向对象程序三大特性之继承（二）
【javaSE】 面向对象程序三大特性之继承（二）
遇事问春风乄
40 0
遇事问春风乄
|
Java 程序员
【javaSE】 面向对象程序三大特性之继承（一）
【javaSE】 面向对象程序三大特性之继承（一）
遇事问春风乄
54 0
遇事问春风乄
|
存储 Java 编译器
【javaSE】面向对象程序三大特性之封装（二）
【javaSE】面向对象程序三大特性之封装（二）
遇事问春风乄
67 0
遇事问春风乄
|
Java 编译器
【javaSE】面向对象程序三大特性之封装（一）
【javaSE】面向对象程序三大特性之封装（一）
遇事问春风乄
60 0
多多!
|
5月前
|
存储 设计模式 Java
JavaSE 面向对象程序设计初级 2024方法变量封装javabean结合内存图详解
JavaSE 面向对象程序设计初级 2024方法变量封装javabean结合内存图详解
多多!
38 7
sky_qiyi
|
5月前
|
存储 Java 程序员
JavaSE——面向对象基础（1/4）-面向对象编程、程序中的对象、对象的产生、对象的执行原理、类和对象的一些注意事项
JavaSE——面向对象基础（1/4）-面向对象编程、程序中的对象、对象的产生、对象的执行原理、类和对象的一些注意事项
sky_qiyi
51 7
土木林森
|
5月前
|
设计模式 Java
一文掌握 Java 面向对象精髓：从类定义到对象实战
【6月更文挑战第15天】Java面向对象编程初学者指南：类是对象模板，如`Person`类含`name`和`age`属性。创建对象用`new`，如`Person person = new Person()`。访问属性如`person.name=&quot;Alice&quot;`，调用方法如`person.sayHello()`。类能继承，如`Student extends Person`。对象间共享数据可传参或共用引用。多态性允许父类引用调用子类方法。注意对象生命周期和内存管理，避免内存泄漏。通过实践和理解这些基础，提升编程技能。
土木林森
30 0
CaojunjiaOnly
|
6月前
|
安全 Java 编译器
【详识JAVA语言】面向对象程序三大特性之三：多态
【详识JAVA语言】面向对象程序三大特性之三：多态
CaojunjiaOnly
60 4
敖云岚
|
存储 SQL 安全
教你精通JavaSE语法之第七章、类和对象
Java是一门纯面向对象的语言(Object Oriented Program，简称OOP，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好！一切皆为对象！面向对象程序设计关注的是对象，而对象是现实生活中的实体，比如：洗衣机。但是洗衣机计算机并不认识，需要开发人员告诉给计算机什么是洗衣机。
敖云岚
66 0