1. Pamana
Upang gumana sa CodeGym game engine, kakailanganin mong gumamit ng inheritance . Ngunit paano kung hindi mo alam kung ano iyon? Sa isang banda, kailangan mong maunawaan at pag-aralan ang paksang ito. Sa kabilang banda, ang makina ay espesyal na idinisenyo upang maging napaka-simple, upang makayanan mo ang isang mababaw na kaalaman sa mana.
Kaya ano ang mana? Sa madaling salita, ang mana ay isang relasyon sa pagitan ng dalawang klase. Ang isa sa kanila ay nagsisilbing parent class, at ang isa ay nagiging child (descendant) class. Higit pa rito, maaaring hindi alam ng isang magulang na klase na mayroon itong mga descendant na klase. Sa madaling salita, hindi gaanong nakikinabang ang magulang sa pagkakaroon ng mga descendant classes.
Ngunit ang pamana ay nagbibigay ng maraming pakinabang sa klase ng bata. Ang pinakamahalaga sa kanila ay ang lahat ng mga variable at pamamaraan ng parent class ay lilitaw sa child class, na parang ang code ng parent class ay direktang kinopya sa child class. Ito ay hindi ganap na tumpak, ngunit ito ay sapat na para sa isang pangunahing pag-unawa sa mana.
Narito ang ilang halimbawa upang matulungan kang mas maunawaan ang mana.
Halimbawa 1 — narito ang pinakasimpleng halimbawa
|
Child Namana ng klase ang Parent klase sa tulong ng extends keyword. |
|
Halimbawa 2 — gamit ang mga variable ng parent class
|
Child Maaaring gamitin ng klase ang age at name mga patlang ng Parent klase na parang idineklara sa Child klase mismo. |
|
Halimbawa 3 — gamit ang mga pamamaraan ng parent class
|
Maaaring gamitin ng Child klase ang mga variable at pamamaraan ng klase ng Parent na parang idineklara sila sa Child klase. Sa halimbawang ito, ginagamit namin ang getName() pamamaraan. |
|
Sa pag-alis ng ilang detalye, masasabi nating mula sa pananaw ng Java compiler, kinopya lang namin ang code ng parent class sa code ng child class:
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);
}
}
Child
lumilitaw ang klase mula sa punto ng view ng compiler
2. Pamamaraan override
Minsan may mga sitwasyon kung saan ginagawa naming Child
magmana ang aming klase ng isang napaka-kapaki-pakinabang Parent
na klase, na nagiging dahilan upang mamanahin ng bata ang lahat ng mga variable at pamamaraan ng magulang. Ngunit ang ilan sa mga pamamaraang iyon ay maaaring hindi gumana sa paraang gusto natin o hindi sa paraang gusto natin.
Ano ang gagawin mo sa kasong ito? Maaari naming i-override ang isang paraan na ang pagpapatupad ay hindi namin gusto . Ito ay isang simpleng bagay na dapat gawin: sa aming Child
klase ay nagdedeklara lang kami ng isang pamamaraan na may parehong lagda tulad ng pamamaraan sa Parent
klase at pagkatapos ay isulat ang aming sariling code dito.
Halimbawa 1 — overriding ng paraan
|
printInfo() Ipapakita ng pamamaraan ang sumusunod na parirala:
|
|
Masyadong pinasimple ang sitwasyon, ang pamana ay nagiging sanhi ng pagkopya ng code ng parent class sa child class. Ngunit kung ang isang descendant class ay isa nang pamamaraan na umiiral sa isang ancestor class, kung gayon ang paraang iyon ay hindi kinopya mula sa ancestor class. Dito sinasabi namin na ang pamamaraan sa klase ng bata ay na-override ang pamamaraan sa klase ng magulang. Tingnan ang halimbawa sa ibaba. Marahil ay makakatulong ito na gawing mas malinaw ang mga bagay:
Narito kung paano lumalabas ang klase ng Bata mula sa pananaw ng compiler: |
---|
|
Halimbawa 2 - isang maliit na inheritance magic (at overriding ng paraan)
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";
}
}
Kung ang printInfo()
pamamaraan ay tinatawag sa isang Parent
uri, ito naman ay tinatawag na getName()
paraan ng Parent
klase.
Kung ang printInfo()
pamamaraan ay tinatawag sa isang Child
bagay, ito naman ay tinatawag na getName()
pamamaraan ng Child
klase.
Sa madaling salita, ang printInfo()
pamamaraan ay idineklara lamang sa Parent
klase, ngunit tinatawag nito ang getName()
pamamaraan ng Child
klase kung ang printInfo()
pamamaraan ay tinatawag sa isang Child
bagay.
Halimbawa:
|
Ipinapakita ng code na ito ang sumusunod na teksto sa screen:
|
|
Ipinapakita ng code na ito ang sumusunod na teksto sa screen:
|
At lahat dahil mula sa punto ng view ng compiler (isang napakasimpleng bersyon nito), ang code ng Child
klase ay ganito ang hitsura:
public class Child extends Parent
{
public getName() {
return "Luke, I am your father";
}
public void printInfo()
{
System.out.println(getName());
}
}
Child
lumilitaw ang klase mula sa punto ng view ng compiler
3. Mga listahan
Narito ang isang maikling paalala tungkol sa mga listahan ( List
). Ang mga listahan ay may maraming pagkakatulad sa mga array:
- Maaari silang mag-imbak ng maraming data ng isang partikular na uri.
- Hinahayaan ka nilang makakuha ng mga elemento ayon sa kanilang index.
- Ang mga indeks ng mga elemento ay nagsisimula sa
0
.
Mga kalamangan ng mga listahan:
Hindi tulad ng mga array, ang mga listahan ay maaaring dynamic na magbago ng laki. Kaagad pagkatapos ng paggawa, ang laki ng isang listahan ay 0
. Habang idinaragdag ang mga item sa listahan, tumataas ang laki nito. Halimbawa ng paggawa ng listahan:
ArrayList<String> myList = new ArrayList<String>();
ArrayList
Ang value na ipinahiwatig sa mga angle bracket ay ang uri ng data na maiimbak ng listahan.
Narito ang ilang paraan para magtrabaho kasama ang isang listahan:
Code | Maikling paglalarawan |
---|---|
|
Paglikha ng bagong listahan ng mga string |
|
Magdagdag ng elemento sa dulo ng listahan |
|
Magdagdag ng elemento sa simula ng listahan |
|
Kumuha ng elemento sa pamamagitan ng index nito |
|
Baguhin ang isang elemento sa pamamagitan ng index nito |
|
Kunin ang bilang ng mga elemento sa listahan |
|
Alisin ang isang elemento sa listahan |
Para sa higit pang impormasyon tungkol sa mga listahan, maaari mong basahin ang mga sumusunod na artikulo:
4. Random na mga numero
Ang CodeGym game engine ay may dalawang pamamaraan na maaaring magamit upang makabuo ng mga random na numero. Ang mga pamamaraang ito ay:
int getRandomNumber(int max)
int getRandomNumber(int min, int max)
Ang unang paraan — getRandomNumber(int max)
— ay nagbabalik ng random na numero sa hanay 0
, 1
, 2
, ... max-1
. Sa ilalim ng hood, ginagamit nito ang Random
klase mula sa java.util
package, ngunit hindi iyon nagbabago kung paano ka gumagamit ng random na numero.
getRandomNumber(int)
tumatanggap ng integer bilang argumento. Ang numerong ito ang magiging upper bound sa mga numero na maaaring ibalik ng random number generator. Ang lower bound ay 0. Pansin! HINDI ibabalik ng random number generator ang halaga ng upper bound. Halimbawa, kung tatawag ka sa getRandomNumber(3)
, sapalarang babalik ito sa alinman sa 0, 1, o 2. Gaya ng nakikita mo, hindi ito babalik ng 3. Ang paggamit ng random na generator ng numero sa paraang ito ay medyo simple, ngunit ito ay angkop para sa maraming mga kaso.
Ang pangalawang paraan — getRandomNumber(int min, int max)
— ay nagbabalik ng random na integer sa hanay [min, max-1]
. Hindi ito magbabalik ng numerong mas mababa sa min
, at hinding hindi ito magbabalik ng numerong mas malaki kaysa sa max-1
.
Paano magagamit ang mga pamamaraang ito sa pagsasanay?
1. Dice
Ipagpalagay na gusto mong gayahin ang roll ng isang die at makakuha ng random na numero sa hanay 1-6
. Paano mo ito gagawin? Magagawa ito gamit ang code na tulad nito:
int dice = getRandomNumber(1, 7);
Ang pamamaraang ito ay magbabalik ng random na integer sa hanay 1-6
.
2. Target na pagsasanay
Ipagpalagay na gusto mong gayahin ang pagbaril sa isang target, at ang katumpakan ng isang shot ay may kasamang random na bahagi na nag-iiba sa hanay mula -10
hanggang +10
kasama. Magagawa ito gamit ang code na tulad nito:
int dx = getRandomNumber(-10, 11);
Ang pamamaraang ito ay magbabalik ng random na integer sa hanay -10
sa +10
.
Mayroong maraming mga paraan upang gumamit ng mga random na numero sa mga laro. Nalilimitahan ka lamang ng iyong imahinasyon. Sumulat ng iyong sariling mga laro, pinuhin ang mga ito, at tamasahin ang proseso.
Ang lahat ay maaaring maglaro, ngunit ang mga programmer lamang ang maaaring lumikha ng mga ito.