రిఫరెన్స్ రకాలను విస్తరించడం మరియు తగ్గించడం

హాయ్! గత పాఠంలో, మేము ఆదిమ రకాలను ప్రసారం చేయడం గురించి చర్చించాము. చర్చించిన వాటిని క్లుప్తంగా గుర్తుచేసుకుందాం. మేము ఆదిమ రకాలను (ఈ సందర్భంలో, సంఖ్యా రకాలు) గూడు బొమ్మలుగా ఊహించాము, అవి ఆక్రమించిన మెమరీ పరిమాణం ప్రకారం పరిమాణంలో మారుతాయి. మీకు గుర్తున్నట్లుగా, పెద్ద బొమ్మలో చిన్న బొమ్మను ఉంచడం నిజ జీవితంలో మరియు జావా ప్రోగ్రామింగ్‌లో సులభం.

public class Main {
   public static void main(String[] args) {
       int bigNumber = 10000000;
       short smallNumber = (short) bigNumber;
       System.out.println(smallNumber);
   }
}

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

public class Main {

   public static void main(String[] args) {

       int bigNumber = 10000000;

       bigNumber = (short) bigNumber;

       System.out.println(bigNumber);

   }

}

పై ఉదాహరణలో మనం చేసినది అదే. ఆపరేషన్ జరిగింది, కానీ shortవేరియబుల్ 32 బైట్‌లలో 16 మాత్రమే ఉంచగలదు కాబట్టి, తుది విలువ వక్రీకరించబడింది మరియు మేము సంఖ్యను పొందుతాము -27008 . అటువంటి చర్యను స్పష్టమైన మార్పిడి లేదా సంకుచితం అంటారు .

రిఫరెన్స్ రకాలను విస్తరించడం మరియు తగ్గించడం యొక్క ఉదాహరణలు

ఇప్పుడు అదే ఆపరేటర్లు ఆదిమ రకాలకు కాకుండా ఆబ్జెక్ట్‌లు మరియు రిఫరెన్స్ వేరియబుల్స్‌కి వర్తింపజేయడం గురించి మాట్లాడుకుందాం ! జావాలో ఇది ఎలా పని చేస్తుంది? ఇది నిజానికి చాలా సులభం. సంబంధం లేని వస్తువులు ఉన్నాయి. అవి ఒకదానికొకటి స్పష్టంగా లేదా స్వయంచాలకంగా మార్చబడవని భావించడం తార్కికంగా ఉంటుంది:

public class Cat {
}

public class Dog {
}

public class Main {

   public static void main(String[] args) {

       Cat cat = new Dog(); // Error!

   }

}

ఇక్కడ, వాస్తవానికి, మనకు లోపం వస్తుంది. మరియు తరగతులు ఒకదానికొకటి సంబంధం కలిగి లేవు మరియు మేము ఒకదాని నుండి మరొకదానికి Catతరలించడానికి Dog'కన్వర్టర్'ని వ్రాయలేదు. మేము దీన్ని చేయలేమని ఇది అర్ధమే: కంపైలర్‌కు ఈ వస్తువులను ఒక రకం నుండి మరొక రకానికి ఎలా మార్చాలో తెలియదు. వస్తువులు సంబంధం కలిగి ఉంటే, అది వేరే విషయం! ఎలా సంబంధం? అన్నింటికంటే, వారసత్వం ద్వారా. తరగతుల యొక్క చిన్న వ్యవస్థను రూపొందించడానికి వారసత్వాన్ని ఉపయోగించి ప్రయత్నిద్దాం. జంతువులను సూచించడానికి మేము ఒక సాధారణ తరగతిని కలిగి ఉంటాము:

public class Animal {

   public void introduce() {

       System.out.println("I'm Animal");
   }
}

జంతువులను పెంపుడు జంతువులు (పెంపుడు జంతువులు) లేదా అడవి అని అందరికీ తెలుసు:

public class WildAnimal extends Animal {

