Mga Klase sa Java: pagsulat ng iyong sariling mga klase, mga tagapagtayo

Hi! Ngayon ay pag-uusapan natin ang tungkol sa mga klase sa Java. Maaari mong sabihin na ang mga klase ay bumubuo sa pundasyon ng Java programming. Kapag naging programmer ka, halos buong trabaho mo ay magsulat ng sarili mong mga klase na may iba't ibang function. Tingnan natin kung ano ang ibig sabihin nito at kung paano ito gumagana. :) Tulad ng alam mo, ang Java ay isang object-oriented programming language. Ang lahat ng mga programa ay binubuo ng mga bagay na sa isang paraan o iba ay nauugnay sa isa't isa. Ang isang klase ay, mahalagang, isang template para sa isang bagay. Tinutukoy nito kung ano ang magiging hitsura ng bagay at kung ano ang mga pag-andar nito. Ang bawat bagay ay isang bagay ng ilang klase. Isaalang-alang ang napakasimpleng halimbawang ito:

public class Cat {

    String name;
    int age;

}

Sabihin nating nagsusulat kami ng isang programa na nagsasangkot ng mga pusa para sa ilang kadahilanan (halimbawa, mayroon kaming isang beterinaryo na klinika na nag-aalok ng access sa isang online na account). Gumawa kami ng klase ng Cat , at nagdeklara ng dalawang variable dito: String name at int age . Ang mga miyembrong variable na ito ay tinatawag na mga field. Sa pangkalahatan, ito ay isang template para sa lahat ng pusang gagawin namin sa hinaharap. Ang bawat object ng Cat ay magkakaroon ng dalawang variable: isang pangalan at isang edad.

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";

        System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
    }

}

Narito kung paano ito gumagana! Gumagawa kami ng pusa, binibigyan ito ng pangalan at edad, at ipinapakita ang lahat sa console. Madali lang. :) Mas madalas kaysa sa hindi, ang mga klase ay naglalarawan ng mga bagay at phenomena sa totoong mundo. Isang pusa, isang mesa, isang tao, isang kidlat, isang pahina ng isang libro, isang gulong—gagawin mo ang lahat ng mga bagay na ito sa iyong mga programa gamit ang mga indibidwal na klase. Sa ngayon, tumuon tayo sa mga variable na idineklara natin sa klase ng Cat . Ang mga ito ay tinatawag na mga patlang, o mga variable ng halimbawa. Ang pangalan nila talaga ang nagsasabi ng lahat. Ang bawat instance (o object) ng klase ng Cat ay magkakaroon ng mga variable na ito. Ang bawat pusa na gagawin namin ay magkakaroon ng sarili nitong variable ng pangalan at sarili nitong edadvariable. Ito ay may katuturan-ito ay karaniwang kung paano ito ay may tunay na pusa. :) Bilang karagdagan sa mga variable ng halimbawa, mayroon ding mga variable ng klase (static variable). Tapusin natin ang ating halimbawa:

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";
        count++;

        Cat fluffy = new Cat();
        fluffy.age = 5;
        fluffy.name = "Fluffy";
        count++;

        System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
        System.out.println("We created a cat named " + fluffy.name + ". His age is " + fluffy.age);

        System.out.println("Total number of cats = " + count);
    }
}

Output ng console: Gumawa kami ng pusa na pinangalanang Smudge. Ang kanyang edad ay 3 Lumikha kami ng isang pusa na pinangalanang Fluffy. Ang kanyang edad ay 5 Kabuuang bilang ng mga pusa = 2 Ngayon ang aming klase ay may bagong variable na tinatawag na bilang. Responsable ito sa pagbibilang ng mga nilikhang pusa. Sa bawat oras na lumikha kami ng isang pusa sa pangunahingparaan, dinadagdagan namin ang variable na ito ng 1. Idineklara ang variable na ito gamit ang keyword na static. Ibig sabihin, ito ay kabilang sa klase, hindi sa isang partikular na bagay ng klase. Na, siyempre, ay may katuturan: ang pangalan ng bawat pusa ay kabilang sa partikular na pusang iyon, ngunit kailangan namin ng isang cat counter na naaangkop sa kanilang lahat. Ito mismo ang nagagawa ng static na keyword: ginagawa nitong iisang variable ang count variable para sa lahat ng pusa. Tandaan: kapag ipinakita namin ang variable, hindi kami gumagamit ng smudge.count o fluffy.count. Hindi ito kabilang sa alinman sa Smudge o Fluffy; ito ay kabilang sa buong klase ng Cat . Kaya lang binibilang lang. Maaari mo ring isulat ang Cat.count. Tama rin sana iyon. Kapag ipinakita ang variable ng pangalan, hindi namin gagawin ang sumusunod:

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";
        count++;

        System.out.println("We created a cat named " + name + ". His age is " + smudge.age);

        System.out.println("Total number of cats = " + count);
    }
}

