Coffee break #111. Polymorphism at dynamic na pagbubuklod sa Java. Para sa loop sa Java + para sa bawat halimbawa ng syntax ng loop

Polymorphism at dynamic na pagbubuklod sa Java

Pinagmulan: Ang DZone Polymorphism ay isa sa mga pangunahing konsepto ng object-oriented programming. Bago ka man sa Java programming o isang batikang developer, dapat mong malaman kung ano ang polymorphism at kung paano ito gumagana. Sinasabi ng karamihan sa mga developer na bihasa sila sa paksang ito, ngunit pagdating sa iba pang mga kumplikadong feature tulad ng static at dynamic na binding, marami sa kanila ang nawawalan ng kumpiyansa.

Ano ang polymorphism sa Java?

Ang ibig sabihin ng polymorphism ay pagkakaroon ng maraming anyo. Sa programming, ito ay tumutukoy sa kakayahan ng isang signal o mensahe na lumabas sa higit sa isang anyo.

Halimbawa ng totoong buhay

Ang isang tao ay maaaring magpakita ng maraming katangian sa parehong oras. Halimbawa, ang isang ina ay maaaring sabay na isang asawa, isang anak na babae, isang kapatid na babae, isang empleyado ng kumpanya, at iba pa. Samakatuwid, ang isang tao ay maaaring magpakita ng iba't ibang mga katangian sa ilalim ng iba't ibang mga kondisyon. Ito ay kilala bilang polymorphism.

Ang Kahalagahan ng Polymorphism

Ang polymorphism ay isa sa pinakamahalagang katangian ng anumang object-oriented programming language (halimbawa, Java). Sa tulong ng polymorphism, ang parehong gawain ay maaaring isagawa sa iba't ibang paraan.

Mga uri ng polymorphism

Sa Java, ang polymorphism ay maaaring nahahati sa dalawang kategorya:

1. Compile-time polymorphism (static linking)
2. Runtime polymorphism (Runtime, dynamic na binding)

Compile-time polymorphism

Ang compile-time polymorphism ay kilala rin bilang static linking. Ang ganitong uri ng polymorphism ay maaaring makamit sa pamamagitan ng function overloading o operator overloading. Ngunit sa Java, limitado ito sa overloading sa paggana dahil hindi sinusuportahan ng Java ang overloading ng operator. Overloading ng Function Kapag mayroong hindi bababa sa dalawang function o pamamaraan na may parehong pangalan ng function, ngunit ang bilang ng mga parameter na naglalaman ng mga ito ay iba, o hindi bababa sa isang uri ng data ng katumbas na parameter ay naiiba (o pareho), kung gayon ito ay tinatawag na function. o paraan ng overloading, at ang mga function na ito ay kilala bilang mga overloaded na function. Halimbawa 1 Sa ngayon ay pinag-aralan natin kung ano ang function na overloading. Ngayon, subukan nating ipakita ang labis na pag-andar ng software.

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {

        // Returns sum of integer numbers
        return a + b;
    }
    // Method 2
    // having the same name but with 2 double parameters
    static double Addition(double a, double b)
    {
        // Returns sum of double numbers
        return a + b;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));

    }
}

Maaari mong patakbuhin ang programa sa itaas dito . Pagpapaliwanag ng programa:

• Ang programa sa itaas ay binubuo ng dalawang static na function na may parehong mga pangalan: Addition .

• Dito, ang parehong mga function ay naglalaman ng parehong bilang ng mga parameter, ngunit ang kanilang mga kaukulang parameter ay iba.

• Ang Paraan 1 ay tumatanggap ng dalawang integer na parameter, habang ang Paraan 2 ay tumatanggap ng dalawang dobleng parameter .

• Mula sa pangunahing function, una nating tinatawag ang Addition(12, 14) function . Ang mga parameter na naipasa ay mga integer (12 at 14), kaya ang Paraan 1 ay tatawagin dito.

• Pagkatapos ay tinawag namin ang Addition(15.2, 16.1) function . Dahil ang mga parameter na naipasa ay dobleng uri ng data (15.2 at 16.1), ang Paraan 2 ay tatawagin sa oras na ito .

• Ito ay kung paano nakakamit ang overloading ng function sa Java batay sa iba't ibang uri ng data ng parameter.

Halimbawa 2 Isaalang-alang ang programa sa ibaba:

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {

        // Returns sum of integer numbers
        return a + b;
    }

    // Method 2
    // having the same name but with 3 integer parameters
    static double Addition(double a, double b)
    {

        // Returns sum of integer numbers
        return a + b;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));

    }
}

Maaari mong patakbuhin ang programa sa itaas dito . Pagpapaliwanag ng programa:

• Ang programa sa itaas ay binubuo ng dalawang static na function na may parehong mga pangalan: Addition .

• Dito, ang parehong mga function ay naglalaman ng iba't ibang bilang ng mga parameter, ngunit ang uri ng data ng unang dalawang kaukulang parameter ay pareho (integer).