   public void introduce() {

       System.out.println("I'm WildAnimal");
   }
}

public class Pet extends Animal {

   public void introduce() {

       System.out.println("I'm Pet");
   }
}

ఉదాహరణకు, కుక్కలను తీసుకోండి — మన దగ్గర పెంపుడు కుక్కలు మరియు కొయెట్‌లు ఉన్నాయి:

public class Dog extends Pet {

   public void introduce() {

       System.out.println("I'm Dog");
   }
}



public class Coyote extends WildAnimal {

   public void introduce() {

       System.out.println ("I'm Coyote");
   }
}

మేము వాటిని సులభంగా అర్థం చేసుకోవడానికి అత్యంత ప్రాథమిక తరగతులను ప్రత్యేకంగా ఎంచుకున్నాము. మాకు నిజంగా ఫీల్డ్‌లు అవసరం లేదు మరియు ఒక పద్ధతి సరిపోతుంది. ఈ కోడ్‌ని అమలు చేయడానికి ప్రయత్నిద్దాం:

public class Main {

   public static void main(String[] args) {

       Animal animal = new Pet();
       animal.introduce();
   }
}

కన్సోల్‌లో ఏమి ప్రదర్శించబడుతుందని మీరు అనుకుంటున్నారు? తరగతి లేదా తరగతి introduceయొక్క పద్ధతిని అమలు చేయవచ్చా ? మీరు చదవడం కొనసాగించే ముందు మీ సమాధానాన్ని సమర్థించడానికి ప్రయత్నించండి. మరియు ఇక్కడ ఫలితం ఉంది! నేను పెంపుడు జంతువును మనం ఎందుకు పొందాము? ఇది అన్ని సులభం. మనకు పేరెంట్ వేరియబుల్ మరియు డిసెండెంట్ ఆబ్జెక్ట్ ఉన్నాయి. రాయడం ద్వారా, PetAnimal

Animal animal = new Pet();

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

Animal animal = new DomesticatedAnimal();

దీనితో ఎటువంటి సమస్య లేదు, సరియైనదా? ఇది నిజ జీవితం అని ఊహించండి మరియు సూచన కేవలం 'జంతువు' అని వ్రాసిన కాగితం లేబుల్. ఆ కాగితాన్ని తీసుకుని ఏదైనా పెంపుడు జంతువు కాలర్‌కు తగిలించినట్లయితే, ప్రతిదీ సరిగ్గా ఉంటుంది. అన్ని తరువాత, ఏదైనా పెంపుడు జంతువు ఒక జంతువు! రివర్స్ ప్రాసెస్ - వారసత్వ వృక్షాన్ని వారసులకు తరలించడం - సంకుచితం:

public class Main {

   public static void main(String[] args) {

       WildAnimal wildAnimal = new Coyote();

       Coyote coyote = (Coyote) wildAnimal;

       coyote.introduce();
   }
}

మీరు చూడగలిగినట్లుగా, ఇక్కడ మేము మా వస్తువును మార్చాలనుకుంటున్న తరగతిని స్పష్టంగా సూచిస్తాము. మేము ఇంతకుముందు WildAnimalవేరియబుల్‌ని కలిగి ఉన్నాము మరియు ఇప్పుడు మనకు ఒక Coyote, వారసత్వ చెట్టుపై తక్కువగా ఉంది. స్పష్టమైన సూచన లేకుండా కంపైలర్ అటువంటి ఆపరేషన్‌ను అనుమతించదని అర్ధమే, కానీ మేము కుండలీకరణాల్లో రకాన్ని సూచిస్తే, అప్పుడు ప్రతిదీ పని చేస్తుంది. మరొక ఆసక్తికరమైన ఉదాహరణను పరిగణించండి:

public class Main {

   public static void main(String[] args) {

       Pet pet = new Animal(); // Error!
   }
}

