Panimula sa mga klase: pagsulat ng iyong sariling mga klase, mga konstruktor

Kamusta! Ngayon ay pag-uusapan natin ang tungkol sa mga klase sa Java. Ang mga klase ay masasabing ang core ng Java programming. Kapag naging programmer ka, ang iyong pangunahing gawain ay magsulat ng sarili mong mga klase na may iba't ibang functionality. Alamin natin kung ano ang bagay na ito at kung paano ito gumagana :) Tulad ng alam mo na, ang Java ay isang object-oriented programming language. Ang lahat ng mga programa ay binubuo ng mga bagay na kahit papaano ay konektado sa isa't isa. Ang isang klase ay mahalagang isang template para sa isang bagay. Tinutukoy nito kung ano ang magiging hitsura ng isang bagay at kung ano ang mga function nito. Ang bawat bagay ay isang bagay ng ilang klase . Tingnan natin ang pinakasimpleng halimbawa:

public class Cat {

    String name;
    int age;

}

Sabihin nating nagsusulat kami ng isang programa, at sa programang ito kailangan namin ng mga pusa para sa isang bagay (halimbawa, mayroon kaming isang beterinaryo na klinika na may kakayahang gumawa ng isang online na appointment). Gumawa kami ng isang klase Catat tinukoy ang dalawang variable para dito - isang string nameat isang numero age. Ang ganitong mga variable ng klase ay tinatawag na mga patlang . Sa pangkalahatan, ito ay isang template para sa lahat ng pusang gagawin namin sa hinaharap. Ang bawat pusa (class object Cat) ay magkakaroon ng dalawang variable - pangalan at edad.

public class Cat {

    String name;
    int age;

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

        System.out.println("We created a cat named" + barsik.name + ", his age - " + barsik.age);
    }

}

Iyan ay kung paano ito gumagana! Gumawa kami ng pusa, binigyan ito ng pangalan at edad, at inilabas ang lahat sa console. Walang kumplikado :) Ang mga klase ay kadalasang naglalarawan ng mga bagay at phenomena ng nakapaligid na mundo. Isang pusa, isang mesa, isang tao, kidlat, isang pahina ng libro, isang gulong - lahat ng ito ay malilikha sa iyong programa gamit ang hiwalay na mga klase. Ngayon tingnan natin ang mga variable na nilikha namin sa klase Cat. Ang mga ito ay tinatawag na mga field, o mga variable ng instance . Ang pangalan, sa katunayan, ay nagpapakita ng kanilang buong diwa. Ang bawat instance (object) ng klase ay magkakaroon ng mga variable na ito Cat. Ang bawat pusa na nilikha namin ay magkakaroon ng sarili nitong variable nameat sarili nitong age. Ito ay lohikal, sa pangkalahatan: sa mga totoong pusa, lahat ay pareho :) Bilang karagdagan sa mga variable ng instance, may iba pa - mga variable ng klase , o mga static. Idagdag natin sa ating halimbawa:

public class Cat {

    String name;
    int age;

    static int count = 0;

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

        Cat vasia = new Cat();
        vasia.age = 5;
        vasia.name = "Vasya";
        count++;

        System.out.println("We created a cat named" + barsik.name + ", his age - " + barsik.age);
        System.out.println("We created a cat named" + vasia.name + ", his age - " + vasia.age);

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

Output ng console:

Мы создали кота по имени Барсик, его возраст - 3
Мы создали кота по имени Вася, его возраст - 5
Общее количество котов = 2

Ngayon mayroon kaming bagong variable sa aming klase - count(dami). Siya ang may pananagutan sa pagbibilang ng mga nilikhang pusa. Sa bawat oras na gumawa kami ng pusa sa pangunahing pamamaraan, dinaragdagan namin ang variable na ito ng 1. Ang variable na ito ay itinalaga ng static na keyword . Nangangahulugan ito na kabilang ito sa klase , at hindi sa isang partikular na bagay ng klase. Alin, siyempre, ay lohikal: kung ang bawat pusa ay dapat magkaroon ng sarili nitong pangalan, kailangan namin ng isang cat counter para sa lahat. Ito ay eksakto kung ano ang pinapayagan ka ng salitang static na makamit - countang parehong variable para sa lahat ng pusa. Pakitandaan: kapag nai-print namin ito sa console, hindi kami nagsusulat barsik.counto vasia.count. Hindi siya kabilang sa Barsik o Vasya - kabilang siya sa buong klase Cat. Samakatuwid, ito ay simple count. Maaari ka ring magsulat Cat.count- iyon ay magiging tama din. nameHindi ito gagana sa pag-output ng isang variable sa console :

public class Cat {

