Mga konsepto ng OOP sa Java

Ang isa sa pinakadakilang lakas ng Java ay ang object-oriented programming (OOP). Iyon ang dahilan kung bakit naging napakapopular ang wikang ito at angkop na angkop para sa mga proyekto sa anumang laki. Ano ang object-oriented programming? Ito ay hindi magic, ngunit ito ay maaaring magmukhang kaakit-akit kung ikaw ay talagang papasok dito. Ang OOP ay tungkol sa kung paano buuin ang iyong software. Ito ay isang konsepto, o sa halip ay isang grupo ng mga konsepto ng oop sa Java, na nagbibigay-daan sa iyong lumikha ng ilang partikular na pakikipag-ugnayan at ugnayan sa pagitan ng mga object ng Java upang epektibong bumuo at gumamit ng software. Kasama sa Classical OOP ang 3 + 1 pangunahing konsepto. Magsimula tayo sa mga klasiko.

Encapsulation

Ang encapsulation ng data ay nagtatago ng panloob na data mula sa labas ng mundo, at ina-access lamang ito sa pamamagitan ng mga paraan na nakalantad sa publiko. Anong ibig sabihin niyan? Anong data? Tinatago kanino? Ang ibig sabihin ng pagtatago ay paghigpitan ang direktang pag-access sa mga miyembro ng data (mga patlang) ng isang klase.

Paano ito gumagana sa Java:

1. Ang mga patlang ay ginawang pribado
2. Ang bawat field sa isang klase ay nakakakuha ng dalawang espesyal na pamamaraan: isang getter at isang setter. Ang mga pamamaraan ng getter ay nagbabalik ng halaga ng field. Hinahayaan ka ng mga paraan ng setter na baguhin ang halaga ng field sa hindi direkta ngunit pinahihintulutang paraan.

Halimbawa ng encapsulation sa Java code:

public class Student {
private int age;
private String name;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

public class Test{
public static void main(String[] args) {
Student firstStudent = new Student();
firstStudent.setName("John");
// The name field is private, so you can no longer do this:  firstStudent.name = "John"; 
}
}

Bakit mo dapat gamitin ang encapsulation?

Ang pangunahing dahilan ay upang gawing mas madali ang pagbabago ng iyong code. Isipin na mayroon kang aplikasyon para sa isang paaralan ng hockey at mayroong isang klase ng HockeyStudent na may dalawang field na nag-iimbak ng pangalan at edad ng estudyante noong siya ay nag-enroll sa paaralan. Isang bagay na tulad nito:

public class HockeyStudent {
public String name;
public  int ageOfEnrollment;
}

Ang field ng ageOfEnrollment ay pampubliko, walang getter o setter... Ang klase na ito ay ginagamit ng marami pang ibang klase, at naging ok ang lahat hanggang sa napagpasyahan ng ilang developer na hindi sapat ang isang int field. Ang ilang hockey player sa isang cohort ay halos isang taon na mas matanda kaysa sa kanilang mga kapantay, kaya mas maginhawang hatiin sila sa dalawang grupo depende sa buwan ng kanilang kapanganakan. Kaya ang field ng ageOfEnrollment ay dapat mapalitan ng int array (int[][]) : ang unang numero ay para sa buong taon at ang pangalawa ay para sa mga buwan. Ngayon ay kailangan mong i-refactor ang lahat ng code na gumagamit ng klase ng Mag-aaral ! Ngunit kung ang iyong edadOfEnrollmentAng field ay pribado at mayroon kang mga getter at setter, kung gayon ang lahat ay mas madali. Kung magbabago ang pangangailangan para sa pagtatakda ng edad ng isang mag-aaral, i-update lang ang logic sa setAgeOfEnrollment() setter method at ang iyong mga klase ay maaaring magpatuloy sa paggamit ng Student nang walang anumang problema! Ang halimbawang ito ay medyo ginawa, ngunit umaasa ako na ipaliwanag kung bakit ang paggamit ng encapsulation ay isang magandang ideya.

Mana

Ang prinsipyong ito ay mas madaling maunawaan kahit na walang anumang praktikal na karanasan. Huwag ulitin ang iyong sarili (DRY) ay maaaring ang motto para sa inheritance concept. Hinahayaan ka ng inheritance na lumikha ng child class na nagmamana ng mga field at pamamaraan ng parent class nang hindi muling tinutukoy ang mga ito. Oo naman, maaari mong i-override ang mga field at pamamaraan ng parent class sa child class, ngunit hindi ito kailangan. Higit pa rito, maaari kang magdagdag ng mga bagong estado at gawi sa klase ng bata. Ang mga parent class ay minsang tinatawag na mga superclass o base class, at ang mga child class ay kilala bilang mga subclass. Ang mga extends na keyword ng Java ay ginagamit upang ipatupad ang prinsipyo ng pamana sa code.

Paano ito gumagana sa Java:

1. Lumikha ng klase ng magulang.
2. Gumawa ng child class gamit ang extends na keyword.
3. Sa constructor ng klase ng Bata, gamitin ang super(parentField1, parentField2, ...) na paraan upang itakda ang mga field ng magulang.

Ilang panuntunan:

1. Ang isang klase ay maaaring magkaroon lamang ng isang magulang.
2. Ang isang klase ng magulang ay maaaring magkaroon ng maraming klase ng bata.
3. Ang isang klase ng bata ay maaaring magkaroon ng sarili nitong mga klase ng bata.

Halimbawa ng inheritance sa Java code

Gumawa tayo ng klase sa Telepono .

public class Phone {
    int price;
    double weight;

// Constructor
public Phone(int price, double weight) {
        this.price = price;
        this.weight = weight;
    }

