நிரலாக்க மொழிகளும் அவற்றின் பிரதிபலிப்பும். (Programming Languages and Reflection)

இன்றைய காலத்தில் உருவாக்கப்படும் பெருன்பான்மையான உயர் நிலை நிரலாக்க மொழிகள் பிரதிபலிப்பு பயன்பாட்டு நிரலாக்க இடைமுகம் (ப.நி.இ) ஒன்றையும் கொண்டுள்ளன. 

மூன்றாம் நபர் ஒருவர், மென்பொருள் சட்டகம் ஒன்றை அமைக்கும் பொது இந்த ப.நி.இ கள் பெரும் துணைபுரிகின்றன. அதுமட்டும் அல்லாது, எங்களின் நிரலாக்கமும், எதிர்காலத்தில் ஆரம்ப நிரலாக்க கோப்புகளில் மாற்றங்களை செய்யாது, அதிக அல்லது வித்தியாசமான இயல்புகளுடன் விரிவுபடுத்த கூடியதாகவும், அல்லது இயக்கநிலையில் அவற்றின் இயங்கும் தன்மையை மாற்றி அமைக்க கூடியதாக அமைத்து கொள்ளுவதற்கும் இது பெரிதும் உதவும்.

நாம் நிரலாக்கம் ஒன்றை எழுதும் போது, இப்படி ஒரு ப.நி.இ எங்களின் நிரலாக்க மொழியில் உண்டா? என்பதையும், அதன் பயன்பாடு மற்றும் வரையறைகள் என்ன என்பதையும் அறிந்து, முயன்ற அளவு அவற்றை பயன்படுத்தினோமானால், அழகான, விரிவு படுத்தகூடிய நிரலாக்கங்களை எழுதிக்கொள்ளலாம்.

Tomcat போன்ற வலை வழங்கன் , Spring போன்ற மென்பொருள் சட்டகம் அல்லது Android போன்ற இன்றைய இயக்க தளங்கள் வரை இவை பெருமளவில் பயன்படுகின்றன.

மென்பொருள் சட்டகங்கள் என்பவை, சில குறிப்பிட்ட ஒத்த இயல்புகளை வழங்க கூடிய மென்பொருட்களை வடிவமைக்க தேவையான பொதுவான இயல்புகளுகளை உள்ளடக்கி வடிவமைக்கப்படும்.  பின்பு, மென்பொருள பொறியியலாளர்கள்  தங்கள் தேவைக்கேற்ப கூடுதல்  நிரலாக்கங்களை சேர்த்து விரிவுபடுத்தவோ அல்லது இறுதிப் பயன்பாடு கொண்ட மென்பொருட்களை உருவாக்கிக்கொள்ளவோ பயன்படுத்துவார்கள்.

இவ்வாறன சட்டகங்களை  அமைத்துக்கொள்ளும் போது, அவ் நிரலாக்கங்களால் இயக்கபோகும் எமது நிரலாக்கங்கள் கொண்டிருக்கும் வகுப்புகள்  அல்லது அவற்றின் பண்புகளோ செயலிகளோ தெரிந்திருக்க வாய்ப்பில்லை. அனால் அவற்றின் பெயர்களை வழங்குவதன் மூலம் புதிதாக சேர்க்கப்பட்ட நிரலாக்கங்களை இயக்க கூடியதாக இருக்க வேண்டும்.

இதனை ஒரு உதாரணத்துடன் பார்ப்பது இலகுவாக இருக்கும். ஜாவா நிரலாக்க மொழி இத்தகையான ப.நி.இ கொண்டுள்ளது. எனவே ஜாவா மொழியை கொண்டு சிறிய உதாரணத்தைப் பார்ப்போம்.

கீழ்காணும் வகுப்புகளை பார்ப்போம்.

இந்த வகுப்பு ஒரு வரியை திரையில் எழுதக்கூடியது.

public class MyPrinter {
public void print(){
System.out.println("My printer printing");
}
}

இந்த வகுப்பு ஆரம்பத்திலும் முடிலும் கோடுகளை வரைகின்றது. அத்துடன் இயக்க ஆரம்ப செயலியை கொண்டுள்ளது .

public class Starter {
public static void main(String[] args) {
MyPrinter printer = new MyPrinter();
System.out.println("==================================");
printer.print();
System.out.println("==================================");
}
}

வகுப்பு இயங்கியதும், திரையில் கிழ்கண்டவாறு இருக்கும்.

> java Starter  
==================================
My printer printing
==================================

இப்போது கீழ்காணும் புதிய வகுப்பு ஒன்றை சேர்ப்போம்.

public class YourPrinter {
public void print(){
System.out.println("Your printer printing");
}
}

