Meniu

Anularea metodelor predefinite în Java

overriding predefined methods java

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Acest tutorial explică cum să suprascrieți metodele predefinite cum ar fi equals (), hashCode (), compareTo () etc. în Java cu exemple:

instrumente de care aveți nevoie pentru dezvoltarea web

În tutorialul nostru anterior, am discutat despre polimorfismul de rulare în Java. Polimorfismul de rulare în Java este implementat folosind metoda suprascriere. Anularea metodei implică redefinirea metodei clasei părinte în subclasă.

Java are diverse metode predefinite, cum ar fi equals (), hashCode (), compareTo (), toString () etc., care sunt utilizate în mod obișnuit pentru obiecte generale, indiferent de clasa la care aparțin. Dar pentru ca aceste metode să funcționeze pentru toate obiectele, trebuie să trecem peste aceste metode sau să le redefinim implementările, astfel încât să poată lucra cu datele dorite.

=> Vizitați aici pentru a afla Java de la zero.

Anularea metodelor predefinite în Java

În acest tutorial, vom discuta despre suprascrierea tuturor acestor metode, împreună cu consecințele, dacă nu vom suprascrie aceste metode.

Ce veți învăța:

Overriding equals () Și hashCode () Metode în Java

Folosim metoda equals () în Java pentru a compara două obiecte. Această metodă returnează adevărat atunci când obiectele sunt egale și false când nu sunt egale.

Două moduri sunt folosite pentru a compara egalitatea a două obiecte.

# 1) Comparație superficială

Comparația superficială este implementarea implicită pentru metoda equals () definită în clasa „java.lang.Object”. Ca parte a acestei implementări, metoda equals () va verifica dacă două obiecte comparate au referințe referitoare la același obiect.

Aceasta înseamnă că dacă obj1 și obj2 sunt două obiecte, atunci implementarea implicită a metodei egal () (comparație superficială) va verifica doar dacă referințele obiect1 și obj2 provin din același obiect.

În comparație superficială, nu se compară conținutul datelor.

# 2) Comparație profundă

În comparație profundă, comparăm membrii fiecărui obiect, adică obiectele sunt comparate în raport cu starea. Deci, comparăm obiectele la un nivel profund, inclusiv conținutul acestuia.

Pentru a compara obiectele folosind o comparație profundă, de obicei trecem peste metoda egal ().

Acum ia în considerare următorul program 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 '); } } }

Ieșire:

Suprascriere egală - ieșire

Dacă vedem rezultatul programului de mai sus, se spune că obiectele nu sunt egale, chiar dacă conținutul celor două obiecte este același. Acest lucru se datorează faptului că, atunci când se verifică egalitatea, se determină dacă cele două obiecte c1 și c2 se referă la același obiect.

După cum se vede în programul c1 și c2 sunt două obiecte diferite, deci sunt referințe diferite și, prin urmare, rezultă astfel.

Acum să creăm o a treia referință c3 și să o echivalăm cu c1 după cum urmează:

Complex c3 = c1;

În acest caz, c3 și c1 se vor referi la același obiect și, prin urmare, (c3 == c1) va reveni adevărat.

Ceea ce a făcut programul de mai sus a fost comparația superficială. Deci, cum putem verifica dacă două obiecte au același conținut?

Aici, mergem pentru o comparație profundă și, în acest scop, anulăm metoda egal ().

Următorul program prezintă suprascrierea metodei equals (). Folosim aceeași clasă 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 '); } } }

Ieșire:

Ieșire - suprascriere

Acum că avem o metodă overridden equals (), atunci când comparăm două obiecte, rezultatul arată că cele două obiecte sunt egale, deoarece conținutul lor este același. Rețineți metoda suprascrisă equals (). Aici verificăm dacă ambele obiecte au aceeași referință. Dacă nu, atunci verificăm individual conținutul acestor obiecte.

În Java, ori de câte ori anulăm metoda equals (), este recomandabil să suprascrieți și metoda hashCode (). Acest lucru se datorează faptului că dacă nu anulăm metoda hashCode (), atunci fiecare obiect poate avea hashCode diferit.

