Coffee break #139. Overloading at Overriding sa Java. 5 Mga Paraan ng Java na Hindi Mo Alam

Overloading at Overriding sa Java

Source: Medium Sa artikulong ito, matututunan mo ang tungkol sa mga pamamaraan ng Overriding at Overloading sa wikang Java. Dahil sa ang katunayan na ang parehong mga terminong ito ay madalas na nalilito sa isa't isa, ito ay nagkakahalaga ng malinaw na pag-unawa sa layunin ng bawat pamamaraan at ang kanilang mga pagpipilian para sa aplikasyon.

Overloading

Ang paggamit ng higit sa isang paraan na may parehong pangalan ngunit may iba't ibang mga parameter sa parehong klase o pamamaraan sa pagitan ng superclass at subclass sa Java ay tinatawag na Overloading. Upang maiwasan ito, isang paraan ang ginagamit sa halip na marami na nagsasagawa ng mga katulad na pagkilos. Ipaliwanag natin sa isang halimbawa:

public class MethodOverloading {

    public static void main(String[] args){
        MethodOverloading operation = new MethodOverloading();
        operation.mod(12,4);
        operation.mod(12.4,4.2);
    }

    void mod(double a, double b){
        System.out.println(a % b);
    }

    void mod(int a, int b){
        System.out.println(a % b);
    }
}

Sa code na ito, overloaded ang paraan ng pagpapatakbo. Ang mga pamamaraan na may parehong mga pangalan ay tumatanggap ng mga parameter ng iba't ibang uri. Ang pagpili ng mode ay tinutukoy nang hiwalay para sa int at double parameter . Kapag pinatakbo namin ang programa, tumatakbo ang operation.mod (12,4) void.mod (int a, int b) at operation.mod (12.4,4.2) ay nagpapatakbo ng void.mod (double a, double b) .

Overriding

Sa Java, maaari tayong lumikha ng isang superclass at mga subclass na nagmana mula sa klase na iyon. Maaaring i-override at palitan ng mga subclass na ito ang mga pamamaraan ng parent class na kanilang minana. Ginagawa ito gamit ang Overriding method. Mas mauunawaan ito sa isang halimbawa:

public class MethodOverriding {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.sound();

        Bee bee = new Bee();
        bee.sound();
    }
}

class Animal {
    void sound(){
        System.out.println("Animal sounds");
    }
}

class Cat extends Animal{
    @Override
    void sound() {
        System.out.println("Cat : meow meow");
    }
}

class Bee extends Animal{
    @Override
    void sound() {
        System.out.println("Bee : buzz buzz");
    }
}

Ang halimbawa ng code na ito ay lumilikha ng superclass na pinangalanang Animal at mga subclass na pinangalanang Cat at Bee na nagmana mula sa superclass na iyon. Ang sound method sa superclass ay na-override. Tandaan: Ang paghihiwalay ng mga overloaded na pamamaraan ay nangyayari sa yugto ng compilation. Ang paghihiwalay ng mga overridden na pamamaraan ay nangyayari sa runtime.

5 Mga Paraan ng Java na Hindi Mo Alam

Source: Javarevisited Ang Java development ecosystem ay may maraming mga tool na magagamit na maaaring i-import at gamitin ng mga programmer sa kanilang mga programa. Kabilang dito ang mga built-in na klase at pamamaraan. Sila ay makabuluhang pinasimple ang gawain ng programmer at pinapayagan silang mas maunawaan at magsulat ng code. Dapat malaman ng bawat developer ang tungkol sa kanila. Narito ang 5 mga pamamaraan ng Java na medyo bihira, ngunit maaaring maging lubhang kapaki-pakinabang sa iyong trabaho.

1. decrementExact

decrementExact() ay isang pangunahing function ng Java mula sa klase ng Math na nagpapababa/nagbabawas ng isang ibinigay na argumento (numero) ng isa at ibinabalik ang resulta. Ang function na ito ay ang kabaligtaran ng incrementExact() function . Halimbawa, kung ang ibinigay na argumento ay 11, kung gayon ang resulta ay 10. Kung ang pagbabawas ng argumento ay nagiging sanhi ng pag-apaw ng uri ng data nito, ang isang pagbubukod ay itatapon. Samakatuwid, mahalagang maging maingat kapag ginagamit ang function na ito, lalo na para sa malalaking numero. Karaniwan, ang mga integer ay ginagamit para sa function na ito. Syntax:

Math.decrementExact(number);

Halimbawa:

System.out.println(Math.decrementExact(11));
// Output: 10

2.getAsDouble

getAsDouble() ay isang paraan na kabilang sa OptionalDouble class . Ang OptionalDouble object ay isa na maaaring magkaroon ng double number. Ang mga pamamaraan sa klase ay maaaring gamitin upang gumana sa isang dobleng halaga na nasa isang bagay, o upang ipahiwatig na ang dobleng halaga ay wala sa lahat. Ang getAsDouble() ay isang ganoong paraan at ibinabalik nito ang dobleng halaga kung naroroon. Kung hindi, ang isang NoSuchElementException ay itinapon . Syntax:

OptionalDoubleObject.getAsDouble();

Halimbawa:

OptionalDouble num = OptionalDouble.of(15.0);
System.out.println(num.getAsDouble());
// Output: 15.0

3. absExact

Ang absExact() method ay katulad ng abs() function sa Math class . Ibinabalik nito ang ganap na halaga ng isang numero, na siyang positibong halaga ng numero anuman ang tanda nito. Ang pagkakaiba lang ay ginagawa lang nito kung eksaktong kinakatawan ito bilang uri ng data nito ( int o long ). Kung ang resulta ng return value ay lumampas sa orihinal na uri ng data, ang isang ArithmeticException ay itatapon . Syntax:

Math.absExact(number);

Halimbawa:

System.out.println(Math.absExact(-11));
// Output: 11

4.endsWith

endsWith() ay isang built-in na paraan ng string na nagbabalik ng boolean value depende sa kung ang ibinigay na string ay nagtatapos sa isang tiyak na suffix (end word/string) sa mga parameter. Ang pamamaraang ito ay kabaligtaran ng startsWith() na pamamaraan , na malamang na pamilyar sa maraming developer. Syntax:

String.endsWith(String suffix);

Halimbawa:

String phrase = "I like bananas";
System.out.println(phrase.endsWith("bananas")); // true
System.out.println(phrase.endsWith("Tandrew")); // false
/* Output:
true
false
*/

5. divideUnissigned

Ang divideUnsigned() na pamamaraan ay isang paraan mula sa klase ng Integer na nagpapahintulot sa iyo na hatiin ang dalawang numero at ibalik ang resulta ng dibisyon. Ang mga unsigned integer, kumpara sa mga regular na sign integer, ay maaari lamang kumatawan sa mga positibong numero. Ang parehong unsigned integer at signed integer ay may parehong bilang ng mga numero sa kanilang range (ang laki ng range ay 65,536 na numero). Gayunpaman, dahil hindi maaaring maging negatibo ang mga unsigned integer, ang kanilang maximum na value sa positive range ay mas mataas kaysa sa maximum na value para sa isang regular na sign integer. Upang pasimplehin ito, maaari nating tingnan ang halimbawa ng mga naka-sign at unsigned na byte. Ang mga byte ay may hanay na 256 na numero. Ang isang regular na byte ay maaaring magkaroon ng halaga mula -128 hanggang 127. Gayunpaman, ang isang unsigned byte ay maaaring magkaroon ng halaga mula 0 hanggang 255. Kung hindi, ang function ay eksaktong kapareho ng regular na dibisyon. Syntax:

Integer.divideUnsigned(int dividend, int divisor);

Halimbawa:

int dividend = 10;
int divisor = 5;
int quotient = Integer.divideUnsigned(dividend, divisor);
System.out.println(quotient);
// Output: 2

Konklusyon

Narito ang isang buod ng mga function at pamamaraan na tinalakay sa artikulong ito:

• decrementExact - binabawasan/binabawas ang isang naibigay na numero ng 1

• getAsDouble - bahagi ng OptionalDouble function , nagbabalik ng numero na may dobleng halaga o nagpapahiwatig ng kawalan nito

• absExact - ibinabalik ang ganap na halaga ng isang numero kung maaari itong katawanin bilang orihinal na uri ng data

• endsWith() - nagbabalik ng boolean value depende sa kung ang tinukoy na suffix ay umiiral sa ibinigay na string

• divideUnsigned() - gumaganap ng normal na paghahati, ibinabalik ang resulta ng paghahati ng isang numero