Valami hasznos

1. Öröklés

A CodeGym játékmotor használatához öröklődést kell használnia . De mi van, ha nem tudod, mi az? Egyrészt meg kell értenie és tanulmányoznia kell ezt a témát. Másrészt a motort kifejezetten nagyon egyszerűre tervezték, így az öröklődés felületes ismeretével meg lehet boldogulni.

Tehát mi az öröklés? Egyszerűen fogalmazva, az öröklődés két osztály közötti kapcsolat. Az egyik szülő osztályként működik, a másik pedig a gyermek (leszármazott) osztály lesz. Ráadásul egy szülő osztály nem is tudja, hogy vannak leszármazott osztályai. Más szóval, a szülőnek nem sok haszna származik abból, hogy leszármazottai vannak.

De az öröklődés számos előnnyel jár a gyermekosztálynak. Ezek közül a legfontosabb, hogy a szülő osztály minden változója és metódusa megjelenik a gyermekosztályban, mintha a szülő osztály kódja közvetlenül a gyermekosztályba másolódott volna. Ez nem teljesen pontos, de elegendő az öröklődés alapvető megértéséhez.

Íme néhány példa, amelyek segítenek jobban megérteni az öröklődést.

1. példa – íme a legegyszerűbb példa

public class Parent
{
}

public class Child extends Parent
{
}

2. példa – a szülőosztály változóinak felhasználásával

public class Parent
{
  public int age;
  public String name;
}

public class Child extends Parent
{
  public void printInfo()
  {
    System.out.println(name + " " + age);
  }
}

3. példa – a szülőosztály metódusaival

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

Néhány részletet kihagyva elmondhatjuk, hogy a Java fordító szemszögéből egyszerűen bemásoltuk a szülő osztály kódját a gyermekosztály kódjába:

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. Módszer felülbírálása

Néha vannak olyan helyzetek, amikor az osztályunk Childegy nagyon hasznos Parentosztályt örököl, aminek következtében a gyermek örökli a szülő összes változóját és metódusát. De előfordulhat, hogy néhány ilyen módszer nem egészen úgy működik, ahogy szeretnénk, vagy egyáltalán nem úgy, ahogy szeretnénk.

Mit tesz ebben az esetben? Felülírhatunk egy olyan módszert, amelynek megvalósítását nem szeretjük . Ez egy egyszerű dolog: az osztályunkban Childegyszerűen deklarálunk egy metódust, amelynek aláírása megegyezik az Parentosztály metódusával, majd írjuk bele a saját kódunkat.

1. példa – módszer felülbírálása

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

A helyzetet némileg leegyszerűsítve, az öröklődés miatt a szülő osztály kódja átmásolódik a gyermekosztályba. De ha egy leszármazott osztály már egy metódus, amely létezik egy ősosztályban, akkor ez a metódus nem kerül kimásolásra az ősosztályból. Itt azt mondjuk, hogy a gyermek osztály metódusa felülírja a szülő osztály metódusát. Nézze meg az alábbi példát. Talán segít egy kicsit világosabbá tenni a dolgokat:

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. példa – egy kis öröklődési mágia (és a módszer felülbírálása)

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";
   }
}

Ha a printInfo()metódus egy típuson van meghívva Parent, az viszont meghívja az osztály getName()metódusát Parent.

Ha a printInfo()metódus meghívásra kerül egy Childobjektumon, az viszont meghívja az osztály getName()metódusát Child.

Más szóval, a printInfo()metódus csak az osztályban van deklarálva Parent, de meghívja az osztály getName()metódusát Child, ha a printInfo()metódus meghívásra kerül egy Childobjektumon.

Példa:

Parent parent = new Parent();
parent.printnInfo();

Luke

Child child = new Child();
child.printnInfo();

Luke, I am your father

És mindez azért, mert a fordító szemszögéből (nagyon leegyszerűsített változata) az osztály kódja Childígy néz ki:

public class Child extends Parent
{
   public getName() {
      return "Luke, I am your father";
   }

   public void printInfo()
   {
      System.out.println(getName());
   }
}

3. Listák

Íme egy rövid emlékeztető a listákról ( List). A listáknak sok közös vonásuk van a tömbökkel:

• Sok, egy adott típusú adatot tárolhatnak.
• Lehetővé teszik, hogy az indexük alapján elemeket kapjon.
• Az elemek indexei 0.

A listák előnyei:

A tömböktől eltérően a listák dinamikusan változtathatják a méretüket. Közvetlenül a létrehozás után a lista mérete 0. Ahogy az elemek hozzáadódnak a listához, a mérete növekszik. Példa lista létrehozására:

ArrayList<String> myList = new ArrayList<String>();

A szögletes zárójelben szereplő érték az az adattípus, amelyet a lista tárolhat.

Íme néhány módszer a listával való munkavégzéshez:

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

A listákkal kapcsolatos további információkért olvassa el a következő cikkeket:

• ArrayList képekben
• ArrayList osztály
• Elem eltávolítása egy ArrayList-ből

4. Véletlen számok

A CodeGym játékmotornak két módja van véletlen számok generálására. Ezek a módszerek a következők:

int getRandomNumber(int max)

int getRandomNumber(int min, int max)

Az első metódus — — véletlen számot ad vissza a , , , ... getRandomNumber(int max)tartományban . A motorháztető alatt a csomagban szereplő osztályt használja , de ez nem változtat a véletlen számok használatán.012max-1Randomjava.util

getRandomNumber(int)egész számot fogad el argumentumként. Ez a szám lesz azoknak a számoknak a felső korlátja, amelyeket a véletlenszám-generátor vissza tud adni. Az alsó határ 0. Figyelem! A véletlenszám-generátor SOHA nem adja vissza a felső korlát értékét. Például, ha meghívja getRandomNumber(3)a , véletlenszerűen 0, 1 vagy 2 értéket ad vissza. Mint látható, nem ad vissza 3-at. A véletlenszám-generátor ilyen módon történő használata meglehetősen egyszerű, de sok esetben megfelelő.

A második módszer — getRandomNumber(int min, int max)— egy véletlenszerű egész számot ad vissza a tartományban [min, max-1]. Soha nem ad vissza nál kisebb számot min, és soha nem ad vissza nál nagyobb számot max-1.

Hogyan használhatók ezek a módszerek a gyakorlatban?

1. Kocka

Tegyük fel, hogy egy kockadobást szeretné szimulálni, és egy véletlen számot szeretne kapni a tartományban 1-6. Hogyan csinálnád? Ezt a következő kóddal lehet megtenni:

int dice = getRandomNumber(1, 7);

Ez a metódus egy véletlenszerű egész számot ad vissza a tartományban 1-6.

2. Célgyakorlat

Tegyük fel, hogy egy célpontra való lövöldözést szeretne szimulálni, és a lövés pontossága egy véletlenszerű összetevőt tartalmaz, amely tartományban -10változik +10. Ezt a következő kóddal lehet megtenni:

int dx = getRandomNumber(-10, 11);

Ez a módszer egy véletlenszerű egész számot ad vissza a -10következő tartományban +10.

Számos módja van a véletlen számok használatának a játékokban. Csak a képzeleted szab határt. Írja meg saját játékait, finomítsa őket, és élvezze a folyamatot.

Mindenki tud játszani, de csak a programozók készíthetik el azokat.