ஜாவாவெர்சன் 8-ல் மெத்தட் ரெஃபெரென்ஸ் என்ற புதிய ஒரு கருத்து சேர்க்கப்பட்டுள்ளது. ஃபங்க்சனல் இண்டெர்ஃபேசின் மெத்த்ட்களை ரெஃபெர் செய்ய உதவுகின்றது.
இது எளிதான லாம்ப்டா எக்ஸ்ப்ரசனில் உள்ளது. ஒவ்வொரு தடவை மெத்த்டை ரெஃபெர் செய்யும் பொழுது லாம்ப்டா எக்ஸ்ப்ரசனுக்கு பதில் மெத்தட் ரெஃபெரென்ஸை பயன்படுத்தலாம். இந்த கட்டுரையில் மெத்தட் ரெஃபெரென்ஸ் பற்றி விரிவாக பார்ப்போம்.
மெத்தட் ரெஃபெரென்ஸ் வகைகள்
மூன்று வகையான மெத்தட் ரெஃபெரென்ஸ்கள் ஜாவாவில் உள்ளன .அவையாவன.
1. ஸ்டேட்டிக் மெத்தடிற்க்கான ரெஃபெரென்ஸ்.
2. இன்ஸ்டன்ஸ் மெத்தடிற்கான ரெஃபெரென்ஸ்
3. கன்ஸ்ட்ரக்டரிற்கான ரெஃபெரென்ஸ்.
1) ஸ்டேட்டிக் மெத்தட் ரெஃபெரென்ஸ்
.ஒரு கிளாசில் உள்ள ஸ்டேட்டிக் மெத்தடைரெஃபெர் செய்யலாம். அதற்கு கீழ்வரும் சிண்டாக்ஸ் பயன்படுகின்றது.
Syntax
1. ContainingClass::staticMethodName
சான்று நிரல்-1
கீழே உள்ள நிரலில் ஒரு ஃபங்க்சனல் இண்டெர்ஃபேஸ் மற்றும் ஒரு ஸ்டேட்டிக் மெத்தடை ரெஃபெர் செய்யும் ஃபங்க்சனல் மெத்தடும் உள்ளது.
interface Sayable{
void say();
}
public class MethodReference {
public static void saySomething(){
System.out.println("Hello, this is static method.");
}
public static void main(String[] args) {
// Referring static method
Sayable sayable = MethodReference::saySomething;
// Calling interface method
sayable.say();
}
}
வெளியீடு:
Hello, this is static method.
சான்று நிரல்-2
கீழே உள்ள நிரலில் ஃபங்க்சனல் இண்டெர்ஃபேஸ் Runnable இன்டெர்ஃபேஸ் ஒரு ஸ்டேட்டிக் மெத்தடை ரெஃபெர் செய்கின்றது
public class MethodReference2 {
public static void ThreadStatus(){
System.out.println("Thread is running...");
}
public static void main(String[] args) {
Thread t2=new Thread(MethodReference2::ThreadStatus);
t2.start();
}
}
வெளியீடு:
Thread is running...
Example 3
நீங்கள்முன்கூட்டியே ஃபங்க்சனல் இண்டெர்ஃபேசை மெத்தடை ரெஃபெர் செய்வதற்கு பயன்படுத்தலாம்
import java.util.function.BiFunction;
class Arithmetic{
public static int add(int a, int b){
return a+b;
}
}
public class MethodReference3 {
public static void main(String[] args) {
BiFunction<Integer, Integer, Integer>adder = Arithmetic::add;
int result = adder.apply(10, 20);
System.out.println(result);
}
}
வெளியீடு:
30
Example 4
நீங்கள் மெத்தடை ரெஃபெர் செய்வதன் மூலம் ஸ்டேட்டிக் மெத்தட்களை ஓவர்ரைட் செய்யலாம். கீழே உள்ள சான்று நிரலில் மூன்று மெத்தட்கள் ஓவர்லோட் செய்யப்பட்டுள்ளன.
import java.util.function.BiFunction;
class Arithmetic{
public static int add(int a, int b){
return a+b;
}
public static float add(int a, float b){
return a+b;
}
public static float add(float a, float b){
return a+b;
}
}
public class MethodReference4 {
public static void main(String[] args) {
BiFunction<Integer, Integer, Integer>adder1 = Arithmetic::add;
BiFunction<Integer, Float, Float>adder2 = Arithmetic::add;
BiFunction<Float, Float, Float>adder3 = Arithmetic::add;
int result1 = adder1.apply(10, 20);
float result2 = adder2.apply(10, 20.0f);
float result3 = adder3.apply(10.0f, 20.0f);
System.out.println(result1);
System.out.println(result2);
System.out.println(result3);
}
}
வெளியீடு
30
30.0
30.0
2)இன்ஸ்டன்ஸ் மெத்தடை ரெஃபெர்செய்தல்.
ஸ்டேட்டிக் மெத்தட்களை போன்று இன்ஸ்டன்ஸ் மெத்தட்களையும் ரெஃபெர் செய்யலாம்..
அதற்கான சிண்டாக்ஸ்
Syntax
1. containingObject::instanceMethodName
சான்று நிரல்-1
கீழே உள்ள நிரலில் ஸ்டேட்டிக் அல்லாத மெத்தட்களை ரெஃபெர் செய்யப்பட்டுள்ளது. மெத்தட்களை ஆப்ஜெக்ட் மூலமோ அல்லது அனானிமஸ் ஆப்ஜெக்ட் மூலமோ ரெஃபெர் செய்யலாம்.
interface Sayable{
void say();
}
public class InstanceMethodReference {
public void saySomething(){
System.out.println("Hello, this is non-static method.");
}
public static void main(String[] args) {
InstanceMethodReference methodReference = new InstanceMethodReference(); // Creating object
// Referring non-static method using reference
Sayable sayable = methodReference::saySomething;
// Calling interface method
sayable.say();
// Referring non-static method using anonymous object
Sayable sayable2 = new InstanceMethodReference()::saySomething; // You can use anonymous object also
// Calling interface method
sayable2.say();
}
}
வெளியீடு:
Hello, this is non-static method.
Hello, this is non-static method.
சான்று நிரல்-2
கீழ உள்ள நிரலில் ஸ்டேட்ட்க் அல்லாத மெத்தட்கள் ரெஃபெர் செய்யப்பட்டுள்ளது. Runnable இன்டெர்ஃபேஸ் ஒரே ஒரு அப்ஸ்ட்ராக்ட் மெத்தடை கொண்டுள்ளது. எனவே அதை ஃபங்க்சனல் இன்டெர்ஃபேஸ் ஆக பயன்படுத்தலாம்.
public class InstanceMethodReference2 {
public void printnMsg(){
System.out.println("Hello, this is instance method");
}
public static void main(String[] args) {
Thread t2=new Thread(new InstanceMethodReference2()::printnMsg);
t2.start();
}
}
வெளியீடு:
Hello, this is instance method
சான்று நிரல்-3
கீழே உள்ள நிரலில் BiFunction இன்டெர்ஃபேஸை பயன்படுத்தியுள்ளோம்.
இதில் apply() என்ற ஃபங்க்சனல் மெத்தட் உள்ளது.இங்கே add மெத்தட்களுக்கு apply மெத்தட்களுக்கு ரெஃபெர் செய்கின்றோம்.
import java.util.function.BiFunction;
class Arithmetic{
public int add(int a, int b){
return a+b;
}
}
public class InstanceMethodReference3 {
public static void main(String[] args) {
BiFunction<Integer, Integer, Integer>adder = new Arithmetic()::add;
int result = adder.apply(10, 20);
System.out.println(result);
}
}
வெளியீடு:
30
3) கன்ஸ்ட்ரக்டரைரெஃபெர்செய்தல்
New கீவேர்டுமூலம்கன்ஸ்ட்ரக்டரைரெஃபெர்செய்யலாம்.
அதற்கானசிண்டாக்ஸ்
1. ClassName::new
சான்று
interface Messageable{
Message getMessage(String msg);
}
class Message{
Message(String msg){
System.out.print(msg);
}
}
public class ConstructorReference {
public static void main(String[] args) {
Messageable hello = Message::new;
hello.getMessage("Hello");
}
}
வெளியீடு:
Hello
நன்றி.
முத்துகார்த்திகேயன், மதுரை.
No comments:
Post a Comment