    void orderPhone(){
        System.out.println("Ordering phone...");
    }
}

Siyempre, may iba't ibang uri ng mga telepono, kaya gumawa tayo ng dalawang klase ng bata: isa para sa mga Android phone at isang segundo para sa mga iPhone. Pagkatapos ay magdaragdag kami ng ilang mga field at pamamaraan na wala ang magulang. At gagamit kami ng super() para tawagan ang mga constructor para masimulan ang mga field na mayroon ang parent class.

Halimbawa ng pamana sa Java

public class Android extends Phone {

// Some new fields     
String androidVersion;
int screenSize;

    String secretDeviceCode;

// Constructor 
    public Android(int price, double weight, String androidVersion, int screenSize, String secretDeviceCode) {
        super(price, weight); // Android inherits Phone’s fields

        //this - reference to the current object
        //super - reference to the parent object

        this.androidVersion = androidVersion;
        this.screenSize = screenSize;
        this.secretDeviceCode = secretDeviceCode;
    }

	// New Android-specific method, does not exist in the Phone class 
    void installNewAndroidVersion() {
        System.out.println("installNewAndroidVersion invoked...");

    }

}

public class IPhone extends Phone {
   
    boolean fingerPrint;

    public IPhone(int price, double weight, boolean fingerPrint) {
        super(price, weight);
        System.out.println("IPhone constructor was invoked...");
        this.fingerPrint = fingerPrint;
    }

    void deleteIPhoneFromDb() {
        System.out.println("deleteIPhoneFromDb invoked...");
    }

@Override // This is about polymorphism, see below
void orderPhone(){
        System.out.println("Ordering my new iPhone and deleting the old one...");
    }
}

Kaya, upang ulitin: sa Java, hinahayaan ka ng inheritance na i-extend ang isang klase na may mga child class na nagmamana ng mga field at pamamaraan ng parent class. Ito ay isang mahusay na paraan upang makamit ang muling paggamit ng code.

Polymorphism

Ang polymorphism ay ang kakayahan ng isang bagay na mag-morph, kumuha ng iba't ibang anyo o sa halip ay kumikilos sa iba't ibang paraan. Sa Java, kadalasang nangyayari ang polymorphism kapag ginagamit ang reference ng parent class para tumukoy sa object ng child class.

Ano ang ibig sabihin nito at kung paano ito gumagana sa Java:

Ano ang polymorphism sa Java? Sa pangkalahatan, nangangahulugan iyon na maaari mong gamitin ang parehong pangalan ng pamamaraan para sa iba't ibang layunin. Mayroong dalawang uri ng polymorphism sa Java: method overriding (dynamic polymorphism) at method overloading (static polymorphism).

Pamamaraan override

Maaari mong i-override ang pamamaraan ng parent class sa isang child class, na pinipilit itong gumana sa ibang paraan. Gumawa tayo ng Musician parent class na may play() method.

Halimbawa ng polymorphism sa Java code

