Meni

Preglasitev vnaprej določenih metod v Javi

  • Glavni
  • Drugo
  • Preglasitev vnaprej določenih metod v Javi

overriding predefined methods java

Preizkusite Naš Instrument Za Odpravo Težav

V tej vadnici je razloženo, kako v Java preglasiti vnaprej določene metode, kot so equals (), hashCode (), compareTo () itd.:

V prejšnji vadnici smo razpravljali o polimorfizmu izvajanja v Javi. Polimorfizem med izvajanjem v Javi se izvaja s preglasitvijo metode. Preglasitev metode vključuje ponovno opredelitev metode nadrejenega razreda v podrazredu.

Java ima različne vnaprej določene metode, kot so equals (), hashCode (), compareTo (), toString () itd., Ki se pogosto uporabljajo za splošne predmete, ne glede na to, kateremu razredu pripadajo. Da pa bodo te metode delovale za vse predmete, moramo te metode preglasiti ali na novo definirati njihove izvedbe, da bodo lahko delale s podatki, ki jih želimo.

=> Obiščite tukaj, če se želite naučiti Jave iz nič.

Preglasitev vnaprej določenih metod v Javi

V tej vadnici bomo razpravljali o razveljavitvi vseh teh metod in posledicah, če teh metod ne bomo preglasili.

Kaj se boste naučili:

Preglasitev metod equals () in hashCode () v Javi

Za primerjavo dveh predmetov v Javi uporabljamo metodo equals (). Ta metoda vrne true, če so predmeti enaki, in false, če niso enaki.

Za primerjavo enakosti dveh predmetov se uporabljata dva načina.

# 1) Plitva primerjava

Plitka primerjava je privzeta izvedba metode equals (), definirane v razredu “java.lang.Object”. Kot del te izvedbe bo metoda equals () preverila, ali imata dva primerjana predmeta sklice na isti predmet.

To pomeni, da če sta obj1 in obj2 dva predmeta, bo privzeta izvedba metode equals () (plitva primerjava) samo preverila, ali sta sklici na obj1 in obj2 iz istega predmeta.

V plitvi primerjavi se ne primerjajo nobene vsebine podatkov.

# 2) Globoka primerjava

V globoki primerjavi primerjamo podatkovne člane vsakega predmeta, tj.predmeti se primerjajo glede na stanje. Tako primerjamo predmete na globoki ravni, vključno z njegovo vsebino.

Za primerjavo predmetov z globoko primerjavo običajno preglasimo metodo equals ().

Zdaj razmislite o naslednjem programu Java.