    String name;
    int age;

    static int count = 0;

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

        System.out.println("We created a cat named" + name + ", his age - " + barsik.age);

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

Error! nameAng bawat pusa ay may kanya-kanyang sarili. Dito nalilito ang compiler. "I-output ang pangalan sa console? Kaninong pangalan ito? :/"

Paraan

Bilang karagdagan sa mga variable, ang bawat klase ay may mga pamamaraan. Pag-uusapan natin ang mga ito sa isang hiwalay na panayam nang mas detalyado, ngunit ang mga pangkalahatang punto ay medyo simple. Ang mga pamamaraan ay ang pag-andar ng iyong klase; anong mga bagay ang kayang gawin ng klaseng ito. Pamilyar ka na sa isa sa mga pamamaraan - ito ang main(). Ngunit ang pamamaraan main, tulad ng naaalala mo, ay static - iyon ay, kabilang ito sa buong klase (ang lohika ay pareho sa mga variable). At ang mga ordinaryong, non-static na pamamaraan ay matatawag lamang sa mga partikular na bagay na aming nilikha. Halimbawa, kung gusto naming magsulat ng isang klase para sa isang pusa, kailangan naming maunawaan kung anong mga function ang dapat magkaroon ng pusa sa aming programa. Batay dito, sumulat tayo ng ilang pamamaraan para dito:

public class Cat {

    String name;
    int age;

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

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

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

        barsik.sayMeow();
        barsik.jump();

    }
}

Well, ngayon ang aming klase ay higit na katulad ng paglalarawan ng isang tunay na pusa! Ngayon hindi lang tayo may pusang tinatawag na Barsik na may pangalan at edad. Marunong din siyang ngumyaw at tumalon! Anong uri ng pusa ang naroon nang walang ganoong "pag-andar" :) Kumuha kami ng isang tiyak na bagay - barsik, at tinatawag ang mga pamamaraan nito sayMeow()at jump(). Tinitingnan namin ang console:

Мяу!
Прыг-скок!

Isang tunay na pusa! :)

Paglikha ng iyong sariling mga klase. Abstraction

Sa hinaharap, kailangan mong magsulat ng iyong sariling mga klase. Ano ang dapat mong bigyang pansin sa pagsulat ng mga ito? Kung pinag-uusapan natin ang tungkol sa mga variable, kailangan mong gumamit ng tinatawag na abstraction . Ang abstraction ay isa sa apat na pangunahing prinsipyo ng object-oriented programming. Ito ay nagsasangkot ng pag-highlight sa mga pangunahing, pinaka makabuluhang katangian ng isang bagay , at vice versa - pagtatapon ng pangalawa, hindi gaanong mahalaga. Halimbawa, gumagawa kami ng file ng mga empleyado ng kumpanya. Upang lumikha ng mga bagay ng empleyado, nagsulat kami ng isang klase Employee. Anong mga katangian ang mahalaga upang ilarawan ang isang empleyado sa isang file ng kumpanya? Buong pangalan, petsa ng kapanganakan, numero ng social security, numero ng pagkakakilanlan ng buwis. Ngunit hindi malamang na kailangan natin ang kanyang taas, mata at kulay ng buhok sa card ng isang empleyado ng kumpanya. Hindi kailangan ng kumpanya ang impormasyong ito. Samakatuwid, para sa klase Employeeay itatakda namin ang mga variable String name, int age, int socialInsuranceNumberat int taxNumber, at iiwan namin ang impormasyon na hindi kailangan para sa amin (tulad ng kulay ng mata) at i-abstract ito . Ngunit kung gagawa kami ng catalog ng mga modelo ng larawan para sa isang ahensya ng pagmomolde, kapansin-pansing nagbabago ang sitwasyon. Upang ilarawan ang isang modelo ng fashion, ang taas, kulay ng mata at kulay ng buhok ay napakahalaga sa amin, ngunit ang numero ng TIN ay talagang hindi mahalaga sa amin. Samakatuwid, sa klase Modelkailangan nating lumikha ng mga variable int height, String hair, String eyes. Ito ay kung paano gumagana ang abstraction, ito ay simple! :)

