Adam Lipowski

boolean   ifbefore=t1.priorTo(t2);

this – pozwala odwołać się wewnątrz metody do ‘adresata’   tej metody.

Dziedziczenie Klas

Dziedziczenie (inheritance) klas pozwala  dostosować istniejącą już klasę do własnych potrzeb. Własność ta jest jedną z największych zalet języków obiektowych. Załóżmy, że istnieje już pewna klasa, która posiada prawie komplet wymaganych przez nas własności. Zamiast tworzyć nową klasę od początku, używamy dziedziczenia aby dodać do istniejącej klasy brakujące cechy.

syntaktyka dziedziczenia:       derived-class extends  base-class

Przykład 1
Załóżmy, że chcemy napisać program przechowujący informację o studentach: nazwisko, wiek, PESEL, kierunek studiów i średnia ocen. Chcemy wykorzystać istniejącą już klasę Person reprezentującą ludzi, która zawiera informacje takie jak: nazwisko, wiek i PESEL.

public class Person{              // klasa bazowa
    private String nazwisko;
    private int wiek;
    private String pesel;
    public  Person (String n, int w, String p){
               nazwisko=n;
               wiek=w;
                pesel=p;
    }
    public void printPerson(){
           System.out.println("Nazwisko: "+nazwisko);
           System.out.println("Wiek: "+wiek);
           System.out.println("PESEL: "+pesel);
    }
}


public class Student extends Person{          // klasa pochodna (dziedzicząca)
      private String kierunek;
      private double srednia;
      public Student(String n, int w, String p, String k, double av){
              super(n,w,p);   // konstruktor klasy bazowej (Person)
              kierunek=k;
              srednia=av;
     }
     public void studentInfo(){
            printPerson();  // metoda z klasy bazowej;
            System.out.println("Kierunek: "+kierunek);
           System.out.println("Średnia: "+srednia);
    }
}

Przykład 2
Chcemy rozszerzyć klasę Time , aby uwzględniała sekundy.
}
Klasa pochodna
class PreciseTime extends Time{
    private int second;
    public PreciseTime(int h, int m, int s){
         super(h,m);   // wywołanie konstruktora klasy Time
         second = s;
   }
   public void advanceSeconds(int s){
         int advMinutes = s/60;
         second+=s%60;
         if(second<0){
              advMinutes--;
               second+=60;
         }
         else if (second>=60){
              advMinutes++;
               second-=60;
         }
         advanceMinutes(advMinutes);
  }
}

Wykorzystanie

public class Tme1Mutate{
   public static void main(String [] args){
         PreciseTime lunchtime = new PreciseTime(13,10,0);
         lunchtime.advanceSeconds(60);
         lunchtime.printTime();System.out.println();
        lunchtime.advanceSeconds(-61);
        lunchtime.printTime();System.out.println();
  }
}

Wydruk:

 1:11PM
 1:09PM

printTime na obiektach klasy PreciseTime działa dokładnie tak samo jak obiektach klasy Time: wypisuje godziny i minuty.
Załóżmy, że w klasie PreciseTime chcemy zdefiniować nową metodę printTime:

public void printTime(){
Metoda ta nie zadziała. Z klasy PreciseTime nie mamy dostępu do prywatnych pól klasy Time. Należy w klasie Time zmienić specyfikator private na protected:

class Time{
Specyfikator protected udostępnia dane pole klasom pochodnym ale nie klientom.

Dynamiczne wiązanie (Dynamic binding)

Zarówno w klasie Time jak i w klasie PreciseTime mamy zdefiniowane metody PrintTime. Rozważmy konstrukcję:

Time dawn;
dawn = new PreciseTime(3,45,30);
dawn.PrintTime();

Pytanie: Z której klasy zostanie wywołana metoda PrintTime ?
Obiekt dawn jest klasy Time, ale zawiera referencję do klasy PreciseTime.
Odpowiedź: z klasy PreciseTime. Wywołana metoda zależy od klasy słuchacza ( receiver) metody.

Zwykle, to która metoda będzie wywołana można wyznaczyć bez uruchamiania programu (w fazie kompilacji). Jest to tzw. wiązanie statyczne. Jednakże, gdy metoda jest przedefiniowana w podklasie, to reguła ta nie jest spełniona i w Javie stosuje się tzw. wiązanie dynamiczne.

Załóżmy, że istnieją dwie podklasy: PreciseTime i PreciseTime1 ;

     Time dawn;
      if(arg[0].equals("A")) dawn= new PreciseTime(3,45,30); // arg[0] - pierwszy parametr
           else dawn= new PreciseTime1(4,25,50);
     dawn.PrintTime();

Jest oczywiste, że w tym przypadku wyznaczenie klasy słuchacza może się odbyć wyłącznie w fazie uruchamiania programu.

Interfejsy

Wielodziedziczenie może niekiedy prowadzić do pewnych niejednoznaczności np. dotyczących przynależności pól.

class A {
 int a;
........
}
class B extends A { // ma pole a
........
}
class C extends A { // ma pole a
........
}
class D extends B i C { //  hipotetyczne wielodziedziczenie
........
}

Obiekt d z klasy D ma pole a. Jedno czy dwa? Jeżeli tak to które? Co oznacza odwołanie d.a?
W Javie zrezygnowano z koncepcji wielodziedziczenia. Zamiast tego wprowadzono pojęcie interfejsu jako klasy nie zawierającej pól, a tylko metody (publiczne i abstrakcyjne) i ewentualnie stałe statyczne.
Interfejs daje więc możliwość definiowania zachowania się obiektów bez określania jak to zachowanie będzie implementowane.

Przykład Interfejs Shape
Interfejs ten zawiera dwie metody typowe dla obiektów posiadających kształt: area i circumference:

public interface Shape{
    public double area();
    public double circumference();

    public static final double PI = 3.14159;
}

Dwa przykładowe kształty, które mogą implementować ten interfejs to Circle i Rectangle. Aby klasa mogła implementować intefejs, musi ona specyfikować jego metody.

public class Circle implements Shape{
      private double radius;
      public Circle (double r) {radius = r;}
      public double area(){
             return PI*radius*radius;
      }
      public double circumference(){
             return 2*PI*radius;
      }
}

public class Rectangle implements Shape{
      private double height;
      private double width;
      public Rectangle (double h, double w) {height=h; width=w}
      public double area(){
             return height*width;
      }
      public double circumference(){
             return 2*(height+width);
      }
}

Wykorzystanie

public class TestShapes{
     public static void display(Shape figure){
          System.out.println("The area is "+figure.area());
          System.out.println("The circumference is "+figure.circumference());
    }
    public static void main(String args[]){
          Shape figOne = new Circle(3.5);
          display(figOne);

          Shape figOne = new Rectangle(3.2,5.1);
          display(figOne);
    }
}

- W tym przykładzie figOne jest referencją polimorficzną.
- Metody interfejsu domyślnie są traktowane jako typ abstract (tzn. są niezdefiniowane).
- W klasach abstrakcyjnych część metod może być zdefiniowana a część nie.
- Implementacja interfejsów odgrywa ważną rolę w Javie: obsługa zdarzeń, tworzenie wątków,...

Obsługa zdarzeń i komponenty AWT

Słuchacz to obiekt, który może obsługiwać zdarzenia (wciśnięcie guzika, przesunięcie myszki lub suwaka, wpisanie tekstu, itp.). Aby móc generować obiekty-Słuchaczy, klasa musi implementować interfejs nasłuchu. Tzn., metody interfejsu nasłuchu muszą zyskać konkretne definicje.

Zdarzenia przytrafiają się obiektom. Obiekt, któremu przytrafiło sie zdarzenie nazywany jest źródłem (source). Zdarzenie do obsługi przekazywane jest ze źródła do słuchacza tylko wtedy, gdy do danego źródła przyłączony jest słuchacz reagujący na ten typ zdarzenia. Przyłączenia dokonujemy za pomocą odwołania:

z.addxxxListener(l);

gdzie  z - źródło ,  xxx - rodzaj nasłuchiwanych zdarzeń ( Action, Item,Adjustement, MouseMotion), l - słuchacz.

ActionEvent to klasa zdarzeń oznaczających wykonanie akcji. Słuchacz akcji (obiekt klasy, która ma ją obsługiwać) musi implementować interfejs ActionListener i zdefiniować metodę actionPerformed  tego interfejsu.

AWT - Abstract Windowing Toolkit
Jest to zbiór klas zapewniających tworzenie prostych elementów graficznego interfejsu  użytkownika ( applet, Label, Button, TextField, ...). Znajdują się one w pakiecie java.awt (wymagany import).