Mga prinsipyo ng OOP

Ang Java ay isang object-oriented na wika. Nangangahulugan ito na kailangan mong magsulat ng mga programang Java gamit ang isang object-oriented na istilo. At ang istilong ito ay batay sa paggamit ng mga bagay at klase sa programa.

Mga pangunahing prinsipyo ng OOP:

• Abstraction
• Encapsulation
• Mana
• Polymorphism

Subukan natin, sa tulong ng mga halimbawa, upang maunawaan kung ano ang mga klase at bagay, pati na rin kung paano ilapat ang mga pangunahing prinsipyo ng OOP sa pagsasanay: abstraction, inheritance, polymorphism at encapsulation.

Ano ang isang bagay?

Ang mundong ating ginagalawan ay binubuo ng mga bagay. Kung titingnan natin ang paligid, makikita natin na napapaligiran tayo ng mga bahay, puno, sasakyan, kasangkapan, pinggan, computer. Ang lahat ng mga item na ito ay mga bagay, at bawat isa sa kanila ay may isang hanay ng mga tiyak na katangian, pag-uugali at layunin. Nakasanayan na namin ang mga bagay, at palagi naming ginagamit ang mga ito para sa mga partikular na layunin. Halimbawa, kung kailangan nating pumasok sa trabaho, gumamit tayo ng kotse, kung gusto nating kumain, gumamit tayo ng mga pinggan, at kung kailangan nating magpahinga, kailangan natin ng komportableng sofa. Ang isang tao ay nakasanayan na mag-isip nang may layunin upang malutas ang mga problema sa pang-araw-araw na buhay. Ito ay isa sa mga dahilan para sa paggamit ng mga bagay sa programming, at ang pamamaraang ito sa paglikha ng mga programa ay tinatawag na object-oriented. Magbigay tayo ng halimbawa. Isipin na nakabuo ka ng bagong modelo ng telepono at gusto mong ilunsad ang mass production nito. Bilang isang taga-disenyo ng telepono, alam mo kung para saan ito, kung paano ito gagana, at kung anong mga bahagi ang bubuo nito (case, mikropono, speaker, mga wire, mga pindutan, atbp.). Gayunpaman, ikaw lang ang nakakaalam kung paano ikonekta ang mga bahaging ito. Gayunpaman, hindi mo planong gumawa ng mga telepono nang personal; para dito mayroon kang isang buong kawani ng mga empleyado. Upang hindi mo na kailangang ipaliwanag sa bawat oras kung paano ikonekta ang mga bahagi ng telepono, at upang ang lahat ng mga telepono sa produksyon ay maging pareho, bago mo simulan ang paggawa ng mga ito, kakailanganin mong gumawa ng isang guhit sa anyo ng isang paglalarawan ng istraktura ng telepono. Sa OOP, ang naturang paglalarawan, pagguhit, diagram o template ay tinatawag na isang klase, kung saan ang isang bagay ay nilikha kapag ang programa ay naisakatuparan. Ang isang klase ay isang paglalarawan ng isang bagay na hindi pa nagagawa, tulad ng isang pangkalahatang template na binubuo ng mga patlang, pamamaraan at isang constructor, at ang isang bagay ay isang halimbawa ng isang klase na nilikha batay sa paglalarawang ito.

OOP Abstraction

Pag-isipan natin ngayon kung paano tayo maaaring lumipat mula sa isang bagay sa totoong mundo patungo sa isang bagay sa isang programa, gamit ang telepono bilang isang halimbawa. Ang kasaysayan ng paraan ng komunikasyon na ito ay lumampas sa 100 taon at ang modernong telepono, hindi katulad ng hinalinhan nito mula sa ika-19 na siglo, ay isang mas kumplikadong aparato. Kapag gumagamit kami ng telepono, hindi namin iniisip ang istraktura nito at ang mga prosesong nagaganap sa loob nito. Ginagamit lang namin ang mga function na ibinigay ng mga developer ng telepono - mga pindutan o touch screen upang pumili ng numero at tumawag. Ang isa sa mga unang interface ng telepono ay isang knob na iyong pinihit para tumawag. Siyempre, hindi ito masyadong maginhawa. Gayunpaman, ang hawakan ay gumanap ng maayos. Kung titingnan mo ang pinakamoderno at pinakaunang telepono, matutukoy mo kaagad ang pinakamahahalagang detalye na mahalaga kapwa para sa isang device mula sa huling bahagi ng ika-19 na siglo at para sa isang ultra-modernong smartphone. Ito ay pagtawag (pag-dial ng numero) at pagtanggap ng tawag. Sa pangkalahatan, ito ang ginagawang telepono ng isang telepono at hindi sa ibang bagay. Ngayon ay inilapat na namin ang prinsipyo sa OOP - pag-highlight ng pinakamahalagang katangian at impormasyon tungkol sa isang bagay. Ang prinsipyong ito ng OOP ay tinatawag na abstraction. Ang abstraction sa OOP ay maaari ding tukuyin bilang isang paraan ng pagkatawan ng mga elemento ng isang problema sa totoong mundo bilang mga bagay sa isang programa. Ang abstraction ay palaging nauugnay sa generalization ng ilang impormasyon tungkol sa mga katangian ng mga bagay o bagay, kaya ang pangunahing bagay ay ang paghiwalayin ang makabuluhang impormasyon mula sa hindi gaanong mahalagang impormasyon sa konteksto ng problemang nilulutas. Sa kasong ito, maaaring mayroong ilang antas ng abstraction. Subukan nating ilapat ang prinsipyo ng abstraction sa ating mga telepono. Una, i-highlight natin ang mga pinakakaraniwang uri ng mga telepono mula noong una hanggang sa kasalukuyan. Halimbawa, maaari silang katawanin sa anyo ng isang diagram na ipinapakita sa Figure 1. Ngayon, sa tulong ng abstraction, maaari nating i-highlight ang pangkalahatang impormasyon sa hierarchy na ito ng mga bagay: isang karaniwang abstract na uri ng mga bagay - telepono, isang pangkalahatang katangian ng ang telepono - ang taon ng paglikha nito, at isang karaniwang interface - lahat ng mga telepono ay may kakayahang tumanggap at magpadala ng mga tawag. Narito ang hitsura nito sa Java:

