కోడ్‌జిమ్‌లోని "గేమ్‌లు" విభాగంలో , మీరు జనాదరణ పొందిన కంప్యూటర్ గేమ్‌లను వ్రాయడం వంటి ఉత్తేజకరమైన ప్రాజెక్ట్‌లను కనుగొంటారు. జనాదరణ పొందిన గేమ్‌లు 2048, మైన్స్‌వీపర్, స్నేక్ మరియు ఇతర గేమ్‌ల యొక్క మీ స్వంత వెర్షన్‌ను సృష్టించాలనుకుంటున్నారా? ఇది సులభం. మేము గేమ్ రైటింగ్‌ను దశల వారీ ప్రక్రియగా మార్చాము. కోడ్‌జిమ్‌లో "గేమ్స్" విభాగం: ఉపయోగకరమైన సిద్ధాంతం - 1గేమ్ డెవలపర్‌గా మీ సామర్థ్యాలను పరీక్షించడానికి, మీరు అధునాతన ప్రోగ్రామర్ కానవసరం లేదు, కానీ నిర్దిష్ట జావా పరిజ్ఞానం అవసరం. గేమ్ రైటింగ్‌లో ఉపయోగపడే సమాచారాన్ని ఇక్కడ మీరు కనుగొంటారు .

1. వారసత్వం

కోడ్‌జిమ్ గేమ్ ఇంజిన్‌తో పనిచేయడం అనేది వారసత్వాన్ని ఉపయోగించడం. కానీ అది ఏమిటో మీకు తెలియకపోతే? ఒక వైపు, మీరు ఈ అంశాన్ని అర్థం చేసుకోవాలి: ఇది స్థాయి 11 లో అధ్యయనం చేయబడింది. మరోవైపు, ఇంజిన్ ప్రత్యేకంగా చాలా సరళంగా రూపొందించబడింది, కాబట్టి మీరు వారసత్వం యొక్క ఉపరితల జ్ఞానంతో బయటపడవచ్చు. కాబట్టి వారసత్వం అంటే ఏమిటి? చాలా సరళంగా చెప్పాలంటే, వారసత్వం అనేది రెండు తరగతుల మధ్య సంబంధం. వారిలో ఒకరు తల్లిదండ్రులు అవుతారు, మరియు మరొకరు పిల్లవాడు (వారసుడు) అవుతాడు. అంతేకాకుండా, మాతృ తరగతికి వారసులు ఉన్నారని కూడా తెలియకపోవచ్చు. మరో మాటలో చెప్పాలంటే, అది వారసులను కలిగి ఉండటం ద్వారా ప్రత్యేక ప్రయోజనాన్ని పొందదు. కానీ వారసత్వం ఒక వారసునికి అనేక ప్రయోజనాలను ఇస్తుంది. మరియు చాలా ముఖ్యమైనది ఏమిటంటే, పేరెంట్ క్లాస్ యొక్క కోడ్ డిసెండెంట్ క్లాస్‌కి కాపీ చేయబడినట్లుగా అన్ని పేరెంట్ క్లాస్ యొక్క వేరియబుల్స్ మరియు మెథడ్స్ డిసెండెంట్‌లో కనిపిస్తాయి. ఇది పూర్తిగా ఖచ్చితమైన వివరణ కాదు, కానీ వారసత్వం గురించి సరళీకృత అవగాహన కోసం ఇది సరిపోతుంది. ఉదాహరణ 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;
  }
}
చైల్డ్ క్లాస్ పేరెంట్ క్లాస్ యొక్క వేరియబుల్స్ మరియు మెథడ్స్‌ని చైల్డ్ క్లాస్‌లో డిక్లేర్ చేసినట్లుగా ఉపయోగించవచ్చు . ఈ ఉదాహరణలో, మేము getName() పద్ధతిని ఉపయోగిస్తాము. 

public class Child extends Parent {

   public void printInfo() {

     System.out.println(getName()+" "+age);
   }
}
కంపైలర్‌కి చైల్డ్ క్లాస్ ఇలా కనిపిస్తుంది: 

public class Child extends Parent{

   public int age;  // Inherited variable
   public String name;  // Inherited variable

   public getName() {  // Inherited method.
      return name;
  }
   public void printInfo() {

     System.out.println(getName()+" "+age);
   }
}

