ప్రారంభించడం

1. వేరియబుల్స్ ప్రారంభించడం

మీకు ఇప్పటికే తెలిసినట్లుగా, మీరు మీ తరగతిలో అనేక వేరియబుల్‌లను ప్రకటించవచ్చు మరియు వాటిని ప్రకటించడమే కాకుండా, వాటి ప్రారంభ విలువలతో వాటిని వెంటనే ప్రారంభించవచ్చు.

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

class Cat
{
   public String name;
   public int age = -1;

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

   public Cat()
   {
     this.name = "Nameless";
   }
}

 Cat cat = new Cat("Whiskers", 2);

 Cat cat = new Cat();

అమలు చేయబడినప్పుడు ఇది జరుగుతుంది Cat cat = new Cat("Whiskers", 2);:

• ఒక Catవస్తువు సృష్టించబడుతుంది
• అన్ని ఇన్‌స్టాన్స్ వేరియబుల్స్ వాటి ప్రారంభ విలువలతో ప్రారంభించబడతాయి
• కన్స్ట్రక్టర్ అంటారు మరియు దాని కోడ్ అమలు చేయబడుతుంది.

మరో మాటలో చెప్పాలంటే, వేరియబుల్స్ మొదట వాటి ప్రారంభ విలువలను పొందుతాయి మరియు అప్పుడు మాత్రమే కన్స్ట్రక్టర్ యొక్క కోడ్ అమలు చేయబడుతుంది.

2. ఒక తరగతిలో వేరియబుల్స్ యొక్క ప్రారంభ క్రమం

కన్స్ట్రక్టర్ రన్ చేయడానికి ముందు వేరియబుల్స్ కేవలం ప్రారంభించబడవు - అవి బాగా నిర్వచించబడిన క్రమంలో ప్రారంభించబడతాయి: అవి తరగతిలో ప్రకటించబడిన క్రమం.

కొన్ని ఆసక్తికరమైన కోడ్‌ను చూద్దాం:

public class Solution
{
   public int a = b + c + 1;
   public int b = a + c + 2;
   public int c = a + b + 3;
}

ఈ కోడ్ కంపైల్ చేయబడదు, ఎందుకంటే వేరియబుల్ సృష్టించబడిన సమయంలో ఇంకా  వేరియబుల్స్ aలేవు  . కానీ మీరు మీ కోడ్‌ని ఈ క్రింది విధంగా వ్రాయవచ్చు - ఈ కోడ్ కంపైల్ అవుతుంది మరియు బాగా రన్ అవుతుంది .bc

public class Solution
{
   public int a;
   public int b = a + 2;
   public int c = a + b + 3;
}

కానీ మీ కోడ్ ఇతర డెవలపర్‌లకు పారదర్శకంగా ఉండాలని గుర్తుంచుకోండి. ఇలాంటి టెక్నిక్‌లను ఉపయోగించకపోవడమే మంచిది, ఎందుకంటే ఇది కోడ్ రీడబిలిటీని దెబ్బతీస్తుంది.

వేరియబుల్స్‌కు విలువను కేటాయించే ముందు వాటికి డిఫాల్ట్ విలువ ఉంటుందని ఇక్కడ మనం గుర్తుంచుకోవాలి . రకం కోసం int, ఇది సున్నా.

JVM aవేరియబుల్‌ను ప్రారంభించినప్పుడు, ఇది పూర్ణాంక రకం కోసం డిఫాల్ట్ విలువను కేటాయిస్తుంది: 0.

అది చేరినప్పుడు b, ఒక వేరియబుల్ ఇప్పటికే తెలిసిపోతుంది మరియు విలువను కలిగి ఉంటుంది, కాబట్టి JVM దానికి విలువ 2ని కేటాయిస్తుంది.

మరియు అది వేరియబుల్‌కు చేరుకున్నప్పుడు c, aమరియు bవేరియబుల్స్ ఇప్పటికే ప్రారంభించబడతాయి, కాబట్టి JVM ప్రారంభ విలువను c0+2+3 కోసం సులభంగా గణిస్తుంది.

మీరు పద్దతి లోపల వేరియబుల్‌ని సృష్టిస్తే, మీరు మునుపు దానికి విలువను కేటాయించకపోతే దాన్ని ఉపయోగించలేరు. కానీ క్లాస్ యొక్క వేరియబుల్స్ కోసం ఇది నిజం కాదు! ఒక ప్రారంభ విలువ తరగతి యొక్క వేరియబుల్‌కు కేటాయించబడకపోతే, అది డిఫాల్ట్ విలువను కేటాయించబడుతుంది.

3. స్థిరాంకాలు

