OOP యొక్క సూత్రాలు

జావా ఒక వస్తువు-ఆధారిత భాష. అంటే మీరు ఆబ్జెక్ట్-ఓరియెంటెడ్ పారాడిగ్మ్‌ని ఉపయోగించి జావా ప్రోగ్రామ్‌లను వ్రాయాలి. మరియు ఈ నమూనా మీ ప్రోగ్రామ్‌లలో వస్తువులు మరియు తరగతులను ఉపయోగించడాన్ని కలిగి ఉంటుంది. తరగతులు మరియు వస్తువులు ఏమిటో అర్థం చేసుకోవడానికి ఉదాహరణలను ఉపయోగించి ప్రయత్నిద్దాం మరియు ఆచరణలో ప్రాథమిక OOP సూత్రాలను (నైరూప్యత, వారసత్వం, పాలిమార్ఫిజం మరియు ఎన్‌క్యాప్సులేషన్) ఎలా వర్తింపజేయాలి.

వస్తువు అంటే ఏమిటి?

మనం జీవిస్తున్న ప్రపంచం వస్తువులతో నిర్మితమైంది. చుట్టూ చూస్తే, మన చుట్టూ ఇళ్లు, చెట్లు, కార్లు, ఫర్నీచర్, వంటకాలు మరియు కంప్యూటర్లు ఉన్నాయి. ఈ విషయాలన్నీ వస్తువులు మరియు వాటిలో ప్రతి ఒక్కటి నిర్దిష్ట లక్షణాలు, ప్రవర్తనలు మరియు ప్రయోజనాల సమితిని కలిగి ఉంటాయి. మేము వస్తువులకు అలవాటు పడ్డాము మరియు మేము వాటిని ఎల్లప్పుడూ చాలా నిర్దిష్ట ప్రయోజనాల కోసం ఉపయోగిస్తాము. ఉదాహరణకు, మేము పనికి వెళ్లాలంటే, మేము కారును ఉపయోగిస్తాము. మనం తినాలంటే వంటలు వాడతాం. మరియు మేము విశ్రాంతి తీసుకోవాలనుకుంటే, మేము సౌకర్యవంతమైన సోఫాను కనుగొంటాము. దైనందిన జీవితంలో సమస్యలను పరిష్కరించడానికి మానవులు వస్తువుల పరంగా ఆలోచించడం అలవాటు చేసుకున్నారు. ప్రోగ్రామింగ్‌లో వస్తువులు ఉపయోగించబడటానికి ఇది ఒక కారణం. ఈ విధానాన్ని ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ అంటారు. ఒక ఉదాహరణ ఇద్దాం. మీరు కొత్త ఫోన్‌ని అభివృద్ధి చేసి, భారీ ఉత్పత్తిని ప్రారంభించాలనుకుంటున్నారని ఊహించుకోండి. ఫోన్ డెవలపర్‌గా, ఇది దేనికి సంబంధించినదో మీకు తెలుసు, ఇది ఎలా పని చేస్తుంది మరియు దాని భాగాలు ఏమిటి (బాడీ, మైక్రోఫోన్, స్పీకర్, వైర్లు, బటన్లు మొదలైనవి). అంతేకాదు, ఈ భాగాలను ఎలా కనెక్ట్ చేయాలో మీకు మాత్రమే తెలుసు. కానీ మీరు వ్యక్తిగతంగా ఫోన్‌లను తయారు చేయడానికి ప్లాన్ చేయరు — దీన్ని చేయడానికి మీకు మొత్తం వర్కర్ల బృందం ఉంది. ఫోన్ భాగాలను ఎలా కనెక్ట్ చేయాలో పదేపదే వివరించాల్సిన అవసరాన్ని తొలగించడానికి మరియు అన్ని ఫోన్‌లు ఒకే విధంగా తయారు చేయబడినట్లు నిర్ధారించుకోవడానికి, మీరు వాటిని ఉత్పత్తి చేయడం ప్రారంభించే ముందు, మీరు ఫోన్ ఎలా నిర్వహించబడుతుందో వివరించే డ్రాయింగ్‌ను రూపొందించాలి. OOPలో, మేము అటువంటి వివరణ, డ్రాయింగ్, రేఖాచిత్రం లేదా టెంప్లేట్‌ని క్లాస్ అని పిలుస్తాము. ప్రోగ్రామ్ నడుస్తున్నప్పుడు వస్తువులను సృష్టించడానికి ఇది ఆధారం. క్లాస్ అనేది నిర్దిష్ట రకం వస్తువుల వివరణ - ఫీల్డ్‌లు, పద్ధతులు మరియు కన్స్ట్రక్టర్‌తో కూడిన సాధారణ టెంప్లేట్ వంటిది. వస్తువు అనేది తరగతికి ఉదాహరణ.

