ఏదో సహాయకరంగా ఉంది

1. వారసత్వం

కోడ్‌జిమ్ గేమ్ ఇంజిన్‌తో పని చేయడానికి, మీరు వారసత్వాన్ని ఉపయోగించాల్సి ఉంటుంది . కానీ అది ఏమిటో మీకు తెలియకపోతే? ఒక వైపు, మీరు ఈ అంశాన్ని అర్థం చేసుకోవాలి మరియు అధ్యయనం చేయాలి. మరోవైపు, ఇంజిన్ చాలా సరళంగా ఉండేలా ప్రత్యేకంగా రూపొందించబడింది, కాబట్టి మీరు వారసత్వం యొక్క ఉపరితల జ్ఞానంతో పొందవచ్చు.

కాబట్టి వారసత్వం అంటే ఏమిటి? సరళంగా చెప్పాలంటే, వారసత్వం అనేది రెండు తరగతుల మధ్య సంబంధం. వారిలో ఒకరు పేరెంట్ క్లాస్‌గా వ్యవహరిస్తారు, మరియు మరొకరు చైల్డ్ (వారసుడు) తరగతి అవుతుంది. ఇంకా ఏమిటంటే, మాతృ తరగతికి అది సంతతి తరగతులు ఉన్నాయని కూడా తెలియకపోవచ్చు. మరో మాటలో చెప్పాలంటే, సంతతి తరగతులను కలిగి ఉండటం వల్ల తల్లిదండ్రులు పెద్దగా ప్రయోజనం పొందలేరు.

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

వారసత్వాన్ని బాగా అర్థం చేసుకోవడంలో మీకు సహాయపడటానికి ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి.

ఉదాహరణ 1 — ఇక్కడ సరళమైన ఉదాహరణ ఉంది

public class Parent
{
}

public class Child extends Parent
{
}

ఉదాహరణ 2 — పేరెంట్ క్లాస్ యొక్క వేరియబుల్స్ ఉపయోగించడం

public class Parent
{
  public int age;
  public String name;
}

public class Child extends Parent
{
  public void printInfo()
  {
    System.out.println(name + " " + age);
  }
}

ఉదాహరణ 3 — పేరెంట్ క్లాస్ యొక్క పద్ధతులను ఉపయోగించడం

public class Parent
{
   public int age;
   public String name;
   public getName() {
      return name;
   }
}

public class Child extends Parent
{
   public void printInfo()
   {
      System.out.println(getName() + " " + age);
   }
}

కొన్ని వివరాలను విస్మరించి, జావా కంపైలర్ దృక్కోణం నుండి, మేము మాతృ తరగతి కోడ్‌ను చైల్డ్ క్లాస్ కోడ్‌లోకి కాపీ చేసాము:

public class Child extends Parent
{
   public int age;        // An inherited variable
   public String name;    // An inherited variable
   public getName() {     // An inherited method
      return name;
   }

   public void printInfo()
   {
      System.out.println(getName() + " " + age);
   }
}

2. మెథడ్ ఓవర్‌రైడింగ్

Childకొన్నిసార్లు మేము మా తరగతిని చాలా ఉపయోగకరమైన తరగతిని వారసత్వంగా పొందే పరిస్థితులు ఉన్నాయి Parent, దీని వలన పిల్లల అన్ని తల్లిదండ్రుల వేరియబుల్స్ మరియు పద్ధతులను వారసత్వంగా పొందేలా చేస్తుంది. కానీ ఆ పద్ధతుల్లో కొన్ని మనం కోరుకున్న విధంగా లేదా మనం కోరుకున్న విధంగా పని చేయకపోవచ్చు.

ఈ సందర్భంలో మీరు ఏమి చేస్తారు? మేము అమలు చేయని పద్ధతిని భర్తీ చేయవచ్చు . ఇది చాలా సులభమైన విషయం: మా Childతరగతిలో మేము తరగతిలోని పద్ధతి వలె అదే సంతకంతో ఒక పద్ధతిని ప్రకటించాము Parentమరియు దానిలో మా స్వంత కోడ్‌ను వ్రాస్తాము.