   public class Musician {
    String name;
    int age;

    // Default constructor
    public Musician() {
    }

    // Parameterized constructor
    public Musician(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void play() {
        System.out.println("I am playing my instrument...");
    }
}

Iba't ibang musikero ang gumagamit ng iba't ibang instrumento. Gumawa tayo ng dalawang klase ng bata: Pianist at Violinist . Salamat sa polymorphism, isasagawa ng bawat isa ang sarili nitong bersyon ng play() method. Kapag nag-o-override, maaari mong gamitin ang @Override annotation, ngunit hindi ito kinakailangan.

public class Pianist extends Musician {
    
    String favoritePianoType;

    public Pianist(String name, int age, String favoritePianoType) {
        super(name, age);
        this.favoritePianoType = favoritePianoType;
    }


    @Override
void play(){
        System.out.println("I am playing the piano...");
    }
}

Ang violin player ay maaaring isang soloista o isang miyembro ng isang orkestra. Isaalang-alang natin iyon kapag na-override ang ating play() na paraan.

public class Violinist extends Musician { 
    boolean isSoloist; 

public Violinist(String name, int age, boolean isSoloist) {
            super(name, age);
            this.isSoloist = isSoloist;
        }


    @Override
void play(){
if (isSoloist) 
        System.out.println("I am playing the violin solo...");
else 
System.out.println("I am playing the violin in an orchestra...");

    }
}

Gumawa tayo ng Demo class, kung saan gagawa tayo ng tatlong object, isang instance ng bawat isa sa mga naunang ginawang klase. Tingnan natin kung anong mga resulta ang makukuha natin.

public class Demo {
  public static void main(String[] args) {
  Musician musician = new Musician();
  Violinist violinist = new Violinist("John", 32, true);
  Pianist pianist = new Pianist("Glen", 30, "Acoustic"); 

  System.out.println("Musician said:");
  musician.play();
  System.out.println("Violinist said:");
  violinist.play();
  System.out.println("Pianist said:");
  pianist.play();
    }
}

Narito ang makukuha natin:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo…
Pianist said:
I am playing the piano...

Ang bawat violinist at pianist ay isang musikero, ngunit hindi lahat ng musikero ay isang violist o pianist. Nangangahulugan iyon na maaari mong gamitin ang paraan ng paglalaro ng musikero kung hindi mo kailangang gumawa ng bago. O maaari mong tawagan ang paraan ng magulang mula sa bata gamit ang super keyword. Gawin natin iyon sa code ng Pianist:

public class Pianist extends Musician {

    String favoritePianoType;
    
    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
}

Ngayon tawagan natin ang aming pangunahing() na pamamaraan sa klase ng Demo . Narito ang resulta:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...

Paraan ng overloading

Ang paraan ng overloading ay nangangahulugan ng paggamit ng iba't ibang pamamaraan na may parehong pangalan sa parehong klase. Dapat ay naiiba ang mga ito sa mga tuntunin ng bilang, pagkakasunud-sunod, o mga uri ng kanilang mga parameter. Ipagpalagay na ang isang pianist ay marunong tumugtog ng acoustic piano at electric piano. Upang tumugtog ng isang electric, ang musikero ay nangangailangan ng kuryente. Gumawa tayo ng dalawang magkaibang play() na pamamaraan. Ang una ay walang mga parameter, para sa isang acoustic piano, at ang pangalawa ay may isang parameter na nagpapahiwatig kung ang kuryente ay magagamit.

public class Pianist extends Musician {