సంగ్రహణ

వాస్తవ ప్రపంచంలోని వస్తువు నుండి ప్రోగ్రామ్‌లోని వస్తువుకు ఎలా మారవచ్చు అనే దాని గురించి ఇప్పుడు ఆలోచిద్దాం. మేము ఫోన్‌ని ఉదాహరణగా ఉపయోగిస్తాము. ఈ కమ్యూనికేషన్ సాధనానికి 100 సంవత్సరాలకు పైగా చరిత్ర ఉంది. ఆధునిక టెలిఫోన్ దాని 19వ శతాబ్దానికి పూర్వం కంటే చాలా క్లిష్టమైన పరికరం. ఫోన్‌ని ఉపయోగిస్తున్నప్పుడు, మేము దాని సంస్థ మరియు దాని లోపల జరిగే ప్రక్రియల గురించి ఆలోచించము. మేము ఫోన్ డెవలపర్‌లు అందించిన ఫంక్షన్‌లను ఉపయోగిస్తాము: ఫోన్ నంబర్‌ను నమోదు చేయడానికి మరియు కాల్‌లు చేయడానికి బటన్లు లేదా టచ్ స్క్రీన్. మొదటి ఫోన్ ఇంటర్‌ఫేస్‌లలో ఒకటి కాల్ చేయడానికి తిప్పాల్సిన క్రాంక్. వాస్తవానికి, ఇది చాలా సౌకర్యవంతంగా లేదు. కానీ అది తన విధిని దోషరహితంగా నెరవేర్చింది. మీరు అత్యంత ఆధునిక మరియు మొట్టమొదటి ఫోన్‌లను పోల్చినట్లయితే, మీరు 19వ శతాబ్దపు చివరి పరికరానికి మరియు ఆధునిక స్మార్ట్‌ఫోన్‌కు అత్యంత ముఖ్యమైన విధులను వెంటనే గుర్తించవచ్చు. అవి కాల్‌లు చేయగల సామర్థ్యం మరియు కాల్‌లను స్వీకరించగల సామర్థ్యం. వాస్తవానికి, ఇది ఫోన్‌ను ఫోన్‌గా చేస్తుంది మరియు మరేదైనా కాదు. ఇప్పుడు OOP సూత్రాన్ని వర్తింపజేయండి: వస్తువు యొక్క అత్యంత ముఖ్యమైన లక్షణాలు మరియు సమాచారాన్ని గుర్తించండి. ఈ సూత్రాన్ని నైరూప్యత అంటారు. OOPలో, నైరూప్యతను ప్రోగ్రామ్‌లోని వస్తువులుగా వాస్తవ-ప్రపంచ టాస్క్‌లోని అంశాలను సూచించే పద్ధతిగా కూడా నిర్వచించవచ్చు. సంగ్రహణ ఎల్లప్పుడూ ఒక వస్తువు యొక్క నిర్దిష్ట లక్షణాల సాధారణీకరణతో ముడిపడి ఉంటుంది, కాబట్టి ప్రధాన విషయం ఏమిటంటే, చేతిలో ఉన్న పని సందర్భంలో ముఖ్యమైన సమాచారం నుండి అర్ధవంతమైన సమాచారాన్ని వేరు చేయడం. అదనంగా, సంగ్రహణ యొక్క అనేక స్థాయిలు ఉండవచ్చు. వీలు' మా ఫోన్‌లకు సంగ్రహణ సూత్రాన్ని వర్తింపజేయడానికి ప్రయత్నించండి. ప్రారంభించడానికి, మేము అత్యంత సాధారణ రకాలైన ఫోన్‌లను గుర్తిస్తాము — మొదటి ఫోన్‌ల నుండి నేటి ఫోన్‌ల వరకు. ఉదాహరణకు, మేము వాటిని మూర్తి 1లోని రేఖాచిత్రం రూపంలో సూచించవచ్చు. సంగ్రహాన్ని ఉపయోగించి, మేము ఇప్పుడు ఈ ఆబ్జెక్ట్ సోపానక్రమంలోని సాధారణ సమాచారాన్ని గుర్తించగలము: సాధారణ నైరూప్య వస్తువు (టెలిఫోన్), టెలిఫోన్ యొక్క సాధారణ లక్షణాలు (ఉదా. అది సృష్టించిన సంవత్సరం) మరియు సాధారణ ఇంటర్‌ఫేస్ (అన్ని టెలిఫోన్‌లు కాల్‌లను స్వీకరించవచ్చు మరియు కాల్‌లు చేయగలవు). జావాలో ఇది ఎలా కనిపిస్తుందో ఇక్కడ ఉంది:

public abstract class AbstractPhone {
    private int year;

    public AbstractPhone(int year) {
        this.year = year;
    }
    public abstract void call(int outgoingNumber);
    public abstract void ring(int incomingNumber);
}

ప్రోగ్రామ్‌లో, మేము ఈ వియుక్త తరగతిని ఉపయోగించి కొత్త రకాల ఫోన్‌లను సృష్టించవచ్చు మరియు OOP యొక్క ఇతర ప్రాథమిక సూత్రాలను వర్తింపజేయవచ్చు, వీటిని మేము దిగువ విశ్లేషిస్తాము.

ఎన్కప్సులేషన్

సంగ్రహణతో, మేము అన్ని వస్తువులకు సాధారణమైన వాటిని గుర్తిస్తాము. కానీ ప్రతి రకమైన ఫోన్ ప్రత్యేకమైనది, ఏదో ఒకవిధంగా ఇతరులకు భిన్నంగా ఉంటుంది. ప్రోగ్రామ్‌లో, మేము సరిహద్దులను ఎలా గీయాలి మరియు ఈ వ్యక్తిత్వాన్ని ఎలా గుర్తించాలి? ఎవరూ అనుకోకుండా లేదా ఉద్దేశపూర్వకంగా మా ఫోన్‌ను విచ్ఛిన్నం చేయలేరు లేదా ఒక మోడల్‌ను మరొక మోడల్‌గా మార్చడానికి ప్రయత్నించకుండా ఎలా తయారు చేయాలి? వాస్తవ ప్రపంచంలో, సమాధానం స్పష్టంగా ఉంది: మీరు ఫోన్ కేసులో అన్ని భాగాలను ఉంచాలి. అన్నింటికంటే, మీరు చేయకపోతే — బదులుగా ఫోన్ యొక్క అన్ని అంతర్గత భాగాలను విడిచిపెట్టి మరియు వైర్‌లను వెలుపల కనెక్ట్ చేయండి — కొంతమంది ఆసక్తికరమైన ప్రయోగాత్మకులు ఖచ్చితంగా మా ఫోన్‌ను "మెరుగుపరచాలని" కోరుకుంటారు. అటువంటి టింకరింగ్‌ను నిరోధించడానికి, వస్తువు రూపకల్పన మరియు ఆపరేషన్‌లో ఎన్‌క్యాప్సులేషన్ సూత్రం ఉపయోగించబడుతుంది. ఈ సూత్రం ఒక వస్తువు యొక్క గుణాలు మరియు ప్రవర్తన ఒకే తరగతి, ఆబ్జెక్ట్‌లో మిళితం చేయబడిందని పేర్కొంది. యొక్క అంతర్గత అమలు వినియోగదారు నుండి దాచబడింది మరియు వస్తువుతో పని చేయడానికి పబ్లిక్ ఇంటర్‌ఫేస్ అందించబడుతుంది. ప్రోగ్రామర్ యొక్క విధి పబ్లిక్ యాక్సెస్ కోసం ఏ వస్తువు యొక్క గుణాలు మరియు పద్ధతులు అందుబాటులో ఉండాలి మరియు ప్రాప్యత చేయలేని అంతర్గత అమలు వివరాలు.