• Ang Paraan 1 ay tumatagal ng dalawang integer na parameter, at ang Paraan 2 ay kumukuha ng tatlong integer na uri ng mga parameter ng data.

• Mula sa pangunahing pag-andar, una naming tinatawag ang Addition(2, 3) function . Dahil ang mga naipasa na parameter ay mga integer (2 at 3), tatawagin nila ang Paraan 1 dito .

• Pagkatapos ay tinawag namin ang Addition(4, 5, 6) function . Ang mga parameter na naipasa ay dobleng uri ng data (4, 5, 6), kaya tatawagin nila ang Paraan 2 sa pagkakataong ito .

• Ito ay kung paano na-overload ang mga function sa Java batay sa ibang bilang ng mga parameter.

Halimbawa 3

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {
        // Return the sum
        return a + b;
    }
    // Method 2
    // having the same name but with 3 parameters
    // 1st parameter is of type double and other parameters
    // are of type integer
    static double Addition(double a, int b,  int c)
    {
        // Return the sum
        return a + b + c;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(2, 4));
        System.out.println(Addition(4.2, 6, 10));

    }
}

Maaari mong patakbuhin ang programa sa itaas dito . Pagpapaliwanag ng programa:

• Ang programa sa itaas ay binubuo ng dalawang static na function na may parehong mga pangalan: Addition .

• Ang parehong mga function ay naglalaman ng ibang bilang ng mga parameter at ang uri ng data ng unang kaukulang elemento ay iba rin.

• Ang Paraan 1 ay kumukuha ng dalawang integer na parameter, habang ang Paraan 2 ay kumukuha ng tatlong parameter - ang una ay double type at ang dalawa pa ay mga integer data type.

• Mula sa pangunahing function, una naming tinatawag ang Addition(2, 4) function . Dahil ang mga naipasa na parameter ay mga integer (2 at 4), tatawagin nila ang Paraan 1 dito .

• Pagkatapos ay tinawag namin ang Addition(4.2, 6, 10) function . Ang unang parameter na naipasa ay integer type at ang natitirang mga parameter ay double (4.2, 6, 10) na uri ng data, kaya ang Paraan 2 ay tatawagin sa oras na ito .

• Ito ay kung paano nakakamit ng Java ang overloading ng function batay sa iba't ibang bilang ng mga parameter pati na rin sa iba't ibang uri ng data ng mga kaukulang parameter.

Tandaan. Ang isang function ay hindi maaaring ma-overload batay lamang sa uri ng pagbabalik ng function.

Runtime polymorphism

Ang opsyong ito ay kilala rin bilang dynamic na pag-link. Sa prosesong ito, ang pagtawag sa isang function na nilikha para sa isa pang function ay pinapayagan lamang sa runtime. Makakamit natin ang dynamic na pagbubuklod sa Java gamit ang overriding na pamamaraan.

Pamamaraan override

Ang pag-override ng pamamaraan sa Java ay nangyayari kapag ang isang pamamaraan sa isang baseng klase ay may kahulugan sa isang nagmula na klase. Ang isang base class method o function ay tinatawag na overridden method.

// Class 1
class Parent {

    // Print method
    void Print()
    {

        // Print statement
        System.out.println("Inside Parent Class");
    }
}

// Class 2
class Child1 extends Parent {

    // Print method
    void Print() { System.out.println("Inside Child1 Class"); }
}

// Class 3
class Child2 extends Parent {

    // Print method
    void Print()
    {
        // Print statement
        System.out.println("Inside Child2 Class");
    }
}

class Main {

    public static void main(String args[]) {

        // Creating an object of class Parent
        Parent parent = new Parent();
        parent.Print();

        // Calling print methods
        parent = new Child1();
        parent.Print();

        parent = new Child2();
        parent.Print();
    }
}

Maaari mong patakbuhin ang programa sa itaas dito . Pagpapaliwanag ng programa:

• Ang programa sa itaas ay binubuo ng tatlong klase: Magulang ( class 1 ), Child1 ( class 2 ) at Child2 ( class 3 ). Class 2 at class 3 inherit class 1 .

• Ang magulang ay may paraan na tinatawag na Print() . Sa loob ng function na ito ay nag-print kami ng " Inside Parent Class ". Ang Child1 at Child2 ay mayroon ding Print() function , na karaniwang nag-o-override sa Print() function ng Parent class at nag-print ng " Inside Child1 Class " at " Inside Child2 Class " ayon sa pagkakabanggit sa console.

• Mula sa pangunahing pag-andar, lumikha muna kami ng isang object ng parent class na tinatawag na parent. Pagkatapos ay gagamitin namin ang bagay na ito upang tawagan ang paraan ng pag-print ng parent class . Samakatuwid ang " Inside Parent Class " ay ipi-print sa console.

• Pagkatapos nito, tinatawagan namin ang default na tagabuo ng klase ng Child1 at tinawag ang Print() function . Tandaan na ang Print() method na tinukoy sa Child1 class ay tatawagin na dahil na-override namin ang Print() method ng parent class . Samakatuwid, ang " Inside Child1 Class " ay ipi-print sa console.