Este posibil ca acest lucru să nu interfereze cu obiectele generale, dar anumite colecții bazate pe hash, cum ar fi HashTable, HashSet și HashMap, s-ar putea să nu funcționeze corect.

Următorul program prezintă metodele equal () și hashCode () suprascrise.

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()); } } }

Ieșire:

Hashmap - ieșire

În acest program, folosim un hashMap. Am înlocuit ambele metode equals () și hashCode (). Deci, atunci când spunem map.put (e1, „C ++”), se hashează într-o anumită locație. Apoi, numim map.put (e2, „Python”). De data aceasta va hash la aceeași cupă și va înlocui valoarea anterioară. Acest lucru se datorează faptului că am anulat metoda hashCode ().

Metoda statică suprascriză în Java

Putem suprascrie metoda statică în Java?

unde se folosește astăzi c ++

În ceea ce privește suprascrierea metodei statice în Java, răspunsul direct la această întrebare este Nu, nu putem suprascrie metoda statică.

Metoda statică este invocată folosind chiar numele clasei. Nu avem nevoie de un obiect pentru a apela o metodă statică. Deci, chiar dacă declarăm o metodă cu același prototip într-o subclasă, nu o putem numi suprascriere. În schimb, ascundem doar definiția clasei părinte a metodei statice.

Următorul program Java arată metoda statică și metoda nestatică într-un sistem de moștenire, împreună cu comportamentul lor în timpul rulării.

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(); } }

Ieșire:

Anulați metoda statică

Din ieșirea programului, putem concluziona următoarele.

  1. Apelul la metoda statică se face întotdeauna pe baza tipului de referință. De aceea, când am sunat new_obj. display () în programul de mai sus, deoarece referința new_obj este din clasa de tip Parent, se apelează metoda display () a clasei Parent.
  2. Pe de altă parte, metodele nestatice sunt numite pe baza conținutului obiectului de referință cu care se numește metoda. Prin urmare, în programul de mai sus, metoda new_obj.print () apelează metoda print () a clasei copil, deoarece conținutul new_obj face obiectul clasei copil.

Aceasta explică rezultatul programului de mai sus și trebuie să ne amintim și următoarele puncte în timp ce ne ocupăm de metodele statice din sistemul OOP.

  • O metodă statică nu poate ascunde o metodă de instanță nestatică și o metodă de instanță nestatică nu poate suprascrie o metodă statică.
  • Putem supraîncărca metodele din clasa părinte într-o subclasă, dar ele nu suprascriu și nici nu ascund metodele clasei părinte, ci mai degrabă sunt metode noi în subclasă.

În comparație cu () În Java

Știm că interfața java.lang.Comparable oferă o metodă „compareTo ()” folosind care putem sorta obiectele într-o ordine naturală precum ordinea lexicală pentru obiectele String, ordinea numerică pentru Numere întregi etc.

Pentru a implementa sortarea în obiecte sau colecții definite de utilizator, trebuie să înlocuim metoda compareTo () pentru a sorta elementele de colecție sau obiectele definite de utilizator.

Deci, ce face o metodă compareTo ()?

O metodă compareTo () trebuie să returneze o valoare pozitivă dacă obiectul curent este mai mare decât obiectul trecut în ordine și valoarea negativă a obiectului curent este mai mică decât obiectul trecut. Dacă ambele obiecte sunt egale, atunci metoda compareTo () va reveni la zero.

Un alt punct de remarcat este că metoda equal () și compareTo () ar trebui să se comporte consecvent între ele. Aceasta înseamnă că, dacă metoda compareTo () returnează faptul că două obiecte sunt egale (returnează zero), atunci ar trebui să avem aceeași ieșire din metoda egal ().

Să implementăm un program Java care suprascrie metoda compareTo (). În acest program, folosim o clasă Color care are două variabile private, adică nume și id. Am asociat „id” cu fiecare culoare și vom înlocui metoda compare () pentru a aranja culorile în funcție de 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() + ' , '); }