ఎన్కప్సులేషన్ మరియు యాక్సెస్ నియంత్రణ

ఫోన్‌ను తయారు చేసినప్పుడు దాని వెనుక భాగంలో (దాని ఉత్పత్తి సంవత్సరం లేదా తయారీదారు యొక్క లోగో) గురించిన సమాచారం చెక్కబడిందని అనుకుందాం. సమాచారం (దాని స్థితి) ఈ నిర్దిష్ట మోడల్‌కు ప్రత్యేకంగా ఉంటుంది. తయారీదారు ఈ సమాచారం మార్పులేనిదని నిర్ధారించుకున్నారని మేము చెప్పగలం - చెక్కిన దానిని తొలగించాలని ఎవరైనా భావించే అవకాశం లేదు. జావా ప్రపంచంలో, ఒక తరగతి ఫీల్డ్‌లను ఉపయోగించి భవిష్యత్ వస్తువుల స్థితిని వివరిస్తుంది మరియు వాటి ప్రవర్తన పద్ధతులను ఉపయోగించి వివరించబడుతుంది. ఫీల్డ్‌లు మరియు పద్ధతులకు వర్తించే మాడిఫైయర్‌లను ఉపయోగించి వస్తువు యొక్క స్థితి మరియు ప్రవర్తనకు యాక్సెస్ నియంత్రించబడుతుంది: ప్రైవేట్, రక్షిత, పబ్లిక్ మరియు డిఫాల్ట్. ఉదాహరణకు, ఉత్పత్తి సంవత్సరం, తయారీదారు పేరు మరియు పద్ధతుల్లో ఒకటి తరగతి యొక్క అంతర్గత అమలు వివరాలు మరియు ప్రోగ్రామ్‌లోని ఇతర వస్తువుల ద్వారా మార్చబడదని మేము నిర్ణయించుకున్నాము. కోడ్‌లో,

public class SomePhone {

    private int year;
    private String company;
    public SomePhone(int year, String company) {
        this.year = year;
        this.company = company;
    }
private void openConnection(){
    // findSwitch
    // openNewConnection...
}
public void call() {
    openConnection();
    System.out.println("Calling");
}

public void ring() {
    System.out.println("Ring-ring");
}

 }

ప్రైవేట్ మాడిఫైయర్ క్లాస్ ఫీల్డ్‌లు మరియు పద్ధతులను ఈ క్లాస్‌లో మాత్రమే యాక్సెస్ చేయడానికి అనుమతిస్తుంది. దీని అర్థం బయటి నుండి ప్రైవేట్ ఫీల్డ్‌లను యాక్సెస్ చేయడం అసాధ్యం, ఎందుకంటే ప్రైవేట్ పద్ధతులను పిలవలేము. ఓపెన్‌కనెక్షన్ పద్ధతికి ప్రాప్యతను పరిమితం చేయడం వలన పద్ధతి యొక్క అంతర్గత అమలును స్వేచ్ఛగా మార్చగల సామర్థ్యం కూడా మాకు లభిస్తుంది, ఎందుకంటే ఈ పద్ధతిని ఇతర వస్తువుల ద్వారా ఉపయోగించబడదని లేదా అంతరాయం కలిగించదని హామీ ఇవ్వబడింది. మా వస్తువుతో పని చేయడానికి, మేము పబ్లిక్ మాడిఫైయర్‌ని ఉపయోగించి అందుబాటులో ఉన్న కాల్ మరియు రింగ్ పద్ధతులను వదిలివేస్తాము. వస్తువులతో పని చేయడానికి పబ్లిక్ పద్ధతులను అందించడం కూడా ఎన్‌క్యాప్సులేషన్‌లో భాగం, ఎందుకంటే యాక్సెస్ పూర్తిగా నిరాకరించబడితే, అది పనికిరానిదిగా మారుతుంది.