2. ఓవర్‌రైడింగ్ పద్ధతులు

కొన్నిసార్లు మేము మా చైల్డ్ క్లాస్‌ని దాని అన్ని వేరియబుల్స్ మరియు మెథడ్స్‌తో పాటు చాలా ఉపయోగకరమైన పేరెంట్ క్లాస్‌ని వారసత్వంగా పొందేలా చేసే పరిస్థితులు ఉన్నాయి, అయితే కొన్ని పద్ధతులు మనం కోరుకున్న విధంగా పని చేయవు. లేదా మనం వాటిని ఎలా కోరుకుంటున్నామో అస్సలు కాదు. ఈ పరిస్థితిలో మనం ఏమి చేయగలం? మనకు నచ్చని పద్ధతిని మనం భర్తీ చేయవచ్చు. దీన్ని చేయడం చాలా సులభం: మా చైల్డ్ క్లాస్‌లో, పేరెంట్ క్లాస్‌లోని పద్ధతి వలె అదే సంతకంతో మేము ఒక పద్ధతిని ప్రకటిస్తాము, ఆపై మేము అందులో మా స్వంత కోడ్‌ను వ్రాస్తాము. ఉదాహరణ 1: ఒక పద్ధతిని భర్తీ చేయడం. 

public class Parent {

   public String name;

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

   public getName() {
      return name;
  }
}
printInfo() పద్ధతి "ల్యూక్, లేదు!!!"ని ప్రదర్శిస్తుంది. 

public class Child extends Parent{

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

   public void printInfo() {
      setName("Luke");
      System.out.println(getName());
   }
}
కంపైలర్‌కి చైల్డ్ క్లాస్ ఇలా కనిపిస్తుంది: 

public Child extends Parent {

   public String name;  // Inherited variable

   public void setName(String nameNew)  // Overridden method instead of the inherited method {

       name = nameNew + ", No!!!";
   }
   public getName() {  // 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చైల్డ్ క్లాస్‌లో పద్ధతి (పేరెంట్ క్లాస్ నుండి) ఓవర్‌రైడ్ చేయకపోతే, ఈ పద్ధతిని చైల్డ్ ఆబ్జెక్ట్‌పై పిలిచినప్పుడు, getName()పేరెంట్ క్లాస్ పద్ధతికి బదులుగా దాని పద్ధతి అంటారు getName(). 

Parent parent = new Parent ();
parent.printnInfo();
ఈ కోడ్ స్క్రీన్‌పై "లూక్"ని ప్రదర్శిస్తుంది . 

Child child = new Child ();
child.printnInfo();
ఈ కోడ్ స్క్రీన్‌పై "ల్యూక్, నేను మీ తండ్రి"ని ప్రదర్శిస్తుంది .
కంపైలర్‌కి చైల్డ్ క్లాస్ ఇలా కనిపిస్తుంది: 

public class Child extends Parent {

   public getName() {
      return "Luke, I am your father";
   }
   public void printInfo() {

     System.out.println(getName());
   }
}

3. జాబితాలు

మీరు ఇంకా జాబితాలను (జాబితా) కలుసుకోకుంటే, ఇక్కడ సంక్షిప్త అవలోకనం ఉంది. కోడ్‌జిమ్ కోర్సు యొక్క 6-7 స్థాయిలలో మీరు పూర్తి సమాచారాన్ని కనుగొనవచ్చు . శ్రేణులతో జాబితాలు చాలా ఉమ్మడిగా ఉన్నాయి:
  • మీరు నిర్దిష్ట రకం డేటాను చాలా నిల్వ చేయవచ్చు;
  • వారు తమ ఇండెక్స్ ద్వారా వస్తువులను పొందడానికి మిమ్మల్ని అనుమతిస్తారు;
  • మూలకం సూచికలు 0 నుండి ప్రారంభమవుతాయి.
జాబితాల ప్రయోజనాలు: శ్రేణుల వలె కాకుండా, జాబితాలు డైనమిక్‌గా పరిమాణాన్ని మార్చగలవు. జాబితా సృష్టించబడినప్పుడు, దాని పరిమాణం 0. మీరు జాబితాకు అంశాలను జోడించినప్పుడు, దాని పరిమాణం పెరుగుతుంది. జాబితాను సృష్టించే ఉదాహరణ ఇక్కడ ఉంది: 

ArrayList<String> myList = new ArrayList<String>(); // Create a new ArrayList
యాంగిల్ బ్రాకెట్లలోని విలువ జాబితా నిల్వ చేయగల డేటా రకాన్ని సూచిస్తుంది. జాబితాతో పని చేయడానికి ఇక్కడ కొన్ని పద్ధతులు ఉన్నాయి:
కోడ్ కోడ్ ఏమి చేస్తుందో సంక్షిప్త వివరణ
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); జాబితా నుండి ఒక మూలకాన్ని తొలగించండి
మీరు ఈ క్రింది కథనాల నుండి జాబితాల గురించి మరింత తెలుసుకోవచ్చు:
  1. అర్రేలిస్ట్ క్లాస్
  2. చిత్రాలలో శ్రేణి జాబితా
  3. అర్రేలిస్ట్ నుండి మూలకాన్ని తొలగిస్తోంది

