4. Zaawansowane programowanie obiektowe

Zapoznamy się tu z niektórymi zagadnieniami zaawansowanego programowania obiektowego w Javie. Niebanalnym problemem okazuje się sposób przedefiniowania niektórych metod. Zobaczymy to na przykładzie metody equals(). Rozważymy także zalety kompozycji w porównaniu z dziedziczeniem, a także sposoby uzyskiwania polimorficznych właściwości odwołań przy kompozycji. Na uwagę zasługują także kwestie związane z kopiowaniem obiektów i ich niezmiennością.

Wysłuchaj omówienia treści wykładu.

1. Kłopoty z przedefiniowaniem metody equals()

• metoda zwraca wynik true, jeśli obiekty są takie same lub false w przeciwnym razie,
• obiekty różnych klas nie są takie same,
• jeżeli  referencja przekazana jako argument jest równa null, to obiekty nie są takie same,
• metoda equals nie powinna sygnalizować żadnego wyjątku, chyba, że porównanie obiektów danej klasy "na równość" jest niedopuszczalne, co sygnalizujemy za pomocą wyjątku UnsupportedOperationException.

• jeśli o nie jest obiektem tej klasy w której zdefiniowano metodę equals albo jest to null - wynikiem operatora instanceof  jest false i obiekty nie są równe,
• aby porównać obiekty (zazwyczaj) trzeba będzie użyć własnych metod klasy Klasa lub odwołać się do jej pól - stąd konieczność konwersji zawężającej z formalnego typu Object do typu Klasa, przy czym możliwość przeprowadzenia tej konwersji jest zagwarantowana, gdyż wcześniej stwierdziliśmy już, że o jest typu Klasa.

• symetryczna: x.equals(y) == y.equals(x)
• przechodnia:  x.equals(y) && y.equals(z) => x.equals(z)

class Person {
  private String name;

  public Person(String s) {
    name = s;
  }

  // ...
}

class Worker extends Person {
  private int salary;

  public Worker(String name, int sal) {
    super(name);
    salary = sal;
  }
  // ...
}

  public boolean equals(Object o) {
    if (!(o instanceof Person)) return false;
    Person p1 = (Person) o;
    return name.equals(p1.name);
  }

  public boolean equals(Object o) {
    if (!(o instanceof Worker)) return false;
    Worker w = (Worker) o;
    return super.equals(o) && salary == w.salary;
  }

    Person p = new Person("Jan");
    Person p1 = new Person("Jan");
    Worker w = new Worker("Jan", 1000);
    Worker w1 = new Worker("Jan", 1000);
    System.out.println("p i p1 oper ==: " + (p == p1) + ", equals: " + p.equals(p1));
    System.out.println("w i w1 oper ==: " + (w == w1) + ", equals: " + w.equals(w1));
    System.out.println("p i w equals: " + p.equals(w));
    System.out.println("w i p equals: " + w.equals(p));

  public boolean equals(Object o) {
    if (!(o instanceof Person)) return false;
    if (!(o instanceof Worker)) return super.equals(o);
    Worker w = (Worker) o;
    return super.equals(o) && salary == w.salary;
  }

    Person p = new Person("Jan");
    Worker w = new Worker("Jan", 1000);
    Worker w1 = new Worker("Jan", 2000);
    System.out.println("p i w equals: " + p.equals(w));
    System.out.println("p i w1 equals: " + p.equals(w1));
    System.out.println("w i w1 equals: " + w.equals(w1));

// W klasie Person

  public String getName() {
     return name;
  }
 
  public boolean equals(Object o) {
    if (o == null) return false;
    if (getClass() != o.getClass()) return false;
    Person p1 = (Person) o;
    return name.equals(p1.name);
  }


// W klasie Worker

  public boolean equals(Object o) {
    if (o == null) return false;
    if (getClass() != o.getClass()) return false;
    Worker w = (Worker) o;
    return getName().equals(w.getName()) && salary == w.salary;
  }

  public boolean equalsAsPerson(Object o) {
    if (!(o instanceof Person)) return false;
    Person p1 = (Person) o;
    return name.equals(p1.name);
  }

class Person {

  private String name;

  public Person(String s) {
    name = s;
  }

  public boolean equals(Object o) {
    if (!(o instanceof Person)) return false;
    Person p1 = (Person) o;
    return name.equals(p1.name);
  }

}

class Worker {

  private Person person;  // kompozycja
  private int salary;

  public Worker(Person p, int sal) {
    person = p;
    salary = sal;
  }

  public Person asPerson() { // zwraca widok na obiekt jako Person
    return person;
  }

  public boolean equals(Object o) {
    if (!(o instanceof Worker)) return false;
    Worker w = (Worker) o;
    return person.equals(w.person) && salary == w.salary;
  }

}

2. Kompozycja a dziedziczenie

class BottleContainer {

  private int bottlesCount;