இதனை மேலே எழுதிய Starter வகுப்பின் உதவியுடன் இயங்க செய்வோம்.

இதற்க்கு, Starter வகுப்பின்
MyPrinter printer = new MyPrinter(); 
வார்த்தைக்கு பதிலாக,
YourPrinter printer = new YourPrinter();
வார்த்தையை மாற்றவேண்டும்.

இப்போது உங்களுக்கு புரிந்திருக்கும். Starter வகுப்பு MyPrinter, YourPrinter வகுப்புகளை இயங்க பயன்படுத்த முடியும். ஆனால் Starter வகுப்பினுள் அதற்கேற்ற மாற்றங்கள் செய்யவேண்டி உள்ளது.

Starter வகுப்பில் மாற்றம் செய்யாது இரண்டு வகுப்புகையும் மாறி மாறி இயக்க என்ன செய்ய வேண்டும் என்று பார்ப்போம்.

முதலில் Printer என்னும் இடைமுகம் ஒன்றை அறிமுகம் செய்வோம்.

public interface Printer {
void print();
}

MyPrinter, YourPrinter  வகுப்புகளை இவ் இடைமுகத்தில் இருந்து மரபியல்பு பெறச்செய்வோம்.

public class MyPrinter implements Printer{

...

}

public class YourPrinter implements Printer{

...

}

Starter  வகுப்பினை இவ்வாறு மாற்றுவோம்.

public class Starter {
public static void main(String[] args) {
Printer printer = null;
if(args[0].equals("MyPrinter")){
printer = new YourPrinter();
}
if(args[0].equals("YourPrinter")){
printer = new YourPrinter();
}
System.out.println("==================================");
printer.print();
System.out.println("==================================");
}
}

இனி Starter  வகுப்பில் எந்தமாற்றமும் செய்யாது MyPrinter, YourPrinter வகுப்புகளை கீழ்க்கண்டவாறு இயக்கலாம்.

>java Starter MyPrinter
==================================
My printer printing
==================================

>java Starter YourPrinter
==================================
Your printer printing
==================================

இங்குபார்த்தால் Starter  வகுப்பு MyPrinter, YourPrinter வகுப்புகளுடன் சேர்ந்து விதம்விதமான இயல்புகளை எமக்கு தருகின்றது. எனவே இந்த Starter  வகுப்பை ஒரு சட்டகமாக பிறருக்கு வழங்கலாம். ஆனால் இந்நிலையில் அவ்வாறு செய்ய முடியாது.

ஏன் இந்நிலையில் Starter வகுப்பு ஒரு சட்டகம் இல்லை என்று பார்ப்போம்?

இப்போது வேறு ஒருவர் TheirPrinter வகுப்பு ஒன்றை உருவாக்குகின்றார்.

public class TheirPrinter implements Printer {
public void print() {
System.out.println("Their printer printing");
}
}

இதனை Starter உடன் இயங்க செய்ய கீழ் காணும் வார்த்தைகளை Starter வாகுப்புடன் சேர்க்க வேண்டும்.

if(args[0].equals("TheirPrinter")){
printer = new TheirPrinter();
}

சட்டகம் அமைக்கும் போது இது சாத்தியமற்றது. ஏன்னெனில் எதிர்காலத்தில் உருவாக்கப்படும் வகுப்புகளை எமது நிரலாக்கத்தில்  பயன்படுத்த முடியாது.

ஆகவே Starter வகுப்பை ஒரு சட்டகமாக மாற்ற வேண்டுமெனில், இயக்கநிலையில் வகுப்பின் பெயரைக்கொண்டு ஒருபொருளை உருவாக்கிக்கொள்ள கூடியதாக இருக்க வேண்டும். அவ் வகுப்பு Printer இடைமுகத்தின் மரபியலை கொண்டிருந்தால், Printer வகை இனம்காட்டி கொண்டு print செயலியை இயக்கலாம் .

இவ்விடத்தில்தான் எமக்கு பிரதிபலிப்பு ப.நி.இ உதவிசெய்கின்றன.

Starter வகுப்பின்

if(args[0].equals("...")){
printer = ...
}

வார்த்தைகளுக்கு பதிலாக, கீழ்காணும் வார்த்தைகளை மாற்றலாம்.

// வகுப்பை தேடுகிறது 
Class<?> forName = Class.forName(args[0]); 
// வகுப்பில் இருந்து பொருளை உருவாக்குகிறது 
Printer printer = (Printer) forName.newInstance(); 

இதன் பின்னர், Starter வகுப்பில் எந்த மாற்றமும் செய்யாது, MyPrinter, YourPrinter மட்டுமல்லாது TheirPrinter போன்ற புதிதாக உருவாக்கப்படும் வகுப்புகளையும் பாவித்து கொள்ளலாம்.இவ்வகையில் பிரதிபலிப்பு ப.நி.இ விரிவுபடுத்த கூடிய நிரலாக்கம் ஒன்றை உருவாக்க எமக்கு உதவி உள்ளது .