4. శ్రేణులు

మాతృక అంటే ఏమిటి? మ్యాట్రిక్స్ అనేది డేటాతో నింపగలిగే దీర్ఘచతురస్రాకార పట్టిక కంటే మరేమీ కాదు. మరో మాటలో చెప్పాలంటే, ఇది రెండు డైమెన్షనల్ శ్రేణి. మీకు బహుశా తెలిసినట్లుగా, జావాలోని శ్రేణులు వస్తువులు. ఒక ప్రామాణిక ఏక డైమెన్షనల్ intశ్రేణి ఇలా కనిపిస్తుంది: 

int [] array = {12, 32, 43, 54, 15, 36, 67, 28};
మేము దీన్ని ఇలా ఊహించవచ్చు:
0 1 2 3 4 5 6 7
12 32 43 54 15 36 67 28
ఎగువ వరుస కణాల చిరునామాలను సూచిస్తుంది. మరో మాటలో చెప్పాలంటే, 67 సంఖ్యను పొందడానికి, మీరు ఇండెక్స్ 6తో శ్రేణి మూలకాన్ని యాక్సెస్ చేయాలి: 

int number = array[6];
ఇది అన్ని చాలా సులభం. ద్విమితీయ శ్రేణి అనేది ఒక డైమెన్షనల్ శ్రేణుల శ్రేణి. మీరు దీని గురించి మొదటిసారిగా వింటున్నట్లయితే, ఆగి మీ తలపై ఊహించుకోండి. రెండు డైమెన్షనల్ శ్రేణి ఇలా కనిపిస్తుంది:
0 ఒకటి - డైమెన్షనల్ అర్రే ఒక డైమెన్షనల్ శ్రేణి
1 ఒక డైమెన్షనల్ శ్రేణి
2 ఒక డైమెన్షనల్ శ్రేణి
3 ఒక డైమెన్షనల్ శ్రేణి
4 ఒక డైమెన్షనల్ శ్రేణి
5 ఒక డైమెన్షనల్ శ్రేణి
6 ఒక డైమెన్షనల్ శ్రేణి
7 ఒక డైమెన్షనల్ శ్రేణి
కోడ్‌లో: 

int [][] matrix = {

{65, 99, 87, 90, 156, 75, 98, 78},
{76, 15, 76, 91, 66, 90, 15, 77},
{65, 96, 17, 25, 36, 75, 54, 78},
{59, 45, 68, 14, 57, 1, 9, 63},
{81, 74, 47, 52, 42, 785, 56, 96},
{66, 74, 58, 16, 98, 140, 55, 77},
{120, 99, 13, 90, 78, 98, 14, 78},
{20, 18, 74, 91, 96, 104, 105, 77}
}
0 0 1 2 3 4 5 6 7
65 99 87 90 156 75 98 78
1 0 1 2 3 4 5 6 7
76 15 76 91 66 90 15 77
2 0 1 2 3 4 5 6 7
65 96 17 25 36 75 54 78
3 0 1 2 3 4 5 6 7
59 45 68 14 57 1 9 63
4 0 1 2 3 4 5 6 7
81 74 47 52 42 785 56 96
5 0 1 2 3 4 5 6 7
66 74 58 16 98 140 55 77
6 0 1 2 3 4 5 6 7
120 99 13 90 78 98 14 78
7 0 1 2 3 4 5 6 7
20 18 74 91 96 104 105 77
47 విలువను పొందడానికి, మీరు [4][2] వద్ద మాతృక మూలకాన్ని సూచించాలి. 

