En Java, l'administrateur double deux-points (::), autrement appelé administrateur de référence de stratégie, est un élément fort présenté dans Java 8. Il donne une méthode succincte et riche pour faire allusion aux techniques ou aux constructeurs sans les évoquer. L'administrateur améliore le code et améliore la cohérence du code, ce qui en fait un instrument important pour les concepteurs. Dans cet article, nous étudierons la structure du langage de l'administrateur à double côlon, parlerons de ses applications et donnerons des guides de code pour une meilleure compréhension.
L'opérateur double deux-points se compose de deux deux-points (::) pris en sandwich entre le nom de la classe ou la référence de l'objet et le nom de la méthode. Il est utilisé comme notation abrégée pour référencer des méthodes ou des constructeurs en Java.
// A functional interface with a single abstract method
interface Printer {
void print(String message);
}
// A class that implements the Printer interface
class ConsolePrinter {
public static void printMessage(String message) {
System.out.println(message);
}
}
public class Main {
public static void main(String[] args) {
Printer printer = ConsolePrinter::printMessage;
printer.print("Hello, World!");
}
}
Dans le code ci-dessus, nous utilisons un point de jointure utilitaire appelé Printer pour définir une classe avec une seule méthode dynamique print(). La classe ConsolePrinter implémente ce point de connexion et fournit une implémentation pour la méthode printMessage(). Dans la classe Principal, nous avons créé une instance Printer à l'aide de l'opérateur double deux-points pour référencer la méthode printMessage() de la classe ConsolePrinter. Enfin, nous appelons la méthode print() de l’instance d’imprimante, qui à son tour appelle la méthode printMessage().
Pour utiliser l'opérateur double deux-points en Java, suivez ces étapes -
Définissez une interface fonctionnelle avec une seule méthode abstraite.
Implémenter l'interface dans une classe et assurer l'implémentation de la méthode.
Utilisez l'opérateur double deux-points pour faire référence à la méthode ou au constructeur
Utilisez l'opérateur double deux-points pour créer des instances d'interfaces fonctionnelles.
L'appel de cette méthode sur une instance appellera la méthode ou le constructeur référencé.
L'approche 1 consiste à utiliser l'opérateur double deux-points pour référencer une méthode statique d'une classe. Cette approche est utile lorsque nous voulons transmettre une référence de méthode qui ne dépend d'aucune variable d'instance.
// A functional interface with a single abstract method
interface Calculator {
int calculate(int a, int b);
}
class MathUtils {
public static int add(int a, int b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
Calculator calculator = MathUtils::add;
int result = calculator.calculate(5, 3);
System.out.println("Result: " + result);
}
}
Result: 8
Calculator est une interface fonctionnelle avec une méthode abstraite calculate(). La fonction statique MathUtils add() est utilisée pour ajouter deux nombres. L'opérateur double-point crée une instance de calculatrice qui fait référence à la méthode MathUtils add(). Nous appelons la méthode calculate() de la calculatrice avec deux nombres. Résultats de sortie de la console.
L'approche 2 consiste à utiliser l'opérateur double deux-points pour référencer une méthode d'instance d'un objet particulier.
import java.util.ArrayList;
import java.util.List;
class Person {
private String name;
public Person(String name) {
this.name = name;
}
public void printName() {
System.out.println(name);
}
}
public class Main {
public static void main(String[] args) {
List<Person> persons = new ArrayList<>();
persons.add(new Person("Alice"));
persons.add(new Person("Bob"));
persons.forEach(Person::printName);
}
}
Alice Bob
Dans cet exemple, nous avons une classe Individual avec une stratégie printName() pour imprimer le nom d'un individu. Nous avons créé une liste de projets individuels et ajouté deux exemples. À l’aide de l’opérateur double deux-points, nous référençons la stratégie printName() de la classe Individual dans la méthode forEach() de l’interface List. Cela provoque l'appel de la méthode printName(), imprimant le nom de chaque élément de la liste sur la console.
L'approche 3 consiste à référencer une méthode d'instance de tout objet arbitraire d'un type spécifique à l'aide de l'opérateur double deux-points.
import java.util.Arrays;
import java.util.List;
class StringUtil {
public boolean isPalindrome(String s) {
String reversed = new StringBuilder(s).reverse().toString();
return s.equals(reversed);
}
}
public class Main {
public static void main(String[] args) {
List<String> words = Arrays.asList("level", "hello", "radar", "world");
StringUtil stringUtil = new StringUtil();
long count = words.stream().filter(stringUtil::isPalindrome).count();
System.out.println("Number of palindromic words: " + count);
}
}
Number of palindromic words: 2
Dans cet extrait de code, une classe StringUtil teste les palindromes avec isPalindrome(). Nous créons une liste de mots et utilisons un flux pour trier les mots palindromiques à l'aide de la méthode isPalindrome() recommandée par l'administrateur du double côlon affiche le nombre de mots palindromiques. .
La méthode 4 consiste à référencer le constructeur à l'aide de l'opérateur double deux-points.
import java.util.function.Supplier;
class Employee {
public String name;
public int age;
public Employee() {
// Default constructor
}
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "Employee [name=" + name + ", age=" + age + "]";
}
}
public class Main {
public static void main(String[] args) {
Supplier<employee> employeeSupplier = Employee::new;
Employee employee = employeeSupplier.get();
employee.name = "John Doe";
employee.age = 30;
System.out.println(employee);
}
}
</employee>Employee [name=John Doe, age=30]
Dans ce modèle, nous avons une classe représentative avec un constructeur défini. À l’aide de l’opérateur double deux-points, nous créons une instance du point d’interaction de la fonction Provider qui fait référence au constructeur Representative. Ensuite, nous appelons la méthode get() sur l'instance employeSupplier pour obtenir un autre objet Representative. Nous définissons le nom et l'âge de l'employé et les imprimons sur la console à l'aide de la méthode toString().
L'opérateur double deux-points (::) en Java est un élément puissant introduit dans Java 8. Il fournit un moyen concis et riche de référencer des méthodes ou des constructeurs sans les appeler directement. En utilisant l'opérateur double deux-points, nous pouvons améliorer le code, augmenter la lisibilité et profiter des avantages de la programmation fonctionnelle en Java. Comprendre la syntaxe et les différentes méthodes d'utilisation de l'opérateur double deux-points est nécessaire pour tout développeur Java. Par conséquent, assurez-vous d'explorer et d'utiliser cette fonctionnalité dans vos futurs projets Java pour améliorer votre expérience de codage.
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