இதுவரை விபரித்தவை, பிரதிபலிப்பு ப.நி.இ  பற்றிய ஒரு நல்ல அறிமுகத்தை தந்திருக்கும் என்று நினைக்கிறன். பிரதிபலிப்பு ப.நி.இ பற்றி கூடுதலாக அடுத்த அடுத்த பாகங்களில் எழுதுகிறேன்.

தேடினேன் அவரை...

உலகம் எங்கும் ஓடி ஓடி தேடினேன் ...
குயில்களுக்கெல்லாம் பாடச் சொல்லிக் கொடுத்தவர் எங்கே ? - என் 
குட்டி மகளை பாட வைக்கவேணும் ...

மயில்களுக்கெல்லாம் ஆடச் சொல்லிக் கொடுத்தவர் எங்கே ? - அவளை 

மயிலை போல் ஆட வைக்கவேணும் ..

மீன்களுக்கெல்லாம் நீந்தச் சொல்லிக் கொடுத்தவர் எங்கே ? - என் 

மகள் நீரின் மேலே நீந்தி செல்ல வேணும் ....

பறவைகளுக்கெல்லாம் பறக்கச் சொல்லிக் கொடுத்தவர் எங்கே ? - சிறகடித்து 

பட்டு மகள் பறந்து திரிய வேணும் ...

தேடியவர் எவரும் கிடைக்கவில்லை - ஏன்  என்றால் 

குயிலும் மயிலும் மீனும் - தாமாகவே

கற்றுக் கொண்டன என்று அறிந்தேன். - அவற்றை எல்லாம் 

என் மகளும் தெரிந்துகொள்வாள் என்று விட்டுவிட்டேன்.

என்னொன்று அறிந்தேன் ...

பறவை போல பறக்க சிறகு வேணும் என்று - ஆனால் 

சிறகு இன்றி பறந்திட... சின்ன மகள் மனம் என்றும்

கனம் இன்றி இருந்திட வேணும் ... -அவள்  

சிட்டாக பறப்பாள் என்றும் தன் மனத்தில்...

உலகம் சுத்தி பார்த்த பிள்ளையார்

ஒவ்வொறு முறையும் விடுமுறை வந்தால் முருகன் தன்னுடைய மயில் வாகணத்தில் ஏறி உலகம் சுத்த போய்விடுவான். வரும் போது புது புது தகவல் மட்டுமல்ல, புது புது தொலை பெசிகளுடன் வந்து பிள்ளையாரை வியப்பில் மூழ்கடிப்பான். இதைப்பாத்த பிள்ளையாருக்கு தானும் உலகம் சுத்தி பாக்கவேணும் என்று ஆசை வந்தது. தன்னுடைய எலி வாகணத்தை அவ்வளவு தூரம் ஒட்டி செல்ல முடியாததால் தன் அம்மா அப்பா ஆனா சிவன் உமாதேவியரிடம் சென்று உதவிகேட்டான் பிள்ளையார்.

சிவன் உமாதேவியார் வழமை போல் தங்கள் வேலை காரணமாக பிள்ளையாரை அழைத்து செல்ல முடியவில்லை. யோசனை செய்ததில் அவர்களுக்கு ஒரு எண்ணம் தோன்றியது. தாங்கள் இருவரும் ஒன்றாக அமர்ந்து கொண்டு "உன் அம்மா அப்பா தான் உலகம் எங்களை சுத்தி வா என்றனர்".

பிள்ளையாருக்கு தான் சிறுவயதில் மாம்பழம் வாங்குவதற்காக செய்த தந்திரம் ஞாபகம் வந்தது, அதனால் இப்போது விழைந்த இந்த நிலையை எண்ணி வருத்தமும் வந்தது.

என்ன செய்வது, நீதிக் கதைகளும் அவற்றில் சொல்லப்படும் உதாரனங்களும் ஒன்றாகவே முடிந்து விடுகின்றன.

இன்றோடு இன்னும் ஒரு வருடம்...

வேறொன்றும் இல்லை எமது சொந்த வீட்டை விட்டு பிரிந்து 22 வருடம் முடிந்து விட்டது. எனக்கு ஞாபகம் இருந்து 1991 ஆண்டு யூன் மாதம் 10ஆம் திகதி வீட்டை விட்டு வெளிக்கிட்டோம்.  ஒரு மத்தியாண நேரம் அம்மா சமைத்து வைத்துவிட்டு நாமெல்லாம் குளித்துக்கொண்டு இருந்தும். துவக்கு சத்தம் வழக்கத்துக்கு மாறாக அருகாமையில் கேட்டது. அதுவும் வடகிழக்கு மூலையில் இருந்து வந்தது. சமைத்த சாப்பாட்டையும் எடுத்து கொண்டு வெளிக்கிட்டோம்.

