பயனுள்ள ஒன்று

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.

கேம்களில் சீரற்ற எண்களைப் பயன்படுத்த பல வழிகள் உள்ளன. நீங்கள் உங்கள் கற்பனையால் மட்டுமே வரையறுக்கப்பட்டிருக்கிறீர்கள். உங்கள் சொந்த கேம்களை எழுதுங்கள், அவற்றைச் செம்மைப்படுத்தி, செயல்முறையை அனுபவிக்கவும்.

எல்லோரும் கேம்களை விளையாடலாம், ஆனால் புரோகிராமர்கள் மட்டுமே அவற்றை உருவாக்க முடியும்.