వారసత్వం

ఫోన్‌ల రేఖాచిత్రాన్ని మరొకసారి చూద్దాం. ఇది ఒక మోడల్ దాని బ్రాంచ్‌తో పాటు ఎత్తులో ఉన్న మోడల్‌ల యొక్క అన్ని లక్షణాలను కలిగి ఉన్న ఒక సోపానక్రమం అని మీరు చూడవచ్చు మరియు దాని స్వంత వాటిలో కొన్నింటిని జోడిస్తుంది. ఉదాహరణకు, స్మార్ట్‌ఫోన్ కమ్యూనికేషన్ కోసం సెల్యులార్ నెట్‌వర్క్‌ను ఉపయోగిస్తుంది (సెల్ ఫోన్ యొక్క లక్షణాలను కలిగి ఉంటుంది), వైర్‌లెస్ మరియు పోర్టబుల్ (కార్డ్‌లెస్ ఫోన్ యొక్క లక్షణాలను కలిగి ఉంటుంది), మరియు కాల్‌లను స్వీకరించవచ్చు మరియు చేయవచ్చు (ఫోన్ యొక్క లక్షణాలను కలిగి ఉంటుంది). మనకు ఇక్కడ ఉన్నది వస్తువు లక్షణాల వారసత్వం. ప్రోగ్రామింగ్‌లో, వారసత్వం అంటే కొత్త వాటిని నిర్వచించడానికి ఇప్పటికే ఉన్న తరగతులను ఉపయోగించడం. స్మార్ట్‌ఫోన్ తరగతిని సృష్టించడానికి వారసత్వాన్ని ఉపయోగించడం యొక్క ఉదాహరణను పరిశీలిద్దాం. అన్ని కార్డ్‌లెస్ ఫోన్‌లు రీఛార్జ్ చేయగల బ్యాటరీల ద్వారా శక్తిని పొందుతాయి, ఇవి నిర్దిష్ట బ్యాటరీ జీవితాన్ని కలిగి ఉంటాయి. దీని ప్రకారం, మేము ఈ ఆస్తిని కార్డ్‌లెస్ ఫోన్ తరగతికి జోడిస్తాము:

public abstract class CordlessPhone extends AbstractPhone {

    private int hour;

    public CordlessPhone (int year, int hour) {
        super(year);
        this.hour = hour;
    }
    }

సెల్ ఫోన్‌లు కార్డ్‌లెస్ ఫోన్ యొక్క లక్షణాలను వారసత్వంగా పొందుతాయి మరియు మేము ఈ తరగతిలో కాల్ మరియు రింగ్ పద్ధతులను అమలు చేస్తాము:

public class CellPhone extends CordlessPhone {
    public CellPhone(int year, int hour) {
        super(year, hour);
    }

    @Override
    public void call(int outgoingNumber) {
        System.out.println("Calling " + outgoingNumber);
    }

    @Override
    public void ring(int incomingNumber) {
        System.out.println("Incoming call from " + incomingNumber);
    }
}

చివరకు, మేము స్మార్ట్ఫోన్ తరగతిని కలిగి ఉన్నాము, ఇది క్లాసిక్ సెల్ ఫోన్ల వలె కాకుండా, పూర్తి స్థాయి ఆపరేటింగ్ సిస్టమ్ను కలిగి ఉంది. మీరు దాని ఆపరేటింగ్ సిస్టమ్‌లో అమలు చేయగల కొత్త ప్రోగ్రామ్‌లను జోడించడం ద్వారా మీ స్మార్ట్‌ఫోన్ కార్యాచరణను విస్తరించవచ్చు. కోడ్‌లో, తరగతిని ఈ క్రింది విధంగా వర్ణించవచ్చు:

public class Smartphone extends CellPhone {