Ito ay isang error! Ang bawat pusa ay may sariling pangalan. Ang compiler ay nalilito dito. "Mag-output ng pangalan sa console? Kaninong pangalan?" :/"

Paraan

Bilang karagdagan sa mga variable, ang bawat klase ay may mga pamamaraan. Pag-uusapan natin ang mga ito nang mas detalyado sa isang hiwalay na aralin, ngunit ang mga pangkalahatang prinsipyo ay medyo simple. Tinutukoy ng mga pamamaraan ang paggana ng iyong klase, ibig sabihin, kung anong mga bagay ang magagawa ng iyong klase. Pamilyar ka na sa isa sa mga pamamaraang ito: ang pangunahing() na pamamaraan. Ngunit, tulad ng maaalala mo, ang pangunahing pamamaraan ay static, na nangangahulugang ito ay kabilang sa buong klase (ang lohika ay kapareho ng sa mga variable). Gayunpaman, ang mga karaniwang, non-static na pamamaraan ay maaari lamang tawagin sa mga partikular na bagay na aming ginawa. Halimbawa, kung gusto nating magsulat ng klase ng pusa, kailangan nating malaman kung anong mga function ang dapat magkaroon ng pusa sa ating programa. Sa premise na iyon, magsulat tayo ng ilang pamamaraan para sa ating pusa:

public class Cat {

    String name;
    int age;

    public void sayMeow() {
        System.out.println("Meow!");
    }

    public void jump() {
        System.out.println("Pounce!");
    }

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";

        smudge.sayMeow();
        smudge.jump();

    }
}

Tingnan ito! Ngayon ang aming klase ay mas malapit na sa kahawig ng isang pusa! Ngayon hindi lang kami may pusang may pangalan ("Smudge") at may edad (3). Marunong din siyang mag meow at tumalon! Anong uri ng pusa ito kung wala ang "functionality" na iyon? :) Kami ay kumukuha ng isang partikular na bagay (smudge) at tinatawag ang mga pamamaraang sayMeow() at jump() nito . Tingnan natin ang console: Meow! Pounce! Isang tunay na pusa! :)

Paglikha ng iyong sariling mga klase. Abstraction

Sa hinaharap, kakailanganin mong magsulat ng iyong sariling mga klase. Ano ang kailangan mong abangan kapag isinusulat mo ang mga ito? Kung pinag-uusapan natin ang tungkol sa mga variable, kakailanganin mong gumamit ng isang bagay na tinatawag na abstraction. Ang abstraction ay isa sa apat na pangunahing prinsipyo ng object-oriented programming. Nangangahulugan ito ng pagkuha ng pinakamahalaga at makabuluhang katangian ng isang bagay, at sa kabaligtaran, itabi ang mga maliliit o hindi gaanong mahalaga. Halimbawa, gumawa tayo ng filing cabinet para sa mga empleyado ng kumpanya. Upang lumikha ng mga bagay ng empleyado, nagsulat kami ng isang Empleyadoklase. Anong mga katangian ang mahalagang tagapaglarawan ng isang empleyado para sa filing cabinet ng aming kumpanya? Pangalan, petsa ng kapanganakan, SSN, at ID ng empleyado. Ngunit malamang na hindi natin kakailanganin ang taas, kulay ng mata, o kulay ng buhok ng empleyado para sa talaan ng empleyado ng kumpanya. Hindi kailangan ng mga kumpanya ang impormasyong ito. Kaya, sa klase ng Employee , ipinapahayag namin ang mga sumusunod na variable: String name , int age , int socialSecurityNumber , at int employeeId. At iniiwan namin ang hindi kinakailangang impormasyon (tulad ng kulay ng mata). Sa madaling salita, lumikha kami ng abstraction. Gayunpaman, kung gagawa kami ng filing cabinet para sa mga ahensya ng pagmomolde, ang sitwasyon ay kapansin-pansing nagbabago. Ang taas, kulay ng mata, at kulay ng buhok ng isang modelo ay mahalagang katangian, ngunit ang kanyang SSN ay ganap na walang kaugnayan sa amin. Kaya, sa klase ng Modelo , kailangan nating lumikha ng mga sumusunod na variable: String height , String hair , String eyes . Ganyan gumagana ang abstraction—madali lang! :)

Mga konstruktor

