Operador de dos puntos dobles(::) en Java
En Java, podemos usar el operador de dos puntos dobles (::) para llamar a un método haciendo referencia a él con la ayuda de su nombre de clase.
También podemos hacer esto usando las expresiones lambda. La única diferencia que encontramos aquí es que podemos hacer referencia directamente al método por su nombre mientras usamos el operador ::.
Mientras que, cuando usamos expresiones lambda, necesitamos un delegado para el método que necesitamos llamar. Este artículo discutirá el uso del operador :: en Java.
Hay varios lugares donde podemos usar el operador :: en Java. Podemos usar el operador :: para hacer referencia a métodos.
Por lo tanto, podemos extraer métodos estáticos de clases u objetos usando ::. Incluso podemos usar el operador :: para constructores.
Además, cuando se nos da un flujo de entrada, podemos usar el operador :: para imprimir los elementos del flujo de entrada.
Cuándo y cómo usar el operador de dos puntos dobles (::) en Java
Podemos usar el operador :: al tratar con métodos estáticos, métodos de instancia, supermétodos, método de instancia de un objeto arbitrario de un tipo particular e incluso constructores de clases.
Discutamos cada uno de los enfoques uno por uno.
Al tratar con métodos estáticos
Podemos usar el operador :: en Java cuando tratamos con métodos estáticos. Para obtener una referencia al método estático de una clase, primero escribiremos el nombre de la clase seguido del operador ::, y luego escribiremos el nombre del método.
Veamos la sintaxis de este enfoque:
Sintaxis:
(ClassName::methodName)
Veamos ahora el siguiente código para entender cómo funciona.
import java.util.*;
public class Main {
static void staticFunction(String s) // static function which is called using :: operator
{
System.out.println(s);
}
public static void main(String args[]) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
list.forEach(Main::staticFunction);
}
}
Producción :
This
is
an
example
Al tratar con métodos de instancia
También podemos usar el operador :: en Java cuando tratamos con métodos de instancia.
Para obtener una referencia al método de instancia de una clase, primero escribiremos el objeto de la clase. Luego pondremos el operador :: y finalmente escribiremos el nombre del método.
Veamos la sintaxis de este enfoque.
Sintaxis:
(ObjectOfTheClass::methodName)
Veamos ahora el siguiente código para entender cómo funciona.
import java.util.*;
public class Main {
void instanceFunction(String s) // function which is called using :: operator
{
System.out.println(s);
}
public static void main(String args[]) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
Main object = new Main();
list.forEach(object::instanceFunction);
}
}
Producción :
This
is
an
example
Al tratar con supermétodos
También podemos usar el operador :: en Java cuando se trata de supermétodos.
Para hacer referencia al método super de una clase, primero escribiremos la palabra clave super. Luego pondremos el operador :: y finalmente escribiremos el nombre del método.
Veamos la sintaxis de este enfoque.
Sintaxis:
(super::methodName)
Veamos ahora el siguiente código para entender cómo funciona.
// Java code to show use of double colon operator for super methods
import java.util.*;
import java.util.function.*;
class SuperClass {
// super function to be called
String printFunction(String s) {
return ("This is Print function output from the SuperClass: " + s);
}
}
public class Main extends SuperClass {
// instance method to override super method
@Override
String printFunction(String s) {
// call the super method
// using double colon operator
Function<String, String> func = super::printFunction;
String newValue = func.apply(s);
System.out.println(newValue);
return newValue;
}
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
Main object = new Main();
list.forEach(object::printFunction);
}
}
Producción :
This is Print function output from the SuperClass: This
This is Print function output from the SuperClass: is
This is Print function output from the SuperClass: an
This is Print function output from the SuperClass: example
Al tratar con el método de instancia de un objeto arbitrario de un tipo particular
También podemos usar el operador :: en Java cuando tratamos con el método de instancia de un objeto arbitrario de un tipo particular.
Para hacer referencia al método de instancia de un objeto arbitrario de un tipo específico, primero escribiremos el nombre de la clase. Luego pondremos el operador :: y finalmente escribiremos el nombre del método.
Veamos la sintaxis de este enfoque.
Sintaxis:
(ClassName::methodName)
Veamos ahora el siguiente código para entender cómo funciona.
// Java code to show the use of double colon operator for instance method of arbitrary type
import java.util.*;
class Test {
String s = null;
Test(String s) {
this.s = s;
}
// instance function to be called
void instanceFunction() {
System.out.println(this.s);
}
}
public class Main {
public static void main(String[] args) {
List<Test> list = new ArrayList<Test>();
list.add(new Test("This"));
list.add(new Test("is"));
list.add(new Test("an"));
list.add(new Test("example"));
list.forEach(Test::instanceFunction); // call the instance method using double colon operator
}
}
Producción :
This
is
an
example
Al tratar con el constructor de clases
También podemos usar el operador :: en Java cuando tratamos con el constructor de clases.
Para obtener una referencia al constructor de la clase, primero escribiremos el nombre de la clase. Luego pondremos el operador :: y finalmente escribiremos new que llamará al constructor de esa clase en particular.
Veamos la sintaxis de este enfoque.
Sintaxis:
(ClassName::new)
Veamos ahora el siguiente código para entender cómo funciona.
// Java code to show the use of double colon operator for class constructor
import java.util.*;
public class Main {
public Main(String s) {
System.out.println(s);
}
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
list.forEach(Main::new); // call the instance method using double colon operator
}
}
Producción :
This
is
an
example
Conclusión
En este artículo, observamos cinco lugares y usamos el operador de dos puntos dobles (::) en Java.
Todas las técnicas tienen su significado, y puede aplicar el operador :: cada vez que se encuentre con alguna de las situaciones anteriores. Tenga cuidado con la sintaxis, ya que un uso inadecuado puede dar lugar a una situación errónea.