Method within method in java
Java does not
support “directly” nested methods. Many functional programming
languages support method within method. But you can achieve nested method
functionality in Java 7 or older version by define local classes, class within
method so this does compile. And in java 8 and newer version you achieve it by
lambda expression. Let’s see how it achieve.
Method 1 (Using anonymous subclasses)
It is an inner class without a name and for which only a single object is created. An anonymous inner class can be useful when making an instance of an object with certain “extras” such as overloading methods of a class or interface, without having to actually subclass a class.
![]() |
method within method in java |
Example:
// 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();
}
}
Output:
Geeksforgeeks
Method 2 (Using local
classes)
Implement a method inside a local class.
A class created inside a method is called local inner class. If you want to
invoke the methods of local inner class, you must instantiate this class inside
method.
Example:
// 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();
}
}
Output:
Geeksforgeeks
Method 3 (Using a lambda expression)
Lambda expressions basically express instances of functional interfaces (An interface with single abstract method is called functional interface. An example is java.lang.Runnable). lambda expressions implement the only abstract function and therefore implement functional interfaces.Example:
// 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();
}
}
No comments:
Post a Comment