Mga relasyon sa pagitan ng mga klase. Pamana, komposisyon, at pagsasama-sama

Hi! Ngayon ay susuriin natin ang isang prinsipyo ng Object Oriented Programming (OOP): Inheritance. Pag-aaralan din namin ang iba pang mga uri ng ugnayan sa pagitan ng mga klase: komposisyon at pagsasama-sama. Ang paksang ito ay hindi magiging mahirap: nakatagpo ka na ng pamana at mga halimbawa ng pamana nang maraming beses sa mga nakaraang aralin. Ngayon, ang pangunahing bagay ay upang palakasin ang iyong kaalaman, suriin ang mekanismo ng pamana nang mas detalyado, at muling tumakbo sa ilang mga halimbawa. :) Aba, tara na!

Pamana sa Java at mga pakinabang nito

Tulad ng tiyak mong natatandaan, ang inheritance ay isang mekanismo na nagbibigay-daan sa iyong ilarawan ang isang bagong klase batay sa isang kasalukuyang klase (parent class). Sa paggawa nito, hinihiram ng bagong klase ang mga katangian at functionality ng parent class. Alalahanin natin ang isang halimbawa ng pamana na ibinigay sa mga nakaraang aralin:

public class Car {

   private String model;
   private int maxSpeed;
   private int yearOfManufacture;

   public Car(String model, int maxSpeed, int yearOfManufacture) {
       this.model = model;
       this.maxSpeed = maxSpeed;
       this.yearOfManufacture = yearOfManufacture;
   }


public void gas() {
       // Gas
   }

   	public void brake() {
       // Brake
   }
}


public class Truck extends Car {

   public Truck(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}



public class Sedan extends Car {
   public Sedan(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

Mayroon kaming isang partikular na programa na nagsasangkot ng pagtatrabaho sa iba't ibang uri ng mga kotse. Kahit na hindi ka mahilig sa kotse, malamang na alam mo na napakaraming uri ng mga kotse sa mundo. :) Alinsunod dito, ihihiwalay namin ang mga karaniwang katangian ng mga kotse sa isang karaniwang parent class na tinatawag na Car. Kaya ano ang karaniwan sa lahat ng mga kotse, anuman ang kanilang uri? Ang bawat kotse ay may isang taon ng paggawa, pangalan ng modelo, at pinakamataas na bilis. Inilalagay namin ang mga katangiang ito sa model, maxSpeed, at yearOfManufacturemga field. Tulad ng para sa pag-uugali, ang anumang kotse ay maaaring mapabilis at bumagal. :) Tinutukoy namin ang pag-uugaling ito sa gas()atbrake()paraan. Anong mga benepisyo ang ibinibigay nito sa atin? Una sa lahat, binabawasan nito ang dami ng code. Siyempre, magagawa natin nang wala ang klase ng magulang. Ngunit dahil ang bawat kotse ay dapat na makapagpabilis at makapagpabagal, kailangan nating gumawa gas()at brake()mga pamamaraan sa Truck, Sedan, F1Car, at SportsCarmga klase at sa bawat iba pang klase ng kotse. Isipin kung gaano karaming dagdag na code ang kailangan nating isulat. At huwag kalimutan ang tungkol sa model, maxSpeed, at yearOfManufacturemga field: kung aalisin natin ang parent class, kakailanganin nating gawin ang mga ito sa bawat klase ng kotse! Kapag mayroon kaming ilang dosenang klase ng kotse, nagiging seryoso talaga ang dami ng duplicate na code. Ang paglipat ng mga karaniwang field at pamamaraan (tinatawag ding "mga estado" at "mga pag-uugali") sa isang klase ng magulang ay nagbibigay-daan sa amin na makatipid ng maraming oras at espasyo. Kung ang ilang uri ay may mga natatanging katangian o pamamaraan na wala sa ibang mga uri ng kotse, walang malaking bagay. Maaari mong gawin ang mga ito anumang oras sa isang descendant na klase, na hiwalay sa lahat.

public class F1Car extends Car {

   public void pitStop() {

       // Only race cars make pit stops
   }

   public static void main(String[] args) {

       F1Car formula1Car = new F1Car();
       formula1Car.gas();
       formula1Car.pitStop();
       formula1Car.brake();
   }
}

Tingnan natin ang Formula One race cars bilang isang halimbawa. Hindi tulad ng kanilang "mga kamag-anak", mayroon silang kakaibang pag-uugali — sila ay humihinto paminsan-minsan. Ito ay hindi nakakaabala sa amin. Nailarawan na namin ang karaniwang gawi sa Carparent class, at ang partikular na gawi ng mga descendant na klase ay maaaring idagdag sa mga klase na iyon. Totoo rin ito sa mga field: kung ang isang klase ng bata ay may mga natatanging katangian, mahinahon naming idineklara ang mga field na ito sa loob ng klase ng bata at itigil ang pag-aalala. :) Ang kakayahang muling gamitin ang code ay ang pangunahing bentahe ng mana. Para sa mga programmer, napakahalaga na huwag magsulat ng karagdagang code. Paulit-ulit mong makikita ito sa iyong trabaho. Mangyaring tandaan ang isang bagay na mahalaga: Java ay walang maramihang mana. Ang bawat klase ay nagmamana lamang ng isang klase. Pag-uusapan pa natin ang mga dahilan nito sa mga susunod na aralin. Sa ngayon, tandaan mo lang. Sa pamamagitan ng paraan, ginagawa nitong naiiba ang Java sa ilang iba pang mga wika ng OOP. Halimbawa, sinusuportahan ng C++ ang maramihang pamana. Ang lahat ay higit pa o hindi gaanong malinaw na may mana. Mag-move on na tayo.

Komposisyon at pagsasama-sama

Maaaring iugnay ang mga klase at bagay. Inilalarawan ng mana ang isang "is-a" na relasyon. Ang leon ay isang hayop. Ang ganitong relasyon ay madaling ipinahayag gamit ang mana, kung saan Animalang klase ng magulang at Lionang anak. Gayunpaman, hindi lahat ng mga relasyon ay inilarawan sa ganitong paraan. Halimbawa, tiyak na nauugnay ang keyboard sa isang computer, ngunit hindi ito isang computer . Ang mga kamay ay kahit papaano ay may kaugnayan sa isang tao, ngunit hindi sila isang tao. Sa mga kasong ito, mayroon kaming isa pang uri ng relasyon: hindi "ay-a", ngunit "may-a". Ang kamay ay hindi isang tao, ngunit bahagi ng isang tao. Ang keyboard ay hindi isang computer, ngunit bahagi ng isang computer. Ang isang may-isang relasyon ay maaaring ilarawan sa code gamit ang komposisyon at pagsasama-sama. Ang pagkakaiba ay nasa "higpit" ng relasyon. Magbigay tayo ng simpleng halimbawa: May Carklase tayo. Bawat sasakyan ay may makina. Bilang karagdagan, ang bawat kotse ay may mga pasahero. Ano ang pangunahing pagkakaiba sa pagitan ng Engine engineat Passenger[] passengersmga patlang? Ang katotohanan na ang pasahero Aay nakaupo sa isang kotse ay hindi nangangahulugan na ang mga pasahero Bat Cwala sa kotse. Ang isang kotse ay maaaring tumutugma sa maraming pasahero. Higit pa rito, kung ang lahat ng mga pasahero ay bumaba sa isang kotse, ito ay gagana pa rin nang maayos. Ang ugnayan sa pagitan ng Carklase at ng Passenger[] passengersarray ay hindi gaanong mahigpit. Ito ay tinatawag na pagsasama-sama . Nagbibigay ito ng isa pang magandang halimbawa ng pagsasama-sama. Kunwari may klase tayo Studentat aStudentGroupklase. Maaaring sumali ang isang mag-aaral sa maraming organisasyon ng mag-aaral: isang physics club, isang Star Wars fan club, at/o isang student comedy club. Ang komposisyon ay isang mas mahigpit na uri ng relasyon. Kapag gumagamit ng komposisyon, ang isang bagay ay bahagi ng ilang bagay at hindi maaaring kabilang sa isa pang bagay na may parehong uri. Ang pinakasimpleng halimbawa ay isang makina ng kotse. Ang isang makina ay bahagi ng isang kotse at hindi maaaring maging bahagi ng isa pang kotse. Tulad ng makikita mo, ang kanilang relasyon ay mas mahigpit kaysa sa relasyon sa pagitan ni Carat Passengers.