வழமையாக இப்படி வெளிக்கிட்டு போனால், சண்டை முடிய திரும்பி வந்து விடுவோம். இம்முறை அப்படி இல்லை, ஆனால் அன்று அது தெரியாது. வழமை போல் முக்கியமான பொருட்களுடன் துவிச்சக்கர வண்டியில் வெளியேறினோம். அதுக்கு பிறகு 20 வருசமா ஒருவரும் போகமுடியவில்லை. இப்ப போக அனுமதித்து விட்டார்கள், ஆனால் இன்னும் என்னால் போக முடிய வில்லை. 

எப்படியும் ஒருநாள் போய் பாக்கலாம் என்ற நம்பிக்கையுடன் இன்றும் இருக்கிறேன். 

ஜாவா இடைமுகம், மறுபயனீடு , பல்முக வாரிசுப்படுத்தல். (Java interface, re-usability, Multiple Inheritance)

ஜாவா என்னும் பொருள் நோக்கு நிரலாக்க மொழி (Object Orientation Language) சற்று இலகுபடுத்தபட்ட வாரிசுப்படுத்தளுடன் (Inheritance) அறிமுகமானது. நிரலாக்கத்தில், வாரிசுப்படுத்துவது மறுபயனீடு பெறுவதற்கே. இந்த பதிவில், வாரிசுப்படுத்துவதன் மூலம் கிடைக்க கூடிய  மறுபயனீடு  வடிவங்களையும், ஜாவாவில் கிடைக்கும் அல்லது இழந்துவிட்ட மறுபயனீடு  வடிவங்களையும் உதாரணங்களுடன் ஆராயப்போகிறேன்.

முதலில் வாரிசுப்படுத்தலை பார்ப்போம். ஒரு பொருளை எடுத்துக்கொண்டால், அவை பண்புக்கூறுகளையும்,  சுயசெயற்பாடுகளையும் கொண்டிருக்கும். கணனியில் நிரலாக்கங்கள் இயங்கும் போது, இப்பொருட்களின் பண்புநிலைகள் மாறிக்கொண்டிருக்கும். சுயசெயட்பாடுகளை தூண்டுவதன் மூலம் அவற்றின் பண்புகளை மாற்றிக்கொள்ளவும் அல்லது அறிந்துகொள்ளவும் முடியும். இதற்காக, பொருள் நோக்கு நிரலாக்கத்தில் வகுப்புகளை உருவாக்கிகொள்வோம், அவை பண்பு மாறிகளையும், சுயசெயலிகளையும் கொண்டிருக்கும். வகுப்புகளை உருவாக்கும் போது, புதிய வகுப்பு ஒன்று ஏற்கனவே அமைத்த ஒரு வகுப்பின் இயல்புகளையும் தன் சொந்த இயல்புகளையும் கொண்டிருந்தால் அதை மரபியல்பு என்போம். இவ்வேளைகளில், புதிய வகுப்பு உருவாக்கும் போது, ஏற்கனவே அமைத்துகொண்ட இயல்புகளையும் அதுசார்ந்த செயலிகளையும் மீள அமைத்து கொள்ளாது, புதிய வகுப்பை முன்னதன் வாரிசாக அமைத்துகொள்வோம், இதனையே வாரிசுப்படுத்தல் என்கிறோம்.

உதாரணத்துக்கு, கோளம் மற்றும் பந்து ஆகிய வகுப்புகளை எடுத்துக்கொள்வோம். கோளங்கள் குறிப்பிட்ட ஆரையை கொண்டிருக்கும். பந்துகள் குறிப்பிட்ட ஆரையையும், மொத்தல் சுட்டியையும் கொண்டிருக்கும். எனவே, கோளங்களை மேல்நிலை வகுப்பாக அமைத்து, பந்தை அதன் வாரிசு வகுப்பாகவும் அமைத்துக்கொள்வோம். கீழ்வரும் படத்தையும் நிரலாக்கத்தையும் பார்ப்போம்.

class Sphere{ // கோளம் வகுப்பு 

private float radius; // ஆரை பண்பு 

public float getRadius(){ // ஆரை அறியும் செயலி 

return radius;

}

public void setRadius(float radius){// ஆரை மாற்றும் செயலி 

this.radius = radius;

}

}

