Une analyse approfondie des références de méthodes en Java-javaDidacticiel-php.cn

Cet article vous apporte des connaissances pertinentes sur java, qui présente principalement des problèmes liés à la référence de méthode. Tout le monde connaît la méthode, qui est la méthode que nous définissons lors de l'écriture de code. La référence de méthode est ce qui est utilisé pour référencer cette méthode. La méthode de référence indique clairement que son objectif est d'optimiser davantage les expressions Lambda, réduisant ainsi le code à écrire plus simplement. J'espère qu'elle sera utile à tout le monde.

Une analyse approfondie des références de méthodes en Java

Étude recommandée : "Tutoriel vidéo Java"

Qu'est-ce que la référence de méthode ? ? . La référence de méthode est ce qui est utilisé pour référencer cette méthode. La méthode de référence indique clairement que son objectif est d'optimiser davantage les expressions Lambda, réduisant ainsi le code à écrire plus simplement. droite! Vous avez bien entendu, les expressions Lambda sont déjà très optimisées, alors comment les optimiser ? Lorsque la classe, l'objet, le super correspondant apparaissent dans notre code, nous pouvons utiliser des références de méthode. Le principe de cette référence de méthode est que nous avons des expressions Lambda. Alors comment est-il utilisé ? Continuons à regarder vers le bas.

Citation de méthode

Puisque le titre est une citation de méthode, qu'est-ce qu'une citation de méthode ? L'opérateur de référence de méthode est le

double deux-points [::]

, qui est la référence de méthode, et c'est aussi une nouvelle syntaxe, qui est un opérateur de référence, et la référence de méthode est implémentée à travers elle. Si la solution de fonction à exprimer par Lambda existe déjà dans l'implémentation d'une méthode, nous pouvons utiliser un double deux-points pour référencer la méthode afin de remplacer Lambda.

Remarque : Les paramètres transmis dans Lambda doivent être d'un type acceptable pour la méthode dans la référence de la méthode, sinon une exception sera levée.
Comment utiliser les références de méthodes ?

Les références de méthodes peuvent être utilisées des manières suivantes :

Une analyse approfondie des références de méthodes en Java Puisqu'il existe des références de méthodes des manières ci-dessus, étudions-les une par une.

Référence aux méthodes membres via les noms d'objet

Nous savons que les objets sont créés via des classes, nous devons donc d'abord créer une classe, puis définir une méthode membre dans la classe, puis créer un objet via la classe et utiliser des paires pour référencer la méthode membre.

Par exemple :

Définissez une méthode membre, transmettez une chaîne et affichez la chaîne en lettres majuscules

Implémentons les exigences ci-dessus.

Définissez d'abord une classe

public class Demo02MethodRerObject {

//定义一个成员方法，传递字符串，把字符串按照大写输出

public void printUpperCaseString(String s){

System.out.println(s.toUpperCase());

}

}

Copier après la connexion

Puisqu'elle est sortie, nous devons l'imprimer, et l'utilisation de Lambdab nous oblige à définir une interface fonctionnelle pour l'impression et à définir une méthode abstraite pour imprimer des chaînes dans l'interface fonctionnelle.

/*

定义一个打印的函数式接口

*/

@FunctionalInterface

public interface Printable {

//定义打印字符串的抽象方法

void print(String s);

}

Copier après la connexion

对 peut citer les méthodes membres via le nom de l'objet. Le principe est que le nom de l'objet existe et que la méthode membre existe également. Vous pouvez utiliser le nom de l'objet pour citer la méthode membre. Écrivons-le dans le code : d'abord, nous utilisons Lambda pour écrire cette exigence, puis nous utilisons des références de méthode pour optimiser Lambda.

public class Demo03ObjectMethodReference {

//定义一个方法，方法参数传递Printable接口

public static void pringString(Printable p){

p.print("abcde");

}

public static void main(String[] args) {

//pringString(System.out::print);

//调用printString方法，方法的参数pringable是一个函数式接口，所以可以传递Lambda

pringString((s)->{

//创建MethodRerObject对象

Demo02MethodRerObject methodRerObject=new Demo02MethodRerObject();

//调用Demo02MethodRerObject对象中的成员方法printUpperCaseString，把字符串按照大写输出

methodRerObject.printUpperCaseString(s);

});

/*

使用方法引用优化Lambda

对象已经存在Demo02MethodRerObject

成员方法也是已经存在的printUpperCaseString

所以我们可以使用对象名引用成员方法

*/

Demo02MethodRerObject methodRerObject=new Demo02MethodRerObject();

pringString(methodRerObject::printUpperCaseString);

}

}

