14 polymorphism at ang paggamit nito sa mga programa. Ano ang polymorphism sa Java

Polymorphism (pagprograma)

Sa madaling sabi, ang kahulugan ng polymorphism ay maaaring ipahayag sa pariralang: "Isang interface, maraming pagpapatupad."

Ang polymorphism ay isa sa apat na pinakamahalagang mekanismo ng object-oriented programming (kasama ang abstraction, encapsulation at inheritance).

Binibigyang-daan ka ng polymorphism na magsulat ng higit pang abstract na mga programa at dagdagan ang muling paggamit ng code. Ang mga pangkalahatang katangian ng mga bagay ay pinagsama sa isang sistema, na maaaring tawaging iba - interface, klase. Ang komunidad ay may panlabas at panloob na pagpapahayag:

• ang panlabas na pagkakatulad ay nagpapakita ng sarili bilang parehong hanay ng mga pamamaraan na may parehong mga pangalan at lagda (mga pangalan ng mga pamamaraan, mga uri ng mga argumento at ang kanilang numero);
• panloob na pagkakatulad - ang parehong pag-andar ng mga pamamaraan. Maaari itong ilarawan nang intuitive o ipinahayag sa anyo ng mga mahigpit na batas, mga panuntunan kung saan dapat sundin ang mga pamamaraan. Ang kakayahang magtalaga ng iba't ibang pag-andar sa isang pamamaraan (function, operasyon) ay tinatawag overloading ng pamamaraan (overloading ng function, labis na karga ng mga operasyon).

Mga halimbawa

Ang isang klase ng mga geometric na hugis (ellipse, polygon) ay maaaring magkaroon ng mga pamamaraan para sa mga geometric na pagbabagong-anyo (displacement, rotation, scaling).

Sa mga functional na wika

Mayroong dalawang uri ng polymorphism sa Haskell - parametric (pure) at espesyal (class-based). Espesyal ay tinatawag din ad hoc(mula sa Latin ad hoc - lalo na). Maaari silang makilala sa mga sumusunod:

Parametric polymorphism

Espesyal na polymorphism

Ang Haskell ay may dibisyon sa mga klase at pagkakataon, na hindi matatagpuan sa OOP. Tinutukoy ng klase ang isang set at mga lagda ng mga pamamaraan (marahil ay nagbibigay ng mga default na pagpapatupad para sa ilan o lahat ng mga ito), at ang mga pagkakataon ay nagpapatupad ng mga ito. Kaya, ang problema ng maramihang pamana ay awtomatikong nawawala. Ang mga klase ay hindi nagmamana o nag-o-override ng mga pamamaraan ng iba pang mga klase - ang bawat pamamaraan ay nabibilang lamang sa isang klase. Ang diskarte na ito ay mas simple kaysa sa kumplikadong diagram ng mga relasyon sa klase sa OOP. Ang isang naibigay na uri ng data ay maaaring kabilang sa ilang mga klase; ang isang klase ay maaaring mangailangan na ang bawat isa sa mga uri nito ay kinakailangang kabilang sa ibang klase, o kahit na ilang; ang parehong pangangailangan ay maaaring iharap ng isang halimbawa. Ito ay mga analogue ng maramihang mana. Mayroon ding ilang mga katangian na walang mga analogue sa OOP. Halimbawa, ang pagpapatupad ng isang listahan bilang isang halimbawa ng klase ng mga maihahambing na dami ay nangangailangan na ang mga elemento ng listahan ay kabilang din sa klase ng mga maihahambing na dami.

Ang mga programmer na lumilipat mula sa OOP patungo sa FP ay dapat magkaroon ng kamalayan sa isang mahalagang pagkakaiba sa pagitan ng kanilang mga sistema ng klase. Kung sa OOP ang isang klase ay "nakatali" sa isang bagay, ibig sabihin, sa data, pagkatapos ay sa FP ito ay "nakatali" sa isang function. Sa FP, ang impormasyon tungkol sa pagiging miyembro ng klase ay ipinapasa kapag tinawag ang isang function, sa halip na nakaimbak sa mga field ng object. Ang diskarte na ito, sa partikular, ay nagbibigay-daan sa amin upang malutas ang problema ng isang paraan ng ilang mga bagay (sa OOP, ang isang pamamaraan ay tinatawag sa isang bagay). Halimbawa: ang paraan ng pagdaragdag (mga numero, mga string) ay nangangailangan ng dalawang argumento, parehong may parehong uri.

Implicit na pag-type

Ang ilang mga programming language (halimbawa, Python at Ruby) ay gumagamit ng tinatawag na duck type (iba pang pangalan: latent, implicit), na isang uri ng signature polymorphism. Kaya, halimbawa, sa Python, ang polymorphism ay hindi kinakailangang nauugnay sa mana.

Mga anyo ng polymorphism

Static at dynamic na polymorphism

(nabanggit sa klasikong aklat nina Sutter at Alexandrescu, na siyang pinagmulan).

Ang polymorphism ay maaaring maunawaan bilang ang pagkakaroon ng mga punto ng pagpapasadya sa code, kapag ang parehong piraso ng code na isinulat ng programmer ay maaaring mangahulugan ng iba't ibang mga operasyon depende sa isang bagay.

Sa isang kaso, ang partikular na kahulugan ng isang fragment ay nakasalalay sa kapaligiran kung saan binuo ang code. Ito ang tinatawag na static na polymorphism. Ang overloading ng function at mga template sa C++ ay nagpapatupad ng static polymorphism. Kung, halimbawa, ang std::sort ay tinatawag sa code ng isang template class, ang tunay na kahulugan ng tawag ay depende sa kung aling uri ng mga parameter ang idi-deploy ang template na ito - isa sa std::sort ang tatawagin .

Sa isa pang kaso, ang tiyak na kahulugan ng isang fragment ay tinutukoy lamang sa yugto ng pagpapatupad at depende sa eksakto kung paano at saan eksakto ang bagay ay binuo. Ito ay ordinaryong, dynamic na polymorphism, na ipinatupad sa pamamagitan ng mga virtual na pamamaraan.

Pagsasama ng polymorphism

Ang polymorphism na ito ay tinatawag na purong polymorphism. Sa pamamagitan ng paggamit ng ganitong anyo ng polymorphism, ang mga kaugnay na bagay ay maaaring gamitin sa pangkalahatang paraan. Gamit ang substitution at inclusion polymorphism, maaari kang sumulat ng isang paraan upang gumana sa lahat ng uri ng mga bagay na TPerson. Gamit ang polymorphism sa pagsasama at pagpapalit, maaari kang magtrabaho sa anumang bagay na pumasa sa pagsubok na "is-A". Ang pagsasama ng polymorphism ay pinapasimple ang gawain ng pagdaragdag ng mga bagong subtype sa isang programa, dahil hindi na kailangang magdagdag ng isang tiyak na pamamaraan para sa bawat bagong uri maaari kang gumamit ng isang umiiral na, sa pamamagitan lamang ng pagbabago ng pag-uugali ng system sa loob nito. Sa polymorphism, maaari mong gamitin muli ang isang base class; gumamit ng anumang inapo o pamamaraan na ginagamit ng batayang klase.

Parametric polymorphism

Gamit ang Parametric Polymorphism maaari kang lumikha ng mga unibersal na uri ng base. Sa kaso ng parametric polymorphism, ang function ay ipinatupad nang pantay-pantay para sa lahat ng mga uri at sa gayon ang function ay ipinatupad para sa isang arbitrary na uri. Sinasaklaw ng Parametric Polymorphism ang mga parametric na pamamaraan at uri.

Parametric na Paraan