మేము ఆబ్జెక్ట్‌లు ఎలా సృష్టించబడతాయో విశ్లేషిస్తున్నప్పుడు, స్థిరాంకాల ప్రారంభీకరణను, అనగా మాడిఫైయర్‌తో వేరియబుల్స్‌ను తాకడం విలువైనదే final.

ఒక వేరియబుల్ finalమాడిఫైయర్‌ను కలిగి ఉంటే, తప్పనిసరిగా ప్రారంభ విలువను కేటాయించాలి. మీకు ఇది ఇప్పటికే తెలుసు మరియు ఇందులో ఆశ్చర్యం ఏమీ లేదు.

కానీ మీకు తెలియని విషయం ఏమిటంటే, మీరు దానిని కన్స్ట్రక్టర్‌లో కేటాయించినట్లయితే మీరు వెంటనే ప్రారంభ విలువను కేటాయించాల్సిన అవసరం లేదు. ఇది చివరి వేరియబుల్ కోసం బాగా పని చేస్తుంది. మీకు బహుళ కన్స్ట్రక్టర్‌లు ఉంటే, ప్రతి కన్స్ట్రక్టర్‌లో తుది వేరియబుల్ తప్పనిసరిగా విలువను కేటాయించాలి.

ఉదాహరణ:

public class Cat
{
   public final int maxAge = 25;
   public final int maxWeight;

   public Cat (int weight)
   {
     this.maxWeight = weight; // Assign an initial value to the constant
   }
}

4. కన్స్ట్రక్టర్‌లో కోడ్

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

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

class FilePrinter
{
   public String content;

   public FilePrinter(String filename) throws Exception
   {
      FileInputStream input = new FileInputStream(filename);
      byte[] buffer = input.readAllBytes();
      this.content = new String(buffer);
   }

   public void printFile()
   {
      System.out.println(content);
   }
}

ఫైల్‌ప్రింటర్ క్లాస్ కన్‌స్ట్రక్టర్‌లో, మేము వెంటనే ఫైల్‌లో బైట్ స్ట్రీమ్‌ను తెరిచి దాని కంటెంట్‌లను చదివాము. ఇది సంక్లిష్టమైన ప్రవర్తన మరియు దోషాలకు దారితీయవచ్చు.

అలాంటి ఫైల్ లేకపోతే? ఫైల్ చదవడంలో సమస్యలు ఉంటే ఏమి చేయాలి? అది చాలా పెద్దది అయితే?

కాంప్లెక్స్ లాజిక్ ఎర్రర్‌ల యొక్క అధిక సంభావ్యతను సూచిస్తుంది మరియు కోడ్ మినహాయింపులను సరిగ్గా నిర్వహించాలి.

ఉదాహరణ 1 — సీరియలైజేషన్

ప్రామాణిక జావా ప్రోగ్రామ్‌లో, మీ తరగతికి సంబంధించిన వస్తువులను సృష్టించేది మీరు కానటువంటి సందర్భాలు పుష్కలంగా ఉన్నాయి. ఉదాహరణకు, మీరు నెట్‌వర్క్ ద్వారా ఒక వస్తువును పంపాలని నిర్ణయించుకున్నారని అనుకుందాం: ఈ సందర్భంలో, జావా మెషీన్ స్వయంగా మీ వస్తువును బైట్‌ల సెట్‌గా మారుస్తుంది, దానిని పంపుతుంది మరియు బైట్‌ల సెట్ నుండి ఆబ్జెక్ట్‌ను మళ్లీ సృష్టిస్తుంది.

కానీ మీ ఫైల్ ఇతర కంప్యూటర్‌లో లేదని అనుకుందాం. కన్స్ట్రక్టర్‌లో లోపం ఉంటుంది మరియు ఎవరూ దాన్ని నిర్వహించరు. మరియు అది ప్రోగ్రామ్‌ను ముగించేలా చేయగలదు.

ఉదాహరణ 2 — తరగతి యొక్క ఫీల్డ్‌లను ప్రారంభించడం

మీ తరగతి కన్స్ట్రక్టర్ తనిఖీ చేయబడిన మినహాయింపులను త్రో చేయగలిగితే, అంటే త్రోస్ కీవర్డ్‌తో గుర్తు పెట్టబడితే, మీరు మీ ఆబ్జెక్ట్‌ను సృష్టించే పద్ధతిలో సూచించిన మినహాయింపులను తప్పనిసరిగా పట్టుకోవాలి.

కానీ అలాంటి పద్ధతి లేకపోతే? ఉదాహరణ:

class Solution
{
   public FilePrinter reader = new FilePrinter("c:\\readme.txt");
}