    private String operationSystem;

    public Smartphone(int year, int hour, String operationSystem) {
        super(year, hour);
        this.operationSystem = operationSystem;
    }
public void install(String program) {
    System.out.println("Installing " + program + " for " + operationSystem);
}

}

మీరు చూడగలిగినట్లుగా, మేము స్మార్ట్‌ఫోన్ తరగతిని వివరించడానికి కొంచెం కొత్త కోడ్‌ని సృష్టించాము , కానీ మేము కొత్త కార్యాచరణతో కొత్త తరగతిని పొందాము. OOP యొక్క ఈ సూత్రం అవసరమైన జావా కోడ్ మొత్తాన్ని గణనీయంగా తగ్గించడం సాధ్యం చేస్తుంది, తద్వారా ప్రోగ్రామర్‌కు జీవితాన్ని సులభతరం చేస్తుంది.

బహురూపత

వివిధ రకాల ఫోన్‌ల రూపాన్ని మరియు రూపకల్పనలో తేడాలు ఉన్నప్పటికీ, మేము కొన్ని సాధారణ ప్రవర్తనను గుర్తించగలము: అవన్నీ కాల్‌లను స్వీకరించగలవు మరియు చేయగలవు మరియు అన్నీ చాలా స్పష్టమైన మరియు సరళమైన నియంత్రణలను కలిగి ఉంటాయి. ప్రోగ్రామింగ్ పరంగా, సంగ్రహణ సూత్రం (మనకు ఇప్పటికే తెలిసినవి) ఫోన్ వస్తువులు సాధారణ ఇంటర్‌ఫేస్‌ని కలిగి ఉన్నాయని చెప్పనివ్వండి. అందుకే వ్యక్తులు పరికరం యొక్క సాంకేతిక వివరాలను లోతుగా పరిశోధించకుండా, ఒకే విధమైన నియంత్రణలు (మెకానికల్ బటన్‌లు లేదా టచ్‌స్క్రీన్) కలిగి ఉన్న వివిధ మోడళ్ల ఫోన్‌లను సులభంగా ఉపయోగించగలరు. అందువలన, మీరు నిరంతరం సెల్ ఫోన్‌ని ఉపయోగిస్తున్నారు మరియు మీరు మీ స్నేహితుని ల్యాండ్‌లైన్ నుండి సులభంగా కాల్ చేయవచ్చు. వస్తువు యొక్క అంతర్గత నిర్మాణం గురించి ఎటువంటి సమాచారం లేకుండా ఒక సాధారణ ఇంటర్‌ఫేస్‌తో వస్తువులను ప్రోగ్రామ్ ఉపయోగించవచ్చని చెప్పే OOP సూత్రాన్ని పాలిమార్ఫిజం అంటారు. వీలు' మరొక వినియోగదారుకు కాల్ చేయడానికి ఏదైనా ఫోన్‌ని ఉపయోగించగల వినియోగదారుని వివరించడానికి మా ప్రోగ్రామ్ అవసరమని ఊహించుకోండి. మేము దీన్ని ఎలా చేయాలో ఇక్కడ ఉంది:

public class User {
    private String name;

    public User(String name) {
        this.name = name;
            }

    public void callAnotherUser(int number, AbstractPhone phone){
// And here's polymorphism: using the AbstractPhone type in the code!
        phone.call(number);
    }
}
 }

ఇప్పుడు మనం అనేక రకాల ఫోన్‌లను వివరిస్తాము. మొదటి ఫోన్‌లలో ఒకటి:

public class ThomasEdisonPhone extends AbstractPhone {

public ThomasEdisonPhone(int year) {
    super(year);
}
    @Override
    public void call(int outgoingNumber) {
        System.out.println("Crank the handle");
        System.out.println("What number would you like to connect to?");
    }

    @Override
    public void ring(int incomingNumber) {
        System.out.println("The phone is ringing");
    }
}

సాధారణ ల్యాండ్‌లైన్ ఫోన్:

public class Phone extends AbstractPhone {

    public Phone(int year) {
        super(year);
    }