int number = matrix[4][2];
మాతృక కోఆర్డినేట్‌లు క్లాసికల్ దీర్ఘచతురస్రాకార కోఆర్డినేట్ సిస్టమ్ (కార్టీసియన్ కోఆర్డినేట్ సిస్టమ్) నుండి భిన్నంగా ఉన్నాయని మీరు గమనించి ఉండవచ్చు. మీరు మాతృకను యాక్సెస్ చేసినప్పుడు, మీరు మొదట y కోఆర్డినేట్ మరియు తర్వాత x కోఆర్డినేట్‌ను పేర్కొనండి. గణితంలో, ముందుగా x కోఆర్డినేట్‌ను పేర్కొనడం ఆచారం, అనగా (x, y). మీరు ఇలా ఆలోచిస్తూ ఉండవచ్చు: "సరే, మాతృక యొక్క మీ ప్రాతినిధ్యాన్ని ఎందుకు తిప్పకూడదు మరియు (x, y) ఉపయోగించి ఎలిమెంట్‌లను సాధారణ మార్గంలో ఎందుకు యాక్సెస్ చేయకూడదు? ఇలా చేయడం వలన మాతృకలోని కంటెంట్‌లు మారవు". అవును, ఏమీ మారదు. కానీ ప్రోగ్రామింగ్ ప్రపంచంలో, మాత్రికలను "మొదట y, తర్వాత x" ద్వారా యాక్సెస్ చేయడం ఆమోదించబడిన పద్ధతి. మీరు దీన్ని సరైన మార్గంగా అంగీకరించాలి. ఇప్పుడు మన ఇంజిన్‌కు మాతృకను ప్రొజెక్ట్ చేయడం గురించి మాట్లాడుదాం (Gameతరగతి). మీకు తెలిసినట్లుగా, ఇంజిన్ నిర్దిష్ట కోఆర్డినేట్ల వద్ద మైదానం యొక్క కణాలను మార్చే అనేక పద్ధతులను కలిగి ఉంది. ఉదాహరణకు, setCellValue(int x, int y, String value)పద్ధతి. ఇది విలువ పరామితికి సమానమైన కోఆర్డినేట్‌లతో (x, y) నిర్దిష్ట సెల్‌ను సెట్ చేస్తుంది. క్లాసికల్ కోఆర్డినేట్ సిస్టమ్‌లో మాదిరిగానే ఈ పద్ధతి మొదట xని తీసుకుంటుందని మీరు గమనించి ఉండవచ్చు. ఇంజిన్ యొక్క ఇతర పద్ధతులు ఇదే విధంగా పని చేస్తాయి. గేమ్‌లను అభివృద్ధి చేస్తున్నప్పుడు, స్క్రీన్‌పై మ్యాట్రిక్స్ స్థితిని పునరుత్పత్తి చేయడం తరచుగా అవసరం. మేము దానిని ఎలా చేస్తాము? ముందుగా, మీరు లూప్‌లోని అన్ని మ్యాట్రిక్స్ మూలకాల ద్వారా మళ్ళించవలసి ఉంటుంది. రెండవది, రివర్స్డ్ కోఆర్డినేట్‌లను ఉపయోగించి వాటిలో ప్రతిదానికి ప్రదర్శన పద్ధతిని కాల్ చేయండి. ఉదాహరణకి: 

private void drawScene() {
    for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[i].length; j++) {
            setCellValue(j, i, String.valueOf(matrix[i][j]));
        }
    }
}
సహజంగానే, రివర్సల్ రెండు దిశలలో పనిచేస్తుంది. మీరు (i, j) పద్ధతికి ఉత్తీర్ణత సాధించవచ్చు setCellValueమరియు మాతృక నుండి ఏకకాలంలో మూలకం [j][i]ని తీసుకోవచ్చు. కోఆర్డినేట్‌లను తిప్పికొట్టడం కొంచెం కష్టంగా అనిపించవచ్చు, కానీ మీరు దానిని గుర్తుంచుకోవాలి. మరియు ఎల్లప్పుడూ, మీకు ఏవైనా సమస్యలు ఎదురైతే, మీరు కాగితం ముక్క మరియు పెన్ను పట్టుకుని, మాతృకను గీయాలి మరియు మ్యాట్రిక్స్‌తో కూడిన ప్రక్రియలను పునరుత్పత్తి చేయాలి.

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