class Complex { private double r, i; //declare real and imaginary component as private public Complex(double r, double i) { //constructor this.r = r; this.i = i; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(5, 10); //c1 object Complex c2 = new Complex(5, 10); //c2 object if (c1 == c2) { System.out.println('Two Complex objects are Equal '); } else { System.out.println('Two Complex objects are not Equal '); } } }

Izhod:

Preglasitev enak - proizvodnja

Če vidimo izhod zgornjega programa, piše, da predmeti niso enaki, čeprav je vsebina obeh predmetov enaka. To je zato, ker se pri preverjanju enakosti ugotovi, ali se predmeta c1 in c2 nanašata na isti objekt.

Kot je razvidno iz programa, sta c1 in c2 dva različna predmeta, torej gre za različna sklica, zato je tako.

Zdaj pa ustvarimo tretjo referenco c3 in jo enačimo s c1, kot sledi:

Kompleksno c3 = c1;

V tem primeru se c3 in c1 sklicujeta na isti objekt, zato bo (c3 == c1) vrnila true.

Zgornji program je naredil plitvo primerjavo. Kako torej preveriti, ali sta dva predmeta vsebinsko enaka?

Tu gremo na globoko primerjavo in v ta namen preglasimo metodo equals ().

Naslednji program prikazuje preglasitev metode equals (). Uporabljamo isti razred Complex.

class Complex { private double r, i; public Complex(double r, double i) { this.r = r; this.i = i; } // override equals () method to compare two complex objects @Override public boolean equals(Object obj) { // returns true=>object is compared to itself if (obj == this) { return true; } //return false if obj is not an instance of Complex class if (!(obj instanceof Complex)) { return false; } // typecast obj to Complex type Complex c = (Complex) obj; // Compare the contents of two objects and return value return Double.compare(r, c.r) == 0 && Double.compare(i, c.i) == 0; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(5, 10); Complex c2 = new Complex(5, 10); if (c1.equals(c2)) { System.out.println('Complex objects c1 and c2 are Equal '); } else { System.out.println('Complex objects c1 and c2 are not Equal '); } } }

Izhod:

Izhod - preglasitev

Zdaj, ko imamo metodo overridden equals (), ko primerjamo dva predmeta, rezultat kaže, da sta oba predmeta enaka, saj sta njihovi vsebini enaki. Upoštevajte metodo overridden equals (). Tu preverimo, ali imata oba predmeta isto referenco. Če ne, potem vsebino teh predmetov preverimo posamično.

V Javi je priporočljivo, da kadar koli preglasimo metodo equals (), preglasimo tudi metodo hashCode (). To je zato, ker če ne preglasimo metode hashCode (), ima lahko vsak objekt drugačno hashCode.

To morda ne bo vplivalo na splošne predmete, vendar nekatere zbirke, ki temeljijo na razpršitvi, kot so HashTable, HashSet in HashMap, morda ne bodo delovale pravilno.

Naslednji program prikazuje nadomeščeni metodi equals () in hashCode ().

import java.io.*; import java.util.*; class EqualsHashCode { String name; int id; EqualsHashCode(String name, int id) { this.name = name; this.id = id; } @Override public boolean equals(Object obj) @Override public int hashCode() { // return current object's id as hashCode return this.id; } } class Main { public static void main (String() args) { // create two objects with same state EqualsHashCode e1 = new EqualsHashCode('Java', 1); EqualsHashCode e2 = new EqualsHashCode('Java', 1); //update the objects Map map = new HashMap(); map.put(e1, 'C++'); map.put(e2, 'Python'); //display contents for(EqualsHashCode eh : map.keySet()) { System.out.println(map.get(eh).toString()); } } }

Izhod:

Hashmap - izhod

V tem programu uporabljamo hashMap. Preglasili smo metode enako () in hashCode (). Torej, ko rečemo map.put (e1, “C ++”), se razprši do nekega vedra. Nato pokličemo map.put (e2, »Python«). Tokrat se bo razpršil v isti segment in nadomestil prejšnjo vrednost. To je zato, ker smo preglasili metodo hashCode ().

Preglasitev statične metode v Javi

Ali lahko v Javi preglasimo statično metodo?

Kar zadeva razveljavitev statične metode v Javi, je neposredni odgovor na to vprašanje ne, statične metode ne moremo preglasiti.

Statična metoda se prikliče s samim imenom razreda. Za klic statične metode ne potrebujemo predmeta. Torej, tudi če metodo z istim prototipom razglasimo v podrazredu, je ne moremo imenovati za nadomestno. Namesto tega samo skrivamo definicijo nadrejenega razreda statične metode.

Naslednji program Java prikazuje statično metodo in nestatično metodo v sistemu dedovanja skupaj z njihovim vedenjem med izvajanjem.

class Parent { // Parent class static method cannot be overridden by Child public static void display() { System.out.println('Parent class::static display()'); } // parent class non-static print method to be overridden by Child public void print() { System.out.println('Parent class::non-static print()'); } } // Subclass class Child extends Parent { // static display() method =>hides display() in Parent class public static void display() { System.out.println('Child class:: static display()'); } //overrides print() in Parent class public void print() { System.out.println('Child class::Non-static print()'); } } public class Main { public static void main(String args( )) { Parent new_obj = new Child(); // static methods are call as per the reference type. Since reference type //Parent, this call will execute Parent class's display method new_obj.display(); // here the print () method of Child class is called new_obj.print(); } }

Izhod:

Preglasitev statične metode

Iz izhoda programa lahko ugotovimo naslednje.

  1. Klic statične metode se vedno izvede na podlagi vrste sklica. Zato, ko smo poklicali new_obj. display () v zgornjem programu, ker je sklic new_obj tipa razreda Parent, se pokliče metoda display () iz razreda Starš.
  2. Po drugi strani se ne-statične metode pokličejo na podlagi vsebine referenčnega predmeta, s katerim je metoda poklicana. Zato metoda v zgornjem programu new_obj.print () pokliče metodo print () otroškega razreda, saj je vsebina new_obj predmet otroškega razreda.

To pojasnjuje rezultate zgornjega programa in med obravnavo statičnih metod v sistemu OOP si moramo zapomniti tudi naslednje točke.

  • Statična metoda ne more skriti metode, ki ni statična, in metoda, ki ni statična, ne more preglasiti statične metode.
  • Metode lahko preobremenimo iz nadrejenega razreda v podrazredu, vendar niti ne preglasijo niti skrijejo metod nadrejenega razreda, temveč so nove metode v podrazredu.

Preglasitev compareTo () v Javi

Vemo, da vmesnik java.lang.Comparable ponuja metodo ‘compareTo ()’, s katero lahko razvrstimo predmete v naravnem vrstnem redu, kot je leksikalni vrstni red za String predmete, številski vrstni red za cela števila itd.

Za izvedbo razvrščanja v uporabniško določenih predmetih ali zbirkah moramo za razvrščanje elementov zbirke ali uporabniško določenih predmetov preglasiti metodo compareTo ().

Torej, kaj naredi metoda compareTo ()?

Metoda compareTo () mora vrniti pozitivno vrednost, če je trenutni objekt večji od posredovanega predmeta in je negativna vrednost trenutnega predmeta manjša od posredovanega predmeta. Če sta oba predmeta enaka, bo metoda compareTo () vrnila nič.

Upoštevati je treba tudi to, da se metoda equals () in compareTo () obnaša med seboj dosledno. To pomeni, da če metoda compareTo () vrne, da sta dva predmeta enaka (vrne nič), bi morali imeti enak izhod tudi iz metode equals ().

Izvedimo program Java, ki preglasi metodo compareTo (). V tem programu uporabljamo razred Color, ki ima dve zasebni spremenljivki, to sta ime in id. Z vsako barvo smo povezali 'id' in bomo razveljavili metodo compare (), da razporedimo barve glede na id.

import java.util.*; //color class class Color implements Comparator, Comparable { private String name; private int id; Color() { } Color(String n, int id) { this.name = n; this.id = id; } public String getColorName() { return this.name; } public int getColorId() { return this.id; } // Overriding the compareTo method @Override public int compareTo(Color c) { return (this.name).compareTo(c.name); } // Overriding the compare method to sort the colors on id @Override public int compare(Color c, Color c1) { return c.id - c1.id; } } public class Main { public static void main(String args()) { // List of Colors List list = new ArrayList(); list.add(new Color('Red', 3)); list.add(new Color('Green', 2)); list.add(new Color('Blue', 5)); list.add(new Color('Orange', 4)); list.add(new Color('Yellow', 1)); Collections.sort(list); // Sorts the array list System.out.println('The list of colors:'); for(Color c: list) // print the sorted list of colors System.out.print(c.getColorName() + ', '); // Sort the array list using comparator Collections.sort(list, new Color()); System.out.println(' '); System.out.println('The sorted list of colors:'); for(Color c: list) // print the sorted list of colors as per id System.out.print(c.getColorId() + ':' + c.getColorName() + ' , '); }

Izhod:

Preglasitev compareTo

V zgornjem izhodu najprej prikažemo seznam barv in nato razvrščen seznam barv. V programu smo preglasili metode compareTo () in compare ().

Preglasitev metode toString () v Javi

Metoda ‘toString ()’ vrne String predstavitev predmeta v Javi. Ko pa imamo uporabniško določene predmete, se ta metoda lahko obnaša drugače.

Na primer,razmislite o naslednjem programu.

class Complex { private double r, i; public Complex(double r, double i) { this.r = r; this.i = i; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(5, 20); //create complex class Object //print the contents of complex number System.out.println('Complex number contents: ' + c1); } }

Izhod:

Preglasitev toString

Kot je prikazano v tem programu, prikazujemo objekt razreda Complex, ki smo ga definirali prej. Prikazani rezultat pa ni vsebina, ampak precej skrivnosten.

Na izhodu je prikazano ime razreda Complex, ki mu sledi znak '@' in nato hashCode predmeta. To je privzeti izhod, natisnjen z metodo toString () razreda Object.

Če želimo ustrezen izhod, moramo v naši aplikaciji preglasiti metodo toString ().

Naslednji program Java prikazuje, kako preglasiti metodo toString () za tiskanje vsebine predmeta Complex.

class Complex { private double r, i; public Complex(double r, double i) { this.r = r; this.i = i; } //override toString () method to return String representation of complex number @Override public String toString() { return String.format(r + ' + i ' + i); } } public class Main { public static void main(String() args) { Complex c1 = new Complex(10, 15); System.out.println('Complex Number contents: ' + c1); } }

Izhod:

Kompleksen projekt

Zgornji program kaže, da je metoda toString () razveljavljena, da vrne vsebino kompleksnega predmeta v dani obliki (real + i * imaginarno).

Na splošno, kadar želimo objekt predmeta prikazati z uporabo print () ali println (), je vedno priporočljivo preglasiti metodo toString (), da dobimo ustrezen izhod.

Pogosto zastavljena vprašanja

V # 1) Zakaj uporabljati .equals namesto == Java?

Odgovor: Za primerjavo primitivnih vrst, kot so int, char, boolean itd., Uporabljamo '=='. Za primerjavo predmetov (vnaprej določenih ali uporabniško določenih) uporabimo equals (). Običajno preglasimo metodo equals (), da primerjamo dva predmeta, vrnjena vrednost equals () pa je odvisna od prepisane kode.

V # 2) Za kaj se uporablja hashCode () in equals ()?

Odgovor: V Javi se metoda equals () uporablja za primerjavo enakosti dveh predmetov. Metoda hashCode () vrne hashCode predmeta. Medtem ko se metoda equals () uporablja pri večini predmetov za preizkušanje njihove enakosti, se hashCode večinoma uporablja v zbirkah hash, kot so HashTable, HashMap, HashSet itd.

V # 3) Ali lahko spremenimo seznam argumentov razveljavljene metode?

Odgovor: Ne. Ko metodo preglasimo, ohranimo podpis metode ali prototip metode enak tudi v podrazredu. Torej ne moremo spremeniti števila parametrov v razveljavljeni metodi.

V # 4) Zakaj preglasimo toString ()?

Odgovor: Ko je metoda toString () razveljavljena, lahko vrnemo vrednosti predmeta, za katerega je metoda toString () razveljavljena, ne da bi napisali preveč kode. To je zato, ker prevajalnik Java pri tiskanju predmeta prikliče metodo toString ().

V # 5) Kaj bi se zgodilo, če ne boste preglasili metode toString ()?

Odgovor: Če ne preglasimo metode toString (), ne bomo dobili nobenih informacij o lastnostih ali stanju predmeta. Ne bomo vedeli, kaj je dejansko znotraj predmeta. Torej bi morali vsi razredi preglasiti metodo toString ().

To je zato, ker privzeta izvedba metode toString () prikaže predstavitev String, a ko na objektu uporabimo privzeto izvedbo toString (), ne bomo dobili vsebine predmeta.

vprašanja za intervju s programiranjem na strani strežnika java

Zaključek

V tej vadnici smo razpravljali o razveljavitvi nekaterih vnaprej določenih metod Java in videli smo tudi, zakaj jih moramo preglasiti.

Ko imamo opravka z objekti, privzete izvedbe metod, kot so equals (), compareTo () in toString (), morda ne bodo dale pravilnih informacij. Zato gremo za preglasitev.

=> Tukaj si oglejte Vodnik za začetnike Java.

Priporočeno branje

^