ஜாவாவில் ஆக்சஸர்கள் மற்றும் மியூடேட்டர்கள்

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

ஜாவாவில் இணைத்தல்

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

ஜாவாவில் ஆக்சஸர்கள் மற்றும் மியூட்டர்கள் என்றால் என்ன?

அணுகல்கள்

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

தொடரியல்

ஜாவா ஆக்சஸர்களுக்கு " கெட் " என்ற முக்கிய சொல்லைப் பயன்படுத்துகிறோம் . " பெயர் " மாறியை அணுக, பின்வரும் getName()ஐப் பயன்படுத்தலாம் . அணுகல் முறையின் உதாரணத்திற்கு, பின்வருவனவற்றைப் பாருங்கள்.

public class Student {

	private String name;

	public String getName() {
		return name;
	}
}

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

பிறழ்வுகள்

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

தொடரியல்

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

public class Student {

	private String name;

	public void setName(String name) {
		this.name = name;
	}
}

நமக்கு ஏன் அணுகல்கள் மற்றும் பிறழ்வுகள் தேவை?

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

அணுகல் மற்றும் பிறழ்வு எடுத்துக்காட்டுகள்

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

உதாரணமாக

import java.util.Arrays;

public class Student {

	private String name;
	private Integer ID;
	private String DOB;
	private double GPA;
	private String[] courses;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getID() {
		return ID;
	}

	public void setID(Integer iD) {
		this.ID = iD;
	}

	public String getDOB() {
		return DOB;
	}

	public void setDOB(String dOB) {
		this.DOB = dOB;
	}

	public double getGPA() {
		return GPA;
	}

	public void setGPA(double gPA) {
		this.GPA = gPA;
	}

	public String[] getCourses() {
		return courses;
	}

	public void setCourses(String[] courses) {
		this.courses = courses;
	}

	public static void main(String[] args) {

		Student student1 = new Student();

		System.out.println("Student Bio [ Before using Accessors & Mutators ]");

		// calling accessor methods
		System.out.print("Name: " + student1.getName());
		System.out.print("\tID: " + student1.getID());
		System.out.print("\tGPA: " + student1.getGPA());
		System.out.print("\tDOB: " + student1.getDOB());
		System.out.println("\tCourses: " +  Arrays.toString(student1.getCourses()));

		// calling mutator methods
		student1.setName("Alex Coy");
		student1.setID(3115);
		student1.setGPA(2.79);
		student1.setDOB("08/08/1998");
		String[] courses = { "Object Oriented Programming", "Cryptography", "Photography", "Network Security" };
		student1.setCourses(courses);

		System.out.println("\nStudent Bio [ After using Mutators & Accessors ]");

		// calling accessor methods
		System.out.print("Name: " + student1.getName());
		System.out.print("\tID: " + student1.getID());
		System.out.print("\tGPA: " + student1.getGPA());
		System.out.print("\tDOB: " + student1.getDOB());
		System.out.println("\tCourses: " + Arrays.toString(student1.getCourses()));
	}
}

வெளியீடு

முடிவுரை

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