Podsumowanie argumentów metod¶

Metody mogą przyjmować zero, jeden lub więcej argumentów.
Argumenty metody:
- mają określony typ (prymitywny, jak na przykład int, bądź złożony, jak String),
- mają nazwę (zgodną z zasadami nazewnictwa obiektów w Javie),
- są rozdzielone przecinkami i nie muszą być tego samego typu,
- nie mogą mieć określonych wartości domyślnych – jeżeli metoda ma przyjąć trzy argumenty, to tyle ich musimy podać podczas wywoływania takiej metody,
- podczas wywoływania muszą być podane w takiej samej kolejności, w jakiej zostały zdefiniowane w metodzie.
W Javie istnieją dwa rodzaje typów: prymitywne (jest ich osiem: boolean, byte, short, int, long, float, double, oraz char) oraz referencyjne (tablice, String, wiele innych).

Zmiany argumentów prymitywnych typów (jak int) w metodach nie zmieniają oryginalnej zmiennej:

public class ZmianaArgumentuTypuPrymitywnego {
  public static void main(String[] args) {
    int x = 5;
    doKwadratu(x);

    System.out.println(
        "Po wywolaniu doKwadratu, x wynosi: " + x
   );
  }

  public static void doKwadratu(int liczba) {
    liczba = liczba * liczba;
  }
}

Na ekranie zobaczymy Po wywolaniu doKwadratu, x wynosi: 5, ponieważ w metodzie doKwadratu nie wykonaliśmy zmiany na oryginalnej zmiennej, lecz na jej kopii.

Argumenty typów referencyjnych operują bezpośrednio na przesłanym obiekcie – na ekranie zobaczymy Drugi element tablicy to: 25, gdyż w metodzie wszystkieDoKwadratu działamy nie na kopii tablicy, lecz na oryginalnym obiekcie:

public class ZmianaArgumentuTypuReferencyjnego {
  public static void main(String[] args) {
    int[] tablicaWartosci = { 5, 10, 15 };

    wszystkieDoKwadratu(tablicaWartosci);

    System.out.println(
        "Drugi element tablicy to: " + tablicaWartosci[0]
    );
  }

  public static void wszystkieDoKwadratu(int[] tablicaLiczb) {
    for (int i = 0; i < tablicaLiczb.length; i++) {
      tablicaLiczb[i] = tablicaLiczb[i] * tablicaLiczb[i];
    }
  }
}

Podsumowanie metod typu String¶

Typ String służy do przechowywania ciągu znaków.
Pamiętajmy! Indeks liter w stringach zaczyna się od 0, a nie 1, więc pierwszy znak w stringu ma indeks 0, a ostatni – liczba znaków w stringu - 1 (czyli pewnyString.length() - 1).
Typ String oferuje wiele przydatnych metod, m. in. (poniżej zakładamy, że zmienna tekst to String tekst = "Ala ma kota";):
- length – zwraca liczbę znaków w stringu:
```
int liczba = tekst.length();
```
- charAt – zwraca znak o podanym indeksie w stringu (indeksy zaczynają się od 0):
```
char pierwszyZnak = tekst.charAt(0);
```
- toLowerCase – zwraca string ze wszystkimi literami zamienionymi na małe litery:
```
String tekstMalymiLiterami = tekst.toLowerCase();
```
- toUpperCase – zwraca string ze wszystkimi literami zamienionymi na wielkie litery:
```
String tekstWielkimiLiterami = tekst.toUpperCase();
```
- endsWith – sprawdza, czy string kończy się na dany ciąg znaków:
```
boolean czyKonczySieNaPsa = tekst.endsWith("psa");
```
- startsWith – sprawdza, czy string zaczyna się na dany ciąg znaków:
```
boolean czyZaczynaSieOdAla = tekst.startsWith("Ala");
```
- contains – sprawdza, czy string zawiera dany ciąg znaków
```
boolean czyZawieraMaKota = tekst.contains("ma kota");
```
- equals – porównuje stringi – jeżeli są sobie równe, zwraca true. W przeciwnym razie zwraca false:
```
boolean czyAlaMaPsa = tekst.equals("Ala ma psa")
```
- equalsIgnoreCase – porównuje stringi bez brania pod uwagę wielkości znaków, tzn. małe i wielkie litery traktuje jako takie same litery. Jeżeli stringi są sobie równe, zwraca true. W przeciwnym razie zwraca false:
```
boolean czyAlaMaKota = tekst.equalsIgnoreCase("ALA MA KOTA")
```
- replace – zamienia wszystkie wystąpienia podanego ciągu znaków na inny, podany ciąg znaków.
```
String nowyTekst = tekst.replace("kota", "psa");
```
- substring – zwraca fragment tekstu pomiędzy dwoma indeksami, nie włączając w wynikowym fragmencie litery znajdującym się pod ostatnim indeksem.
```
String al = tekst.substring(0, 2); // al ma wartosc "Al"
```
- split – dzieli tekst na słowa za pomocą podanego separatora – zwraca tablicę Stringów.
```
// separator (argument metody) to spacja
String[] slowaTekstu = tekst.split(" ");
```
Żadna z powyższych metod nie zmienia w żaden sposób oryginalnego stringa. Dla przykładu: jakisString.toLowerCase() nie spowoduje zmiany liter w stringu jakisString na małe litery, lecz zwróci jego kopię ze wszystkimi literami zamienionymi na małe litery.
Uwaga: małe i wielkie litery są w stringach rozróżniane, czyli stringi "kot" i "KOT" nie są sobie równe. Ma to znaczenie podczas używania opisanych powyżej metod – sprawdzanie, czy string zawiera ciąg znaków "ala" i "Ala" to dwa różne sprawdzenia.
Nigdy nie powinniśmy porównywać stringów za pomocą operatora porównania == – zamiast niego, powinniśmy stosować metodę equals lub equalsIgnoreCase.
Nie powinniśmy mylić stringów ze znakami – stringi zapisujemy w cudzysłowach np. "Witajcie!", natomiast znaki w apostrofach, np. 'a'. Znaki należy, w przeciwieństwie do stringów, porównywać za pomocą operatora ==.
Typ String jest dobrze udokumentowany – oficjalną dokumentację można znaleźć pod adresem: JavaDoc - Typ String