తరగతి కన్స్ట్రక్టర్ తనిఖీ చేయబడిన మినహాయింపునుFilePrinter విసిరివేయవచ్చు , అంటే మీరు ఒక వస్తువును ప్రయత్నించి-క్యాచ్ బ్లాక్‌లో చుట్టకుండా సృష్టించలేరు. మరియు ట్రై-క్యాచ్ బ్లాక్ అనేది ఒక పద్ధతిలో మాత్రమే వ్రాయబడుతుందిFilePrinter

5. బేస్ క్లాస్ కన్స్ట్రక్టర్

మునుపటి పాఠాలలో, మేము వారసత్వం గురించి కొంచెం చర్చించాము. దురదృష్టవశాత్తూ, వారసత్వం మరియు OOP గురించి మా పూర్తి చర్చ OOPకి అంకితమైన స్థాయికి కేటాయించబడింది మరియు కన్‌స్ట్రక్టర్‌ల వారసత్వం మాకు ఇప్పటికే సంబంధితంగా ఉంది.

మీ తరగతి మరొక తరగతిని వారసత్వంగా పొందినట్లయితే, మాతృ తరగతికి చెందిన వస్తువు మీ తరగతిలోని ఒక వస్తువులో పొందుపరచబడుతుంది. ఇంకా ఏమిటంటే, మాతృ తరగతికి దాని స్వంత వేరియబుల్స్ మరియు దాని స్వంత కన్స్ట్రక్టర్లు ఉన్నాయి.

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

తరగతులు

వేరియబుల్స్ ప్రారంభించబడిన మరియు కన్స్ట్రక్టర్‌లను పిలిచే క్రమంలో మనకు ఎలా తెలుస్తుంది? రెండు తరగతులకు కోడ్ రాయడం ద్వారా ప్రారంభిద్దాం. ఒకరు మరొకరు వారసత్వంగా పొందుతారు:

class ParentClass
{
   public String a;
   public String b;

   public ParentClass()
   {
   }
}

class ChildClass extends ParentClass
{
   public String c;
   public String d;

   public ChildClass()
   {
   }
}

వేరియబుల్స్ ప్రారంభించబడిన మరియు కన్స్ట్రక్టర్లను పిలిచే క్రమాన్ని మనం గుర్తించాలి. దీన్ని చేయడానికి లాగింగ్ మాకు సహాయం చేస్తుంది.

లాగింగ్

లాగింగ్ అనేది ఒక ప్రోగ్రామ్ అమలు చేస్తున్నప్పుడు, వాటిని కన్సోల్ లేదా ఫైల్‌కు వ్రాయడం ద్వారా చేసే చర్యలను రికార్డ్ చేసే ప్రక్రియ.

కన్స్ట్రక్టర్‌ని పిలిచినట్లు గుర్తించడం చాలా సులభం: కన్స్ట్రక్టర్ యొక్క శరీరంలో, కన్సోల్‌కు సందేశాన్ని వ్రాయండి. వేరియబుల్ ప్రారంభించబడితే మీరు ఎలా చెప్పగలరు?

వాస్తవానికి, ఇది కూడా చాలా కష్టం కాదు: వేరియబుల్‌ను ప్రారంభించేందుకు ఉపయోగించిన విలువను తిరిగి ఇచ్చే ప్రత్యేక పద్ధతిని వ్రాయండి మరియు ప్రారంభాన్ని లాగ్ చేయండి. కోడ్ ఇలా ఉండవచ్చు:

చివరి కోడ్

public class Main
{
   public static void main(String[] args)
   {
      ChildClass obj = new ChildClass();
   }

   public static String print(String text)
   {
      System.out.println(text);
      return text;
   }
}

class ParentClass
{
   public String a = Main.print("ParentClass.a");
   public String b = Main.print("ParentClass.b");

   public ParentClass()
   {
      Main.print("ParentClass.constructor");
   }
}

class ChildClass extends ParentClass
{
   public String c = Main.print("ChildClass.c");
   public String d = Main.print("ChildClass.d");

   public ChildClass()
   {
      Main.print("ChildClass.constructor");
   }
}

మీరు ఈ కోడ్‌ని అమలు చేస్తే, స్క్రీన్‌పై వచనం క్రింది విధంగా ప్రదర్శించబడుతుంది:

ParentClass.a
ParentClass.b
ParentClass.constructor
ChildClass.c
ChildClass.d
ChildClass.constructor

కాబట్టి మీరు ఎల్లప్పుడూ వ్యక్తిగతంగా ఒక క్లాస్ యొక్క వేరియబుల్స్ కన్స్ట్రక్టర్ అని పిలవబడే ముందు ప్రారంభించబడతాయని నిర్ధారించుకోవచ్చు. వారసత్వ తరగతిని ప్రారంభించే ముందు ఒక బేస్ క్లాస్ పూర్తిగా ప్రారంభించబడుతుంది.