Přetěžování metod

Tomáš Pitner, upravil Marek Šabo
tomp@fi.muni.cz

Přetěžování metod

Jedna třída může mít více metod se stejnými názvy, ale různými parametry.
Pak hovoříme o tzv. přetížené (overloaded) metodě.
I když jsou to teoreticky úplně různé metody, jmenují se stejně, proto by měly dělat něco podobného.

Přetěžování — příklad I

public void transferTo(Account whereTo, double amount) {
  this.add(-amount);
  whereTo.add(amount);
}
public void transferTo(Account whereTo) {
  whereTo.add(balance);
  balance = 0;
}

První metoda převede na účet příjemce amount peněz.
Druhá metoda převede na účet celý zůstatek (balance) z účtu odesílatele.
Nedala by se jedna metoda volat pomocí druhé?

Přetěžování — příklad II

public void transferTo(Account whereTo, double amount) {
  this.add(-amount);
  whereTo.add(amount);
}
public void transferTo(Account whereTo) {
  transferTo(whereTo, balance);
}

Toto je jednodušší, přehlednější, udělá se tam potenciálně méně chyb.
Kód se neopakuje, tudíž se neopakuje ani případná chyba
Je to přesně postup divide-et-impera, rozděl a panuj, dělba práce mezi metodami!

Přetěžování — příklad III

Zkusme naší metodu lépe popsat:

public void transferTo(Account whereTo, double amount) {
  this.add(-amount);
  whereTo.add(amount);
}
public void transferAllMoneyTo(Account whereTo) {
  transferTo(whereTo, balance);
}

Převod celého zůstatku jsme napsali jako nepřetíženou metodu, která popisuje přesně, co dělá.
Z názvu metody je zřejmé, co dělá — netřeba ji komentovat!

Přetěžování konstruktorů

Přetěžovat můžeme i konstruktory
Můžeme tak mít více konstruktorů v jedné třídě
Pro vzájemné volání konstruktorů použijeme klíčové slovo this
Používá se hodně často, častěji než přetěžování jiných metod

public Person() {
  this("Default name"); // calls second constructor
}
public Person(String name) {
  this.name = name;
}

Přetěžování — jak ne

Proč nelze přetížit metodu pouze změnou typu návratové hodnoty?

Která metoda se zavolá?

public int getNumber() {
  return 5;
}
public short getNumber() { // smaller int
  return 6;
}
...
long bigInt = getNumber(); // 5 or 6?

V Javě se číselné typy proměnných přetypují automaticky.
Mělo by dojít k přetypování int na long, nebo short na long?

Obdobný příklad

Nelze také přetížit uvedením a neuvedením návratové hodnoty
Protože vracenou hodnotu stejně nemusíme použít:

new String("Sss").isEmpty(); // result is omitted

Opět nevíme, která metoda se zavolá:

public void getNumber() {
  // do nothing
}
public int getNumber() { // smaller int
  return 6;
}
...
getNumber(); // which one is called?

Vracení odkazu na sebe

Metoda může vracet odkaz na objekt, nad nímž je volána pomocí this:

public class Account {
  private double balance;

  public Account(double balance) {
    this.balance = balance;
  }

  public Account transferTo(Account whereTo, double amount) {
    add(-amount);
    whereTo.add(amount);
    return this; // return original object
  }
}

Řetězení volání

Vracení odkazu na sebe lze využít k řetězení volání:

Account petrsAccount = new Account(100);
Account ivansAccount = new Account(100);
Account robertsAccount = new Account(1000);

// we can chain methods
petrsAccount
   .transferTo(ivansAccount, 50)
   .transferTo(robertsAccount, 20);

Stejný princip se dost často využívá u StringBuilder metody append.

/