public abstract class AbstractPhone {
    private int year;

    public AbstractPhone(int year) {
        this.year = year;
    }
    public abstract void call(int outputNumber);
    public abstract void ring (int inputNumber);
}

Batay sa abstract class na ito, makakagawa kami ng mga bagong uri ng mga telepono sa programa gamit ang iba pang mga pangunahing prinsipyo ng Java OOP, na isasaalang-alang namin sa ibaba.

Encapsulation

Sa tulong ng abstraction, itinatampok namin kung ano ang karaniwan sa lahat ng bagay. Gayunpaman, ang bawat modelo ng telepono ay indibidwal at medyo naiiba sa iba. Paano natin mabubuo ang mga hangganan sa programa at itatalaga ang indibidwalidad na ito? Paano namin matitiyak na walang sinuman sa mga gumagamit ang maaaring aksidenteng o sinasadyang masira ang aming telepono, o subukang i-convert ang isang modelo sa isa pa? Para sa mundo ng mga tunay na bagay, ang sagot ay malinaw: kailangan mong ilagay ang lahat ng mga bahagi sa katawan ng telepono. Pagkatapos ng lahat, kung hindi natin gagawin ito at iiwan ang lahat ng loob ng telepono at ang mga wire na kumokonekta sa kanila sa labas, tiyak na magkakaroon ng matanong na eksperimento na gustong "pahusayin" ang pagpapatakbo ng ating telepono. Upang maiwasan ang gayong panghihimasok sa disenyo at pagpapatakbo ng isang bagay, ginagamit ng OOP ang prinsipyo ng encapsulation - isa pang pangunahing prinsipyo ng OOP, kung saan ang mga katangian at pag-uugali ng isang bagay ay pinagsama sa isang klase, ang panloob na pagpapatupad ng bagay ay nakatago mula sa ang gumagamit, at isang bukas na interface ay ibinigay para sa pagtatrabaho sa bagay. Ang trabaho ng programmer ay upang matukoy kung aling mga katangian at pamamaraan ang maa-access ng publiko at kung alin ang mga panloob na pagpapatupad ng bagay at hindi dapat baguhin.

Encapsulation at Access Control

Sabihin natin na sa panahon ng produksyon, ang impormasyon tungkol dito ay nakaukit sa likod ng telepono: ang taon ng paggawa nito o ang logo ng kumpanya ng tagagawa. Ang impormasyong ito ay medyo partikular na nagpapakilala sa modelong ito - ang kondisyon nito. Masasabi nating pinangalagaan ng developer ng telepono ang hindi nababago ng impormasyong ito - malamang na hindi maiisip ng sinuman na alisin ang ukit. Sa mundo ng Java, ang estado ng mga hinaharap na bagay ay inilarawan sa isang klase gamit ang mga patlang, at ang kanilang pag-uugali ay inilarawan gamit ang mga pamamaraan. Ang kakayahang baguhin ang estado at pag-uugali ay isinasagawa gamit ang mga modifier ng access sa mga field at pamamaraan - private, protected, public, at default(default na pag-access). Halimbawa, napagpasyahan namin na ang taon ng paglikha, ang pangalan ng tagagawa ng telepono, at isa sa mga pamamaraan ay nabibilang sa panloob na pagpapatupad ng klase at hindi mababago ng iba pang mga bagay sa programa. Gamit ang code, ang klase ay maaaring ilarawan tulad ng sumusunod:

public class SomePhone {

    private int year;
    private String company;
    public SomePhone(int year, String company) {
        this.year = year;
        this.company = company;
    }
private void openConnection(){
    //findComutator
    //openNewConnection...
}
public void call() {
    openConnection();
    System.out.println("I'm calling a number");
}

public void ring() {
    System.out.println("Дзынь-дзынь");
}

 }

Ang isang modifier privateay gumagawa ng mga field at pamamaraan ng isang klase na magagamit lamang sa loob ng klase na iyon. Nangangahulugan ito na privateang mga patlang ay hindi ma-access mula sa labas, at hindi rin privatematatawag ang mga pamamaraan. Ang pagtatago ng pag-access sa isang pamamaraan openConnectionay nag-iiwan din sa amin ng pagkakataon na malayang baguhin ang panloob na pagpapatupad ng pamamaraang ito, dahil ang pamamaraang ito ay ginagarantiyahan na hindi gagamitin ng iba pang mga bagay at hindi makagambala sa kanilang operasyon. Upang gumana sa aming bagay, iniiwan namin ang mga pamamaraan na bukas callgamit ringang modifier public. Ang pagbibigay ng mga pampublikong pamamaraan para sa pagtatrabaho sa isang bagay ay bahagi din ng mekanismo ng encapsulation, dahil kung ang pag-access sa isang bagay ay ganap na tinanggihan, ito ay magiging walang silbi.

Mana

Tingnan natin muli ang tsart ng telepono. Makikita mo na ito ay kumakatawan sa isang hierarchy kung saan ang modelong matatagpuan sa ibaba ay mayroong lahat ng katangian ng mga modelong matatagpuan sa mas mataas na sangay, kasama ang sarili nito. Halimbawa, ang isang smartphone ay gumagamit ng isang cellular network para sa komunikasyon (may mga katangian ng isang cell phone), ay wireless at portable (may mga katangian ng isang cordless phone), at maaaring tumanggap at tumawag (may mga katangian ng isang telepono). Sa kasong ito, maaari nating pag-usapan ang tungkol sa pamana ng mga katangian ng bagay. Sa programming, ang inheritance ay ang paggamit ng mga umiiral na klase upang tukuyin ang mga bago. Tingnan natin ang isang halimbawa ng paglikha ng isang klase ng smartphone gamit ang mana. Ang lahat ng cordless phone ay pinapagana ng mga rechargeable na baterya, na may tiyak na buhay ng pagpapatakbo sa ilang oras. Kaya't idagdag natin ang property na ito sa klase ng mga wireless phone:

public abstract class WirelessPhone extends AbstractPhone {

    private int hour;

    public WirelessPhone(int year, int hour) {
        super(year);
        this.hour = hour;
    }
    }

callAng mga cell phone ay nagmamana ng mga katangian ng isang wireless na telepono, nagdagdag din kami ng pagpapatupad ng at mga pamamaraan sa klase na ito ring:

public class CellPhone extends WirelessPhone {
    public CellPhone(int year, int hour) {
        super(year, hour);
    }

    @Override
    public void call(int outputNumber) {
        System.out.println("Calling a number" + outputNumber);
    }

    @Override
    public void ring(int inputNumber) {
        System.out.println("A subscriber is calling you" + inputNumber);
    }
}

At sa wakas, ang klase ng smartphone, na, hindi katulad ng mga klasikong cell phone, ay may ganap na operating system. Maaari kang magdagdag ng mga bagong program na suportado ng operating system na ito sa iyong smartphone, kaya lumalawak ang functionality nito. Gamit ang code, ang klase ay maaaring ilarawan tulad ng sumusunod:

public class Smartphone extends CellPhone {
    
    private String operationSystem;

    public Smartphone(int year, int hour, String operationSystem) {
        super(year, hour);
        this.operationSystem = operationSystem;
    }
public void install(String program){
    System.out.println("Installing" + program + "For" + operationSystem);
}

}

Gaya ng nakikita mo, Smartphonegumawa kami ng napakakaunting bagong code upang ilarawan ang klase, ngunit nakakuha kami ng bagong klase na may bagong functionality. Ang paggamit ng OOP inheritance principle ay maaaring makabuluhang bawasan ang dami ng code, at samakatuwid ay gawing mas madali ang gawain ng programmer.

Polymorphism