class Ball extends Sphere{// பந்து வகுப்பு 

private float collisionIndex; // மொத்தல் சுட்டி பண்பு 

public getCollisionIndex(){ // மொத்தல் சுட்டி அறியும் செயலி 

return collisionIndex;

}

public void setCollisionIndex(float collisionIndex){ // மொத்தல் சுட்டி மாற்றும் செயலி 

this.collisionIndex = collisionIndex;

}

}

இங்கே பந்து வகுப்பு அமைக்கும் போது ஆரை பண்பையோ அல்லது அது சார்ந்த செயலிகளையோ மீள அமைத்துக்கொள்ளவில்லை. ஆனால் பந்து வகுப்பு கோளம் வகுப்பின் வாரிசு என்பதால், தானாகவே அவை அமைந்துவிடும். அதுதான் வாரிசுப்படுதல் என்கிறோம். கீழுள்ள நிரலாக்கம் இதை உணர்த்தும்.

Ball ball = new Ball(); // பந்து ஒன்று உருவாக்கப்படும் 

ball.setRadius(10.0f); // ஆரை மாற்றுப்படும் 

ball.setCollisionIndex(0.80f); // மொத்தல் சுட்டி மாற்றுபடும்

இதை மரபியல்பு மறுபயனீடு என்கிறோம்.

இன்னொரு வகை மறுபயனீடு உள்ளது, அதற்கு கீழ்வரும் பெட்டி வகுப்பை பார்ப்போம். இந்த வகுப்பில் ஒரு செயலி அமைக்கப்பட்டுள்ளது, அதைக்கொண்டு இந்த பெட்டிக்குள் குறிப்பிட்ட எத்தனை கோளங்களை வைக்கலாம் என்று கணிக்கலாம்.

class Box{ // பெட்டி வகுப்பு 

private float width; // பெட்டியின் அகலம் பண்பு 

private float length; // பெட்டியின் நீளம் பண்பு 

private float height; // பெட்டியின் உயரம் பண்பு

/**

இந்த பெட்டிக்குள் வைக்ககூடிய கோளங்களின் எண்ணிக்கையை தரும்.

**/

public int numberOfSphere(Sphere sphere){// செயலி 

int diameter = sphere.getRadius();

return (int)width/diameter*(int)length/diameter*(int)height/diameter;

}

}

இப்போது கீழ்காணும் நிரலாக்கத்தைப்பார்ப்போம். இதன்மூலம் இந்த செயலியின் பயன்பாடு புரியும்.

Box box = new Box(); // ஒரு பெட்டி உருவாக்கப்படும் 
... // பெட்டியின் நீளம், அகலம், உயரம் மாற்றி கொள்ளவும்  

Sphere sphere = new Sphere(); // ஒரு கோளம் உருவாக்கப்படும் 
...// கோளத்தின் ஆரையை மாற்றி கொள்ளவும் 

int numberOfSphere = box.numberOfSphere(sphere); // கோளங்களின் எண்ணிக்கை கிடைக்கும்.

இது மட்டும் இல்லை, இந்த செயலியை பாவித்து அதே பெட்டியினுள் வைக்க கூடிய பந்துகளின் எண்ணிக்கையையும் அறிந்து கொள்ளலாம். ஏனென்றால், பந்து கோளத்தின் வாரிசு.

Ball ball = new Ball(); // ஒரு பந்து உருவாக்க படும் 
...// பந்தின் ஆரையை மாற்றி கொள்ளவும் 

int numberOfBalls = box.numberOfSphere(ball); // பந்துகளின் எண்ணிக்கை கிடைக்கும்.

இதுதான் அடுத்த மறுபயனீடு வடிவம், மேல் நிலை வகுப்பிற்காக அமைக்கப்பட்ட செயலியை  அவற்றின் வாரிசு வகுப்புகளுக்கும் பயன்படுத்தலாம். இதனை பல்லுறுத்தோற்ற (Polymorphism) மறுபயனீடு என்கிறோம். அதாவது, இயக்கநிலையில் இந்த செயலிக்கு அதன் கோளம் சுட்டளவு பலவகை பொருட்களாக அமையும் அல்லது தோன்றும். இதுவே அதிகப்படியான பயன்பாடு உடைய மறுபயனீடு. கோளங்களை பயன்படுத்துவதன் மூலம் தூண்டகூடிய அதிக செயலிகளை அமைத்திருப்போம். அவை அனைத்தையும் இப்போது பந்துகளுக்கும் பாவிக்கமுடியும் அல்லது கோளத்தின் அனைத்து வாரிசுகளுக்கும் பாவிக்கமுடியும்.

