काहीतरी उपयुक्त

1. वारसा

CodeGym गेम इंजिनसह कार्य करण्यासाठी, तुम्हाला वारसा वापरण्याची आवश्यकता असेल . पण ते काय आहे हे तुम्हाला माहीत नसेल तर? एकीकडे, तुम्हाला हा विषय समजून घेणे आणि त्याचा अभ्यास करणे आवश्यक आहे. दुसरीकडे, इंजिन विशेषत: अगदी सोप्या पद्धतीने डिझाइन केलेले आहे, त्यामुळे तुम्ही वारशाचे वरवरचे ज्ञान मिळवू शकता.

तर वारसा म्हणजे काय? सोप्या भाषेत, वारसा हा दोन वर्गांमधील संबंध आहे. त्यापैकी एक पालक वर्ग म्हणून कार्य करतो आणि दुसरा मूल (वंशज) वर्ग बनतो. इतकेच काय, पालक वर्गाला हे सुद्धा माहीत नसावे की त्याचे वंशज वर्ग आहेत. दुसऱ्या शब्दांत, वंशज वर्ग असल्‍याने पालकांना फारसा फायदा मिळत नाही.

परंतु वारसा बालवर्गाला अनेक फायदे देतो. त्यापैकी सर्वात महत्त्वाचे म्हणजे पालक वर्गाचे सर्व चल आणि पद्धती बाल वर्गात दिसतात, जसे की पालक वर्गाचा कोड थेट बाल वर्गात कॉपी केला जातो. हे संपूर्णपणे अचूक नाही, परंतु वारशाच्या मूलभूत समजासाठी ते पुरेसे आहे.

तुम्हाला वारसा अधिक चांगल्या प्रकारे समजून घेण्यात मदत करण्यासाठी येथे काही उदाहरणे आहेत.

उदाहरण 1 - येथे सर्वात सोपे उदाहरण आहे

public class Parent
{
}

public class Child extends Parent
{
}

उदाहरण २ — पॅरेंट क्लासचे व्हेरिएबल्स वापरणे

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);

सूचीबद्दल अधिक माहितीसाठी, तुम्ही खालील लेख वाचू शकता:

• चित्रांमध्ये अॅरेलिस्ट
• ArrayList वर्ग
• ArrayList मधून आयटम काढत आहे

4. यादृच्छिक संख्या

CodeGym गेम इंजिनमध्ये दोन पद्धती आहेत ज्या यादृच्छिक संख्या निर्माण करण्यासाठी वापरल्या जाऊ शकतात. या पद्धती आहेत:

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.

गेममध्ये यादृच्छिक संख्या वापरण्याचे अनेक मार्ग आहेत. तुम्ही फक्त तुमच्या कल्पनेने मर्यादित आहात. तुमचे स्वतःचे गेम लिहा, त्यांना परिष्कृत करा आणि प्रक्रियेचा आनंद घ्या.

प्रत्येकजण गेम खेळू शकतो, परंतु केवळ प्रोग्रामर ते तयार करू शकतात.