Obiekty i referencje

1. Obiekty i referencje

• o nazwie set - ustalająca wartość pary (obu składników pary),
• i o nazwie show - pokazująca parę (wyprowadzająca na konsolę oba składniki pary).
  

public class Para {
  private int a;
  private int b;
 
  // konstruktor bezparametrowy
  public Para() { 
  }
 
  // konstruktor z dwoma argumentami = elementami pary
  public Para(int x, int y) { 
    a = x;
    b = y;
  }
 
  // Metoda ustalająca składniki pary 
  public void set(int x, int y) { 
    a = x;
    b = y;
  }
 
  // Metoda pokazujaca parę
  public void show() {
    System.out.println("( " + a + "," + b + " )");
  }

}

• Po pierwsze, musimy mieć zmienną, która będzie oznaczać obiekt- parę.
• Po drugie, musimy utworzyć obiekt-parę.
• Po trzecie, temu obiektowi trzeba wydać polecenia set i show.

public class ParaSetAndShow {

  public static void main(String[] args) {

    Para para1 = new Para(); // 1
    para1.set( 1, 2 );       // 2
    para1.show();            // 3

  }
}

• w wierszu oznaczonym 1 deklarujemy zmienną o nazwie para1 i tworzymy obiekt parę za pomocą wyrażenia new (wywołując konstruktor bezparametrowy);
• teraz mamy już (jeden) obiekt-parę i zmienną (o nazwie para1) za pomocą której będziemy na tym obiekcie operować;
• w wierszu // 2 do obiektu oznaczanego przez zmienną para1 posyłamy polecenie set. Aby posłać polecenie musimy wybrać jakiego konkretnie obiektu ma ono dotyczyć. Temu wyborowi służy kropka (.). Gdy piszemy para1. - znaczy to, że następujące po kropce polecenie ma być wysłane do obiektu oznaczanego przez zmienną para1.  Poleceniem tym jest set. Jak już wiemy jest to wywołanie metody set na rzecz obiektu, oznaczanego przez zmienną para1. W nawiasach okrągłych podajemy argumenty wywołania metody. W tym przypadku pierwszy argument jest wartością, która ma być nadana pierwszemu składnikowi pary, a drugi - drugiemu. W sumie para1.set( 1, 2); znaczy: ustalić wartość pierwszego elementu obiektu (składnika pary) oznaczanego przez zmienną para1 na 1, a drugiego elementu (składnika pary) - na 2;
• w wierszu // 3 na rzecz obiektu, oznaczanego przez para1 wywołujemy metodę show ("pokaż się") i w rezultacie na konsolę wyprowadzana jest "wartość pary", w tym przypadku podana jako ( wartość_pierwszego_skladnika , wartość_drugiego_skladnika ) czyli ( 1 , 2 );
  

1. Przydzielenie pamięci zmiennej p do przechowania referencji do obiektu (4 bajty w pamięci). Referencja jest nieustalona, ma wartość null, co oznacza, że nie odnosi się do żadnego obiektu.
2. Opracowanie wyrażenia new powoduje przydzielenie pamięci dla obiektu klasy Para na stercie pod jakimś wolnym adresem (tu symbolicznie 1304). Wielkość przydzielonego obszaru jest wystarczająca, by zmieścić dwie liczby całkowite (składniki pary). W tym momencie oba składniki pary równe są 0.
3. Wartością wyrażenia new jest referencja (adres 1304). Jest ona umieszczana w uprzednio przydzielonym zmiennej p obszarze pamięci
4. Zmienna p ma teraz wartość = referencji do obiektu klasy Para, któremu w kroku 2 przydzielono pamięć na stercie (adres 1304).
   

• porównywać referencje na równość (==) lub nierówność (!=),
• przypisywać im wartości innych referencji oraz wartość null
  

1. Nadanie wartości pierwszej danej, nadanie wartości drugiej danej.
2. Przypisanie zmiennej oznaczającej pierwszą daną wartości zmienej oznaczającej drugą daną
3. Zmianę wartości drugiej danej.
4. Porównanie zmiennych, oznaczających obie dane

public class Roznica {