Ieșire:

Comparație predominantă către

În rezultatul de mai sus, afișăm mai întâi lista de culori și apoi lista de culori sortată. În program, am anulat metodele compareTo () și compare ().

Înlocuiți metoda toString () în Java

Metoda ‘toString ()’ returnează reprezentarea String a unui obiect în Java. Dar când avem obiecte definite de utilizator, atunci această metodă se poate comporta diferit.

De exemplu,ia în considerare următorul program.

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); } }

Ieșire:

Înlocuiți la șir

Așa cum se arată în acest program, afișăm obiectul clasei Complex pe care l-am definit mai devreme. Cu toate acestea, rezultatul afișat nu este conținutul, ci este destul de criptic.

Ieșirea arată un nume de clasă Complex urmat de caracterul „@” și apoi codul hash al obiectului. Aceasta este ieșirea implicită tipărită prin metoda toString () a clasei Object.

Dacă dorim ieșirea corectă, atunci trebuie să înlocuim metoda toString () în aplicația noastră.

Următorul program Java arată cum să suprascrieți metoda toString () pentru a imprima conținutul obiectului 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); } }

Ieșire:

Proiect complex

Programul de mai sus arată că metoda toString () este suprascrisă pentru a returna conținutul obiectului Complex în formatul dat (imaginar real + i *).

În general, atunci când dorim să afișăm obiectul clasei folosind fie print (), fie println (), este întotdeauna recomandabil să suprascrieți metoda toString (), astfel încât să obținem rezultatul corespunzător.

întrebări frecvente

Q # 1) De ce să folosiți .equals în loc de == Java?

care este cel mai bun software de curățare a computerului

Răspuns: Folosim „==” pentru a compara tipurile primitive, cum ar fi int, char, boolean etc. Folosim egal () pentru a compara obiecte (predefinite sau definite de utilizator). De obicei, suprascriem metoda equals () pentru a compara două obiecte, iar valoarea returnată a egalului () depinde de codul suprascris.

Q # 2) Pentru ce se utilizează hashCode () și equal ()?

Răspuns: În Java, metoda equals () este utilizată pentru a compara egalitatea a două obiecte. Metoda hashCode () returnează hashCode al obiectului. În timp ce metoda equals () este utilizată cu majoritatea obiectelor pentru a le testa egalitatea, hashCode este utilizat în cea mai mare parte în colecțiile hash precum HashTable, HashMap, HashSet etc.

Î # 3) Putem schimba lista de argumente a metodei suprascrise?

Răspuns: Nu. Când anulăm metoda, păstrăm semnătura metodei sau prototipul metodei la fel și în subclasă. Deci, nu putem modifica numărul de parametri din metoda suprascrisă.

Q # 4) De ce suprascriem la String ()?

Răspuns: Când metoda toString () este anulată, putem returna valorile obiectului pentru care metoda toString () este suprascrisă fără a scrie prea mult cod. Acest lucru se datorează faptului că compilatorul Java invocă metoda toString () atunci când imprimăm un obiect.

Q # 5) Ce s-ar întâmpla dacă nu veți suprascrie metoda toString ()?

Răspuns: Dacă nu anulăm metoda toString (), atunci nu vom primi nicio informație despre proprietățile sau starea obiectului. Nu vom ști ce este de fapt în interiorul obiectului. Deci, toate clasele ar trebui să înlocuiască metoda toString ().

Acest lucru se datorează faptului că implementarea implicită a metodei toString () afișează reprezentarea String, dar când folosim implementarea implicită toString () pe obiect, atunci nu vom obține conținutul obiectului.

Concluzie

În acest tutorial, am discutat despre suprascrierea câtorva metode predefinite Java și am văzut, de asemenea, de ce trebuie să le înlocuim.

Când avem de-a face cu obiecte, este posibil ca implementările implicite ale metodelor precum equals (), compareTo () și toString () să nu ofere informațiile corecte. Prin urmare, ne îndreptăm spre supremație.

=> Consultați aici Ghidul pentru începători Java.

Lectură recomandată

^