கட்டுரை
தொடங்குங்கள்
கற்கத் தொடங்குங்கள்
இப்போதே கற்கத் தொடங்குங்கள்
CodeGym/Java Blog/சீரற்ற/கோட்ஜிம் பற்றிய விளையாட்டுப் பிரிவு: பயனுள்ள கோட்பாடு
John Squirrels
நிலை 41
San Francisco

கோட்ஜிம் பற்றிய விளையாட்டுப் பிரிவு: பயனுள்ள கோட்பாடு

சீரற்ற குழுவில் வெளியிடப்பட்டது
members
CodeGym இல் உள்ள "கேம்ஸ்" பிரிவில் , பிரபலமான கணினி கேம்களை எழுதுவதை உள்ளடக்கிய அற்புதமான திட்டங்களைக் காணலாம். பிரபலமான கேம்கள் 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: ஒரு முறையை மீறுதல்.
Java webinar 
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 ஆல் குறைக்க வேண்டும். வேறுவிதமாகக் கூறினால், நமது சீரற்ற மூன்று இலக்க எண்ணைப் பெறுவதற்கான குறியீடு இப்படி இருக்கும். :
Java university 
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 ஆக இருந்தால், "ஒரு மணிநேரம் முன்னதாகவே எழுந்திரு" நிகழ்வு உள்ளது. இது மிகவும் எளிமையானது. வரம்பில் 5 எண்கள் உள்ளன [0] ..4], ஒவ்வொன்றும் 10% நிகழ்தகவுடன் திரும்பப் பெறலாம், மொத்தம் 50%; வரம்பில் 4 எண்கள் உள்ளன [5..8], சரி, மேலும் 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");
}
பொதுவாக, சீரற்ற எண்களைப் பயன்படுத்த பல வழிகள் உள்ளன. நீங்கள் உங்கள் கற்பனையால் மட்டுமே வரையறுக்கப்பட்டிருக்கிறீர்கள். ஆனால் நீங்கள் மீண்டும் மீண்டும் சில முடிவுகளைப் பெற வேண்டும் என்றால் அவை மிகவும் திறம்பட பயன்படுத்தப்படுகின்றன. பின்னர் புதிய முடிவு முந்தையதை விட வித்தியாசமாக இருக்கும். சில நிகழ்தகவுடன், நிச்சயமாக. இப்பொழுது இத்துடன் நிறைவடைகிறது! "கேம்ஸ்" பகுதியைப் பற்றி மேலும் அறிய விரும்பினால், உதவக்கூடிய சில பயனுள்ள ஆவணங்கள் இங்கே உள்ளன:

மேலும் வாசிப்பு:
கருத்துக்கள்
  • பிரபலமானவை
  • புதியவை
  • பழையவை
ஒரு கருத்தைத் தெரிவிக்க நீங்கள் உள்நுழைந்திருக்க வேண்டும்
இந்தப் பக்கத்தில் இதுவரை எந்தக் கருத்தும் வழங்கப்படவில்லை