  public static void main(String[] args) {

    // Operacje na zmiennych typów prostych
    int x, y, z;
    x = 3;
    y = 4;
    x = y;
    y = 5;
    z = 5;
    System.out.println("x = " + x);
    System.out.println("y = " + y);
    System.out.println("z = " + z);
    if (x == y) System.out.println ("x i y równe.");
    else System.out.println ("x i y nierówne.");
    if (y == z) System.out.println ("y i z równe.");
    else System.out.println ("y i z nierówne."); 

    // Podobne operacje na zmiennych typu referencyjnego
    Para px = new Para(), py = new Para(), pz = new Para();
    px.set( 3, 3 );
    py.set( 4, 4 );
    pz.set( 5, 5 );
    px = py;
    py.set( 5, 5 );
    System.out.print("Para px: "); px.show();
    System.out.print("Para py: "); py.show();
    System.out.print("Para pz: "); pz.show();
    if (px == py) System.out.println ("px i py równe.");
    else System.out.println ("px i py nierówne.");
    if (py == pz) System.out.println ("py i pz równe.");
    else System.out.println ("py i pz nierówne.");

  }
}

• wyrażenie new Para() zwraca referencję do nowoutworzonego obiektu klasy Para; uzyskiwane referencje przypisywane są zmiennym typu Para (który jest typem referencyjnym),
  