Mga konstruktor

Bumalik tayo sa ating halimbawa ng pusa.

public class Cat {

    String name;
    int age;

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

        System.out.println("Something has been happening in the program for 2 hours...");

        barsik.age = 3;
        barsik.name = "Barsik";

    }
}

Tingnan ang code na ito at subukang hulaan kung ano ang mali sa aming programa. Sa loob ng dalawang oras sa aming programa ay may isang pusang walang pangalan o edad! Siyempre, ito ay ganap na mali. Dapat ay walang pusa sa database ng beterinaryo na klinika nang walang impormasyon tungkol sa kanila. Ngayon ipaubaya natin ito sa programmer. Kung hindi niya nakalimutang ipahiwatig ang kanyang pangalan at edad, magiging ok ang lahat. Kung nakalimutan niya, magkakaroon ng error sa database, mga hindi kilalang pusa. Paano natin malulutas ang problemang ito? Kinakailangan na kahit papaano ay ipagbawal ang paglikha ng mga pusa na walang pangalan at edad. Dito nakakatulong sa amin ang mga function ng constructor . Narito ang isang halimbawa:

public class Cat {

    String name;
    int age;

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

    public static void main(String[] args) {

        Cat barsik = new Cat("Barsik", 5);
    }
}

Ang isang constructor ay mahalagang isang template para sa mga bagay ng klase. Sa kasong ito, tinukoy namin na para sa bawat bagay catay dapat tukuyin ang dalawang argumento - isang string at isang numero. Kung susubukan nating lumikha ng isang walang pangalan na pusa, hindi tayo magtatagumpay.

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 barsik = new Cat(); //error!
    }
}

Ngayon na ang isang 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 walang mga argumentong tinukoy dito. Ngayon tingnan natin ang keyword thisna nakikita mo sa loob ng constructor. Simple lang din ang lahat sa kanya. "ito" sa Ingles ay nangangahulugang "ito, ito". Iyon ay, ang salitang ito ay nagpapahiwatig ng isang tiyak na bagay. Code sa constructor

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

maaaring isalin nang halos literal: " pangalan para sa pusang ito (na aming ginagawa) = ang argumento ng pangalan na tinukoy sa konstruktor. edad para sa pusang ito (na aming ginagawa) = ang argumento ng edad na tinukoy sa konstruktor." Pagkatapos magpaputok ng constructor, maaari mong tingnan kung naitalaga na sa aming pusa ang lahat ng kinakailangang halaga:

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 barsik = new Cat("Barsik", 5);
        System.out.println(barsik.name);
        System.out.println(barsik.age);
    }
}

Output ng console:

Барсик
5

Kapag natapos na ang tagabuo:

Cat barsik = new Cat("Barsik", 5);

Ang mga sumusunod ay aktwal na nangyari sa loob:

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

At ang bagay barsik(ito ay this) ay itinalaga ng mga halaga mula sa mga argumento ng constructor. Sa katunayan, kung hindi mo tukuyin ang mga konstruktor sa klase, ito ay magpapaputok pa rin sa konstruktor ! Ngunit paano ito posible? O_O Ang katotohanan ay sa Java ang lahat ng mga klase ay may tinatawag na default constructor . Wala itong anumang mga argumento, ngunit nagpapaputok ito sa tuwing nagagawa ang anumang bagay ng anumang klase.

public class Cat {

    public static void main(String[] args) {

        Cat barsik = new Cat(); //this is where the default constructor worked
    }
}

Sa unang tingin ito ay hindi napapansin. Buweno, lumikha kami ng isang bagay at nilikha ito, nasaan ang gawa ng taga-disenyo? Upang makita ito, sumulat tayo ng isang walang laman na constructor para sa klase sa pamamagitan ng kamay Cat, at sa loob nito ay magpi-print tayo ng ilang parirala sa console. Kung ito ay ipinapakita, kung gayon ang tagabuo ay nagtrabaho.

public class Cat {

    public Cat() {
        System.out.println("Created a cat!");
    }

    public static void main(String[] args) {

        Cat barsik = new Cat(); //this is where the default constructor worked
    }
}

Output ng console:

Создали кота!