இனி பல்முக வாரிசுப்படுத்தலை பார்ப்போம். இதற்கு, கூடுதலாக, பழங்களை உதாரணமாக எடுப்போம். பழம் வகுப்பு ஒன்றையும், குளிரூட்டி வகுப்பு ஒன்றையும் ஏற்கனவே அமைத்துவிட்டோம் என எடுத்துகொள்வோம். குளிரூட்டி வகுப்பில் ஒரு செயலி ஒன்றையும் அமைத்திருக்கிறோம், அதனை பயன்படுத்தி, குறிப்பிட்ட பழம் எத்தனை நாட்கள் அக் குளிரூட்டியில் வைக்ககாம் என்று அறியலாம். 

class Fruit{...} // பழம் வகுப்பு 

class Refrigerator{ // குளிரூட்டி வகுப்பு 

public int numberOfDays(Fruit fruit){...} // செயலி 

}

Fruit fruit = new Fruit(); // பழம் ஒன்று உருவாக்கப்படும் 
...// பழத்தின் பண்புகளை மாற்றி கொள்ளவும் 

Refrigerator refrigerator = new Refrigerator(); // குளிரூட்டி ஒன்று உருவாக்கப்படும் 
..//குரிரூட்டியின் பண்புகளை மாற்றி கொள்ளவும் 

int numberOfDays = refrigerator.numberOfDays(fruit); // நாட்களின் எண்ணிக்கை கிடைக்கும்.

இப்போது தோடம்பழம் வகுப்பு ஒன்றை உருவாக்க வேண்டும் என எடுத்துகொள்வோம். இயற்கையில் தோடை ஒரு பழம், அத்துடன் அது கொளவடிவானது. ஆகவே இதனை பழம் வகுப்பின் வாரிசாகவும், கோளம் வகுப்பின் வாரிசாகவும் அமைத்துக்கொள்ளலாம். இதனால் பழங்களின் பண்புக்கூறும் அவைசார் செயலிகளும், கோளத்தின் பண்புக்கூறும் அவைசார் செயலிகளும் தோடைக்கு கிடைத்துவிடும். அதுமட்டுமில்லை, பெட்டியில் உள்ளது போன்ற மற்றும் குளிரூட்டியில் உள்ளது போன்ற பழம் அல்லது கோளத்தை உள்வாங்கும் செயலிகளையும் பாவிக்கமுடியும். அதாவது, எத்தனை நாட்கள் வைக்கலாம்? என்றும் எத்தனை பழம் வைக்கலாம்? என்றும் அறிந்து கொண்டுவிடலாம். 

இங்கே ஒன்றுக்கு மேற்பட்ட மேல்நிலை வகுப்புகளில் இருந்து ஒரு வாரிசு வகுப்பு உருவாக்க படுகிறது, இது பல்முக வாரிசுப்படுத்தல் ஆகும். ஆனால் இம்முறை ஜாவாவின் வகுப்புகளுக்கு செய்துவிட முடியாது. அதற்கு முற்பட்ட காலத்தில் இருந்த சீ++ போன்ற மொழிகளில் இருந்தது. இதற்காக, ஜாவாவில் இடைமுகங்களை அறிமுகப்படுத்தினர்.

இடைமுகங்கள் என்பது, செயலிகளின் அடையாள குறியீடுகளை மட்டுமே கொண்டிருக்கும். அதாவது, செயலிகளின் உடலை அமைத்துக்கொள்ள வேண்டியதில்லை. ஆனால், வகுப்பு ஒன்றிக்கு இடைமுகம் ஒன்றை அமைத்துகொள்ளும் போது, அவ் இடைமுகத்தில் உறுதிபடுத்தப்பட்ட செயலிகளை அமைத்துக்கொள்ளவேண்டும். அத்துடன்,

1 . வகுப்பு ஒன்றுக்கு, ஒன்றுக்குமேற்பட்ட இடைமுகங்களை அமைத்துக்கொள்ளலாம்.

2 .இடைமுகங்களை, வேறு ஒரு இடைமுகத்திலிருந்தோ அல்லது ஒன்றுக்கு மேற்பட்ட இடைமுகங்களிலிருந்தோ வாரிசுப்படுத்திக்கொள்ளலாம்.

3 .இடைமுகத்தின் சுட்டுக்குறி ஒன்றால், அவ் இடைமுகத்தை அமைத்துக்கொண்ட வகுப்பின் பொருள் அனைத்தையும் சுட்டிக்கொள்ளலாம்.

இப்போது, இந்த இடைமுகங்களின் அறிமுகத்துடன் கோளம், பெட்டி ஆகிய வகுப்புகளை மேம்படுத்திக்கொள்வோம்.

கோளம் இடைமுகம் ஒன்றை அமைப்போம்.

interface ISphere{ // கோளம் இடைமுகம் 
float getRadius(); // ஆரை அறிவிக்கும் செயலியின் வரையறை 
}