ఉదాహరణ 1 — పద్ధతి ఓవర్‌రైడింగ్

public class Parent
{
   public String name;
   public void setName(String nameNew) {
      name = nameNew;
   }

   public getName() {
      return name;
   }
}

Luke, No!!!

public class Child extends Parent
{
   public void setName(String nameNew) {
      name = nameNew + ", No!!!";
   }

   public void printInfo()
   {
      setName("Luke");
      System.out.println(getName());
   }
}

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

public class Child extends Parent
{
   public String name;    // An inherited variable

   public void setName(String nameNew)  // The overridden method replaces the inherited one
   {
      name = nameNew + ", No!!!";
   }

   public getName()    // An inherited method
   {
      return name;
   }

   public void printInfo()
   {
      setName("Luke");
      System.out.println(getName());
   }
}

ఉదాహరణ 2 - కొద్దిగా వారసత్వ మాయాజాలం (మరియు పద్ధతి ఓవర్‌రైడింగ్)

public class Parent
{
   public getName() {
      return "Luke";
   }

   public void printInfo()
   {
      System.out.println( getName() );
   }
}

public class Child extends Parent
{
   public getName() {
      return "Luke, I am your father";
   }
}

పద్ధతిని printInfo()ఒక రకంగా పిలిస్తే , అది తరగతి పద్ధతిని Parentపిలుస్తుంది .getName()Parent

ఒక వస్తువుపై పద్ధతిని printInfo()పిలిస్తే , అది తరగతి పద్ధతిని Childపిలుస్తుంది .getName()Child

మరో మాటలో చెప్పాలంటే, printInfo()పద్ధతి తరగతిలో మాత్రమే ప్రకటించబడుతుంది Parent, కానీ ఒక వస్తువుపై పద్ధతిని పిలిస్తే అది తరగతి getName()యొక్క పద్ధతిని పిలుస్తుంది .ChildprintInfo()Child

ఉదాహరణ:

Parent parent = new Parent();
parent.printnInfo();

Luke

Child child = new Child();
child.printnInfo();

Luke, I am your father

మరియు అన్నీ ఎందుకంటే కంపైలర్ యొక్క దృక్కోణం నుండి (దాని యొక్క చాలా సరళీకృత సంస్కరణ), తరగతి కోడ్ Childఇలా కనిపిస్తుంది:

public class Child extends Parent
{
   public getName() {
      return "Luke, I am your father";
   }

   public void printInfo()
   {
      System.out.println(getName());
   }
}

3. జాబితాలు

జాబితాలు ( ) గురించి ఇక్కడ క్లుప్త రిమైండర్ ఉంది List. శ్రేణులతో జాబితాలు చాలా ఉమ్మడిగా ఉన్నాయి:

• వారు నిర్దిష్ట రకం డేటాను చాలా నిల్వ చేయవచ్చు.
• వారు తమ ఇండెక్స్ ద్వారా మూలకాలను పొందడానికి మిమ్మల్ని అనుమతిస్తారు.
• మూలకాల సూచికలు ప్రారంభమవుతాయి 0.

జాబితా యొక్క ప్రయోజనాలు:

శ్రేణుల వలె కాకుండా, జాబితాలు డైనమిక్‌గా పరిమాణాన్ని మార్చగలవు. సృష్టించిన వెంటనే, జాబితా పరిమాణం 0. జాబితాకు అంశాలు జోడించబడినప్పుడు, దాని పరిమాణం పెరుగుతుంది. జాబితాను రూపొందించడానికి ఉదాహరణ:

ArrayList<String> myList = new ArrayList<String>();

యాంగిల్ బ్రాకెట్లలో సూచించబడిన విలువ జాబితా నిల్వ చేయగల డేటా రకం.

జాబితాతో పని చేయడానికి ఇక్కడ కొన్ని పద్ధతులు ఉన్నాయి:

ArrayList<String> list = new ArrayList<String>();

list.add("name");

list.add(0, "name");

String name = list.get(5);

list.set(5, "new name");

int count = list.size();

list.remove(4);