Copier après la connexion

Faire référence aux méthodes statiques via les noms de classe

Nous avons déjà appris que lorsqu'il y a des méthodes statiques dans notre classe, nous pouvons appeler les méthodes statiques via le nom de la classe, et il en va de même pour les références de méthodes. méthodes statiques via la méthode du nom de classe. Ci-dessous, nous utilisons également du code pour démontrer.

Cette fois nous définissons une méthode,
Les paramètres de la méthode sont passés pour calculer la valeur absolue de l'entier et l'interface fonctionnelle Calcable

Définissez d'abord une interface

@FunctionalInterface

public interface Calcable {

//定义一个抽象方法，传递一个整数，对整数进行绝对值计算并返回

int AbsCals(int number);

}

Copier après la connexion

Le principe est que la classe existe déjà et que la méthode membre statique existe déjà, vous pouvez directement utiliser le nom de la classe pour référencer la méthode membre statique. Nous créons également d'abord la classe, définissons la méthode, écrivons le code avec Lambda, puis utilisons l'optimisation des références de méthode.

public class Demo04StaticMethodReference {

//定义一个方法，方法的参数传递计算绝对值的整数和函数式接口Calcable

public static int method1(int number,Calcable c){

return c.AbsCals(number);

}

public static void main(String[] args) {

//调用method方法，传递计算绝对值的整数和lambda表达式

int number=method1(-10,(n)->{

//对参数进行绝对值计算并返回结果

return Math.abs(n);

});

System.out.println(number);

/*

使用方法引用优化Lambdab表达式

Math类是存在的

abs计算绝对值的静态方法也是存在的

所以我们可以直接通过类名引用静态方法

*/

int number2=method1(-10, Math::abs);

System.out.println(number2);

}

}

Copier après la connexion

u via Super pour citer la méthode membre

a mentionné que l'explication Super est liée à la méthode parent, c'est-à-dire l'héritage. Lorsqu'il existe une relation d'héritage et que super est appelé dans Lambda, nous avons à la place une référence de méthode.

Définissez une méthode de réunion

Nous utilisons la méthode de rencontre et de salutation entre les classes d'enfants et de parents pour la démonstrationCette fois également, nous définissons l'interface fonctionnelle de la réunion

/*

定义见面的函数式接口

*/

@FunctionalInterface

public interface Greetable {

//定义一个见面的方法

void greet();

}

Copier après la connexion

Puisque nous devons hériter, nous définissons une classe de parents

/*

定义父类方法

*/

public class Demo05Fu_Human {

//定义一个sayHello的方法

public void sayHello(){

System.out.println("Hello! 我是Human。");

}

}

Copier après la connexion

再定义一个子类，在子类中出现父类的成员方法，先使用Lambda编写代码，再进行方法引用优化。

使用super引用父类的成员方法，前提super是已经存在的，父类的成员方法也是存在的，就可以直接使用super引用父类成员方法。

import java.nio.channels.ShutdownChannelGroupException;

/*

定义子类

*/

public class Demo06Zi_Man extends Demo05Fu_Human {

//子类重写父类sayHello方法

@Override

public void sayHello() {

System.out.println("Hello!我是Man。");

}

//定义一个方法，参数传递Gerrtable接口

public void method(Greetable g){

g.greet();

}

public void show(){

//调用method方法，方法参数Greetable是一个函数式接口，所以可以传递Lambda表达式

method(()->{

//创建父类的Human对象

Demo05Fu_Human fHuman=new Demo05Fu_Human();

fHuman.sayHello();

});

//因为有子父类关系，所以存在的一个关键super，代表父类，可以直接使用super调用父类的成员方法

method(()->{

super.sayHello();

});

/*

使用super引用类的成员方法

super是已经存在的

父类的成员方法也是存在的

使用可以直接使用super引用父类成员方法

*/

method(super::sayHello);

}

public static void main(String[] args) {

//调用show方法

new Demo06Zi_Man().show();

}

}

Copier après la connexion

通过this引用成员方法

既然上面用super引用了父类的成员方法，我们之前也学过this也可以调用本类的成员方法，那同样this也可以引用本类的成员方法。

示例：

定义一个买房子的方法

同样，首先定义函数式接口。

/*

定义一个富有的函数式接口

*/

@FunctionalInterface

public interface Richable {

//定义一个想买什么就买什么的方法

void buy();

}

Copier après la connexion

然后怎么创建类，再定义买房子的方法。通过this引用成员方法，前提this是已经存在的，买房子的成员方法也是存在的，就可以直接使用this引用成员方法。同样先使用Lambda编写代码，再进行方法引用优化。