Narito ang kumpirmasyon. Ang default na tagabuo ay palaging hindi nakikita sa iyong mga klase. Ngunit kailangan mong malaman ang isa pang tampok nito. Ang default na constructor ay nawawala sa klase kapag lumikha ka ng ilang constructor na may mga argumento. Ang patunay nito, sa katunayan, nakita na natin sa itaas. Dito sa 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 barsik = new Cat(); //error!
    }
}

Hindi kami makakagawa ng pusa nang walang pangalan at edad dahil tinukoy namin ang isang constructor para sa Cat: string + number. Ang default na tagabuo ay nawala mula sa klase kaagad pagkatapos nito. Samakatuwid, siguraduhing tandaan: kung kailangan mo ng ilang constructor sa iyong klase, kabilang ang isang walang laman, kailangan mong likhain ito nang hiwalay . Halimbawa, ang aming klinika sa beterinaryo ay gustong gumawa ng mabubuting gawa at tumulong sa mga pusang walang tirahan, na hindi namin alam ang mga pangalan at edad. Kung gayon ang aming code ay dapat magmukhang ganito:

public class Cat {

    String name;
    int age;

    //for domestic cats
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //for street cats
    public Cat() {
    }

    public static void main(String[] args) {

        Cat barsik = new Cat("Barsik", 5);
        Cat streetCat = new Cat();
    }
}

Ngayon na tahasan na naming tinukoy ang isang default na tagabuo, maaari kaming lumikha ng parehong uri ng pusa. Sa constructor, maaari kang magtalaga ng mga halaga nang tahasan, at hindi lamang kunin ang mga ito mula sa mga argumento. Halimbawa, maaari naming i-record ang lahat ng mga street cats sa isang database sa ilalim ng pangalang "Street cat number...":

public class Cat {

    String name;
    int age;

    static int count = 0;

    public Cat() {
        count++;
        this.name = "Street cat number" + 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 countna isang street cat counter. Sa bawat oras na i-execute namin ang default na constructor, dinadagdagan namin ito ng 1 at itinatalaga ang numerong iyon bilang pangalan ng pusa. Para sa isang constructor, ang pagkakasunud-sunod ng mga argumento ay napakahalaga. Palitan natin ang mga argumento ng pangalan at edad 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 barsik = new Cat("Barsik", 10); //error!
    }
}

Error! Ang constructor ay malinaw na naglalarawan: kapag lumilikha ng isang bagay, Catdapat itong maipasa sa isang numero at isang string, sa ganoong pagkakasunud-sunod . Iyon ang dahilan kung bakit hindi gumagana ang aming code. Tiyaking tandaan ito at isaisip ito kapag gumagawa 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 designer! Ngayon lutasin ang ilang mga problema upang pagsamahin ang materyal :)

• Museo ng Antiquities.

Ang iyong gawain ay ang disenyo ng klase Artifact. Ang mga artifact na itinatago sa museo ay may tatlong uri. Ang una ay tungkol sa kung saan walang nalalaman maliban sa serial number na itinalaga ng museo (halimbawa: 212121). Ang pangalawa ay tungkol sa kung saan kilala ang serial number at ang kultura kung saan ito nilikha (halimbawa: 212121, "Aztecs"). Ang ikatlong uri ay tungkol sa kung saan kilala ang serial number, ang kultura kung saan ito nilikha, at ang eksaktong edad ng paglikha nito (halimbawa: 212121, "Aztecs", 12). Gumawa ng klase Artifactna naglalarawan sa mga antigo na nakaimbak sa museo, at isulat ang kinakailangang bilang ng mga constructor para dito. Sa pamamaraan main(), lumikha ng isang artifact ng bawat uri.

public class Artifact {

    public static void main(String[] args) {
    }
}

• Website ng pulong

Gumagawa ka ng database ng gumagamit para sa isang dating site. Ngunit ang problema ay nakalimutan mo kung anong pagkakasunud-sunod ang kailangan nilang tukuyin, at wala kang mga teknikal na pagtutukoy sa kamay. Magdisenyo ng klase Userna magkakaroon ng mga field - pangalan ( String), edad ( short) at taas ( int). Lumikha ng kinakailangang bilang ng mga konstruktor para dito upang ang pangalan, edad at taas ay matukoy sa anumang pagkakasunud-sunod.

public class User {

    String name;
    short age;
    int height;

    public static void main(String[] args) {

    }
}