జాబితాల గురించి మరింత సమాచారం కోసం, మీరు ఈ క్రింది కథనాలను చదవవచ్చు:

• చిత్రాలలో శ్రేణి జాబితా
• అర్రేలిస్ట్ క్లాస్
• అర్రేలిస్ట్ నుండి ఒక అంశాన్ని తీసివేయడం

4. యాదృచ్ఛిక సంఖ్యలు

కోడ్‌జిమ్ గేమ్ ఇంజిన్ యాదృచ్ఛిక సంఖ్యలను రూపొందించడానికి ఉపయోగించే రెండు పద్ధతులను కలిగి ఉంది. ఈ పద్ధతులు:

int getRandomNumber(int max)

int getRandomNumber(int min, int max)

మొదటి పద్ధతి — getRandomNumber(int max)— పరిధిలో యాదృచ్ఛిక సంఖ్యను అందిస్తుంది 0, 1, 2, ... max-1. హుడ్ కింద, ఇది ప్యాకేజీ Randomనుండి తరగతిని ఉపయోగిస్తుంది java.util, కానీ మీరు యాదృచ్ఛిక సంఖ్యను ఎలా ఉపయోగించాలో అది మారదు.

getRandomNumber(int)పూర్ణాంకాన్ని వాదనగా అంగీకరిస్తుంది. ఈ సంఖ్య యాదృచ్ఛిక సంఖ్య జనరేటర్ తిరిగి ఇవ్వగల సంఖ్యలపై ఎగువ సరిహద్దుగా ఉంటుంది. దిగువ సరిహద్దు 0. శ్రద్ధ! యాదృచ్ఛిక సంఖ్య జనరేటర్ ఎగువ సరిహద్దు విలువను ఎప్పటికీ అందించదు. ఉదాహరణకు, మీరు కాల్ చేస్తే getRandomNumber(3), అది యాదృచ్ఛికంగా 0, 1 లేదా 2ని అందిస్తుంది. మీరు చూడగలిగినట్లుగా, అది 3ని తిరిగి ఇవ్వదు. ఈ విధంగా యాదృచ్ఛిక సంఖ్య జనరేటర్‌ను ఉపయోగించడం చాలా సులభం, కానీ ఇది చాలా సందర్భాలలో అనుకూలంగా ఉంటుంది.

రెండవ పద్ధతి — getRandomNumber(int min, int max)— పరిధిలో యాదృచ్ఛిక పూర్ణాంకాన్ని అందిస్తుంది [min, max-1]. ఇది ఎన్నటికీ తక్కువ సంఖ్యను తిరిగి ఇవ్వదు minమరియు దాని కంటే ఎక్కువ సంఖ్యను తిరిగి ఇవ్వదు max-1.

ఈ పద్ధతులను ఆచరణలో ఎలా ఉపయోగించవచ్చు?

1. పాచికలు

మీరు డై యొక్క రోల్‌ను అనుకరించాలని మరియు పరిధిలో యాదృచ్ఛిక సంఖ్యను పొందాలని అనుకుందాం 1-6. మీరు దీన్ని ఎలా చేస్తారు? ఇది ఇలాంటి కోడ్‌తో చేయవచ్చు:

int dice = getRandomNumber(1, 7);

ఈ పద్ధతి పరిధిలో యాదృచ్ఛిక పూర్ణాంకాన్ని అందిస్తుంది 1-6.

2. లక్ష్య సాధన

మీరు లక్ష్యం వద్ద షూటింగ్‌ను అనుకరించాలనుకుంటున్నారని అనుకుందాం మరియు షాట్ యొక్క ఖచ్చితత్వం యాదృచ్ఛిక భాగాన్ని కలిగి ఉంటుంది, ఇది పరిధి నుండి కలుపుకొని -10ఉంటుంది +10. ఇది ఇలాంటి కోడ్‌తో చేయవచ్చు:

int dx = getRandomNumber(-10, 11);

-10ఈ పద్ధతి పరిధిలో యాదృచ్ఛిక పూర్ణాంకాన్ని అందిస్తుంది +10.

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

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