பெட்டி வகுப்பின் செயலியை இப்போது கீழ்க்கண்டவாறு மாற்றி அமைத்து கொள்ளலாம். முன்பு  செயலியின் சுட்டளவாக கோளம் வகுப்பு இருந்தது, இப்போது அதை கோளம் இடைமுகமாக மாற்றி அமைப்போம்.

public int numberOfSphere(ISphere sphere){ // செயலின் சுட்டளவு கோளம் இடைமுகம் 
        // கோளம் இடைமுகம் சுட்டளவைகொண்டு ஆரை அறிந்து கொள்ளலாம் 
int diameter = sphere.getRadius();
return (int)width/diameter*(int)length/diameter*(int) height/diameter;
}

சரி, இப்போது இந்த செயலியை கொளங்களுக்கோ அல்லது அவற்றின் வாரிசுகளுக்கோ பாவித்துகொள்வதற்கு கோளம் வகுப்பை கீழுள்ளவாறு மாற்றியமைக்க வேண்டும்.

class Sphere implements ISphere{ // கோளம் வகுப்பு , கோளம் இடைமுகத்தை அமைத்து கொள்கிறது.
.......

/**
இடைமுகத்தில் உறுதிப்படுத்தபட்ட செயலி அமைக்கப்பட்டுள்ளது.
**/


public float getRadius(){
return radius;
}
........

}

இப்பொழுது, ஒரு பெட்டியினுள் வைக்ககூடிய கோளங்களின், பந்துகளின் எண்ணிக்கையை முன்பு செய்ததுபோலவே அறிந்துகொள்ளலாம். அவ் நிரலாக்கத்தில் எந்த மாற்றமும் இல்லை.

int numberOfSphere = box.numberOfSphere(sphere); // கோளங்களின் எண்ணிக்கை கிடைக்கும்.
int numberOfBalls = box.numberOfSphere(ball); // பந்துகளின் எண்ணிக்கை கிடைக்கும்.

இயக்கநிலையில், பெட்டியின் செயலி கோளம் இடைமுகத்தில் வரையறை செய்யப்பட்ட செயலிகளின் ஊடாக கோளத்தின் ஆரையை அறிந்துகொள்கிறது, அதாவது, இடைமுகங்கள் இயக்கநிலையில் பொருளுக்கும் செயலிக்கும் ஒரு இடைமுகமாக தொழில்படுகிறது.

இப்போது, தோடை வகுப்பை பார்ப்போம், பெட்டி ஒன்றினுள் வைக்ககூடிய தோடை பழங்களின் எண்ணிக்கையை அறிவதுக்கு தோடை வகுப்புக்கு கோளம் இடைமுகத்தை அமைத்து கொள்ளவேண்டும், அத்துடன் ஆரை பண்புகூறை அறியும் செயலியை அமைக்கவேண்டும். அதாவது, ஆரை பண்புகூறு, அது சார்ந்த செயலிகளை அமைத்துக்கொள்ளவேண்டும்.


class Orange extends Fruit implements ISphere{
private float radius;
public float getRadius(){
return radius;
}
public void setRadius(float radius){
this.radius = radius;
}
}


தோடை ஒரு கோள வடிவான பழம், இது பல்முக வாரிசுப்படுத்தல், ஜாவாவில் இது வகுப்புகளில் செய்துவிட முடியாது. ஆனால் இடைமுங்களின் உதவியுடன் அடைந்துவிட முனைகிறோம். எனவே, தோடையை பழத்தின் வாரிசாக அமைத்து கோளம் இடைமுகத்தை அமைத்திருக்கிறோம். அதனால் ஆரை பண்புகூறு சார்ந்தவற்றை மீள அமைக்கவேண்டி இருந்தது. அதாவது, மரபியல்பு மறுபயனீடு கிடைக்கவில்லை. ஆனால் இப்போதும் கீழ் காண்பதுபோல் பெட்டி வகுப்பின் செயலியை தோடைப்பழங்களுக்கும் பாவிக்கலாம்.


Orange orange = new Orange(); // தோடை ஒன்று உருவாக்கப்படும் 
...//தோடையின் பண்புகளை மாற்றி கொள்ளவும் 
int numberOfOranges = box.numberOfSphere(orange); // தோடைகளின் எண்ணிக்கை கிடைக்கும் 