• Sa wakas, tinatawagan namin ang default na tagabuo ng klase ng Child2 at tinatawag ang Print() function . Dito tatawagin ang Print() method na tinukoy sa Child2 class dahil na-override namin ang Print() method ng parent class . Samakatuwid, ang " Inside Child2 Class " ay ipi-print sa console.

• Ito ay kung paano nakakamit ang overriding ng pamamaraan sa Java.

Mga resulta

Sa artikulong ito, natutunan namin kung ano ang polymorphism sa Java. Pagkatapos ay hinalukay namin nang mas malalim ang paksa at tinalakay ang dalawang uri ng polymorphism sa Java: compile-time polymorphism at run-time polymorphism. Ipinakita namin sa pamamagitan ng mga programa kung paano makakamit ang static at dynamic na binding sa Java.

Para sa loop sa Java + para sa bawat halimbawa ng syntax ng loop

Source: FreeCodeCamp Ang Loop sa programming ay isang sequence ng mga tagubilin na patuloy na isinasagawa hanggang sa matugunan ang isang partikular na kundisyon. Sa artikulong ito, malalaman natin ang tungkol sa para at para sa bawat loop sa Java.

Para sa Loop Syntax sa Java

Narito ang syntax para sa paglikha ng for loop :

for (initialization; condition; increment/decrement) {
   // code to be executed
}

Tingnan natin ang ilan sa mga keyword sa code:

• para sa ay nagpapahiwatig na kami ay gagawa ng isang loop. Sinusundan ito ng mga panaklong, na naglalaman ng lahat ng kailangan natin para gumana ang ating loop.

• Tinutukoy ng initialization ang paunang variable bilang panimulang punto ng loop, karaniwang isang integer.

• tinutukoy ng kundisyon kung ilang beses dapat isagawa ang loop.

• increment / decrement increment/decrement ang value ng paunang variable sa tuwing tatakbo ang loop. Habang tumataas/bumababa ang halaga ng variable, ito ay humahantong sa tinukoy na kundisyon.

• Tandaan na ang bawat keyword ay pinaghihiwalay ng semicolon ( ; ).

Narito ang ilang halimbawa:

for(int x = 1; x <=5; x++) {
  System.out.println(x);
}

/*
1
2
3
4
5
*/

Sa halimbawa sa itaas, ang panimulang variable ay x na may halagang 1. Ang loop ay patuloy na tatakbo hangga't ang halaga ng x ay mas mababa sa o katumbas ng 5 - ito ang kundisyon. Ang x++ ay nagdaragdag ng halaga ng x pagkatapos ng bawat pagtakbo. Ipinagpatuloy namin ang pag-print ng halaga ng x na humihinto pagkatapos ng 5 dahil natugunan ang kundisyon. Ang pagtaas sa 6 ay hindi posible dahil ito ay mas malaki kaysa sa at hindi katumbas ng 5. Sa sumusunod na halimbawa, gagamitin namin ang isang for loop upang i-print ang lahat ng mga halaga sa isang array.

int[] randomNumbers = {2, 5, 4, 7};
for (int i = 0; i < randomNumbers.length; i++) {
  System.out.println(randomNumbers[i]);
}

// 2
// 5
// 4
// 7

Ito ay halos kapareho ng huling halimbawa. Dito ginamit namin ang haba ng array bilang isang kundisyon at ang paunang halaga ng variable bilang zero dahil ang ordinal na numero ng unang elemento ng array ay zero.

para sa bawat loop syntax sa Java

Ang forEach loop ay partikular na ginagamit upang umulit sa mga elemento ng isang array. Ito ang hitsura ng syntax nito:

for (dataType variableName : arrayName) {
  // code to be executed
}

Mapapansin mo na ang syntax dito ay mas maikli kaysa sa for loop . At ang forEach loop ay nagsisimula din sa para sa keyword . Sa halip na simulan ang isang variable na may halaga, una naming tinukoy ang uri ng data (dapat itong tumugma sa uri ng data ng array). Sinusundan ito ng pangalan ng aming variable at ang pangalan ng array , na pinaghihiwalay ng colon. Narito ang isang halimbawa upang matulungan kang mas maunawaan ang syntax:

int[] randomNumbers = {2, 5, 4, 7};
for (int x : randomNumbers) {
  System.out.println(x + 1);
}

/*
3
6
5
8
*/

Sa halimbawang ito, inulit namin ang bawat elemento at dinagdagan ang kanilang paunang halaga ng 1. Bilang default, hihinto ang loop kapag naulit na nito ang lahat ng elemento ng array. Nangangahulugan ito na hindi namin kailangang magpasa ng anumang halaga sa aming variable o tumukoy ng anumang kundisyon para matapos ang loop.

Konklusyon

Sa artikulong ito, natutunan namin kung ano ang mga loop at ang syntax para sa paggawa para sa at para sa bawat loop sa Java. Nakakita rin kami ng ilang halimbawa na nakatulong sa amin na maunawaan kung kailan at paano gamitin ang mga ito. Maligayang coding!