కంపైలర్ లోపాన్ని సృష్టిస్తుంది! కానీ ఎందుకు? ఎందుకంటే మీరు మాతృ వస్తువును సంతతి సూచనకు కేటాయించడానికి ప్రయత్నిస్తున్నారు. మరో మాటలో చెప్పాలంటే, మీరు ఇలాంటివి చేయడానికి ప్రయత్నిస్తున్నారు:

DomesticatedAnimal domesticatedAnimal = new Animal();

సరే, మనం మార్చడానికి ప్రయత్నిస్తున్న రకాన్ని స్పష్టంగా పేర్కొంటే ప్రతిదీ పని చేస్తుందా? అది సంఖ్యలతో పని చేస్తుంది — దీనిని ఒకసారి ప్రయత్నిద్దాం! :)

public class Main {

   public static void main(String[] args) {

       Pet pet = (Pet) new Animal();
   }
}

థ్రెడ్ "ప్రధాన" java.langలో మినహాయింపు.ClassCastException: జంతువు పెట్ ఎర్రర్‌కి ప్రసారం చేయబడదు ! కంపైలర్ ఈ సమయంలో మాకు అరవలేదు, కానీ మేము మినహాయింపుతో ముగించాము. మాకు ఇప్పటికే కారణం తెలుసు: మేము మాతృ వస్తువును సంతతి సూచనకు కేటాయించడానికి ప్రయత్నిస్తున్నాము. కానీ మీరు సరిగ్గా ఎందుకు చేయలేరు? ఎందుకంటే అన్ని జంతువులు పెంపుడు జంతువులు కావు. మీరు ఒక Animalవస్తువును సృష్టించారు మరియు దానిని వేరియబుల్‌కు కేటాయించడానికి ప్రయత్నిస్తున్నారు Pet. ఒక కొయెట్ కూడా ఒక Animal, కానీ అది కాదు Pet. మరో మాటలో చెప్పాలంటే, మీరు వ్రాసేటప్పుడు

Pet pet = (Pet) new Animal();

new Animal()ఏదైనా జంతువును సూచించవచ్చు, పెంపుడు జంతువు కాదు! సహజంగానే, మీ Pet petవేరియబుల్ పెంపుడు జంతువులను (మరియు వాటి వారసులు) నిల్వ చేయడానికి మాత్రమే అనుకూలంగా ఉంటుంది మరియు ఏ రకమైన జంతువులను కాదు. అందుకే ప్రత్యేక జావా మినహాయింపు, ClassCastException, తరగతులను ప్రసారం చేస్తున్నప్పుడు లోపం సంభవించే సందర్భాలలో సృష్టించబడింది. విషయాలను మరింత స్పష్టం చేయడానికి దాన్ని మళ్లీ సమీక్షిద్దాం. ఒక పేరెంట్ రిఫరెన్స్ సంతతి తరగతికి సంబంధించిన ఉదాహరణలను సూచించవచ్చు:

public class Main {

   public static void main(String[] args) {

       Pet pet = new Pet();
       Animal animal = pet;

       Pet pet2 = (Pet) animal;
       pet2.introduce();
   }
}

ఉదాహరణకు, ఇక్కడ మాకు ఎటువంటి సమస్యలు లేవు. మనకు వేరియబుల్ Petద్వారా సూచించబడిన వస్తువు ఉంది Pet. తరువాత, ఒక Animalసూచన అదే వస్తువుపై చూపబడింది. ఆ తర్వాత, మేము animala కు మారుస్తాము Pet. మార్గం ద్వారా, అది మాకు ఎందుకు పని చేసింది? చివరిసారి మాకు మినహాయింపు వచ్చింది! ఎందుకంటే ఈసారి మన అసలు వస్తువు ఒక Pet!

Pet pet = new Pet();

కానీ చివరి ఉదాహరణలో, ఇది ఒక Animalవస్తువు:

Pet pet = (Pet) new Animal();

మీరు వంశపారంపర్య వేరియబుల్‌కు పూర్వీకుల వస్తువును కేటాయించలేరు. మీరు దీనికి విరుద్ధంగా చేయవచ్చు.