அதாவது, பல்லுறுத்தோற்ற மறுபயனீடு இப்போதும் சாத்தியமாகும். முன்பு சொன்னதுபோல் இந்த மறுபயனீடுதான் அதிக பயனுள்ளது. எம்மால் அமைத்துகொள்ளப்படும் வகுப்புகளின் செயலிகளுக்கு மட்டும் அல்லாது, மூன்றாம் நபர்கள் அமைத்துக்கொள்ளும் வகுப்புகளின் செயலிகளையும் எமது வகுப்புகளுக்கு பயன்படுத்தி கொள்ளலாம். மரபியல்பு மறுபயனீடு கிடைக்கவில்லை எனின் அதனை அமைத்துகொள்வது கடினம் இல்லை, ஏனெனில் அது எமது புதிய வகுப்பு சார்ந்தது. அவ் வகுப்பை பற்றி முழுமையாக ஆராய்ந்தால் அமைத்துக்கொள்வது சுலபம். அதாவது தோடை வகுப்பில் ஆரை சார்ந்த அமைப்புகள் சுலபமானது. ஆனால், பெட்டி வகுப்பு அல்லது அதுபோன்ற எத்தனையோ வகுப்புகளை மீள அமைப்பது என்பது கடினம்.


தோடையை கோளத்தின் வாரிசாக மட்டும் அமைத்துவிட்டிருக்கலாமே என்று தோன்றுகிறதா? அடுத்த நிரலாக்கவரியை பாருங்கள். அவ்வாறு செய்தால் இது சாத்தியமாகாது.


int numberOfDays = refrigerator.numberOfDays(orange);
// தோடை வைக்க கூடிய நாட்களின் எண்ணிக்கை கிடைக்கும்.


அதாவது பழங்களை பாவித்து அமைக்கபட்ட செயலிகளையும் நாம் மறுபயனீடு செய்யவேண்டும்  அல்லவா? அப்படியானால் தோடையை பழத்தின் வாரிசாக அமைத்தே ஆகவேண்டும்.


அதுமட்டும் இல்லை, கோளம் இடைமுகத்தை அறிமுகம் செய்ததன் மூலம் எப்படி பெட்டி வகுப்பின் மறுபயனீடு அதிகரிக்கசெய்யபட்டதோ அதே போன்று பழம் இடைமுகங்களை அறிமுகம் செய்து குளிரூட்டியின் மறுபயனீடும் அதிகரிக்க செய்வது நல்லது.


முடிவாக, ஜாவாவில் அறிமுகமான இலகுபடுத்தபட்ட வாரிசுப்படுத்தளினால் வகுப்புகளுக்கு பல்முக வாரிசுப்படுத்தல் செய்யமுடியாது, இதனால் மரபியல்பு மறுபயனீடை இழந்துவிட்டோம், எனினும் இடைமுகங்களின் உதவியுடன் மிகவும் முக்கியமான பல்லுறுத்தோற்ற மறுபயனீடை பெற்றுவிட முடியும். எனவே முடிந்த அளவு இடைமுங்களை பாவித்து அதிக மறுபயனீடு கொண்ட நிரலாக்கங்களை அமைத்துகொள்வோம்.

தமிழ் அழகு !

தமிழ் ஒரு அழகான மொழி என்று பலர் கூறிக் கேட்டிருக்கிறேன். என்னை கவர்ந்த சிலவற்றை இங்கே தொகுப்போம் என்று நினைக்கிறன்.

வளைக்குள் இருந்த நண்டு வலைக்குள் போனது.

மழைக்கு நல்ல குடையென மலை பிடித்த கண்ணனாம்.

கண்ணில் ஒரு வலி இருந்தால் கனவுகள் வருவதில்லை - அதேபோல் 

கண்ணில் ஒரு வழி தெரிந்தால் கனவுகள் தேவையில்லை.

அழகு! கிளி அலகு.

குழல் ஊதும் கண்ணன்
குளளில் பூ சூடினான்.

வணக்கம்

கடந்த சில வருடங்களாக ஆங்கிலத்தில் வலை பதிவுகளை எழுதிவருகிறேன். அடிப்படையில் நான் ஒரு பொறியியலாளர் என்பதால், கூடுதலாக தொழில்நுட்பம் சார்ந்த விடையங்களையும், அவ்வப்போது கவிதா என்ற பெயரில் ஓரிரண்டு தமிழ் பதிவுலும் எழுதி வந்தேன். 

எப்படியும் ஒருநாள் திரும்பி போறதுதானே

எப்படியும் ஒருநாள் எம் முற்றம் மிதிப்போம்தானே!

மாற்றம் 

சுத்தியல் 

இன்றில் இருந்து தமிழ் பதிவுகளை இங்கே எழுத தொடங்குகிறேன். கவிதைகள், கதைகள் என்று 

மட்டுமல்லாமல் தொழில்நுட்ப விடையங்களையும் எழுதபோகிறேன். 

முடிந்தால், நான் ஏற்கனவே எழுதிய ஆங்கில பதிவுகளையும் தமிழிலும் எழுத முனைகிறேன்.

உங்கள் பாடு கஷ்டம்தான்!.