జావాలో యాక్సెసర్లు మరియు మ్యుటేటర్లు

మేము ఈ భావనలోకి ప్రవేశించే ముందు, మీరు జావాలో తరగతులు మరియు ఎన్‌క్యాప్సులేషన్ గురించి తెలుసుకోవాలి .

జావాలో ఎన్‌క్యాప్సులేషన్

ఎన్‌క్యాప్సులేషన్, పేరు సూచించినట్లుగా, డేటా మరియు పద్ధతులను ఒకే యూనిట్‌గా చేర్చే ప్రక్రియ. ఆబ్జెక్ట్ - ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో , క్లాస్‌లోని డేటా మెంబర్‌లకు నేరుగా యాక్సెస్‌ని పరిమితం చేయడానికి ప్రైవేట్‌గా చేస్తారు. కాబట్టి ఎన్‌క్యాప్సులేటెడ్ డేటా సభ్యులను సరిగ్గా నిర్వచించిన మార్గం లేకుండా తిరిగి పొందడం లేదా సవరించడం సాధ్యం కాదు. దీని కోసం, మేము జావాలో యాక్సెసర్ మరియు మ్యుటేటర్ పద్ధతులను నిర్వచించాము. ఈ పద్ధతులను వివరంగా పరిశీలిద్దాం.

జావాలో యాక్సెసర్‌లు మరియు మ్యుటేటర్‌లు అంటే ఏమిటి?

యాక్సెసర్లు

యాక్సెసర్ పద్ధతి పేరు “ యాక్సెస్ ” అనే పదం ద్వారా నడపబడుతుంది, ఇది తరగతిలోని ప్రైవేట్ సమాచారాన్ని యాక్సెస్ చేయడానికి వినియోగదారుని అనుమతిస్తుంది. మీరు ఎప్పుడైనా “ గెట్ ” పద్ధతి లేదా “ గెట్టర్స్ ” గురించి విన్నట్లయితే , ఇది యాక్సెసర్‌ల మాదిరిగానే ఉంటుంది. పొందేవారు తరగతి పరిధి వెలుపల యాక్సెస్ చేయడానికి ప్రైవేట్ వేరియబుల్స్ మరియు స్థిరాంకాలను తిరిగి పొందుతారు.

వాక్యనిర్మాణం

మేము జావా యాక్సెసర్‌ల కోసం “ గెట్ ” అనే కీవర్డ్‌ని ఉపయోగిస్తాము . వేరియబుల్ “ పేరు ”ని యాక్సెస్ చేయడానికి మనం ఈ క్రింది గెటర్ getName()ని ఉపయోగించవచ్చు . యాక్సెసర్ పద్ధతి యొక్క ఉదాహరణ కోసం, కింది వాటిని చూడండి.

public class Student {

	private String name;
	
	public String getName() {
		return name;
	}
}

మెథడ్ సిగ్నేచర్‌లోని వేరియబుల్ పేరుకు ముందు ప్రతి గెటర్ కీవర్డ్ “ గెట్ ” అని మరియు రిటర్న్ రకం రిటర్న్ చేయాల్సిన వేరియబుల్ మాదిరిగానే ఉంటుందని దయచేసి గమనించండి. వేరియబుల్ “ పేరు ” “ స్ట్రింగ్ ” రకానికి చెందినది కాబట్టి, గెటర్/యాక్సెసర్ పద్ధతి కూడా “ స్ట్రింగ్ ”ని అందిస్తుంది.

మ్యుటేటర్స్

జావాలోని మ్యుటేటర్ పద్ధతి "మ్యుటేట్" అనే పదం ద్వారా నడపబడుతుంది, దీని అర్థం సవరించడం. ఉత్పరివర్తనలు వినియోగదారులను క్లాస్ ఆబ్జెక్ట్ యొక్క ప్రైవేట్ వేరియబుల్స్ విలువను సెట్ చేయడానికి/మ్యుటేషన్ చేయడానికి అనుమతిస్తాయి. ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ సందర్భంలో, “ సెట్ ” పద్ధతి లేదా “ సెట్టర్‌లు ” కూడా మ్యుటేటర్‌లుగా పిలువబడతాయి. ప్రైవేట్ డేటా సభ్యులను నేరుగా సవరించడం సాధ్యం కాదు కాబట్టి సెట్టర్‌లు ఎన్‌క్యాప్సులేషన్‌ను సులభతరం చేస్తాయి. కాబట్టి క్లాస్ స్కోప్ వెలుపల వేరియబుల్ విలువను అప్‌డేట్ చేయడానికి సెట్టర్ పద్ధతులు/మ్యుటేటర్‌లు ఉపయోగించబడతాయి.

వాక్యనిర్మాణం

మ్యుటేటర్ల కోసం, మేము " సెట్ " కీవర్డ్‌ని ఉపయోగిస్తాము. ప్రతి సెట్టర్ "సెట్" అనే కీవర్డ్ ద్వారా నిర్వచించబడుతుంది, దాని తర్వాత మ్యుటేషన్ చేయాల్సిన వేరియబుల్ పేరు ఉంటుంది. ఇక్కడ, మేము స్ట్రింగ్ టైప్ వేరియబుల్‌ను పారామీటర్‌గా తీసుకునే సెట్‌నేమ్ () సెట్టర్‌ని ఉపయోగిస్తాము.

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 ద్వారా స్వయంచాలకంగా గెట్టర్‌లు మరియు సెట్టర్‌లను జోడించే మార్గాలను కనుగొనవచ్చు. కనుగొని మాకు తెలియజేయండి!