Java no admite métodos anidados «directamente» . Muchos lenguajes de programación funcionales admiten el método dentro del método. Pero puede lograr la funcionalidad del método anidado en Java 7 o una versión anterior definiendo clases locales, clase dentro del método para que se compile. Y en Java 8 y versiones más recientes, lo logra mediante la expresión lambda. Vamos a ver cómo lo logra.
Método 1 (Uso de subclases anónimas)
Es una clase interna sin nombre y para la cual se crea un único objeto. Una clase interna anónima puede ser útil al crear una instancia de un objeto con ciertos «extras», como métodos de sobrecarga de una clase o interfaz, sin tener que subclasificar una clase. para obtener más detalles sobre la clase interna anónima, haga clic aquí
// Java program implements method inside method
public class GFG {
// create a local interface with one abstract
// method run()
interface myInterface {
void run();
}
// function have implements another function run()
static void Foo()
{
// implement run method inside Foo() function
myInterface r = new myInterface() {
public void run()
{
System.out.println("geeksforgeeks");
};
};
r.run();
}
public static void main(String[] args)
{
Foo();
}
}
geeksforgeeks
Método 2 (usando clases locales)
También puede implementar un método dentro de una clase local. Una clase creada dentro de un método se llama clase interna local. Si desea invocar los métodos de la clase interna local, debe instanciar esta clase dentro del método.
// Java program implements method inside method
public class GFG {
// function have implementation of another
// function inside local class
static void Foo()
{
// local class
class Local {
void fun()
{
System.out.println("geeksforgeeks");
}
}
new Local().fun();
}
public static void main(String[] args)
{
Foo();
}
}
geeksforgeeks
Método 3 (usando una expresión lambda)
Las expresiones lambda básicamente expresan instancias de interfaces funcionales (una interfaz con un único método abstracto se denomina interfaz funcional. Un ejemplo es java.lang.Runnable). Las expresiones lambda implementan la única función abstracta y, por lo tanto, implementan interfaces funcionales. para obtener más información sobre la expresión , haga clic aquí
// Java program implements method inside method
public class GFG {
interface myInterface {
void run();
}
// function have implements another function
// run() using Lambda expression
static void Foo()
{
// Lambda expression
myInterface r = () ->
{
System.out.println("geeksforgeeks");
};
r.run();
}
public static void main(String[] args)
{
Foo();
}
}
geeksforgeeks