    String name;
    int age;
    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
    void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            System.out.println("I am playing the piano...");
        }
        else System.out.println("I can't play this without electricity.");
    }
}

Sa pamamagitan ng paraan, maaari mong gamitin ang unang play() na pamamaraan sa loob ng pangalawang play(boolean) na pamamaraan sa ganitong paraan:

void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            play();
        }
        else System.out.println("I can't play this without electricity.");
    }

Magdagdag tayo ng ilang linya sa aming Demo class para ipakita ang aming sobrang karga:

public class Demo {
    public static void main(String[] args) {

        Musician musician = new Musician();
        Violinist violinist = new Violinist("John", 23, true);
        Pianist pianist = new Pianist("Glen", 30, "Acoustic"); 

        System.out.println("Musician said:");
        musician.play();
        System.out.println("Violinist said:");
        violinist.play();
        System.out.println("Pianist said:");
        pianist.play();
        System.out.println("The pianist will now try the electric piano:");
        pianist.play(true);
        System.out.println("The electricity has been shut off. Now when trying the electric piano, the pianist says:");
        pianist.play(false);
    }
}

Narito ang resulta:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...
The pianist will now try the electric piano:
The electricity is on.
I am playing my instrument...
I am playing the piano...
The electricity has been shut off. Now when trying the electric piano, the pianist says:
I can't play this without electricity.

Alam ng Java kung aling paraan ang dapat gamitin batay sa mga parameter nito at sa uri ng bagay. Iyan ay polymorphism.

Abstraction

Kapag tinukoy namin ang isang klase, sinusubukan naming bumuo ng isang modelo ng isang bagay. Halimbawa, ipagpalagay na nagsusulat kami ng isang video game na tinatawag na MyRacer na may iba't ibang lahi ng mga kotse. Ang isang manlalaro ay maaaring pumili ng isa sa mga ito at pagkatapos ay i-update ito sa ibang pagkakataon o bumili ng iba. Kaya... Ano ang kotse? Ang isang kotse ay isang medyo kumplikadong bagay, ngunit kung sinusubukan naming lumikha ng isang racing video game (kumpara sa isang driving simulator), hindi namin kailangang ilarawan ang lahat ng libu-libong gear at gasket na nilalaman nito. Kailangan namin ang modelo nito, pinakamataas na bilis, mga katangian ng kakayahang magamit, presyo, kulay... At marahil sapat na iyon. Iyan ang modelo ng isang kotse para sa aming laro. Mamaya sa MyRacer 2, ipagpalagay na nagpasya kaming magdagdag ng mga gulong na nakakaapekto sa paghawak sa kalsada. Dito iba ang modelo, dahil nagdagdag kami ng higit pang mga detalye. Hayaan na Tinukoy ni s ang data abstraction bilang proseso ng pagtukoy lamang sa mga mahahalagang (o kinakailangan) na katangian ng isang bagay at hindi pinapansin ang anumang hindi nauugnay na mga detalye. Mayroong iba't ibang antas ng abstraction. Halimbawa, kung ikaw ay isang pasahero sa isang bus, kailangan mong malaman kung ano ang hitsura ng iyong bus at kung saan ito papunta, ngunit hindi mo kailangang malaman kung paano ito imaneho. Kung ikaw ay driver ng bus, hindi mo kailangang malaman kung paano gumawa ng bagong bus — kailangan mo lang malaman kung paano ito magmaneho. Ngunit kung ikaw ay isang tagagawa ng bus, kailangan mong pumunta sa isang mas mababang antas ng abstraction, dahil ang mga detalye ng disenyo ng bus ay napakahalaga sa iyo. Sana maintindihan mo ang ibig kong sabihin. kailangan mong malaman kung ano ang hitsura ng iyong bus at kung saan ito pupunta, ngunit hindi mo kailangang malaman kung paano ito imaneho. Kung ikaw ay driver ng bus, hindi mo kailangang malaman kung paano gumawa ng bagong bus — kailangan mo lang malaman kung paano ito magmaneho. Ngunit kung ikaw ay isang tagagawa ng bus, kailangan mong pumunta sa isang mas mababang antas ng abstraction, dahil ang mga detalye ng disenyo ng bus ay napakahalaga sa iyo. Sana maintindihan mo ang ibig kong sabihin. kailangan mong malaman kung ano ang hitsura ng iyong bus at kung saan ito pupunta, ngunit hindi mo kailangang malaman kung paano ito imaneho. Kung ikaw ay driver ng bus, hindi mo kailangang malaman kung paano gumawa ng bagong bus — kailangan mo lang malaman kung paano ito magmaneho. Ngunit kung ikaw ay isang tagagawa ng bus, kailangan mong pumunta sa isang mas mababang antas ng abstraction, dahil ang mga detalye ng disenyo ng bus ay napakahalaga sa iyo. Sana maintindihan mo ang ibig kong sabihin.