Podsumowanie dokumentowania metod¶

Komentarz w kodzie zaczynający się od znaków /** i kończący znakami */ to komentarz dokumentacyjny.
Komentarze dokumentujące służą między innymi do pomocy w zrozumieniu działania metody, opisie jej parametrów, zwracanej wartości itp.
Z takich komentarzy można wygenerować dokumentację opisującą metody.
Przykład komentarza dokumentującego:

/**
 * Zwraca przeslana liczbe podniesiona do kwadratu.
 *
 * Przyklad: dla argumentu liczba rownego 5, zwroci 25.
 *
 * @param liczba Liczba, ktora chcemy podniesc do kwadratu.
 * @return Liczba podniesiona do kwadratu.
 */
public static double policzKwadrat(int liczba) {
  return liczba * liczba;
}

Pytania¶

Do czego służą argumenty metod?
Czy metody mogą przyjmować zero argumentów?
Czy metodę, która przyjmuje jeden argument – liczbę typu int, możemy wywołać bez podania żadnego argumentu?
Czy kolejność argumentów ma znaczenie?
Jeżeli w metodzie zmodyfikujemy argument typu prymitywnego, to czy po powrocie z tej metody wartość zmiennej użytej jako argument do metody zachowa wartość ustawioną w wywołanej metodzie, czy będzie miała swoją oryginalną wartość?
Jak można udokumentować metodę, opisując jej działanie, parametry, zwracany typ itp.?

Czy poniższy kod jest poprawny?

public class Pytanie {
  public static void main(String[] args) {
    wypiszKomunikat;
  }

  public static void wypiszKomunikat() {
    System.out.println("Witajcie!");
  }
}

Jaka wartość zostanie wypisana na ekran w poniższym programie?

public class Pytanie {
  public static void main(String[] args) {
    int[] tab = { 7, 8, 9 };

    metoda(tab);

    System.out.println(tab[0]);
  }

  public static void metoda(int[] tab) {
    int[] tablica = tab;

    for (int i = 0; i < tab.length; i++) {
      tablica[i] = tab[i] * tab[i];
    }
  }
}

Które z poniższych sygnatur (pomijamy brak ciała metod) metod są nieprawidłowe i dlaczego?

public static void metoda(wiadomosc String)

public static void metoda

public static void metoda(int byte, char znak)

public static void metoda()

public static void metoda(int #numerPracownika)

public static void metoda(string wiadomosc)

public static void metoda(int)

public static void metoda(int liczba String wiadomosc)

public static void metoda(int _numerPracownika)

public static void metoda(double pi = 3.14)

Jak będzie wynik wykonania poniższego programu?

public class Pytanie {
  public static void main(String[] args) {
    metoda(3.14, 20);
  }

  public static void metoda(int liczba, double drugaLiczba) {
    System.out.println("Liczba = " + liczba);
    System.out.println("Druga liczba = " + drugaLiczba);
  }
}

Wymień kilka metod, które udostępnia typ String.
Jaki jest indeks pierwszego znaku w każdym stringu? A jaki ostatniego?
Czy małe i wielkie litery są rozróżniane w stringach?