    @Override
    public void call(int outgoingNumber) {
        System.out.println("Calling " + outgoingNumber);
    }

    @Override
    public void ring(int incomingNumber) {
        System.out.println("The phone is ringing");
    }
}

చివరకు, ఒక చల్లని వీడియో ఫోన్:

public class VideoPhone extends AbstractPhone {

    public VideoPhone(int year) {
        super(year);
    }
    @Override
    public void call(int outgoingNumber) {
        System.out.println("Connecting video call to " + outgoingNumber);
    }
    @Override
    public void ring(int incomingNumber) {
        System.out.println("Incoming video call from " + incomingNumber);
    }
  }

మేము ప్రధాన() పద్ధతిలో వస్తువులను సృష్టిస్తాము మరియు callAnotherUser() పద్ధతిని పరీక్షిస్తాము:

AbstractPhone firstPhone = new ThomasEdisonPhone(1879);
AbstractPhone phone = new Phone(1984);
AbstractPhone videoPhone=new VideoPhone(2018);
User user = new User("Jason");
user.callAnotherUser(224466, firstPhone);
// Crank the handle
// What number would you like to connect to?
user.callAnotherUser(224466, phone);
// Calling 224466
user.callAnotherUser(224466, videoPhone);
// Connecting video call to 224466

వినియోగదారు ఆబ్జెక్ట్‌పై ఒకే పద్ధతిని కాల్ చేయడం వలన విభిన్న ఫలితాలు వస్తాయి. ప్రోగ్రామ్ రన్ అవుతున్నప్పుడు పాస్ చేయబడిన నిర్దిష్ట రకం ఆబ్జెక్ట్ ఆధారంగా callAnotherUser() పద్ధతిలో కాల్ పద్ధతి యొక్క నిర్దిష్ట అమలు డైనమిక్‌గా ఎంపిక చేయబడుతుంది . ఇది పాలిమార్ఫిజం యొక్క ప్రధాన ప్రయోజనం - రన్‌టైమ్‌లో అమలును ఎంచుకునే సామర్థ్యం. పైన ఇవ్వబడిన ఫోన్ క్లాస్‌ల ఉదాహరణలలో, మేము మెథడ్ ఓవర్‌రైడింగ్‌ని ఉపయోగించాము — మెథడ్ సిగ్నేచర్‌ని మార్చకుండా బేస్ క్లాస్‌లో నిర్వచించిన పద్ధతి యొక్క అమలును మార్చే ట్రిక్. ఇది తప్పనిసరిగా పద్ధతిని భర్తీ చేస్తుంది: ప్రోగ్రామ్ అమలు చేయబడినప్పుడు సబ్‌క్లాస్‌లో నిర్వచించబడిన కొత్త పద్ధతిని పిలుస్తారు. సాధారణంగా, మేము ఒక పద్ధతిని భర్తీ చేసినప్పుడు, @Overrideఉల్లేఖనం ఉపయోగించబడుతుంది. ఇది ఓవర్‌రైడ్ మరియు ఓవర్‌రైడింగ్ పద్ధతుల సంతకాలను తనిఖీ చేయమని కంపైలర్‌కు చెబుతుంది. చివరగా, మీ జావా ప్రోగ్రామ్‌లు OOP సూత్రాలకు అనుగుణంగా ఉన్నాయని నిర్ధారించుకోవడానికి, ఈ చిట్కాలను అనుసరించండి:

• వస్తువు యొక్క ప్రధాన లక్షణాలను గుర్తించడం;
• సాధారణ లక్షణాలు మరియు ప్రవర్తనను గుర్తించండి మరియు తరగతులను సృష్టించేటప్పుడు వారసత్వాన్ని ఉపయోగించండి;
• వస్తువులను వివరించడానికి నైరూప్య రకాలను ఉపయోగించండి;
• తరగతి అంతర్గత అమలుకు సంబంధించిన పద్ధతులు మరియు ఫీల్డ్‌లను ఎల్లప్పుడూ దాచడానికి ప్రయత్నించండి.