Kung ang polymorphism sa pagsasama ay nakakaapekto sa ating pang-unawa sa isang bagay, ang parametric polymorphism ay nakakaapekto sa mga pamamaraan na ginamit, dahil posible na lumikha ng mga pamamaraan ng mga kaugnay na klase, na ipinagpaliban ang deklarasyon ng mga uri hanggang sa runtime. Upang maiwasan ang pagsusulat ng hiwalay na paraan para sa bawat uri, ginagamit ang parametric polymorphism, kung saan ang uri ng mga parameter ay magiging kapareho ng parameter ng mga operand.

Mga uri ng parametric

Sa halip na magsulat ng klase para sa bawat partikular na uri, dapat tayong lumikha ng mga uri na ipapatupad sa panahon ng pagpapatupad ng programa, iyon ay, lumikha tayo ng parametric na uri.

I-override ang polymorphism

Ang mga abstract na pamamaraan ay madalas na tinutukoy bilang mga ipinagpaliban na pamamaraan. Ang klase kung saan tinukoy ang pamamaraang ito ay maaaring tumawag sa pamamaraan, at tinitiyak ng polymorphism na ang naaangkop na bersyon ng ipinagpaliban na pamamaraan ay tinatawag sa mga klase ng bata. Ang ad hoc polymorphism ay nagbibigay-daan sa isang espesyal na pagpapatupad para sa bawat uri ng data.

Polymorphism-overload

Ito ay isang espesyal na kaso ng polymorphism. Sa tulong ng overloading, ang parehong pangalan ay maaaring magtalaga ng iba't ibang mga pamamaraan, at ang mga pamamaraan ay maaaring magkakaiba sa bilang at uri ng mga parameter, iyon ay, hindi sila nakasalalay sa kanilang mga argumento. Ang pamamaraan ay maaaring hindi limitado sa mga partikular na uri ng parameter ng maraming iba't ibang uri.

Ang polymorphism ay isa sa tatlong pangunahing paradigms ng OOP. Sa madaling salita, ang polymorphism ay ang kakayahan ng isang bagay na gumamit ng mga pamamaraan ng isang nagmula na klase na hindi umiiral sa oras na nilikha ang base. Para sa mga hindi partikular na kaalaman sa OOP, ito ay malamang na mukhang kumplikado. Samakatuwid, tingnan natin ang paggamit ng polymorphism gamit ang isang halimbawa.

Pagbubuo ng problema

Ipagpalagay natin na ang site ay nangangailangan ng tatlong uri ng mga publikasyon - mga balita, anunsyo at mga artikulo. Magkatulad sila sa ilang paraan - lahat sila ay may pamagat at teksto, balita at anunsyo ay may petsa. Sa ilang mga paraan ay naiiba ang mga ito - ang mga artikulo ay may mga may-akda, ang mga balita ay may mga mapagkukunan, at ang mga anunsyo ay may petsa kung saan ito ay nagiging hindi nauugnay.

Ang pinakasimpleng mga opsyon na nasa isip ay ang magsulat ng tatlong magkakahiwalay na klase at magtrabaho kasama nila. O sumulat ng isang klase na maglalaman ng lahat ng katangiang likas sa lahat ng tatlong uri ng publikasyon, at ang mga kinakailangan lamang ang gagamitin. Ngunit para sa iba't ibang uri, ang mga pamamaraan na magkatulad sa lohika ay dapat gumana nang iba. Ang paggawa ng ilang paraan ng parehong uri para sa iba't ibang uri (get_news, get_announcements, get_articles) ay ganap na walang alam. Ito ay kung saan ang polymorphism ay madaling gamitin.

Abstract na klase

Sa halos pagsasalita, ito ay isang klase ng template. Ito ay nagpapatupad ng functionality lamang sa antas kung saan ito ay kasalukuyang kilala. Ang mga nagmula na klase ay umaakma dito. Ngunit, oras na upang lumipat mula sa teorya patungo sa pagsasanay. Hayaan akong magpareserba kaagad: isinasaalang-alang namin ang isang primitive na halimbawa na may kaunting functionality. Ang lahat ng mga paliwanag ay nasa mga komento sa code.

abstract class Publication
{
// table na nag-iimbak ng data sa elemento
protektado $table ;

// ang mga katangian ng elemento ay hindi alam sa amin
protektado $properties = array();

// tagabuo

{
// tandaan na hindi namin alam kung aling talahanayan ang kailangan naming makuha ang data
$result = mysql_query ("SELECT * FROM `" . $this -> table . "` WHERE `id`="" . $id . "" LIMIT 1" );
// hindi rin namin alam kung anong data ang natanggap namin
$this -> properties = mysql_fetch_assoc ($result );
}

// paraan, pareho para sa anumang uri ng publikasyon, ibinabalik ang halaga ng ari-arian
pampublikong function get_property ($pangalan)
{
if (isset($this -> properties [ $name ]))
ibalik ang $this -> properties [ $name ];

Ibalik ang mali ;
}

// paraan, pareho para sa anumang uri ng publikasyon, ay nagtatakda ng halaga ng ari-arian
pampublikong function set_property ($pangalan, $value)
{
if (!isset($this -> properties [ $name ]))
ibalik ang mali;

$this -> properties [ $name ] = $value ;

Ibalik ang $value ;
}

// at ang pamamaraang ito ay dapat mag-print ng publikasyon, ngunit hindi namin alam kung paano eksaktong gawin ito, at samakatuwid ay ipinapahayag namin itong abstract
abstract public function do_print();
}

Mga nagmula na klase

Ngayon ay maaari ka nang magpatuloy sa paglikha ng mga nagmula na klase na nagpapatupad ng nawawalang pagpapagana.

class News extended Publication
{
// constructor ng news class, na nagmula sa publications class
pampublikong function __construct ($id)
{
// itakda ang halaga ng talahanayan kung saan nakaimbak ang data ng balita
$this -> table = "news_table" ;
magulang :: __construct ($id );
}

Pampublikong function do_print()
{
echo $this -> properties ["title" ];
echo"

" ;
echo $this -> properties ["text" ];
echo"
Pinagmulan: " . $this -> properties [ "source" ];
}
}

Pinapalawig ng Anunsyo ng Klase ang Paglalathala
{
// constructor ng ad class na nagmula sa publication class
pampublikong function __construct ($id)
{
// itakda ang halaga ng talahanayan kung saan iniimbak ang data ng ad
$this -> table = "announcements_table" ;
// tawagan ang constructor ng parent class
magulang :: __construct ($id );
}

// i-override ang abstract na paraan ng pag-print
pampublikong function do_print()
{
echo $this -> properties ["title" ];
echo "
Pansin! Ang anunsyo ay may bisa hanggang ". $this -> properties ["end_date" ];
echo"

" . $this -> properties [ "text" ];
}
}

Pinalawak ng Artikulo ng Klase ang Paglalathala
{
// constructor ng klase ng artikulo, na nagmula sa klase ng publikasyon
pampublikong function __construct ($id)
{
// itakda ang halaga ng talahanayan kung saan iniimbak ang data sa mga artikulo
$this -> table = "articles_table" ;
// tawagan ang constructor ng parent class
magulang :: __construct ($id );
}

// i-override ang abstract na paraan ng pag-print
pampublikong function do_print()
{
echo $this -> properties ["title" ];
echo"

" ;
echo $this -> properties ["text" ];
echo"
" . $this -> properties [ "may-akda" ];
}
}

Ngayon tungkol sa paggamit

Ang punto ay ang parehong code ay ginagamit para sa mga bagay ng iba't ibang klase.