Kung titingnan natin ang lahat ng mga modelo ng telepono, kung gayon, sa kabila ng mga pagkakaiba sa hitsura at disenyo ng mga modelo, matutukoy natin ang ilang karaniwang pag-uugali sa kanila - lahat sila ay maaaring tumanggap at tumawag at magkaroon ng medyo malinaw at simpleng hanay ng mga control button. Ang paglalapat ng isa sa mga pangunahing prinsipyo ng OOP, na alam na natin, abstraction sa mga tuntunin ng programming, maaari nating sabihin na ang object ng telepono ay may isang karaniwang interface. Samakatuwid, ang mga gumagamit ng telepono ay maaaring kumportable na gumamit ng iba't ibang mga modelo gamit ang parehong mga pindutan ng kontrol (mekanikal o pagpindot), nang hindi pumunta sa mga teknikal na detalye ng device. Kaya, palagi kang gumagamit ng cell phone, at madali kang makakatawag mula sa landline na katapat nito. Ang prinsipyo sa OOP kapag ang isang programa ay maaaring gumamit ng mga bagay na may parehong interface na walang impormasyon tungkol sa panloob na istraktura ng bagay ay tinatawag na polymorphism . Isipin natin na sa ating programa kailangan nating ilarawan ang isang user na maaaring gumamit ng anumang modelo ng telepono upang tumawag sa isa pang user. Narito kung paano ito gawin:

public class User {
    private String name;

    public User(String name) {
        this.name = name;
            }

    public void callAnotherUser(int number, AbstractPhone phone){
// here it is polymorphism - using the abstract type AbstractPhone phone in the code!
        phone.call(number);
    }
}
 }

Ngayon, ilarawan natin ang iba't ibang modelo ng telepono. Isa sa mga unang modelo ng telepono:

public class ThomasEdisonPhone extends AbstractPhone {

public ThomasEdisonPhone(int year) {
    super(year);
}
    @Override
    public void call(int outputNumber) {
        System.out.println("Turn the Handle");
        System.out.println("Give me the phone number, sir");
    }

    @Override
    public void ring(int inputNumber) {
        System.out.println("Phone calls");
    }
}

Regular na landline na telepono:

public class Phone extends AbstractPhone {

    public Phone(int year) {
        super(year);
    }

    @Override
    public void call(int outputNumber) {
        System.out.println("I'm calling a number" + outputNumber);
    }

    @Override
    public void ring(int inputNumber) {
        System.out.println("Phone calls");
    }
}

At sa wakas, isang cool na video phone:

public class VideoPhone extends AbstractPhone {

    public VideoPhone(int year) {
        super(year);
    }
    @Override
    public void call(int outputNumber) {
        System.out.println("I connect a video channel for the subscriber" + outputNumber );
    }
    @Override
    public void ring(int inputNumber) {
        System.out.println("You have an incoming video call..." + inputNumber);
    }
  }

Gumawa tayo ng mga bagay sa pamamaraan main()at subukan ang pamamaraan callAnotherUser:

AbstractPhone firstPhone = new ThomasEdisonPhone(1879);
AbstractPhone phone = new Phone(1984);
AbstractPhone videoPhone=new VideoPhone(2018);
User user = new User("Andrey");
user.callAnotherUser(224466,firstPhone);
// Rotate the knob
// Tell me the number of the subscriber, sir
user.callAnotherUser(224466,phone);
//Call number 224466
user.callAnotherUser(224466,videoPhone);
//I connect the video channel for subscriber 224466

Sa pamamagitan ng pagtawag sa parehong paraan sa object user, nakakuha kami ng iba't ibang resulta. Ang pagpili ng isang partikular na pagpapatupad ng pamamaraan callsa loob ng isang pamamaraan callAnotherUseray ginawang dynamic batay sa partikular na uri ng object ng pagtawag sa panahon ng pagpapatupad ng programa. Ito ang pangunahing bentahe ng polymorphism - ang pagpili ng pagpapatupad sa panahon ng pagpapatupad ng programa. Sa mga halimbawa ng klase ng telepono sa itaas, ginamit namin ang pag-overriding ng pamamaraan, isang pamamaraan na nagbabago sa pagpapatupad ng pamamaraan na tinukoy sa batayang klase nang hindi binabago ang lagda ng pamamaraan. Ito ay mahalagang kapalit ng pamamaraan, at ito ang bagong pamamaraan na tinukoy sa subclass na tinatawag kapag tumatakbo ang programa. Kadalasan, kapag nag-o-override sa isang paraan, ginagamit ang anotasyon @Override, na nagsasabi sa compiler na suriin ang mga lagda ng mga na-override at na-overriding na pamamaraan. Bilang resulta , upang matiyak na ang istilo ng iyong programa ay sumusunod sa konsepto ng OOP at mga prinsipyo ng OOP java, sundin ang mga tip na ito:

• i-highlight ang mga pangunahing katangian ng bagay;
• i-highlight ang mga karaniwang katangian at pag-uugali at gumamit ng mana kapag lumilikha ng mga bagay;
• gumamit ng mga abstract na uri upang ilarawan ang mga bagay;
• Subukang palaging itago ang mga pamamaraan at field na nauugnay sa panloob na pagpapatupad ng klase.