1. వారసత్వం
కోడ్జిమ్ గేమ్ ఇంజిన్తో పని చేయడానికి, మీరు వారసత్వాన్ని ఉపయోగించాల్సి ఉంటుంది . కానీ అది ఏమిటో మీకు తెలియకపోతే? ఒక వైపు, మీరు ఈ అంశాన్ని అర్థం చేసుకోవాలి మరియు అధ్యయనం చేయాలి. మరోవైపు, ఇంజిన్ చాలా సరళంగా ఉండేలా ప్రత్యేకంగా రూపొందించబడింది, కాబట్టి మీరు వారసత్వం యొక్క ఉపరితల జ్ఞానంతో పొందవచ్చు.
కాబట్టి వారసత్వం అంటే ఏమిటి? సరళంగా చెప్పాలంటే, వారసత్వం అనేది రెండు తరగతుల మధ్య సంబంధం. వారిలో ఒకరు పేరెంట్ క్లాస్గా వ్యవహరిస్తారు, మరియు మరొకరు చైల్డ్ (వారసుడు) తరగతి అవుతుంది. ఇంకా ఏమిటంటే, మాతృ తరగతికి అది సంతతి తరగతులు ఉన్నాయని కూడా తెలియకపోవచ్చు. మరో మాటలో చెప్పాలంటే, సంతతి తరగతులను కలిగి ఉండటం వల్ల తల్లిదండ్రులు పెద్దగా ప్రయోజనం పొందలేరు.
కానీ వారసత్వం పిల్లల తరగతికి అనేక ప్రయోజనాలను ఇస్తుంది. వాటిలో ముఖ్యమైనది ఏమిటంటే, పేరెంట్ క్లాస్ యొక్క అన్ని వేరియబుల్స్ మరియు పద్ధతులు చైల్డ్ క్లాస్లో కనిపిస్తాయి, పేరెంట్ క్లాస్ కోడ్ నేరుగా చైల్డ్ క్లాస్లోకి కాపీ చేయబడినట్లుగా. ఇది పూర్తిగా ఖచ్చితమైనది కాదు, కానీ వారసత్వం గురించి ప్రాథమిక అవగాహన కోసం ఇది సరిపోతుంది.
వారసత్వాన్ని బాగా అర్థం చేసుకోవడంలో మీకు సహాయపడటానికి ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి.
ఉదాహరణ 1 — ఇక్కడ సరళమైన ఉదాహరణ ఉంది
|
కీవర్డ్ సహాయంతో తరగతి తరగతిని వారసత్వంగా Child పొందుతుంది .Parent extends |
|
ఉదాహరణ 2 — పేరెంట్ క్లాస్ యొక్క వేరియబుల్స్ ఉపయోగించడం
|
క్లాస్లోని క్లాస్ మరియు ఫీల్డ్లను క్లాస్లోనే డిక్లేర్ చేసినట్లుగా క్లాస్ Child ఉపయోగించవచ్చు .age name Parent Child |
|
ఉదాహరణ 3 — పేరెంట్ క్లాస్ యొక్క పద్ధతులను ఉపయోగించడం
|
Child పేరెంట్ క్లాస్ యొక్క వేరియబుల్స్ మరియు మెథడ్స్ని క్లాస్లో డిక్లేర్ చేసినట్లుగా క్లాస్ ఉపయోగించవచ్చు Child . ఈ ఉదాహరణలో, మేము getName() పద్ధతిని ఉపయోగిస్తాము. |
|
కొన్ని వివరాలను విస్మరించి, జావా కంపైలర్ దృక్కోణం నుండి, మేము మాతృ తరగతి కోడ్ను చైల్డ్ క్లాస్ కోడ్లోకి కాపీ చేసాము:
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);
}
}
Child
కంపైలర్ దృక్కోణం నుండి తరగతి ఎలా కనిపిస్తుందో ఇక్కడ ఉంది
2. మెథడ్ ఓవర్రైడింగ్
Child
కొన్నిసార్లు మేము మా తరగతిని చాలా ఉపయోగకరమైన తరగతిని వారసత్వంగా పొందే పరిస్థితులు ఉన్నాయి Parent
, దీని వలన పిల్లల అన్ని తల్లిదండ్రుల వేరియబుల్స్ మరియు పద్ధతులను వారసత్వంగా పొందేలా చేస్తుంది. కానీ ఆ పద్ధతుల్లో కొన్ని మనం కోరుకున్న విధంగా లేదా మనం కోరుకున్న విధంగా పని చేయకపోవచ్చు.
ఈ సందర్భంలో మీరు ఏమి చేస్తారు? మేము అమలు చేయని పద్ధతిని భర్తీ చేయవచ్చు . ఇది చాలా సులభమైన విషయం: మా Child
తరగతిలో మేము తరగతిలోని పద్ధతి వలె అదే సంతకంతో ఒక పద్ధతిని ప్రకటించాము Parent
మరియు దానిలో మా స్వంత కోడ్ను వ్రాస్తాము.
ఉదాహరణ 1 — పద్ధతి ఓవర్రైడింగ్
|
పద్ధతి printInfo() క్రింది పదబంధాన్ని ప్రదర్శిస్తుంది:
|
|
పరిస్థితిని కొంచెం సరళీకృతం చేయడం ద్వారా, వారసత్వం మాతృ తరగతి యొక్క కోడ్ను పిల్లల తరగతికి కాపీ చేయడానికి కారణమవుతుంది. కానీ ఒక వంశపారంపర్య తరగతి ఇప్పటికే పూర్వీకుల తరగతిలో ఉన్న పద్ధతి అయితే, ఆ పద్ధతి పూర్వీకుల తరగతి నుండి కాపీ చేయబడదు. ఇక్కడ మేము చైల్డ్ క్లాస్లోని పద్ధతి మాతృ తరగతిలోని పద్ధతిని భర్తీ చేస్తుందని చెప్పాము. దిగువ ఉదాహరణ చూడండి. బహుశా ఇది విషయాలను కొంచెం స్పష్టంగా చేయడానికి సహాయపడుతుంది:
కంపైలర్ దృక్కోణం నుండి చైల్డ్ క్లాస్ ఎలా కనిపిస్తుందో ఇక్కడ ఉంది: |
---|
|
ఉదాహరణ 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()
యొక్క పద్ధతిని పిలుస్తుంది .Child
printInfo()
Child
ఉదాహరణ:
|
ఈ కోడ్ స్క్రీన్పై కింది వచనాన్ని ప్రదర్శిస్తుంది:
|
|
ఈ కోడ్ స్క్రీన్పై కింది వచనాన్ని ప్రదర్శిస్తుంది:
|
మరియు అన్నీ ఎందుకంటే కంపైలర్ యొక్క దృక్కోణం నుండి (దాని యొక్క చాలా సరళీకృత సంస్కరణ), తరగతి కోడ్ Child
ఇలా కనిపిస్తుంది:
public class Child extends Parent
{
public getName() {
return "Luke, I am your father";
}
public void printInfo()
{
System.out.println(getName());
}
}
Child
కంపైలర్ దృక్కోణం నుండి తరగతి ఎలా కనిపిస్తుందో ఇక్కడ ఉంది
3. జాబితాలు
జాబితాలు ( ) గురించి ఇక్కడ క్లుప్త రిమైండర్ ఉంది List
. శ్రేణులతో జాబితాలు చాలా ఉమ్మడిగా ఉన్నాయి:
- వారు నిర్దిష్ట రకం డేటాను చాలా నిల్వ చేయవచ్చు.
- వారు తమ ఇండెక్స్ ద్వారా మూలకాలను పొందడానికి మిమ్మల్ని అనుమతిస్తారు.
- మూలకాల సూచికలు ప్రారంభమవుతాయి
0
.
జాబితా యొక్క ప్రయోజనాలు:
శ్రేణుల వలె కాకుండా, జాబితాలు డైనమిక్గా పరిమాణాన్ని మార్చగలవు. సృష్టించిన వెంటనే, జాబితా పరిమాణం 0
. జాబితాకు అంశాలు జోడించబడినప్పుడు, దాని పరిమాణం పెరుగుతుంది. జాబితాను రూపొందించడానికి ఉదాహరణ:
ArrayList<String> myList = new ArrayList<String>();
ArrayList
యాంగిల్ బ్రాకెట్లలో సూచించబడిన విలువ జాబితా నిల్వ చేయగల డేటా రకం.
జాబితాతో పని చేయడానికి ఇక్కడ కొన్ని పద్ధతులు ఉన్నాయి:
కోడ్ | సంక్షిప్త సమాచారం |
---|---|
|
స్ట్రింగ్ల కొత్త జాబితాను సృష్టిస్తోంది |
|
జాబితా చివర ఒక మూలకాన్ని జోడించండి |
|
జాబితా ప్రారంభంలో ఒక మూలకాన్ని జోడించండి |
|
దాని సూచిక ద్వారా మూలకాన్ని పొందండి |
|
మూలకాన్ని దాని సూచిక ద్వారా మార్చండి |
|
జాబితాలోని మూలకాల సంఖ్యను పొందండి |
|
జాబితా నుండి ఒక మూలకాన్ని తీసివేయండి |
జాబితాల గురించి మరింత సమాచారం కోసం, మీరు ఈ క్రింది కథనాలను చదవవచ్చు:
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
.
గేమ్లలో యాదృచ్ఛిక సంఖ్యలను ఉపయోగించడానికి అనేక మార్గాలు ఉన్నాయి. మీరు మీ ఊహకు మాత్రమే పరిమితం అయ్యారు. మీ స్వంత గేమ్లను వ్రాయండి, వాటిని మెరుగుపరచండి మరియు ప్రక్రియను ఆస్వాదించండి.
అందరూ గేమ్లు ఆడగలరు, కానీ ప్రోగ్రామర్లు మాత్రమే వాటిని సృష్టించగలరు.
GO TO FULL VERSION