// punan ang hanay ng publikasyon ng mga bagay na nagmula sa Publication
$publications = bagong Balita ($news_id);
$publications = bagong Anunsyo($announcement_id);
$publications = bagong Artikulo($article_id);

Foreach ($mga publikasyon bilang $publiko) (
// kung makikipagtulungan tayo sa mga tagapagmana ng Publication
kung ($publication instanceof Publication) (
// pagkatapos ay i-print ang data
$publication -> do_print();
) iba (
// exception o paghawak ng error
}
}

Iyon lang. Sa bahagyang paggalaw ng kamay, nagiging eleganteng shorts ang pantalon :-).

Ang pangunahing benepisyo ng polymorphism ay ang kadalian kung saan ang mga bagong klase ay maaaring malikha na kumikilos nang katulad sa mga kaugnay na mga, na kung saan ay nagbibigay-daan para sa pagpapalawak at pagbabago. Ang artikulo ay nagpapakita lamang ng isang primitive na halimbawa, ngunit kahit na ito ay nagpapakita kung paano ang paggamit ng mga abstraction ay maaaring gawing mas madali ang pagbuo. Maaari kaming gumawa ng balita tulad ng ginagawa namin sa mga advertisement o artikulo, at hindi na namin kailangang malaman kung ano ang aming ginagawa! Sa totoo, mas kumplikadong mga aplikasyon, mas malaki ang benepisyong ito.

Isang maliit na teorya

• Ang mga pamamaraan na nangangailangan ng overriding ay tinatawag na abstract. Ito ay lohikal na kung ang isang klase ay naglalaman ng hindi bababa sa isang abstract na pamamaraan, kung gayon ito ay abstract din.
• Malinaw, ang isang bagay ng isang abstract na klase ay hindi maaaring malikha, kung hindi, ito ay hindi magiging abstract.
• Ang isang nagmula na klase ay may mga katangian at pamamaraan na kabilang sa batayang klase, at maaari ding magkaroon ng sarili nitong mga pamamaraan at katangian.
• Ang isang pamamaraan na na-override sa isang nagmula na klase ay tinatawag na isang virtual na pamamaraan. Walang impormasyon tungkol sa pamamaraang ito sa batayang abstract na klase.
• Ang punto ng abstraction ay upang tukuyin ang isang pamamaraan sa lugar kung saan mayroong pinaka kumpletong impormasyon tungkol sa kung paano ito dapat gumana.

UPD: Tungkol sa mga paglabag sa sql-inj at MVC - mga ginoo, ito ay isang halimbawa lamang, at isang halimbawa ng polymorphism, kung saan hindi ko itinuturing na kinakailangang bigyang-pansin ang mga bagay na ito. Ito ay isang paksa para sa ganap na magkakaibang mga artikulo.

Object-oriented na programming(OOP) ay isang diskarte sa paglikha ng mga programa batay sa paggamit ng mga klase at bagay na nakikipag-ugnayan sa isa't isa.

Ang isang klase (java class) ay naglalarawan sa istraktura at pag-uugali ng mga bagay. Ang isang aparato ay inilalarawan sa pamamagitan ng isang hanay ng mga katangian (properties), at ang pag-uugali ay inilalarawan sa pamamagitan ng isang hanay ng mga operasyon (paraan) na magagamit para sa mga bagay. Maaaring malikha ang mga klase batay sa mga umiiral na sa pamamagitan ng pagdaragdag o pag-override ng mga katangian at pamamaraan.

Kinakatawan ng mga klase ang mga template kung saan binuo ang mga bagay. Ang mga bagay ay mga elemento ng programa na may magkatulad na hanay ng mga katangian at pag-uugali (iyon ay, sila ay mga elemento na binuo batay sa parehong klase). Ang bawat bagay ay may isang tiyak na estado, ito ay tinutukoy ng halaga ng lahat ng mga katangian nito. Maraming mga klase ang maaaring umiral sa isang programa, at ang mga bagay ng iba't ibang klase ay maaaring makipag-ugnayan sa isa't isa (sa pamamagitan ng mga pamamaraan).

Mana, umaabot

Ang mana ay isang mahalagang bahagi ng Java. Kapag gumagamit ng inheritance, isinasaalang-alang na ang isang bagong klase na nagmamana ng mga katangian ng base (magulang) na klase ay mayroong lahat ng mga katangian na mayroon ang magulang. Ginagamit ng code ang operand umaabot, na sinusundan ng pangalan ng batayang klase. Binubuksan nito ang access sa lahat ng field at pamamaraan ng base class.

Gamit ang inheritance, maaari kang lumikha ng generic na "java class" na tumutukoy sa mga katangiang karaniwan sa isang hanay ng mga kaugnay na elemento. Pagkatapos ay maaari kang magmana mula dito at lumikha ng mga karagdagang klase kung saan maaari mong tukuyin ang mga karagdagang katangian na natatangi sa kanila.

Ang pangunahing minanang klase sa Java ay tinatawag na superclass sobrang. Tinatawag ang inheriting class subclass. Kaya, ang isang subclass ay isang espesyal na bersyon ng isang superclass na nagmamana ng lahat ng mga katangian ng superclass at nagdaragdag ng sarili nitong mga natatanging elemento.

Isaalang-alang natin ang isang halimbawa ng paglalarawan ng klase ng java na "isang mag-aaral na Mag-aaral, na mayroong pangalan, apelyido, edad, at numero ng grupo. Gagawa tayo ng klase ng mag-aaral batay sa super klase ng User ng user, na mayroon nang isang pangalan, apelyido at edad na tinukoy:

Pampublikong User ng klase ( int age; String firstName; String lastName; // Constructor public User(int age, String firstName, String lastName) ( this.age = edad; this.firstName = firstName; this.lastName = lastName; ) )

Ngayon ay lumikha kami ng isang hiwalay na Class Student, na nagmamana ng mga katangian ng super class. Kapag nagmamana ng klase, dapat mo ring i-override ang mga constructor ng parent class:

Pinapalawak ng Estudyante ng pampublikong klase ang User ( int group; // Pampublikong Estudyante ng Constructor(int age, String firstName, String lastName) ( super(edad, firstName, lastName); ) boolean isMyGroup(int g) ( return g == group; ) )

Keyword umaabot nagpapakita na kami ay nagmamana mula sa klase ng User.

Super ng keyword

Sa constructor ng Student class, tinatawag namin ang constructor ng parent class sa pamamagitan ng operator sobrang, pagpasa dito ng buong kinakailangang hanay ng mga parameter. Sa Java ang keyword sobrang nagsasaad ng superclass, i.e. Ang klase kung saan nagmula ang kasalukuyang klase. Ang super keyword ay maaaring gamitin upang tumawag sa isang superclass constructor at upang ma-access ang isang superclass na miyembro na nakatago ng isang subclass na miyembro.

Tingnan natin kung paano ito mangyayari mana sa mga tuntunin ng paglikha ng bagay:

Student student = new Student(18, "Kisa", "Vorobyaninov", 221);

Una, ang constructor ng Student class ay binuksan, pagkatapos ay ang constructor ng superclass User ay tinawag, at pagkatapos ay ang natitirang mga operasyon sa Student constructor ay ginanap. Ang pagkakasunud-sunod ng mga aksyon na ito ay medyo lohikal at nagbibigay-daan sa iyo upang lumikha ng mas kumplikadong mga bagay batay sa mga mas simple.

Ang isang superclass ay maaaring magkaroon ng maraming overloaded na bersyon ng mga konstruktor nito, kaya ang super() na pamamaraan ay maaaring tawagin na may iba't ibang mga parameter. Ipapatupad ng programa ang constructor na tumutugma sa mga tinukoy na argumento.

Pangalawang anyo ng keyword sobrang gumaganap tulad ng isang keyword ito, tanging sa kasong ito palagi kaming sumangguni sa superclass ng subclass kung saan ito ginagamit. Ang pangkalahatang anyo ay ang mga sumusunod:

Dito ang miyembro ay maaaring isang paraan o isang variable na halimbawa. Ang form na ito ay angkop sa mga kaso kung saan ang mga pangalan ng mga miyembro ng isang subclass ay nagtatago ng mga miyembro ng isang superclass na may parehong mga pangalan.

Class A ( int i; ) // inherit mula sa class A class B extends A ( int i; // variable name matches and hides variable i in class A B(int a, int b) ( super.i = a; // access sa variable i mula sa class A i = b; // access variable i mula sa class B ) void show() ( System.out.println("i from superclass is " + super.i); System.out.println(" i sa subclass ay " + i); ) ) class MainActivity ( B subClass = new B(1, 2); subClass.show(); )

Bilang resulta, dapat nating makita sa console:

Ako mula sa superclass ay 1 ako sa subclass ay 2

Pamamaraan override, Override

Kung sa isang class hierarchy, ang pangalan at uri ng lagda ng isang subclass na pamamaraan ay tumutugma sa mga katangian ng isang superclass na pamamaraan, pagkatapos ay ang subclass na pamamaraan ay override ang superclass na pamamaraan. Kapag ang isang overridden na pamamaraan ay tinawag mula sa subclass nito, palaging ire-refer nito ang bersyon ng pamamaraang iyon na tinukoy ng subclass. At ang superclass na bersyon ng pamamaraan ay itatago.

Kung kailangan mong i-access ang isang bersyon ng isang overridden na pamamaraan na tinukoy sa isang superclass, dapat mong gamitin ang keyword sobrang.

Huwag ipagkamali ang overriding sa overloading. Ang pag-overriding ng pamamaraan ay nangyayari lamang kung ang mga pangalan at uri ng mga lagda ng dalawang pamamaraan ay magkapareho. Kung hindi man, ang dalawang pamamaraan ay na-overload lang.

Lumitaw ang anotasyon sa Java SE5 @Override;. Kung kailangan mong i-override ang isang paraan, gamitin ang @Override at ang compiler ay magtapon ng error kung hindi mo sinasadyang ma-overload ito sa halip na i-override ito.

Sa Java, maaari ka lamang magmana mula sa isang klase.

Encapsulation

Sa computer science, ang encapsulation (Latin: en capsula) ay ang packaging ng data at/o mga function sa iisang bagay.

Ang batayan ng encapsulation sa Java ay ang klase. Nangangahulugan ang Encapsulation na ang mga field ng isang bagay ay hindi direktang naa-access ng mga kliyente nito - nakatago ang mga ito mula sa direktang pag-access mula sa labas. Pinoprotektahan ng Encapsulation ang data ng isang bagay mula sa hindi gustong pag-access sa pamamagitan ng pagpapahintulot sa object na kontrolin ang access sa data nito.

I-access ang mga modifier

Kapag naglalarawan ng isang klase, ginagamit ang mga modifier ng access. I-access ang mga modifier maaaring tingnan mula sa pananaw encapsulation kaya at mana. Kapag tiningnan mula sa pananaw ng encapsulation, pinapayagan ka ng mga modifier ng access na paghigpitan ang hindi gustong pag-access sa mga miyembro ng klase mula sa labas.

Ang mga pampublikong miyembro ng isang klase ay bumubuo ng panlabas na functionality na available sa ibang mga klase. Ang mga miyembro na independiyente sa panlabas na paggana ay karaniwang idineklara na pribado, gayundin ang mga pantulong na pamamaraan na mga detalye lamang ng pagpapatupad at hindi pangkalahatan. Sa pamamagitan ng pagtatago ng pagpapatupad ng isang klase, maaari mong baguhin ang panloob na lohika ng isang hiwalay na klase nang hindi binabago ang code ng iba pang mga bahagi ng system.

Maipapayo na gumamit ng access sa mga pag-aari ng klase sa pamamagitan lamang ng mga pamamaraan nito (ang prinsipyo bean mga klase, "POJO"), na nagpapahintulot sa iyo na patunayan ang mga halaga ng field, dahil ang direktang pag-access sa mga pag-aari ay napakahirap subaybayan, na nangangahulugang maaari silang italaga ng mga maling halaga sa yugto ng pagpapatupad ng programa. Ang prinsipyong ito ay tumutukoy sa pamamahala ng naka-encapsulated na data at nagbibigay-daan sa iyong mabilis na baguhin ang paraan ng pag-imbak ng data. Kung ang data ay hindi nakaimbak sa memorya, ngunit sa mga file o isang database, kung gayon ilang mga pamamaraan lamang ng isang klase ang kailangang baguhin, sa halip na ipakilala ang pagpapaandar na ito sa lahat ng bahagi ng system.

Ang program code na nakasulat gamit ang prinsipyo ng encapsulation ay mas madaling i-debug. Upang malaman kung anong oras at kung sino ang nagbago ng pag-aari ng bagay na interesado kami, sapat na upang magdagdag ng output ng impormasyon sa pag-debug sa paraan ng bagay kung saan na-access ang pag-aari ng bagay na ito. Kapag gumagamit ng direktang pag-access sa mga katangian ng bagay, ang programmer ay kailangang magdagdag ng output ng impormasyon sa pag-debug sa lahat ng mga seksyon ng code kung saan ginagamit ang bagay na interesado sa amin.

Halimbawa ng isang simpleng paglalarawan ng robot

Pampublikong klase Robot ( pribadong double x = 0; // Kasalukuyang X coordinate pribadong double y = 0; // Kasalukuyang Y coordinate pribadong double course = 0; // Kasalukuyang kurso (sa degree) pampublikong double getX() ( return x; ) public void setX(double x) ( this.x = x; ) public double getY() ( return y; ) public void setY(double y) ( this.y = y; ) public double getCourse() ( return course; ) // Determining the course public void setCourse(double course) ( this.course = course; ) // Paglipat sa malayong public void forward (int distance) ( // Pag-access sa object field X x = x + distance * Math.cos ( course / 180 * Math.PI); // Access sa object field Y y = y + distance * Math.sin(course / 180 * Math.PI ) // Print robot coordinates public void printCoordinates() ( System.out ); .println(x + "," + y);

Ang ipinakitang halimbawa ng robot ay gumagamit ng mga hanay ng mga pamamaraan na nagsisimula sa itakda At makuha. Ang pares ng mga pamamaraan na ito ay madalas na tinatawag na setter/getter. Ang mga pamamaraan na ito ay ginagamit upang ma-access ang mga patlang ng isang bagay. Ang mga pangalan ng pamamaraan ay nagtatapos sa pangalan ng field na nagsisimula sa isang CAPITAL na titik.

Sa mga pamamaraan itakda ipinapasa namin ang halaga sa pamamagitan ng isang pormal na parameter sa pamamaraan. Sa procedure code, nagtatalaga kami ng value sa isang object/class variable gamit ang keyword ito.

This.course = kurso ...

Paggamit ng keyword ito kailangan, dahil ang pangalan ng pormal na parameter ay tumutugma sa pangalan ng object variable. Kung magkaiba ang mga pangalan, posible ito Huwag gamitin.

Polymorphism

Ang polymorphism ay isa sa mga pangunahing konsepto sa object-oriented programming, kasama ang inheritance at encapsulation. Ang salitang polymorphism ay nagmula sa Greek at nangangahulugang "may maraming anyo." Upang maunawaan kung ano ang ibig sabihin ng polymorphism na may kaugnayan sa object-oriented programming, isaalang-alang ang isang halimbawa ng paglikha ng isang vector graphics editor kung saan kinakailangan na gumamit ng isang bilang ng mga klase sa anyo ng isang hanay ng mga graphic primitives - parisukat, Linya, Bilog, Tatsulok, atbp. Ang bawat isa sa mga klase ay dapat na may tinukoy na pamamaraan gumuhit upang ipakita ang kaukulang primitive sa screen.

Malinaw, kakailanganin mong magsulat ng ilang code na, upang maipakita ang larawan, ay magkakasunod na umulit sa lahat ng mga primitive na kailangang ipakita sa screen at tawagan ang paraan ng pagguhit sa bawat isa sa kanila.

Ang isang taong hindi pamilyar sa polymorphism ay malamang na lumikha ng ilang mga array: isang hiwalay na array para sa bawat primitive na uri, at magsulat ng code na umuulit sa mga elemento mula sa bawat array nang sunud-sunod at tumatawag sa paraan ng pagguhit sa bawat elemento. Ang magiging resulta ay humigit-kumulang sa sumusunod na code:

// Defining arrays of graphic primitives Square s = new Square ; Linya l = bagong Linya; Circle c = bagong Circle ; Triangle t = bagong Triangle; // Punan ang lahat ng mga array ng naaangkop na mga bagay. . . // Loop iterating sa lahat ng mga cell ng array. para sa (int i = 0; i< s.length; i++){ // вызов метода draw() в случае, если ячейка не пустая. if (s[i] != null) s.draw(); } for(int i = 0; i < l.length; i++){ if (l[i] != null) l.draw(); } for(int i = 0; i < c.length; i++){ if (c[i] != null) c.draw(); } for(int i = 0; i < t.length; i++){ if (t[i] != null) t.draw(); }

Ang kawalan ng code na nakasulat sa itaas ay ang pagdoble ng halos magkaparehong code upang ipakita ang bawat uri ng primitive. Hindi rin maginhawa na sa karagdagang modernisasyon ng aming graphic editor at pagdaragdag ng kakayahang gumuhit ng mga bagong uri ng mga graphic primitive, halimbawa Text, Star, atbp., gamit ang diskarteng ito kailangan naming baguhin ang umiiral na code at magdagdag ng mga kahulugan ng mga bagong array. dito, pati na rin ang pagproseso ng elementong nakapaloob sa kanila.

Gamit ang polymorphism, maaari mong lubos na gawing simple ang pagpapatupad ng naturang pag-andar. Una sa lahat, gumawa tayo ng karaniwang Shape parent class para sa lahat ng ating klase.

Public class Shape ( public void draw() ( System.out.println("Stub"); ) )

Pagkatapos nito, lumikha kami ng iba't ibang mga descendant class: Square, Line, Circle at Triangle:

Public class Point extends Shape ( public void draw() ( System.out.println("Square"); ) ) public class Line extends Shape ( public void draw() ( System.out.println("Line"); ) ) pinalawak ng bilog ng pampublikong klase ang Hugis ( public void draw() ( System.out.println("Circle"); ) ) Ang pampublikong klase na Triangle ay nagpapalawak ng Shape ( public void draw() ( System.out.println("Triangle"); ) )

Sa mga inapo ay na-override natin ang paraan ng pagguhit. Bilang resulta, nakakuha kami ng hierarchy ng klase, na ipinapakita sa figure.

Ngayon tingnan natin ang kamangha-manghang tampok ng polymorphism:

// Defining and initializing the Shape array a = new Shape (new Shape(), new Triangle(), new Square(), new Circle()); // Looping sa pamamagitan ng array elements for(int i = 0; i< a.length; i++) { a[i].draw(); }

Ang mga sumusunod na linya ay ilalabas sa console:

Blangkong Triangle Square Circle

Sa ganitong paraan, tinawag ng bawat descendant class ang sarili nitong paraan ng draw, sa halip na tawagan ang draw method mula sa parent na Shape class.

Ang polymorphism ay isang probisyon ng teorya ng uri, ayon sa kung aling mga pangalan (halimbawa, mga variable) ay maaaring magpahiwatig ng mga bagay ng iba't ibang klase, ngunit may isang karaniwang magulang. Dahil dito, ang anumang bagay na tinutukoy ng isang polymorphic na pangalan ay maaaring tumugon sa sarili nitong paraan sa isang tiyak na pangkalahatang hanay ng mga operasyon.

Paraan ng labis na karga, labis na karga

Sa procedural programming, mayroon ding konsepto ng polymorphism, na naiiba sa kinokonsiderang mekanismo sa OOP. Ang procedural polymorphism ay nagpapahiwatig ng posibilidad na lumikha ng ilang mga pamamaraan o function na may parehong pangalan, ngunit iba't ibang mga numero o uri ng mga parameter ang pumasa. Ang ganitong mga function ng parehong pangalan ay tinatawag na overloaded, at ang phenomenon mismo ay tinatawag na overload. Ang overloading ng function ay umiiral din sa OOP at tinatawag na method overloading. Ang isang halimbawa ng paggamit ng paraan ng overloading sa wikang Java ay ang klase ng PrintWriter, na partikular na ginagamit para sa pag-print ng mga mensahe sa console. Ang klase na ito ay may maraming mga pamamaraan ng println na naiiba sa mga uri at/o bilang ng mga parameter ng input. Narito ang ilan lamang sa kanila:

Void println() // pumunta sa isang bagong linya void println(boolean x) // nagpi-print ng value ng Boolean variable (true or false) void println(String x) // nagpi-print ng string - ang value ng isang text parameter

Ang mga klase ay tinukoy hindi sa pamamagitan ng mga hanay ng mga katangian, ngunit sa pamamagitan ng mga semantika. Kaya, halimbawa, ang mga bagay na "matatag" at "kabayo" ay maaaring magkaroon ng parehong mga katangian: presyo at edad. Bukod dito, maaari silang kabilang sa parehong klase, kung isasaalang-alang sila sa gawain bilang isang produkto lamang, o sa iba't ibang klase, kung sa loob ng balangkas ng gawain ay gagamitin sila nang iba, i.e. Iba't ibang aksyon ang gagawin sa kanila.

Ang pagsasama-sama ng mga bagay sa mga klase ay nagpapahintulot sa amin na isaalang-alang ang problema sa isang mas pangkalahatang pagbabalangkas. Ang isang klase ay may pangalan (halimbawa, "kabayo") na tumutukoy sa lahat ng bagay ng klase na iyon. Bilang karagdagan, ang klase ay naglalaman ng mga pangalan ng mga katangian na tinukoy para sa mga bagay. Sa ganitong diwa, ang paglalarawan ng isang klase ay katulad ng paglalarawan ng isang uri ng istruktura o talaan (record), na malawakang ginagamit sa procedural programming; Bukod dito, ang bawat bagay ay may parehong kahulugan bilang isang halimbawa ng istraktura (isang variable o pare-pareho ng kaukulang uri).

Pormal Klase ay isang pattern ng pag-uugali ng mga bagay ng isang tiyak na uri na may tinukoy na mga parameter na tumutukoy sa estado. Ang lahat ng mga pagkakataon ng parehong klase (mga bagay na nagmula sa parehong klase) ay may parehong hanay ng mga katangian at karaniwang pag-uugali, iyon ay, ang mga ito ay tumutugon sa parehong paraan sa parehong mga mensahe.

Alinsunod sa UML( Pinag-isang Wika ng Pagmomodelo - pinag-isa wika ng pagmomodelo), ang klase ay may sumusunod na graphical na representasyon.

Ang klase ay inilalarawan bilang isang parihaba na binubuo ng tatlong bahagi. Ang pangalan ng klase ay inilalagay sa itaas na bahagi, ang mga katangian ng mga bagay ng klase ay nasa gitna, at ang mga aksyon na maaaring isagawa sa mga bagay ng klase na ito (mga pamamaraan) ay nasa ibabang bahagi.

Ang bawat klase ay maaari ding magkaroon ng mga espesyal na pamamaraan na awtomatikong tinatawag kapag ang mga bagay ng klase na iyon ay nilikha at nawasak:

• tagabuo(constructor) - naisakatuparan kapag lumilikha ng mga bagay;
• maninira(destructor) - pinaandar kapag nasira ang mga bagay.

Karaniwan, ang constructor at destructor ay may espesyal na syntax, na maaaring iba sa syntax na ginamit sa pagsulat ng mga normal na pamamaraan ng klase.

Encapsulation

Encapsulation(encapsulation) ay itinatago ang pagpapatupad ng isang klase at pinaghihiwalay ang panloob na representasyon nito mula sa panlabas (interface). Kapag gumagamit ng isang object-oriented na diskarte, hindi kaugalian na direktang i-access ang mga katangian ng isang klase mula sa mga pamamaraan ng iba pang mga klase. Upang ma-access ang mga katangian ng isang klase, kaugalian na gumamit ng mga espesyal na pamamaraan ng klase na ito upang makuha at baguhin ang mga katangian nito.

Sa loob ng isang bagay, ang data at mga pamamaraan ay maaaring magkaroon ng iba't ibang antas ng pagiging bukas (o pagiging naa-access). Ang mga antas ng pagiging naa-access na pinagtibay sa wikang Java ay tatalakayin nang detalyado sa Kabanata 6. Nagbibigay-daan sa iyo ang mga ito na mas makontrol ang pag-aari ng encapsulation.

Ang mga pampublikong miyembro ng isang klase ay bumubuo sa panlabas na interface ng isang bagay. Ito ang functionality na available sa ibang mga klase. Ang lahat ng mga katangian ng isang klase ay karaniwang idineklara na pribado, pati na rin ang mga pantulong na pamamaraan na mga detalye ng pagpapatupad at kung saan ang ibang mga bahagi ng system ay hindi dapat umasa.

Sa pamamagitan ng pagtatago ng pagpapatupad sa likod ng panlabas na interface ng isang klase, maaari mong baguhin ang panloob na lohika ng isang hiwalay na klase nang hindi binabago ang code ng iba pang mga bahagi ng system. Ang ari-arian na ito ay tinatawag na modularity.

Ang pagtiyak na ang mga katangian ng klase ay maa-access lamang sa pamamagitan ng mga pamamaraan nito ay nagbibigay din ng ilang mga benepisyo. Una, ginagawa nitong mas madaling kontrolin ang mga tamang halaga ng mga patlang, dahil imposibleng subaybayan ang direktang pag-access sa mga pag-aari, na nangangahulugang maaari silang italaga sa mga maling halaga.

Pangalawa, hindi magiging mahirap na baguhin ang paraan ng pag-imbak ng data. Kung ang impormasyon ay naka-imbak sa hindi memory storage, tulad ng isang file system o database, kakailanganin mo lamang na baguhin ang ilang mga pamamaraan sa isang klase sa halip na ipakilala ang functionality na ito sa buong system.

Sa wakas, ang code na nakasulat gamit ang prinsipyong ito ay mas madaling i-debug. Upang malaman kung sino at kailan binago ang pag-aari ng bagay na interesado kami, sapat na upang magdagdag ng output ng impormasyon sa pag-debug sa paraan ng bagay kung saan na-access ang ari-arian ng bagay na ito. Kapag gumagamit ng direktang pag-access sa mga katangian ng bagay, ang programmer ay kailangang magdagdag ng output ng impormasyon sa pag-debug sa lahat ng mga seksyon ng code kung saan ginagamit ang object ng interes.

Mana

Mana Ang inheritance ay isang relasyon sa pagitan ng mga klase kung saan ginagamit ng isang klase ang istruktura o pag-uugali ng ibang klase (solong mana) o iba pang mga klase (multiple inheritance). Ang inheritance ay nagpapakilala ng pampubliko/pribadong hierarchy kung saan subclass nagmana mula sa isa o higit pang karaniwan mga superclass. Ang mga subclass ay karaniwang nagpapalawak o nag-o-override sa minanang istraktura at pag-uugali.

Bilang isang halimbawa, maaari nating isaalang-alang ang isang problema kung saan kinakailangan na ipatupad ang mga klase na "Kotse" at "Truck". Malinaw, ang dalawang klase na ito ay may karaniwang pag-andar. Kaya, pareho silang may 4 na gulong, isang makina, maaaring gumalaw, atbp. Anumang kotse ay may lahat ng mga katangiang ito, hindi alintana kung ito ay isang trak o isang pampasaherong sasakyan, 5- o 12-seater. Makatuwirang ilagay ang mga karaniwang katangian at functionality na ito sa isang hiwalay na klase, halimbawa, "Kotse" at magmana mula rito ng mga klase na "Kotse" at "Truck", upang maiwasan ang pagsusulat ng parehong code nang paulit-ulit sa iba't ibang klase.

Ang ugnayan sa pangkalahatan ay ipinapahiwatig ng isang solidong linya na may tatsulok na arrow sa dulo. Ang arrow ay tumuturo sa isang mas pangkalahatang klase ( klase ng ninuno o superclass), at ang kawalan nito - sa isang mas espesyal na klase ( klase ng bata o subclass).

Ang paggamit ng inheritance ay nakakatulong na bawasan ang dami ng code na ginawa para ilarawan ang mga katulad na entity, at nakakatulong din sa iyong magsulat ng mas mahusay at flexible na code.

Sa halimbawang isinasaalang-alang, ginagamit ang solong mana. Ang isang klase ay maaari ding magmana ng mga katangian at pag-uugali ng ilang mga klase nang sabay-sabay. Ang pinakasikat na halimbawa ng paggamit ng maramihang mana ay ang pagdidisenyo ng isang sistema ng imbentaryo ng produkto sa isang tindahan ng alagang hayop.

Ang lahat ng mga hayop sa tindahan ng alagang hayop ay mga tagapagmana ng klase ng "Animal", pati na rin ang mga tagapagmana ng klase ng "Produkto". Yung. lahat sila ay may edad, nangangailangan ng pagkain at tubig at kasabay nito ay may presyo at maaaring ibenta.

Ang maramihang pamana sa diagram ay inilalarawan nang eksakto sa parehong paraan tulad ng iisang pamana, maliban na ang mga linya ng mana ay nagkokonekta ng isang descendant na klase sa ilang superclass nang sabay-sabay.

Hindi lahat ng object-oriented programming language ay naglalaman ng mga construct ng wika upang ilarawan ang maramihang pamana.

Sa Java, ang multiple inheritance ay may limitadong suporta sa pamamagitan ng mga interface at sasakupin sa Kabanata 8.

Polymorphism

Polymorphism ay isa sa mga pangunahing konsepto sa object-oriented na programming kasama ng mana at encapsulation. Ang salitang "polymorphism" ay nagmula sa Greek at nangangahulugang "may maraming anyo." Upang maunawaan kung ano ang ibig sabihin nito kaugnay sa object-oriented na programming, tingnan natin ang isang halimbawa.

Ipagpalagay na gusto naming lumikha ng isang vector graphics editor kung saan kailangan naming ilarawan ang isang hanay ng mga graphic primitive sa anyo ng mga klase - Point, Line, Circle, Box, atbp. Para sa bawat isa sa mga klase ay tutukuyin namin ang isang paraan ng pagguhit upang ipakita ang kaukulang primitive sa screen.

Malinaw, kailangan mong magsulat ng code na, kung kinakailangan, upang magpakita ng isang guhit, ay magkakasunod na umuulit sa lahat ng mga primitive na nasa screen sa oras ng pagguhit, at tawagan ang paraan ng pagguhit sa bawat isa sa kanila. Ang isang taong hindi pamilyar sa polymorphism ay malamang na lumikha ng maraming array (isang hiwalay na array para sa bawat primitive na uri) at magsusulat ng code na umuulit sa mga elemento sa bawat array nang sunud-sunod at tumatawag sa paraan ng pagguhit sa bawat elemento. Ang magiging resulta ay humigit-kumulang sa sumusunod na code:

... //paglikha ng isang walang laman na hanay na maaaring // naglalaman ng mga Point object na may pinakamataas na // kapasidad na 1000 Point p = bagong Point; Linya l = bagong Linya; Circle c = bagong Circle; Kahon b = bagong Kahon; ... // ipagpalagay na sa puntong ito // ang lahat ng mga arrays ay puno ng katumbas na // objects... for(int i = 0; i< p.length;i++) { //цикл с перебором всех ячеек массива. //вызов метода draw() в случае, // если ячейка не пустая. if(p[i]!=null) p[i].draw(); } for(int i = 0; i < l.length;i++) { if(l[i]!=null) l[i].draw(); } for(int i = 0; i < c.length;i++) { if(c[i]!=null) c[i].draw(); } for(int i = 0; i < b.length;i++) { if(b[i]!=null) b[i].draw(); } ...

Ang kawalan ng code na nakasulat sa itaas ay ang pagdoble ng halos magkaparehong code upang ipakita ang bawat uri ng primitive. Hindi rin maginhawa na sa karagdagang modernisasyon ng aming graphic editor at pagdaragdag ng kakayahang gumuhit ng mga bagong uri ng mga graphic primitive, halimbawa Text, Star, atbp., gamit ang diskarteng ito kailangan naming baguhin ang umiiral na code at magdagdag ng mga kahulugan ng mga bagong array. dito, pati na rin ang pagproseso na nakapaloob sa mga ito ng mga elemento.

Sa pamamagitan ng paggamit ng polymorphism, maaari naming lubos na gawing simple ang pagpapatupad ng naturang pag-andar. Una sa lahat, lumikha tayo ng isang karaniwang magulang

Ang genetic polymorphism ay isang kondisyon kung saan mayroong pangmatagalang pagkakaiba-iba ng mga gene, ngunit ang dalas ng pinakabihirang gene sa populasyon ay higit sa isang porsyento. Ang pagpapanatili nito ay nangyayari dahil sa patuloy na mutation ng mga gene, pati na rin ang kanilang patuloy na recombination. Ayon sa pananaliksik na isinagawa ng mga siyentipiko, ang genetic polymorphism ay naging laganap, dahil maaaring mayroong ilang milyong mga kumbinasyon ng gene.

Malaking stock

Ang mas mahusay na pagbagay ng isang populasyon sa isang bagong kapaligiran ay nakasalalay sa isang malaking supply ng polymorphism, at sa kasong ito, ang ebolusyon ay nangyayari nang mas mabilis. Hindi praktikal na tantyahin ang buong bilang ng mga polymorphic alleles gamit ang tradisyonal na genetic na pamamaraan. Ito ay dahil sa ang katunayan na ang pagkakaroon ng isang tiyak na gene sa genotype ay nakakamit sa pamamagitan ng pagtawid sa mga indibidwal na may iba't ibang mga katangian ng phenotypic na tinutukoy ng gene. Kung alam mo kung anong bahagi ng isang tiyak na populasyon ang binubuo ng mga indibidwal na may iba't ibang mga phenotypes, kung gayon posible na matukoy ang bilang ng mga alleles kung saan nakasalalay ang pagbuo ng isang partikular na katangian.

Kung paano nagsimula ang lahat?

Ang mga genetika ay nagsimulang umunlad nang mabilis noong 60s ng huling siglo, pagkatapos ay nagsimulang gamitin ang mga enzyme sa mga gel, na naging posible upang matukoy ang genetic polymorphism. Ano ang pamamaraang ito? Ito ay sa tulong nito na ang mga protina ay gumagalaw sa isang electric field, na nakasalalay sa laki ng protina na inililipat, pagsasaayos nito, pati na rin ang kabuuang singil sa iba't ibang bahagi ng gel. Pagkatapos nito, depende sa lokasyon at bilang ng mga spot na lumilitaw, natukoy ang natukoy na sangkap. Upang masuri ang polymorphism ng protina sa isang populasyon, sulit na suriin ang humigit-kumulang 20 o higit pang loci. Pagkatapos, gamit ang isang matematikal na pamamaraan, ang bilang at ratio ng homo- at heterozygotes ay tinutukoy. Ayon sa pananaliksik, ang ilang mga gene ay maaaring monomorphic, habang ang iba ay maaaring hindi pangkaraniwang polymorphic.

Mga uri ng polymorphism

Napakalawak ng konsepto ng polymorphism; Depende ito sa piling halaga ng gene at natural na pagpili, na naglalagay ng presyon sa populasyon. Bilang karagdagan, maaari itong genetic at chromosomal.

Gene at chromosomal polymorphism

Ang polymorphism ng gene ay kinakatawan sa katawan ng higit sa isang allele na isang kapansin-pansing halimbawa nito ay dugo. Ang Chromosomal ay kumakatawan sa mga pagkakaiba sa loob ng mga chromosome na nangyayari dahil sa mga aberration. Gayunpaman, may mga pagkakaiba sa mga heterochromatic na rehiyon. Sa kawalan ng patolohiya na hahantong sa kapansanan o kamatayan, ang mga naturang mutasyon ay neutral.

Transisyonal na polymorphism

Ang transitional polymorphism ay nangyayari kapag ang isang allele na dating karaniwan ay pinalitan sa isang populasyon ng isa pa na nagbibigay sa carrier nito ng higit na kakayahang umangkop (tinatawag ding multiple allelism). Sa isang naibigay na iba't, mayroong isang direksyon na pagbabago sa porsyento ng mga genotype, dahil sa kung saan nangyayari ang ebolusyon at ang mga dinamika nito ay isinasagawa. Ang kababalaghan ng mekanismong pang-industriya ay maaaring maging isang magandang halimbawa na nagpapakilala sa transisyonal na polymorphism. Kung ano ito ay ipinapakita ng isang simpleng paru-paro, na, sa pag-unlad ng industriya, nagbago ang puting kulay ng mga pakpak nito sa madilim. Ang hindi pangkaraniwang bagay na ito ay nagsimulang maobserbahan sa England, kung saan higit sa 80 species ng mga butterflies ang naging madilim na bulaklak mula sa maputlang cream, na unang napansin pagkatapos ng 1848 sa Manchester dahil sa mabilis na pag-unlad ng industriya. Noong 1895, higit sa 95% ng mga gamugamo ang nakakuha ng madilim na kulay ng kanilang mga pakpak. Ang ganitong mga pagbabago ay nauugnay sa katotohanan na ang mga puno ng kahoy ay naging mas mausok, at ang mga mapusyaw na paruparo ay naging madaling biktima ng mga thrush at robin. Ang mga pagbabago ay naganap dahil sa mutant melanistic alleles.

Balanseng polymorphism

Ang kahulugan ng "balanseng polymorphism" ay nagpapakita ng kawalan ng pagbabago sa anumang numerical ratios ng iba't ibang anyo ng genotypes sa isang populasyon na nasa matatag na kondisyon sa kapaligiran. Nangangahulugan ito na mula sa henerasyon hanggang sa henerasyon ang ratio ay nananatiling pareho, ngunit maaaring bahagyang magbago sa loob ng isang tiyak na halaga, na pare-pareho. Kung ihahambing sa transisyonal, balanseng polymorphism - ano ito? Pangunahin itong isang static na proseso ng ebolusyon. I. I. Shmalhausen noong 1940 ay binigyan din ito ng pangalang equilibrium heteromorphism.

Halimbawa ng balanseng polymorphism

Ang isang malinaw na halimbawa ng balanseng polymorphism ay ang pagkakaroon ng dalawang kasarian sa maraming monogamous na hayop. Ito ay dahil sa ang katunayan na sila ay may pantay na pumipili na mga pakinabang. Ang kanilang ratio sa loob ng isang populasyon ay palaging pantay. Kung mayroong polygamy sa isang populasyon, ang selective ratio ng mga kinatawan ng parehong kasarian ay maaaring maputol, kung saan ang mga kinatawan ng isang kasarian ay maaaring ganap na masira o maalis mula sa pagpaparami sa mas malaking lawak kaysa sa mga kinatawan ng hindi kabaro.

Ang isa pang halimbawa ay ang pangkat ng dugo ayon sa sistema ng ABO. Sa kasong ito, ang dalas ng iba't ibang genotype sa iba't ibang populasyon ay maaaring magkakaiba, ngunit sa parehong oras ay hindi nito binabago ang pagiging matatag nito mula sa henerasyon hanggang sa henerasyon. Sa madaling salita, walang isang genotype ang may pumipiling kalamangan sa iba. Ayon sa istatistika, ang mga lalaking may unang pangkat ng dugo ay may mas mahabang pag-asa sa buhay kaysa sa iba pang mga miyembro ng mas malakas na pakikipagtalik sa ibang mga grupo ng dugo. Kasabay nito, ang panganib na magkaroon ng duodenal ulcer sa pagkakaroon ng unang grupo ay mas mataas, ngunit maaari itong magbutas, at ito ay magdudulot ng kamatayan kung ang tulong ay naantala.

Balanse ng genetiko

Ang marupok na estadong ito ay maaaring magambala sa isang populasyon bilang resulta ng paglitaw, at dapat itong mangyari sa isang tiyak na dalas at sa bawat henerasyon. Ipinakita ng mga pag-aaral na ang mga polymorphism ng mga gene ng sistema ng hemostatic, ang pag-decode nito ay nagpapalinaw kung ang proseso ng ebolusyon ay nagtataguyod ng mga pagbabagong ito o, sa kabaligtaran, ay sumasalungat sa kanila, ay napakahalaga. Kung masusubaybayan mo ang kurso ng proseso ng mutant sa isang partikular na populasyon, maaari mo ring hatulan ang halaga nito para sa pagbagay. Ito ay maaaring katumbas ng isa kung ang mutation ay hindi ibinukod sa panahon ng proseso ng pagpili at walang mga hadlang sa pagkalat nito.

Karamihan sa mga kaso ay nagpapakita na ang halaga ng naturang mga gene ay mas mababa sa isa, at sa kaso ng kawalan ng kakayahan ng naturang mga mutant na magparami, ang lahat ay bumaba sa 0. Ang mga mutasyon ng ganitong uri ay itinatabi sa proseso ng natural na pagpili, ngunit ito ay hindi ibubukod ang paulit-ulit na pagbabago sa parehong gene, na nagbabayad para sa pag-aalis na isinasagawa sa pamamagitan ng pagpili. Pagkatapos ay maabot ang equilibrium, maaaring lumitaw ang mga mutated genes o, sa kabaligtaran, mawala. Ito ay humahantong sa isang balanseng proseso.

Ang isang halimbawa na malinaw na mailalarawan kung ano ang nangyayari ay sickle cell anemia. Sa kasong ito, ang isang nangingibabaw na mutated gene sa isang homozygous na estado ay nag-aambag sa maagang pagkamatay ng organismo. Ang mga heterozygous na organismo ay nabubuhay ngunit mas madaling kapitan ng sakit na malaria. Ang balanseng polymorphism ng sickle cell anemia gene ay maaaring masubaybayan sa mga lugar kung saan laganap ang tropikal na sakit na ito. Sa ganitong populasyon, ang mga homozygotes (mga indibidwal na may parehong mga gene) ay tinanggal, at ang pagpili ay kumikilos pabor sa mga heterozygotes (mga indibidwal na may iba't ibang mga gene). Dahil sa pagpili ng multi-vector na nagaganap sa gene pool ng populasyon, ang mga genotype ay pinananatili sa bawat henerasyon, na nagsisiguro ng mas mahusay na kakayahang umangkop ng organismo sa mga kondisyon sa kapaligiran. Kasama ang pagkakaroon ng sickle cell anemia gene, may iba pang mga uri ng mga gene na nagpapakilala sa polymorphism. Ano ang ibinibigay nito? Ang sagot sa tanong na ito ay isang phenomenon na tinatawag na heterosis.

Heterozygous mutations at polymorphism

Ang heterozygous polymorphism ay nagbibigay para sa kawalan ng mga pagbabago sa phenotypic sa pagkakaroon ng mga recessive mutations, kahit na sila ay nakakapinsala. Ngunit sa parehong oras, maaari silang maipon sa isang populasyon sa isang mataas na antas, na maaaring lumampas sa nakakapinsalang nangingibabaw na mutasyon.

proseso ng ebolusyon

Ang proseso ng ebolusyon ay tuloy-tuloy, at ang obligadong kondisyon nito ay polymorphism. Ang ipinapakita nito ay ang patuloy na kakayahang umangkop ng isang partikular na populasyon sa tirahan nito. Ang mga organismo ng iba't ibang kasarian na naninirahan sa loob ng parehong grupo ay maaaring nasa isang heterozygous na estado at naililipat mula sa henerasyon hanggang sa henerasyon sa loob ng maraming taon. Kasama nito, ang kanilang phenotypic manifestation ay maaaring hindi umiiral - dahil sa malaking reserba ng genetic variability.

Fibrinogen gene

Sa karamihan ng mga kaso, isinasaalang-alang ng mga mananaliksik ang fibrinogen gene polymorphism bilang isang pasimula sa pag-unlad ng ischemic stroke. Ngunit sa ngayon, ang problema kung saan ang genetic at nakuha na mga kadahilanan ay maaaring maka-impluwensya sa pag-unlad ng sakit na ito ay darating sa unahan. Ang ganitong uri ng stroke ay bubuo dahil sa thrombosis ng cerebral arteries, at sa pamamagitan ng pag-aaral ng polymorphism ng fibrinogen gene, mauunawaan ng isa ang maraming proseso, sa pamamagitan ng pag-impluwensya kung aling sakit ang maiiwasan. Sa kasalukuyan, hindi sapat na pinag-aralan ng mga siyentipiko ang mga koneksyon sa pagitan ng mga pagbabago sa genetic at mga parameter ng biochemical ng dugo. Ang karagdagang pananaliksik ay gagawing posible na maimpluwensyahan ang kurso ng sakit, baguhin ang kurso nito, o pigilan lamang ito sa maagang yugto ng pag-unlad.