మీరు యాదృచ్ఛిక సంఖ్య జనరేటర్‌తో ఎలా పని చేస్తారు? తరగతి పద్ధతిని Gameనిర్వచిస్తుంది getRandomNumber(int). హుడ్ కింద, ఇది Randomjava.util ప్యాకేజీ నుండి తరగతిని ఉపయోగిస్తుంది, కానీ మీరు యాదృచ్ఛిక సంఖ్య జనరేటర్‌తో పని చేసే విధానం మారదు. getRandomNumber(int)పూర్ణాంకాన్ని వాదనగా తీసుకుంటుంది. ఈ సంఖ్య జనరేటర్ వాపసు చేసే గరిష్ట పరిమితిగా ఉంటుంది. తక్కువ పరిమితి 0. ముఖ్యమైనది! జెనరేటర్ ఎప్పటికీ ఎగువ పరిమితి సంఖ్యను తిరిగి ఇవ్వదు. ఉదాహరణకు, మీరు కాల్ చేస్తే getRandomNumber(3), అది యాదృచ్ఛికంగా 0, 1 లేదా 2ని అందిస్తుంది. మీరు చూడగలిగినట్లుగా, అది 3ని తిరిగి ఇవ్వదు. ఈ విధంగా జనరేటర్‌ని ఉపయోగించడం చాలా సులభం, కానీ చాలా సందర్భాలలో చాలా ప్రభావవంతంగా ఉంటుంది. మీరు కొంత పరిధిలో యాదృచ్ఛిక సంఖ్యను పొందాలని అనుకుందాం: మీకు [100..999] పరిధిలో మూడు అంకెల సంఖ్య అవసరమని ఊహించుకోండి. మీకు ఇప్పటికే తెలిసినట్లుగా, తిరిగి వచ్చిన కనీస సంఖ్య 0. కాబట్టి మీరు 100ని జోడించాలి. అయితే ఈ సందర్భంలో, మీరు గరిష్ట పరిమితిని మించకుండా జాగ్రత్త వహించాలి. గరిష్ట యాదృచ్ఛిక విలువగా 999ని పొందడానికి, కాల్ చేయండిgetRandomNumber(int)ఆర్గ్యుమెంట్ 1000తో పద్ధతి. కానీ ఇప్పుడు మనం ఫలితానికి 100ని జోడిస్తున్నామని గుర్తుంచుకోవాలి: దీని అర్థం ఎగువ సరిహద్దును 100 తగ్గించాలి. మరో మాటలో చెప్పాలంటే, మన యాదృచ్ఛిక మూడు అంకెల సంఖ్యను పొందే కోడ్ ఇలా కనిపిస్తుంది. : 

int number = 100 + getRandomNumber(900);
కానీ ఈ విధానాన్ని సులభతరం చేయడానికి, ఇంజిన్ getRandomNumber(int, int)మొదటి పరామితి కనీస సంఖ్యను తిరిగి ఇచ్చే పద్ధతిని అందిస్తుంది. ఈ పద్ధతిని ఉపయోగించి, మునుపటి ఉదాహరణను ఈ క్రింది విధంగా తిరిగి వ్రాయవచ్చు: 

int number = getRandomNumber(100, 1000);
యాదృచ్ఛిక శ్రేణి మూలకాన్ని పొందడానికి యాదృచ్ఛిక సంఖ్యలను ఉపయోగించవచ్చు: 