• użycie metody (polecenia) set ustala wartości danych w obiekcie klasy Para; do obiektu odwołujemy się przez referencję, która na niego wskazuje (np. px.set(...)
• przypisanie px = py powoduje skopiowanie referencji (wskazującej na obiekt-parę o składnikach (4, 4)) do zmiennej px (dotąd wskazującej na obiekt-parę o wartościach (3,3). Od tej chwili px i py oznaczają ten sam obiekt (który jest parą o wartościach (4,4)). Do obiektu-pary (3,3) nie mamy już w tej chwili żadnego dostępu.
• ponieważ za pomocą referencji py ustalamy nowe wartości składników pary (py.set(5,5)), na którą wskazuje zarówna zmienna py jak i px, to odwołania show wobec tych zmiennych pokażą identyczne wartości (składniki pary o wartościach 5, 5)
  
• dalej porównanie referencji px i py da wartość true (bo referencje wskazują na ten sam obiekt, a nie dlatego, że wskazują na dwa obiekty o tych samych wartościach elementów - składników pary)
• o czym dobitnie się przekonujemy porównując zmienne py i pz. Zmienne te wskazują na dwa różne obiekty (zatem wartości tych zmiennych są różne) i dlatego wynik porównania jest false, mimo, że wartości elementów obu tych obiektów (składniki pary) są takie same (5, 5).

2. Napisy

• stworzenie obiektu klasy String z zawartością "Ala ma kota"
• przypisanie referencji do tego obiektu zmiennej s

String s1 = "Ala ma kota";
String s2 = " szaroburego";
String s3;
s3 = s1 + s2;

• wyrażenie s1 + s2 stworzy (nowy) obiekt klasy String, który jest połączeniem napisów oznaczanych przez zmienne s1 i s2,
• referencja do nowoutworzonego obiektu zostanie przypisana zmiennej s3,
• s3 będzie teraz oznaczać napis "Ala ma kota szaroburego".
  

String s1 = "Ala ma kota";
String s2 = " szaroburego";
String s3;
s3 = s1 + s2 + " w wieku " + 3 + " lat ";

• najpierw będzie opracowane wyrażenie 100 + " Nr " (jego wynik - napis " 100 Nr ")
• następnie zostanie opracowane wyrażenie 1 + 2 (ponieważ nawiasy zmieniają kolejność opracowania wyrażeń), a jego wynikiem będzie liczba 3
• w końcu zostanie zastosowany drugi operator +, który do wyniku pierwszego wyrażenia (napisu "100 Nr ") dołączy przeksztalconą do postaci znakowej wartość drugiego wyrazenia (liczbę 3)

String s1 = "Al";
String s2 = "a";
String s3 = s1 + s2;
String s4 = "Ala";
System.out.println(s3 + " " + s4);
if (s3 == s4) System.out.println("To jest Ala");
else System.out.println("To nie Ala"

String s1 = "Ala";
String s2 = "Ala";
if (s1 == s2) System.out.println("To jest Ala");

3. Interakcja: wprowadzanie napisów i liczb, komunikaty

• skanera (klasy Scanner z pakietu java.util)
• dialogów wejściowych (statycznych metod showInputDialog z klasy JOptionPane z pakietu javax.swing).

import javax.swing.JOptionPane;

public class GreetMsg {

  public static void main(String[] args) {

    String name = JOptionPane.showInputDialog("Podaj swoje imię");
    if (name == null) name = "";
    JOptionPane.showMessageDialog( null, "Witaj " + name + "!");

  }

}

import java.util.*;

public class ScanString {

  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    System.out.println("Podaj imię");
    String name = scan.next();
    System.out.println("Witaj " + name);

  }

}

import java.util.*;

public class ScanNums {

  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    scan.useLocale(new Locale("en"));
    System.out.println("Wprowadż liczbę całkowitą:");
    int i = scan.nextInt();
    System.out.println("Wprowadż liczbę rzeczywistą:");
    double d = scan.nextDouble();
    System.out.println("Wprowadzono: " + i + " " + d);
  }

}

import javax.swing.*;

public class ParseInt {

  public static void main(String[] args) {

    String s1 = JOptionPane.showInputDialog("Podaj pierwszą liczbę");
    if (s1 != null) {
      String s2 = JOptionPane.showInputDialog("Podaj drugą liczbę");
      if (s2 != null) {
         int l1 = Integer.parseInt(s1);
         int l2 = Integer.parseInt(s2);
         JOptionPane.showMessageDialog(null, "Suma: " + (l1 + l2));
      }
    }
  }

}

import java.util.*;
import javax.swing.*;

public class ScanNumsFromString {

  public static void main(String[] args) {
    String in = JOptionPane.showInputDialog("Podaj dwie liczby całkoitew rozdzielone spacjami");
    if (in != null) {
      Scanner scan = new Scanner(in);
      if (scan.hasNextInt()) {
        int n1 = scan.nextInt();
        if (scan.hasNextInt()) {
          int n2 = scan.nextInt();
          JOptionPane.showMessageDialog(null, "Suma: "+  (n1 + n2));
        }
      }
    }
  }
}

4. O metodach equals() i toString()

public class Para {
 private int a, b;
 // ...
 public boolean equals(Object obj) {
   if (this == obj) return true;                   // 1
   if (obj == null) return false;                  // 2
   if (getClass() != obj.getClass()) return false; // 3 
   Para other = (Para) obj;                        // 4 
   if (a != other.a || b != other.b) return false; // 5
   return true;                                    // 6
 }
// ...
}

1. Jeżeli to jest ten sam obiekt - zwracamy true (para jest równa samej sobie).
2. Jeżeli jako argument przekazano null - pary nie są takie same (null nie jest parą).
3. Jeżeli klasy tego obiektu i argumentu są różne - pary nie są takie same (argument nie jest referencją do obiektu klasy Para); proszę zwrócić uwagę, że argument jest formalnie typu Object, więc można tu podać referencję do obiektu dowolnej klasy; metoda getClass() pozwala uzyskać klasę obiektu i w ten sposób możemy sprawdzić czy obiekt wskazywany przez argument należy do tej samej klasy co TEN obiekt (czyli klasy Para).
4. Po to, by móc odwoływać się do składowych pary-argumentu musieliśmy dokonać rzutowania (konwersji zawężającej) do klasy Para.
5. Jeżeli którykolwiek ze składników pary w tym obiekcie nie jest taki sam jak odpowiedni składnik pary w obiekcie-argumencie - pary nie są takie same.
6. W przeciwnym razie (oba składniki par są odpowiednio takie same) zwracamy true (pary są takie same)

public class Test {
  
  static void test(String jakiePary, Para p1, Para p2) {
    System.out.println(jakiePary + "   ==   - daje wynik: " + (p1 == p2));
    System.out.println(jakiePary + " equals - daje wynik: " + p1.equals(p2));
  }

  public static void main(String[] args) {
    
    Para para1 = new Para(1,2);
    Para para2 = new Para(3,4);
    Para para3 = new Para(1,2);
    test("para1 i para2", para1, para2);
    test("para1 i para3", para1, para3);
    para2 = para1;
    System.out.println("Po podstawieniu para2 = para1");
    test("para1 i para2", para1, para2);
    test("para1 i para3", para1, para3);
  }

}

• sygnatura (nazwa i parametr) metody equals oraz jej typ wyniku musi być zawsze taka sama: boolean equals(Object),
• definiując metodę equals() warto też zdefiniować metodę hashCode(); o tym dlaczego tak jest dowiemy się z materiału o kolekcjach.

public class Para {

 private int a;
 private int b;
 
 // ...
 
 public String toString() {
   return " ( " + a + " , " + b + " )";
 }
 
 public static void main(String[] args) {
   Para p1 = new Para(1,2);
   Para p2 = new Para(3,4);
   System.out.println(p1);
   System.out.println(p2);
   System.out.println(p1.add(p2));
 }

}

5. Wyliczenia (enumeracje)

• nie ma kontroli poprawności danych - nic nie stoi na przeszkodzie, aby zmiennej poraRoku nadać nonsensowną wartość 111,
• jeżeli zmienimy wyliczenie (np. dodamy stałe i dotychczasowe wartości stałych ulegną modyfikacji np. dodamy PRZEDWIOSNIE z wartością 1, a wartości WIOSNA, LATO, JESIEN zmienimy na  2, 3 , 4 ), to inne fragmenty kodu już korzystające z tych stałych nie będą prawidłowo działać,
• wprowadzanie i wyprowadzanie informacji o wartościach jest żmudne (konwersji String - int), proste wypisanie wartości jest całkowicie "nieinformacyjne": println(ZIMA) da nam na wyjściu 0 (a co to?),
• wyliczenie definiowane za pomocą typu int nie ma właściwości programowania obiektowego (nie ma odrębnego typu, który by zawężał zbiór dopuszczalnych wartości i możliwych operacji na nich).

enum Pora { ZIMA, WIOSNA, LATO, JESIEŃ }

• zastosowanie metody toString() wobec zmiennej typu wyliczeniowego zwróci jej wartość w postaci napisu (w naszym przykładowym przypadku np. "ZIMA"); umożliwia to eleganckie i łatwe pokazywanie wartości typu wyliczeniowego np. p = Pora.ZIMA;  System.out.println(p); wypisze na konsoli napis ZIMA,
• zastosowanie statycznej metody valueOf(String s) zwróci wartość typu wyliczeniowego odpowiadająca podanemu jako argument napisowi: np. Pora.valueOf("LATO") zwróci wartość Pora.LATO,
• metoda ordinal() zastosowana wobec zmiennej typu wyliczeniowego zwraca pozycję w wyliczeniu, zajmowaną przez wartość tej zmiennej (np. po Pora p = Pora.WIOSNA;  p.ordinal() zwróci 1),
• metoda statyczna values() zwraca zestaw wszystkich wartości danego typu wyliczeniowego (w naszym przykładzie zestaw ten składa się z elementów Pora.ZIMA, Pora.WIOSNA, Pora.LATO, Pora.JESIEŃ; będzie to tablica - zob. rozdział o tablicach),
• dla porównania wartości typów wyliczeniowych  na równość wystarczy operator == (tu przy porównaniach zawsze wchodzi w grę tylko identyczność obiektów na które wskazują referencje).

import javax.swing.*;

public class PoryRoku {
  
  enum Pora { ZIMA, WIOSNA, LATO, JESIEŃ };
  
  public static String opisz(Pora p) {
    
    if (p == Pora.ZIMA) return p + " - pada śnieg.";
    if (p == Pora.WIOSNA) return p + " - kwitnie bez.";
    if (p == Pora.LATO) return p + " - jest ciepło.";
    if (p == Pora.JESIEŃ) return p + " - pada deszcz.";
    return "Pora roku nie została wybrana";
  }
  
  public static void main(String[] args) {
    
    String nazwa = JOptionPane.showInputDialog("Podaj porę roku:");
    Pora p = Pora.valueOf(nazwa);
    JOptionPane.showMessageDialog(null, opisz(p) );
  }

}