Paano ito gumagana sa Java:

Bumuo tayo ng apat na antas ng abstraction sa Java, o sa halip sa OOP — mula sa pinakamababa (pinaka tiyak) hanggang sa pinakamataas (pinaka abstract).

1. Ang pinakamababang antas ng abstraction ay isang partikular na bagay. Ito ay isang entity na may isang hanay ng mga katangian na nabibilang sa isang partikular na klase. Mayroon itong mga tiyak na halaga ng field

2. Ang isang template para sa paglikha ng mga bagay ay isang klase. Ito ay isang paglalarawan ng isang hanay ng mga bagay na may katulad na mga katangian at panloob na istraktura.

3. Ang abstract na klase ay isang abstract na paglalarawan ng mga katangian ng isang hanay ng mga klase (ito ay gumaganap bilang isang template para sa pamana ng ibang mga klase). Ito ay may mataas na antas ng abstraction, kaya imposibleng lumikha ng mga bagay nang direkta mula sa isang abstract na klase. Tanging mga bata na klase ng mga abstract na klase ang maaaring gamitin upang lumikha ng mga bagay. Ang isang abstract na klase ay maaaring magsama ng mga pamamaraan na may pagpapatupad, ngunit hindi ito kinakailangan.

4. Ang isang interface ay isang construct ng Java programming language construct na naglalaman lamang ng abstract na pampublikong pamamaraan at static constant field (final static). Sa madaling salita, hindi maaaring gamitin ang mga abstract na klase o mga interface upang makabuo ng mga bagay.

BTW, sa Java 8 o mas bago, ang mga interface ay maaaring magkaroon ng hindi lamang abstract na mga pamamaraan at constants, kundi pati na rin ang mga default at static na pamamaraan. Sa Java, ang isang interface ay tumutukoy sa isang pag-uugali, habang ang isang abstract na klase ay ginagamit upang lumikha ng isang hierarchy. Ang isang interface ay maaaring ipatupad ng maraming klase.

Halimbawa ng interface sa Java code

interface Human {
	public void struggle();
	public void protect();
}

interface Vulcan {
	int angleOfPointyEars; 
	public void turnOffEmotions(boolean isOn);
	public void telepathy();
}

Maaari kang magpatupad ng higit sa isang interface

The Spock class implements Human and Vulcan {
public void struggle() {
System.out.println("I am struggling...");
}
	public void protect() {
System.out.println("You are under my protection!”);
}
public void turnOffEmotions(boolean isOn){
If (isOn) {
System.out.println("I am turning off my emotions.");
isOn= !isOn;
}
}
	public void telepathy() {
System.out.println("Connecting to your brain...");
}

}

Para sa mga nagsisimulang mag-aaral, sinasaklaw nito ang lahat ng pangunahing konsepto ng object-oriented programming sa Java. Bukod sa 4 na pangunahing prinsipyo ng OOP, ang Java ay mayroon ding asosasyon, pagsasama-sama, at komposisyon. Maaari mo silang tawaging "mga karagdagang prinsipyo ng OOP". Karapat-dapat sila sa kanilang sariling hiwalay na artikulo.