String [] names = {"Sarah", "Val", "Sergey"};
String randomName = names[getRandomNumber(names.length)]
కొంత సంభావ్యతతో కొన్ని ఈవెంట్‌లను రూపొందించడం. మానవులకు, ఉదయం కొన్ని సాధ్యమైన దృశ్యాలతో ప్రారంభమవుతుంది: అతిగా నిద్రపోవడం - 50% అవకాశం; సమయానికి మేల్కొన్నాను - 40% అవకాశం; ఒక గంట ముందుగానే మేల్కొన్నాను - 10% అవకాశం. మీరు ఉదయం ఫలితం జనరేటర్‌ని వ్రాస్తున్నారని ఊహించుకోండి. మీరు నిర్దిష్ట సంభావ్యతతో ఈవెంట్‌లను రూపొందించాలి. దీన్ని చేయడానికి, మీరు మళ్లీ యాదృచ్ఛిక సంఖ్య జనరేటర్‌ను ఉపయోగించాలి. వివిధ అమలులు సాధ్యమే, కానీ సరళమైనది క్రింది అల్గోరిథం ఆధారంగా ఉండాలి:
  1. సంఖ్యను రూపొందించడానికి ఉపయోగించే పరిమితులను సెట్ చేయండి;
  2. యాదృచ్ఛిక సంఖ్యను రూపొందించండి;
  3. పొందిన సంఖ్యను ప్రాసెస్ చేయండి.
ఈ సందర్భంలో, గరిష్టంగా 10 ఉంటుంది. కాల్getRandomNumber(10)పద్ధతి మరియు మేము దానిని తిరిగి చేయవచ్చు అని విశ్లేషించండి. ఇది 10 సంఖ్యలను (0 నుండి 9 వరకు) అందించగలదు, ప్రతి ఒక్కటి ఒకే సంభావ్యతతో — 10%. ఇప్పుడు మనం సాధ్యమయ్యే అన్ని ఫలితాలను కలపాలి మరియు వాటిని మా సాధ్యమయ్యే ఈవెంట్‌లకు మ్యాప్ చేయాలి. మీ ఊహ చాలా సాధ్యమైన కలయికల గురించి ఆలోచించవచ్చు, కానీ ఇక్కడ చాలా స్పష్టంగా ఉంది: "యాదృచ్ఛిక సంఖ్య [0..4] పరిధిలో ఉన్నట్లయితే, మేము "ఓవర్‌స్లెప్ట్" ఈవెంట్‌ను కలిగి ఉంటాము; సంఖ్య పరిధిలో ఉన్నట్లయితే [5 ..8], మేము "సమయానికి మేల్కొన్నాము" ఈవెంట్‌ని కలిగి ఉన్నాము; మరియు సంఖ్య 9 అయితే, మేము "ఒక గంట ముందుగానే మేల్కొన్నాము" ఈవెంట్‌ని కలిగి ఉన్నాము. ఇది చాలా సులభం. [0 పరిధిలో 5 సంఖ్యలు ఉన్నాయి. ..4], వీటిలో ప్రతి ఒక్కటి 10% సంభావ్యతతో, మొత్తం 50%కి అందించబడవచ్చు; [5..8] పరిధిలో 4 సంఖ్యలు ఉన్నాయి, అలాగే, 9 అనేది కేవలం ఒక సంఖ్యతో కనిపించే ఒక సంఖ్య 10% సంభావ్యత. 

int randomNumber = getRandomNumber(10);
if (randomNumber < 5) {
    System.out.println("Overslept");
} else if (randomNumber < 9) {
    System.out.println("Woke up on time");
} else {
    System.out.println("Woke up an hour early");
}
సాధారణంగా, యాదృచ్ఛిక సంఖ్యలను ఉపయోగించడానికి టన్నుల కొద్దీ మార్గాలు ఉన్నాయి. మీరు మీ ఊహకు మాత్రమే పరిమితం అయ్యారు. మీరు పదేపదే కొంత ఫలితాన్ని పొందాలంటే అవి చాలా ప్రభావవంతంగా ఉపయోగించబడతాయి. అప్పుడు కొత్త ఫలితం మునుపటి దానికంటే భిన్నంగా ఉంటుంది. కొంత సంభావ్యతతో, వాస్తవానికి. ఇప్పటికి ఇంతే! మీరు "గేమ్స్" విభాగం గురించి మరింత తెలుసుకోవాలనుకుంటే, సహాయపడే కొన్ని ఉపయోగకరమైన డాక్యుమెంటేషన్ ఇక్కడ ఉంది:

మరింత పఠనం: