హాయ్! గత పాఠాలలో, మేము ఇంటర్‌ఫేస్‌లను కలుసుకున్నాము మరియు అవి దేనికి సంబంధించినవి అని కనుగొన్నాము. నేటి అంశం మునుపటిది ప్రతిధ్వనిస్తుంది. జావాలో వియుక్త తరగతుల గురించి మాట్లాడుకుందాం .![జావాలోని వియుక్త తరగతులకు నిర్దిష్ట ఉదాహరణలు - 1]()
![జావాలోని వియుక్త తరగతులకు నిర్దిష్ట ఉదాహరణలు - 2]()
ఈ 'గందరగోళం' కారణంగా, ఆ వస్తువు ఎలాంటి ప్రవర్తనను ప్రదర్శించాలో తెలియక, జావా సృష్టికర్తలు బహుళ వారసత్వాన్ని విడిచిపెట్టారు. అయినప్పటికీ, జావా తరగతులు బహుళ ఇంటర్‌ఫేస్‌లను అమలు చేయగలవని మీరు గుర్తుంచుకుంటారు. చెప్పాలంటే, మీ అధ్యయనాలలో, మీరు ఇప్పటికే కనీసం ఒక వియుక్త తరగతిని ఎదుర్కొన్నారు!
తరగతులను 'నైరూప్య' అని ఎందుకు అంటారు
'నైరూప్యత' అంటే ఏమిటో మీకు బహుశా గుర్తుండే ఉంటుంది — మేము ఇప్పటికే దాని మీదకు వెళ్ళాము. :) మీరు మర్చిపోతే, భయపడకండి. గుర్తుంచుకోండి: ఇది OOP యొక్క సూత్రం, ఇది తరగతులను రూపకల్పన చేసేటప్పుడు మరియు వస్తువులను సృష్టించేటప్పుడు, మేము ఎంటిటీ యొక్క ప్రధాన లక్షణాలను మాత్రమే గుర్తించి, మైనర్‌ను విస్మరించాలి. ఉదాహరణకు, మేము తరగతిని రూపొందిస్తున్నట్లయితే , మనకు ' ఎత్తుSchoolTeacher ' ప్రాపర్టీ అవసరం లేదు . నిజానికి, ఈ ఆస్తి ఉపాధ్యాయునికి అసంబద్ధం. కానీ మేము ఒక తరగతిని సృష్టిస్తున్నట్లయితే , వృద్ధి అనేది ఒక ముఖ్యమైన లక్షణం. కాబట్టి వినండి. ఒక వియుక్త తరగతిBasketballPlayerఅవి వచ్చినంత నైరూప్యమైనది — భవిష్యత్ తరగతుల సమూహానికి అసంపూర్తిగా ఉన్న 'ఖాళీ'. ఖాళీని అలాగే ఉపయోగించలేరు. ఇది చాలా 'రా'. కానీ ఇది నైరూప్య తరగతిని వారసత్వంగా పొందే భవిష్యత్ తరగతులచే కలిగి ఉండే నిర్దిష్ట స్థితి మరియు సాధారణ ప్రవర్తనను వివరిస్తుంది.
వియుక్త జావా తరగతుల ఉదాహరణలు
కార్లతో ఒక సాధారణ ఉదాహరణను పరిగణించండి:
public abstract class Car {
private String model;
private String color;
private int maxSpeed;
public abstract void gas();
public abstract void brake();
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getMaxSpeed() {
return maxSpeed;
}
public void setMaxSpeed(int maxSpeed) {
this.maxSpeed = maxSpeed;
}
}
public class Sedan extends Car {
@Override
public void gas() {
System.out.println("The sedan is accelerating!");
}
@Override
public void brake() {
System.out.println("The sedan is slowing down!");
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car(); // Error! The Car class is abstract!
}
}
Carవియుక్తమైనది కాకపోతే, మేము దాని ఉదాహరణలను సులభంగా సృష్టించగలము:
public class Car {
private String model;
private String color;
private int maxSpeed;
public void gas() {
// Some logic
}
public void brake() {
// Some logic
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car(); // Everything is fine. A car is created.
}
}
Animal( నైరూప్య జంతువులు ). ఇది ఎలాంటి జంతువు, అది ఏ కుటుంబానికి చెందినది మరియు దాని లక్షణాలు ఏవి అనేది అస్పష్టంగా ఉంది. అది మీ ప్రోగ్రామ్‌లో చూస్తే వింతగా ఉంటుంది. ప్రకృతిలో 'నైరూప్య జంతువులు' లేవు. కేవలం కుక్కలు, పిల్లులు, నక్కలు, పుట్టుమచ్చలు మొదలైనవి. వియుక్త తరగతులు మనకు వియుక్త వస్తువుల నుండి బట్వాడా చేస్తాయి. అవి మనకు ప్రాథమిక స్థితిని మరియు ప్రవర్తనను అందిస్తాయి. ఉదాహరణకు, అన్ని కార్లు మోడల్ , రంగు మరియు గరిష్ట వేగం కలిగి ఉండాలి మరియు మీరు దరఖాస్తు చేయగలగాలిగ్యాస్ మరియు బ్రేక్ . అంతే. ఇది సాధారణ నైరూప్య ప్రణాళిక. తదుపరి మీరు మీకు అవసరమైన తరగతులను రూపొందించండి. గమనిక: అబ్‌స్ట్రాక్ట్ క్లాస్‌లోని రెండు పద్ధతులు కూడా అబ్‌స్ట్రాక్ట్‌గా పేర్కొనబడ్డాయి మరియు వాటికి ఎటువంటి అమలు లేదు. కారణం అదే: వియుక్త తరగతులు వియుక్త కార్ల కోసం డిఫాల్ట్ ప్రవర్తనను సృష్టించవు. ప్రతి కారు ఏమి చేయగలదో వారు సూచిస్తారు. అయినప్పటికీ, మీకు డిఫాల్ట్ ప్రవర్తన అవసరమైతే, మీరు వియుక్త తరగతిలో పద్ధతులను అమలు చేయవచ్చు. జావా దీన్ని నిషేధించలేదు:
public abstract class Car {
private String model;
private String color;
private int maxSpeed;
public void gas() {
System.out.println("Gas!");
}
public abstract void brake();
// Getters and setters
}
public class Sedan extends Car {
@Override
public void brake() {
System.out.println("The sedan is slowing down!");
}
}
public class Main {
public static void main(String[] args) {
Sedan sedan = new Sedan();
sedan.gas();
}
}
Sedanతరగతి ప్రవర్తన రెండు భాగాలుగా విభజించబడింది: మీరు పద్ధతిని కాల్ చేస్తే gas(), కాల్ అబ్‌స్ట్రాక్ట్ పేరెంట్ క్లాస్ వరకు 'పెరుగుతుంది' Car, కానీ మేము క్లాస్‌లో brake()పద్ధతిని ఓవర్‌రోడ్ చేసాము Sedan. ఇది చాలా సౌకర్యవంతంగా మరియు ఫ్లెక్సిబుల్‌గా మారుతుంది. కానీ ఇప్పుడు మా క్లాస్ అంత వియుక్తమైనది కాదా ? అన్నింటికంటే, దాని పద్ధతులు సగం అమలు చేయబడ్డాయి. ఇది నిజానికి చాలా ముఖ్యమైన లక్షణం - ఒక తరగతి కనీసం దాని పద్ధతుల్లో ఏదైనా వియుక్తంగా ఉంటే అది వియుక్తమైనది. రెండు పద్ధతుల్లో ఒకటి, లేదా కనీసం వెయ్యి పద్ధతుల్లో ఒకటి - దీనికి తేడా లేదు. మేము అన్ని పద్ధతులను కూడా అమలు చేయవచ్చు మరియు వాటిలో దేనినీ వియుక్తంగా ఉంచకూడదు. అప్పుడు అది నైరూప్య పద్ధతులు లేని నైరూప్య తరగతి అవుతుంది. సూత్రప్రాయంగా, ఇది సాధ్యమే, మరియు కంపైలర్ లోపాలను సృష్టించదు, కానీ దానిని నివారించడం మంచిది: నైరూప్య పదం దాని అర్థాన్ని కోల్పోతుంది మరియు మీ తోటి ప్రోగ్రామర్లు చాలా ఆశ్చర్యపోతారు :/ అదే సమయంలో, ఒక పద్ధతిని గుర్తించినట్లయితే అబ్‌స్ట్రాక్ట్ అనే పదంతో, ప్రతి చైల్డ్ క్లాస్ తప్పనిసరిగా దానిని అమలు చేయాలి లేదా వియుక్తంగా ప్రకటించాలి. లేకపోతే, కంపైలర్ లోపాన్ని సృష్టిస్తుంది. వాస్తవానికి, ప్రతి తరగతి ఒక వియుక్త తరగతిని మాత్రమే వారసత్వంగా పొందగలదు, కాబట్టి వారసత్వం పరంగా వియుక్త మరియు సాధారణ తరగతుల మధ్య తేడా లేదు. మనం ఒక అబ్‌స్ట్రాక్ట్ క్లాస్‌ని లేదా ఆర్డినరీ క్లాస్‌ని వారసత్వంగా పొందినా పర్వాలేదు, పేరెంట్ క్లాస్ ఒక్కటే ఉంటుంది.
జావాకు బహుళ వారసత్వ తరగతులు ఎందుకు లేవు
జావాకు బహుళ వారసత్వం లేదని మేము ఇప్పటికే చెప్పాము, కానీ మేము నిజంగా ఎందుకు అన్వేషించలేదు. ఇప్పుడు అలా చేయడానికి ప్రయత్నిద్దాం. వాస్తవం ఏమిటంటే, జావాకు బహుళ వారసత్వం ఉంటే, పిల్లల తరగతులు వారు ఏ నిర్దిష్ట ప్రవర్తనను ఎంచుకోవాలో నిర్ణయించలేరు. మనకు రెండు తరగతులు ఉన్నాయని అనుకుందాం -Toasterమరియు NuclearBomb:
public class Toaster {
public void on() {
System.out.println("The toaster is on. Toast is being prepared!");
}
public void off() {
System.out.println("The toaster is off!");
}
}
public class NuclearBomb {
public void on() {
System.out.println("Boom!");
}
}
on()పద్ధతి ఉంది. టోస్టర్ కోసం, అది కాల్చడం ప్రారంభమవుతుంది. అణు బాంబు కోసం, అది పేలుడును ఏర్పాటు చేస్తుంది. అయ్యో: / ఇప్పుడు మీరు మధ్యలో ఏదైనా సృష్టించాలని నిర్ణయించుకున్నారని (నన్ను ఎందుకు అడగవద్దు!) ఊహించుకోండి. అందువలన మీకు MysteriousDeviceతరగతి ఉంది! ఈ కోడ్, వాస్తవానికి, పని చేయదు మరియు మేము దీనిని 'కానీ అది కావచ్చు' ఉదాహరణగా మాత్రమే అందిస్తాము:
public class MysteriousDevice extends Toaster, NuclearBomb {
public static void main(String[] args) {
MysteriousDevice mysteriousDevice = new MysteriousDevice();
mysteriousDevice.on(); // So what should happen here? Do we get toast or a nuclear apocalypse?
}
}
on()పద్ధతులు ఉన్నాయి. ఫలితంగా, మేము on()పద్ధతిని పిలిస్తే, ఆబ్జెక్ట్‌పై ఏది ఉపయోగించాలో అస్పష్టంగా ఉంటుంది MysteriousDevice. వస్తువు ఎప్పుడూ తెలుసుకునే మార్గం లేదు. మరియు అన్నింటినీ అధిగమించడానికి: NuclearBombకి ఒక పద్ధతి లేదు off(), కనుక మనం సరిగ్గా ఊహించకపోతే, పరికరాన్ని నిలిపివేయడం అసాధ్యం. 
ఈ 'గందరగోళం' కారణంగా, ఆ వస్తువు ఎలాంటి ప్రవర్తనను ప్రదర్శించాలో తెలియక, జావా సృష్టికర్తలు బహుళ వారసత్వాన్ని విడిచిపెట్టారు. అయినప్పటికీ, జావా తరగతులు బహుళ ఇంటర్‌ఫేస్‌లను అమలు చేయగలవని మీరు గుర్తుంచుకుంటారు. చెప్పాలంటే, మీ అధ్యయనాలలో, మీరు ఇప్పటికే కనీసం ఒక వియుక్త తరగతిని ఎదుర్కొన్నారు!
public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar>
Calendarతరగతి. ఇది వియుక్తమైనది మరియు అనేక మంది పిల్లలను కలిగి ఉంది. వాటిలో ఒకటి GregorianCalendar. తేదీల గురించిన పాఠాల్లో మీరు దీన్ని ఇప్పటికే ఉపయోగించారు. :) ప్రతిదీ తగినంత స్పష్టంగా ఉంది. కేవలం ఒక ప్రశ్న మాత్రమే ఉంది: ఏమైనప్పటికీ నైరూప్య తరగతులు మరియు ఇంటర్‌ఫేస్‌ల మధ్య ప్రాథమిక వ్యత్యాసం ఏమిటి? భాషని ఒకదానికి పరిమితం చేయకుండా జావాకు రెండింటినీ ఎందుకు జోడించారు? అన్ని తరువాత, అది పూర్తిగా సరిపోయేది. మేము దీని గురించి తదుపరి పాఠంలో మాట్లాడుతాము ! అప్పటివరుకు :)
GO TO FULL VERSION