జావా పాలిమార్ఫిజం

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

జావాలో పాలిమార్ఫిజం అంటే ఏమిటి?

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

public class Dancer {
    private String name;
    private int age;

    public Dancer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void dance() {
        System.out.println(toString() + " I dance like everyone else.");
    }

    @Override
    public String toString() {
        Return "I'm " + name + ". I'm " + age + " years old.";
    }
}

సబ్‌క్లాస్‌లలో, బేస్ క్లాస్ పద్ధతిని భర్తీ చేయండి:

public class ElectricBoogieDancer extends Dancer {
    public ElectricBoogieDancer(String name, int age) {
        super(name, age);
    }
// Override the method of the base class
    @Override
    public void dance() {
        System.out.println(toString () + " I dance the electric boogie!");
    }
}

public class Breakdancer extends Dancer {

    public Breakdancer(String name, int age) {
        super(name, age);
    }
// Override the method of the base class
    @Override
    public void dance() {
        System.out.println(toString() + " I breakdance!");
    }
}

పాలీమార్ఫిజం యొక్క ఉదాహరణ మరియు ప్రోగ్రామ్‌లో ఈ వస్తువులు ఎలా ఉపయోగించబడతాయి:

public class Main {

    public static void main(String[] args) {
        Dancer dancer = new Dancer("Fred", 18);

        Dancer breakdancer = new Breakdancer("Jay", 19); // Widening conversion to the base type 
        Dancer electricBoogieDancer = new ElectricBoogieDancer("Marcia", 20); // Widening conversion to the base type

        List<dancer> disco = Arrays.asList(dancer, breakdancer, electricBoogieDancer);
        for (Dancer d : disco) {
            d.dance(); // Call the polymorphic method
        }
    }
}

ప్రధాన పద్ధతిలో , పంక్తులు చూపించు

Dancer breakdancer = new Breakdancer("Jay", 19);
Dancer electricBoogieDancer = new ElectricBoogieDancer("Marcia", 20);

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

public interface CanSwim {
    void swim();
}

స్పష్టత కోసం, మేము వివిధ సంబంధం లేని తరగతులను తీసుకుంటాము మరియు వాటిని ఇంటర్‌ఫేస్‌ని అమలు చేసేలా చేస్తాము:

public class Human implements CanSwim {
    private String name;
    private int age;

    public Human(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public void swim() {
        System.out.println(toString()+" I swim with an inflated tube.");
    }

    @Override
    public String toString() {
        return "I'm " + name + ". I'm " + age + " years old.";
    }

}
 
public class Fish implements CanSwim {
    private String name;

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

    @Override
    public void swim() {
        System.out.println("I'm a fish. My name is " + name + ". I swim by moving my fins.");

    }

public class UBoat implements CanSwim {

    private int speed;

    public UBoat(int speed) {
        this.speed = speed;
    }

    @Override
    public void swim() {
        System.out.println("I'm a submarine that swims through the water by rotating screw propellers. My speed is " + speed + " knots.");
    }
}

ప్రధాన పద్ధతి:

public class Main {

    public static void main(String[] args) {
        CanSwim human = new Human("John", 6);
        CanSwim fish = new Fish("Whale");
        CanSwim boat = new UBoat(25);

        List<swim> swimmers = Arrays.asList(human, fish, boat);
        for (Swim s : swimmers) {
            s.swim();
        }
    }
}

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

for (Swim s : swimmers) {
            s.swim();        
}

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

for (Swim s : swimmers) {
            s.swim();        
}

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

public interface CanSwim {
    default void swim() {
        System.out.println("I just swim");
    }
}

పాలిమార్ఫిజం సూత్రం ఉల్లంఘించబడకుండా ఉండటానికి బేస్ క్లాస్‌లలో పద్ధతులు ఎలా ప్రకటించబడాలి అని కొన్నిసార్లు ఇంటర్వ్యూ చేసేవారు అడుగుతారు. సమాధానం చాలా సులభం: ఈ పద్ధతులు స్టాటిక్ , ప్రైవేట్ లేదా ఫైనల్ కాకూడదు . ప్రైవేట్ పద్ధతిని తరగతిలో మాత్రమే అందుబాటులో ఉంచుతుంది, కాబట్టి మీరు దానిని సబ్‌క్లాస్‌లో భర్తీ చేయలేరు. స్టాటిక్ ఏదైనా వస్తువుతో కాకుండా తరగతితో ఒక పద్ధతిని అనుబంధిస్తుంది, కాబట్టి సూపర్‌క్లాస్ పద్ధతి ఎల్లప్పుడూ పిలువబడుతుంది. మరియు తుది పద్ధతిని మార్చలేనిదిగా చేస్తుంది మరియు ఉపవర్గాల నుండి దాచబడుతుంది.

పాలిమార్ఫిజం మనకు ఏమి ఇస్తుంది?

పాలీమార్ఫిజం మనకు ఎలా ప్రయోజనం చేకూరుస్తుందనే దాని గురించి కూడా మీరు ఎక్కువగా అడగబడతారు. మీరు వెంట్రుకల వివరాలలో చిక్కుకోకుండా క్లుప్తంగా సమాధానం ఇవ్వవచ్చు:

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

కొన్ని విడిపోయే పదాలు

పాలిమార్ఫిజం అనేది చాలా ముఖ్యమైన మరియు విస్తృతమైన అంశం. ఇది జావాలోని OOPపై ఈ కథనంలో దాదాపు సగం అంశం మరియు భాష యొక్క పునాదిలో మంచి భాగాన్ని ఏర్పరుస్తుంది. మీరు ఇంటర్వ్యూలో ఈ సూత్రాన్ని నిర్వచించకుండా ఉండలేరు. మీకు తెలియకపోయినా లేదా అర్థం చేసుకోకపోయినా, ఇంటర్వ్యూ ముగింపుకు వచ్చే అవకాశం ఉంది. కాబట్టి అలసత్వం వహించవద్దు — ఇంటర్వ్యూకి ముందు మీ పరిజ్ఞానాన్ని అంచనా వేయండి మరియు అవసరమైతే దాన్ని రిఫ్రెష్ చేయండి.