  public BottleContainer(int n) {
    bottlesCount = n;
  }

  public int getCount() {
    return bottlesCount;
  }

  public String toString() {
    return "BottleContainer, bottles = " + bottlesCount;
  }
}

class BeerBox extends BottleContainer {

  public BeerBox(int n) { super(n); }

  public String toString() {
    return "BeerBox, bottles = " + getCount();
  }
}

class Inhe1 {
  public static void main(String[] args) {
    BeerBox bb = new BeerBox(10);
    int n = bb.getCount();
    //...
  }
}

class BottleContainer { 

 private double bottlesCount;

  public BottleContainer(double n) {
    bottlesCount = n;
  }


  public double getCount() {
    return bottlesCount;
  }
}

class BottleContainer {

  private int bottlesCount;

  public BottleContainer(int n) {
    bottlesCount = n;
  }

  public double getCount() {
    return bottlesCount;
  }

}

class BeerBox  {

  // wykorzystanie klasy BottleContainer przez kompozycję

  private BottleContainer cont;

  public BeerBox(int n) {
    cont = new BottleContainer(n);
  }

  public int getCount() {
    return  cont.getCount();
  }

}

class Compos1 {

  public static void main(String[] args) {
    BeerBox bb = new BeerBox(10);
    int n = bb.getCount();
    // ...
  }
}

class BottleContainer {

 private double  bottlesCount;
 // ...

  public double getCount() {
    return bottlesCount;
  }

}

class BeerBox {

  private BottleContainer cont;

  // ...

  public int getCount() {
    return (int) cont.getCount();  // drobna zmiana implementacji
  }

}

// nie wymaga zmian po zmianie interfejsu klasy BottleContainer
class Compos1 {
  public static void main(String[] args) {
    BeerBox bb = new BeerBox(10);
    int n = bb.getCount();
  }

3. Polimorfizm kompozycji  - zastosowanie interfejsów.

interface Stringable {
  public String asString();
}

class BottleContainer {
 // ...
}

class BeerBox implements Stringable  {

  private BottleContainer cont;

  public BeerBox(int n) {
    cont = new BottleContainer(n);
  }

  public int getCount() {
    return cont.getCount();
  }

  public String asString() {
    return "BeerBox, bottles = " + getCount();
  }
}

class Frige implements Stringable  {

  private BottleContainer cont;

  public Frige(int n) {
    cont = new BottleContainer(n);
  }

  public int getCount() {
    return cont.getCount();
  }

  public String asString() {
    return "Frige, bottles = " + getCount();
  }
}


class Compos1 {

  static String  getInfo(Stringable s) {
    return s.asString();
  }

  public static void main(String[] args) {
    BeerBox bb = new BeerBox(10);
    Frige fr = new Frige(20);
    System.out.println(getInfo(bb));
    System.out.println(getInfo(fr));
  }
}

4. Reguły ponownego wykorzystania klas

5. Kopie obiektów

class A implements Cloneable {

  private int a = 3;
  int get() { return a; }

  public Object clone() {
    try {
      return super.clone();
    } catch (CloneNotSupportedException exc) {
        throw new Error("Dziękujemy za klonowanie!");
    }
  }
}


class Cloning1 {

  public static void main(String[] args) {
    A a = new A();
    A a1 = a;
    A a2= (A) a.clone();
    System.out.println(a.get() + " " + a1.get() + " " + a2.get());
    System.out.println("a==a1: " + (a==a1) + "  a==a2: " + (a==a2));
  }

}

class B implements Cloneable {

  private int[] arr = {1, 2, 3};

  public int[] get() { return arr; }
  public void set(int i, int val) { arr[i] = val; }


  public Object clone() {
    try {
      return super.clone();
    } catch (CloneNotSupportedException exc) {
        throw new Error("Dziękujemy za klonowanie!");
    }
  }

}


class Cloning2 {

  static void show(String nam, int[] arr) {
    System.out.println(nam);
    for (int i=0; i<arr.length; i++) System.out.print(" " + arr[i]);
    System.out.println("");
  }

  public static void main(String[] args) {
    B x  = new B();
    B x1 = (B) x.clone();
    show("x", x.get());
    show("x1 - nowy obiekt kopia x" , x1.get());
    x.set(1, 10);
    show("x1 - płytka kopia, nie jest niezależnym obiektem!", x1.get());
  }

class B implements Cloneable {

  private int[] arr = {1, 2, 3};

  public int[] get() { return arr; }
  public void set(int i, int val) { arr[i] = val; }


  public Object clone() {
    try {
      B copy = (B) super.clone();
      copy.arr = (int[]) arr.clone();
      return copy;
    } catch (CloneNotSupportedException exc) {
        throw new Error("Dziękujemy za klonowanie!");
    }
  }

class E  {

  private final int[] arr = {1, 2, 3};

  public E() { }