Bumalik tayo sa ating halimbawa ng pusa.

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat smudge = new Cat();

        System.out.println("Here the program does something for 2 hours...");

        smudge.age = 3;
        smudge.name = "Smudge";

    }
}

Tingnan ang code na ito at subukang malaman kung ano ang mali sa aming programa. Ang aming programa ay may pusang walang pangalan o edad sa loob ng 2 oras! Siyempre, ito ay likas na mali. Ang database ng veterinary clinic ay hindi dapat magsama ng mga pusang walang impormasyon. Sa kasalukuyan, ang aming pusa ay nasa awa ng programmer. Nagtitiwala kami na hindi niya makakalimutang tukuyin ang pangalan at edad, at magiging okay ang lahat. Kung nakalimutan niya, ang database ay magkakaroon ng problema: hindi pinangalanang mga pusa. Paano natin malulutas ang problemang ito? Dapat nating pigilan ang mga pusa na malikha nang walang pangalan at edad. Dito sumagip ang mga konstruktor. Magbigay tayo ng isang halimbawa:

public class Cat {

    String name;
    int age;

    // Constructor for the Cat class
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
    }
}

Mahalaga, ang isang constructor ay isang template para sa mga bagay ng isang klase. Sa kasong ito, ipinapahiwatig namin na ang dalawang argumento, isang String at isang int , ay dapat tukuyin para sa bawat bagay ng pusa . Kung susubukan naming lumikha ng isang walang pangalan na pusa ngayon, hindi ito gagana.

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // Error!
    }
}

Ngayon na ang klase ay may constructor, alam ng Java compiler kung ano ang dapat na hitsura ng mga bagay, at hindi pinapayagan ang mga bagay na malikha nang hindi tinukoy ang mga argumento. Ngayon, imbestigahan natin ang keyword na ito, na nakikita mo sa loob ng constructor. Simple lang din. Ang keyword na ito ay para sa pagpahiwatig ng isang partikular na bagay. Ang code sa constructor

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

maaaring bigyang-kahulugan halos verbatim: "Ang pangalan ng pusang ito (ang ginagawa natin) = ang argumento na ipinasa para sa parameter ng pangalan ng tagabuo. Ang edad ng pusang ito (ang ginagawa natin) = ang argumento na ipinasa para sa tagapagtayo. parameter ng edad." Pagkatapos tumakbo ng constructor, maaari mong i-verify na ang lahat ng kinakailangang value ay naitalaga sa aming pusa:

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
        System.out.println(smudge.name);
        System.out.println(smudge.age);
    }
}

Output ng console: Smudge 5 Noong tinawag ang constructor:

Cat smudge = new Cat("Smudge", 5);

Ito ang aktwal na nangyari sa loob:

this.name = "Smudge";
this.age = 5;

At ang mga halaga ng mga argumento na ipinasa sa constructor ay itinalaga sa smudge object (iyan ang tinutukoy nito sa kasong ito). Sa katunayan, kahit na hindi ka magdeklara ng anumang mga constructor sa isang klase, tatawag pa rin ito ng isang constructor! Ngunit paano ito posible? О_О Dahil, ang lahat ng mga klase ng Java ay may tinatawag na default constructor. Hindi ito nangangailangan ng anumang mga argumento, ngunit ito ay hinihingi sa bawat oras na lumikha ka ng anumang bagay ng anumang klase.

public class Cat {

    public static void main(String[] args) {

        Cat smudge = new Cat(); // The default constructor is invoked here
    }
}

Sa unang tingin, maaaring hindi ito halata. Gumawa kami ng isang bagay, kaya ano? Nasaan ang gumagawa ng anumang bagay dito? Para makita ito, tahasang magsulat tayo ng walang laman na constructor para sa klase ng Cat . Sa loob nito, maglalabas kami ng ilang parirala sa console. Kung ang parirala ay ipinapakita, kung gayon ang tagabuo ay tinawag.

public class Cat {

    public Cat() {
        System.out.println("A cat has been created!");
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // The default constructor is invoked here
    }
}

Output ng console: Isang pusa ang nagawa! Nandiyan ang kumpirmasyon. Ang default na tagabuo ay palaging hindi nakikita sa iyong mga klase. Ngunit kailangan mong malaman ang isa pang bagay tungkol dito. Ang default na constructor ay tinanggal mula sa isang klase kapag lumikha ka ng isang constructor na may mga argumento. Sa katunayan, nakita na natin ang patunay nito sa itaas. Ito ay nasa code na ito:

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // Error!
    }
}