/*

通过this引用本类的成员方法

*/

public class Demo07_Husband {

//定义一个买房子的方法

public void buyHouse(){

System.out.println("北京二环内买一套四合院！");

}

//定义一个结婚的方法，参数传递Richable接口

public void marry(Richable r){

r.buy();

}

//定义一个高兴的方法

public void soHappy(){

//调用结婚的方法，方法的参数Richable是一个函数式接口，传递Lambda表达式

marry(()->{

//使用this，成员方法，调用本类买房子的方法

this.buyHouse();

});

/*

使用方法引用优化Lambda

this是已经存在的

买房子的成员方法也是存在的

可以直接使用this引用成员方法

*/

marry(this::buyHouse);

}

public static void main(String[] args) {

new Demo07_Husband().soHappy();

}

}

Copier après la connexion

类的构造器引用

类的构造器引用也叫构造方法引用。而由于构造器名称和类名完全一样，所以构造器引用格式是这样的，类名称::new的格式表示。既然是构造器引用也就是构造方法引用，所以我们需要：

定义一个Person类。

/*

person类

*/

public class Person {

private String name;

public Person() {

super();

// TODO Auto-generated constructor stub

}

public Person(String name) {

super();

this.name = name;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

Copier après la connexion

然后创建一个Person对象的函数式接口

*

定义一个创建erson对象的函数式接口

*/

@FunctionalInterface

public interface PersonBuilder {

//定义一个方法，根据传递的姓名，创建person对象返回

Person buliderPerson(String name);

}

Copier après la connexion

再传递一个方法，参数传递姓名和PersonBulider接口,方法中通过姓名创建Person对象。类的构造器引用，前提构造方法new Person（String name）已知，创建对象已知 new，就可以使用Person引用new创建对象。同样先使用Lambda编写代码，再进行方法引用优化。

/*

类的构造器（构造方法）引用

*/

import java.time.chrono.MinguoChronology;

import javax.print.attribute.standard.PrinterName;

public class Demo08Person {

//传递一个方法，参数传递姓名和PersonBulider接口,方法中通过 姓名创建Person对象

public static void printName(String name,PersonBuilder pb){

Person person=pb.buliderPerson(name);

System.out.println(person.getName());

}

public static void main(String[] args) {

//调用printName方法，方法的参数传递了函数式接口，我们可以使用Lambda表达式

printName("张三",(name)->{

return new Person(name);

});

/*使用方法引用优化Lambda表达式

构造方法new Person（String name）已知

创建对象已知 new

就可以使用Person引用new创建对象*/

printName("痛而不言笑而不语的浅伤",Person::new);

}

}

Copier après la connexion

数组的构造器引用

数组也是Object的子类，所以它也有方法引用，只是语法上稍有不同。

示例：

定义一个方法

方法的参数传递创建数组的长度和ArrayBulider接口

方法内部根据创建的长度使用ArrayBuilder中的方法创建数组并返回

同样，先创建一个数组的函数式接口

/*

定义一个创建数组的函数式接口

*/

@FunctionalInterface

public interface ArrayBulider {

// 定义一个int类型的数组方法，参数传递数组的长度，返回创建好的int类型的数组

int[] buliderArray(int length);

}

Copier après la connexion

方法的参数传递创建数组的长度和ArrayBulider接口，方法内部根据创建的长度使用ArrayBuilder中的方法创建数组并返回。前提，已知创建的就是int[]数组，数组的长度也是已知的，就可以通过数组int[]引用new，根据参数传递的长度来创建数组同样先使用Lambda编写代码，再进行方法引用优化。

import java.lang.reflect.Array;

import java.util.Arrays;

/*

数组的构造器引用

*/

public class Demo09Array_BuilderArray {

/*
定义一个方法

方法的参数传递创建数组的长度和ArrayBulider接口

方法内部根据创建的长度使用ArrayBuilder中的方法创建数组并返回

*/

public static int[] arrayLength(int length,ArrayBulider ab){

return ab.buliderArray(length);

}

public static void main(String[] args) {

//调用arrayLength方法、传递数组的长度和Lambda表达式

int[]arr=arrayLength(10,(len)->{

return new int[len];

});

System.out.println(arr.length);

/*使用方法引用优化Lambda表达式

已知创建的就是int[]数组

数组的长度也是已知的

就可以通过数组int[]引用new，根据参数传递的长度来创建数组*/

int[]arr1=arrayLength(5, int[]::new);

System.out.println(arr1.length);

System.out.println(Arrays.toString(arr1));

}

}

Copier après la connexion

推荐学习：《java视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!