  // statyczna metoda fabryczna
  public static E getInstance(E orgObj) {
    // nowy obiekt
    E newInst = new E();
    // skopiowanie zawartości tablicy
    // - wugodna metoda arraycopy (zob. dokumentacje)  
    System.arraycopy(orgObj.arr, 0, newInst.arr, 0, orgObj.arr.length);
    // zwrot wyniku  
    return newInst;
  }

  // konstruktor kopiujący
  public E( E orgObj ) {
    for (int i=0; i<orgObj.arr.length; i++) arr[i] = orgObj.arr[i];
  }

  public int[] get() { return arr; }
  public void set(int i, int val) { arr[i] = val; }

}

class Cloning5 {

  static void show(String nam, int[] arr) {
    System.out.println(nam);
    for (int i=0; i<arr.length; i++) System.out.print(" " + arr[i]);
    System.out.println("");
  }

  public static void main(String[] args) {
    E x = new E();
    E x1 = new E(x);
    show("x", x.get());
    show("x1 - nowy obiekt kopia x" , x1.get());
    x.set(1, 10);
    show("x1 - głęboka kopia, jest niezależnym obiektem!", x1.get());
    show("x jest teraz", x.get());
    E x2 = E.getInstance(x);
    x.set(2, 11);
    show("x2 - głęboka kopia, jest niezależnym obiektem!", x2.get());
    show("a x jest teraz", x.get());
  }


}

• jeśli klasa jest serializowalna, to można stworzyć kopię jej obiektu za pomocą serializacji i deserializacji (zapisu stanu obiektu do strumienia - zwykle pamięciowego - z następującym odczytaniem tego obiektu).
• jeśli klasa spełnia protokół Java Beans - to można użyć XMLEncodera i XMLDecodera na strumieniach pamięciowych.

6. Niezmienność obiektów

class Dimension {
  public int width;
  public int height;
  public Dimension(int w, int h) {
    width = w;
    height = h;
  }
}

class Box {
  Dimension dim;
  String cont;

  public Box(Dimension d, String c) {
    dim = d;
    cont = c;
  }

  public void show() {
    System.out.println("Pudełko: " + dim.width + "x" + dim.height +
                       " Zawartość: " + cont);
  }
}

  public static void main(String[] args) {
    // Wymiary pudełka na płyty
    Dimension d = new Dimension(50, 50);
    // ... tworzymy pudełka na płyty
    // ...
    Box b10 = new Box(d, "Płyty 10");
    b10.show();
    // pudełko na książki będzie szersze o 20 cm
    d.width += 20;
    Box bk = new Box(d, "Ksiązki");
    bk.show();
    System.out.println("Co się stało z pudełkiem na płyty?");
    b10.show();
  }

• klasa nie może być dziedziczona (gdyż poprzez przedefiniowanie lub dostarczenie nowych metod w podklasie moglibyśmy uczynić jej obiekty zmiennymi); specyfikator final użyty w deklaracji klasy (np. final public class Dimension) zabrania jej dziedziczenia,
• nieprywatne pola klasy (jeśli są) powinny być finalne,
• obiektowe pola klasy powinny być prywatne i niezmienne po ich pierwszej efektywnej inicjacji (to ostatnie niekoniecznie oznacza, że pola muszą być finalne: np. w niezmiennej klasie String pola nie są finalne, ale po inicjacji, która - jak np w przypadku pola hashcode jest efektywnie odłożona do momentu użycia metody hashCode() - nie są zmieniane w klasie String i nie mogą być zmienione z zewnątrz),
• klasa nie powinna udostępniać metod uzyskiwania referencji do pól, zawierających odniesienia do obiektów, które nie są niezmienne (np. do tablic).

• unikanie błędów przy przekazywaniu argumentów (np. jeśli przekazujemy argument typu String, to mamy pewność, że metoda nie zmieni przekazanego napisu, bo klasa String jest niezmienna),
• bezproblemowe współdzielenie obiektów w programach wielowątkowych (ponieważ niezmienność obiektów wyklucza możliwości powstawania niespójnych stanów, gdy na obiekcie operuje kilka wątków jednocześnie, zatem unikamy narzutu synchronizacji ),
• spójne  przechowywanie referencji w strukturach danych (np. klucze w tablicach asocjacyjnych - mapach (takich jak np. Hashtable) powinny być obiektami niezmiennymi, bowiem zmiana klucza po zapisaniu go do tablicy prowadzi do niespójności danych,

7. Podsumowanie

• subtelnościami przedefiniowania metody equals(),
• problemem "słabej hermetyzacji" przy dziedziczeniu i zaletami kompozycji,
• porównaniem sposobów ponownego wykorzystania klas (dziedziczenie a kompozycja),
• problemem kopiowania obiektów (słabości klonowania, potrzeba tworzenia konstruktorów kopiujących lub fabryk),
• pojęciem niezmienności klas i obiektów oraz jego zaletami.

8. Zadania