Hindi kami makakagawa ng Cat nang walang pangalan at edad, dahil nagdeklara kami ng Cat constructor na may string at int na mga parameter. Naging sanhi ito upang ang default na tagabuo ay agad na mawala sa klase. Kaya siguraduhing tandaan na kung kailangan mo ng ilang mga konstruktor sa iyong klase, kabilang ang isang walang-argumentong tagabuo, kakailanganin mong ideklara ito nang hiwalay. Nais ng aming klinika na gumawa ng mabubuting gawa at tumulong sa mga kuting na walang tirahan na hindi alam ang mga pangalan at edad. Kung gayon ang aming code ay dapat magmukhang ganito:

public class Cat {

    String name;
    int age;

    // For cats with owners
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // For street cats
    public Cat() {
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
        Cat streetCat = new Cat();
    }
}

Ngayong natukoy na namin ang isang tahasang default na tagabuo, maaari kaming lumikha ng parehong uri ng pusa. Sa constructor, maaari kang direktang magtalaga ng mga halaga. Hindi mo kailangang palaging kunin ang mga ito mula sa mga argumento. Halimbawa, maaari naming lagyan ng label ang lahat ng pusang kalye sa database gamit ang "Street cat No. <count>" bilang isang template. :

public class Cat {

    String name;
    int age;

    static int count = 0;

    public Cat() {
        count++;
        this.name = "Street cat No. " + count;
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat streetCat1 = new Cat();
        Cat streetCat2 = new Cat();
        System.out.println(streetCat1.name);
        System.out.println(streetCat2.name);
    }
}

Mayroon kaming variable na bilang , na binibilang ang aming mga pusa sa kalye. Sa tuwing isasagawa ang default na constructor, dinadagdagan namin ang bilang ng 1 at ilakip ang numerong ito sa pangalan ng pusa. Ang pagkakasunud-sunod ng mga argumento ay napakahalaga para sa mga konstruktor. Palitan natin ang mga argumento ng pangalan at edad na ipinasa sa ating constructor.

public class Cat {

    String name;
    int age;

    public Cat(int age, String name) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 10); // Error!
    }
}

Nagkaroon kami ng error! Malinaw na itinatakda ng tagabuo na kapag nilikha ang isang bagay na Cat , dapat itong magpasa ng isang numero at isang string, sa ganitong pagkakasunud-sunod. Kaya, hindi gumagana ang aming code. Tiyaking tandaan at igalang ang panuntunang ito kapag nagdedeklara ng sarili mong mga klase:

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

public Cat(int age, String name) {
    this.age = age;
    this.name = name;
}

Ito ay dalawang ganap na magkaibang mga konstruktor! Ngayon, kumpletuhin ang ilang gawain upang patatagin ang iyong pag-unawa sa materyal. :)

Museo ng Antiquities.

Ang iyong gawain ay magdisenyo ng klase ng Artifact .
May tatlong uri ng artifact na iniingatan sa museo.
Wala kaming alam tungkol sa unang uri maliban sa serial number na itinalaga ng museo (halimbawa: 212121).
Para sa pangalawang uri, alam namin ang serial number at ang kulturang lumikha nito (halimbawa: 212121, "Aztecs").
Para sa ikatlong uri, alam natin ang serial number, ang kulturang lumikha nito, at ang siglo kung saan ito nilikha (halimbawa: 212121, "Aztecs", 12).

Gumawa ng klase ng Artifact na naglalarawan sa mga antiquities na itinatago sa museo, at isulat ang kinakailangang hanay ng mga constructor para sa klase. Pagkatapos, sa pangunahing() na pamamaraan, lumikha ng isang artifact ng bawat uri.
```
public class Artifact {

    // Write your code here

    public static void main(String[] args) {
        // Write your code here
    }
}
```
Website ng pakikipag-date

Gumawa tayo ng database ng user para sa isang dating website.
Ngunit narito ang problema: nakalimutan mo ang kinakailangang pagkakasunud-sunod ng mga argumento, at walang magagamit na teknikal na dokumentasyon.
Magdisenyo ng klase ng User , na magkakaroon ng mga sumusunod na field: name ( String ), edad ( short ), at height ( int ).
Lumikha ng naaangkop na bilang ng mga konstruktor, upang ang pangalan, edad, at taas ay matukoy sa anumang pagkakasunud-sunod.
```
public class User {

    String name;
    short age;
    int height;

    // Write your code here

    public static void main(String[] args) {

    }
}
```

Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course

Higit pang pagbabasa:
Anonymous na klase Mga static na nested na klase Mga nested na panloob na klase Mga relasyon sa pagitan ng mga klase. Pamana, komposisyon, at pagsasama-sama Ang pagkakaiba sa pagitan ng mga abstract na klase at mga interface