Budowa i ponowne wykorzystanie klas

1. Abstrakcja i hermetyzacja

• prywatna – dostępna tylko w danej klasie (specyfikator private),
• zaprzyjaźniona – dostępna ze wszystkich klas danego pakietu; mówi się tu też o dostępie pakietowym lub domyślnym - domyślnym dlatego, iż ten rodzaj dostępności występuje wtedy, gdy w deklaracji składowej nie użyjemy żadnego specyfikatora,
• chroniona lub zabezpieczona – dostępna z danej klasy, wszystkich klas ją dziedziczących oraz z klas danego pakietu (specyfikator protected),
• publiczna – dostępna zewsząd (specyfikator public).

• uczynimy atrybuty pojazdów prywatnymi,
• dostarczymy – jako publicznego – tylko niezbędnego interfejsu,
• ukryjemy "roboczą" metodę zmieniającą stan obiektu,
• wprowadzimy publiczne stałe oznaczające stany pojazdu oraz odpowiadające im nazwy stanów (które uczynimy prywatnymi, by ew. zmiany nazw nie wpływały na oprogramowanie wykorzystujące klasę Vehicle). Alternatywnie na oznaczenie stanów moglibyśmy użyć enumeracji, ale bez nich przykład będzie będzie bardziej zwarty i klarowny.

  public class Vehicle  {

  // stany
  public final int BROKEN = 0, STOPPED = 1, MOVING = 2;
  private final String[] states =  { "ZEPSUTY", "STOI", "JEDZIE" };

  private int width, height, length, weight;
  private Person owner;
  private int state;

  public Vehicle(Person p, int w, int h, int l, int ww)  {  // konstruktor
     owner = p;      width = w;     height = h;
     length = l;     weight = ww;   state = STOPPED;
  }

  public void start()  {     setState(MOVING);  }

  public void stop()   {     setState(STOPPED);  }

  // Prywatna metoda robocza wykorzystywana w metodach start() i stop().
  // Arbitralne ustalenie stanu spoza klasy nie jest możliwe
  private void setState(int newState)  {
     if (state == newState || state == BROKEN)
        System.out.println("Nie jest mozliwe przejscie ze stanu " +
                            states[state] + " do stanu " + states[newState]);
     else state = newState;
  }

  public void repair()  {
    if (state != BROKEN)
       System.out.println("Pojazd sprawny");
    else state = STOPPED;
  }

  // Sprzedaż pojazdu
  public void sellTo(Person p)  {
     owner = p;
  }

  public String toString()  {
    return "Pojazd, właścicielem którego jest "
            + owner.getName() + " - " + states[state];
  }

}

• atrybuty pojazdu (wysokość, waga etc) nadawane są przy tworzeniu obiektu i żadna inna klasa nie może ich później zmienić,
• stan pojazdu jest zmieniany tylko na skutek wywołania publicznych metod start(), stop(), repair()  przy czym "sam obiekt" dba, by nie dopuścić do niewłaściwych zmian (zob. definicje tych metod oraz prywatnej metody setState(...)).
• przypomnijmy, że metoda toString() ma ważną właściwość:
  jest wywoływana, gdy referencja do obiektu klasy, w której ją zdefiniowano, pojawi się w wyrażeniu konkatenacji; wynik zastępuje w tym wyrażeniu wspomnianą referencję. A zatem jeśli v jest obiektem klasy Vehicle, i użyliśmy wobec niego metody start(),  to gdy napiszemy  System.out.println(" => " + v); to na konsolę zostanie wyprowadzony napis "=> Pojazd, właścicielem którego jest ... - JEDZIE". Sama metoda println(...) wołana z argumentem-dowolnym obiektem w swoim wnętrzu też używa metody toString() z klasy obiektu do wypisania informacji o obiekcie.

2. Wykorzystanie składowych statycznych

public class Vehicle  {

  public final static int BROKEN = 0, STOPPED = 1, MOVING = 2;
  private final static String[] states =  { "ZEPSUTY", "STOI", "JEDZIE" };

  private static int count;   // ile obiektów dotąd utworzyliśmy
  private int currNr;         // bieżący numer pojazdu

  //...
  public Vehicle(Person p, int w, int h, int l, int ww)  {
     // ....
     // Każde utworzenie nowego obiektu zwiększa licznik o 1
     // bieżąca wartość licznika nadawana jest jako numer pojazdu
     // numer pojazdu jest niestatycznym polem klasy, a więc elementem obiektu
     currNr = ++count;
  }
  //.....

  // zwraca unikalny numer pojazdu
  public int getNr()  { return currNr; }

  // zwraca liczbę dotąd utworzonych obiektów
  // metoda jest statyczna, by móc zwrócić 0
  // gdy nie ma jeszcze żadnego obiektu
  public static int getCount()  { return count; }

  // zwraca tablicę nazw stanów
  // Metoda jest statyczna, bo dopuszczalne stany
  // nie zależą od istnienia obiektów
  public static String[] getAvailableStates()  {
     return states;
  }
  // ...
}

3. Inicjacje

• pola klasy mają zagwarantowaną inicjację na wartości ZERO  (0, false – dla typu boolean, null – dla referencji, co oznacza referencję "pustą", nie odnosząca się do żadnego obiektu),
• zwykle w konstruktorze dokonuje się reinicjacji pól,
• ale można również posłużyć się jawną inicjacją przy deklaracji pól.

• użycie niestatycznego bloku inicjacyjnego,
• oraz użycie statycznego bloku inicjacyjnego.

public class Vehicle {
  // ...
  private int state;

  // Niestatyczny blok inicjacyjny
  // -- w niedzielę wszystkie samochody inicjalnie stoją
  // -- w poniedziałek te o parzystych numerach inicjalnie jadą,
  //    inne - stoją
  // -- w pozostałe dni tygodnia: pierwszy stworzony inicjalnie stoi,
  //    inne jadą

  { // początek bloku
    int dayOfWeek = Calendar.getInstance().get(Calendar.DAY_OF_WEEK);
    switch (dayOfWeek) {
      case Calendar.SUNDAY : state = STOPPED; break;
      case Calendar.MONDAY : state = (currNr % 2 == 0 ? MOVING : STOPPED);
                             break;
                   default : state = (currNr == 1 ? STOPPED : MOVING);
                             break;
    }
  } // koniec bloku


  // Konstruktory i metody klasy
  public Vehicle(...)  {
    // ...
  }
  // ...
} 

public class Vehicle  {

  public final static int BROKEN = 0, STOPPED = 1, MOVING = 2;
  private final static String[] states =  { "ZEPSUTY", "STOI", "JEDZIE" };
  private static int count;

  // Statyczny blok inicjacyjny
  // za jego pomocą inicjujemy zmienną count w taki sposób,
  // by numery pojazdów zaczynały się w zależności
  // od domyślnej lokalizacji aplikacji
  // np. jeśli aplikacja jest wykonywana w lokalizacji włoskiej
  // numery zaczynają się od 10000.

  static { 
    
    Locale[] loc = { Locale.UK, Locale.US, Locale.JAPAN, Locale.ITALY, };
    int[] begNr =  { 1, 100, 1000, 10000, };

    count = 300;  // jeżeli aplikacja działa w innej od wymienionych
                  // w tablicy lokalizacji, zaczynamy numery od 300

    Locale defLoc = Locale.getDefault(); // jaka jest domyślna lokalizacja? 

    for (int i=0; i < loc.length; i++)
      if (defLoc.equals(loc[i])) {
        count = begNr[i];
        break;
      }
  }  // koniec bloku


  // pola niestatyczne

  private int currNr = ++count;
  private int width, height, length, weight;
  // ...
  // Konstruktory i metody
  // ...

} // koniec klasy

public class InitOrder {
  
  private static int s = 100;
  private static final int C;
  
  private int a = 1;
  
  InitOrder() {
    report("Konstruktor: s, C, a, b mają wartości :", s, C, a, b);
  }
  
  private int b = 2;
  
  { 
    report("Blok inicjacyjny: s, C, a =", s, C, a);
  }
  
  static {
    report("Statyczny blok inicjacyjny, zmienna s = ", s);
    C = 101;  // opóźniona inicjacja stałej!
  }
  
  private static void report(String msg, int ... args  ) {
    System.out.print(msg + " ");
    for (int i : args) {
      System.out.print(i + " ");
    }
    System.out.println();
  }
  
  public static void main(String[] args) {
    report("Wywołanie metody main");
    new InitOrder();

  }

}

class Vehicle {
   private int currNr = ++count;
   private static count = 100;
   ...
   public int getNr() { return currNr; }
   public static int getCount() { return count; }
}

4. Przeciążanie metod i konstruktorów

• dodawania innych obiektów-par
• dodawania (do składników pary) kolejno dwóch podanych liczb całkowitych
• dodawania (do każdego składnika pary) jednej i tej samej podanej  liczby całkowitej

5. Zastosowanie słowa kluczowego this

class Vehicle {
  private int width, height, length, weight;
  private Person owner = null;
  private int state;

  public Vehicle(Person owner, int width, int height, int length, int weight)  {
     this.owner = owner;      this.width = width;     this.height = height;
     this.length = length;    this.weight = weight;
}

Vehicle repair() {
  // ...
  return this;
}

6. Ponowne wykorzystanie klas: kompozycja i dziedziczenie

• kompozycja,
• dziedziczenie.

6.1. Kompozycja

public class Person {

  private String firstName;
  private String lastName;

  public Person (String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  public String getFirstName() {
    return firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public String toString() {
    return firstName + " " + lastName;
  }

}

import java.util.*;

public class Address {
  private String country;
  private String city;
  private String street;

  public Address (String country, String city, String address) {
    this.country = country;
    this.city = city;
    this.street = address;
  }

  public String getCountry() {
    return country;
  }

  public String getCity() {
    return city;
  }

  public String getStreet() {
    return street;
  }

  public String getCurrentTimeThere() {
    TimeZone tz = TimeZonesMap.getTimeZone(country, city);
    if (tz == null) return "Uknown time";
    // pobieramy kalendarz dla danej strefy czasowej
    // i formatujemy datę
    Calendar cal = Calendar.getInstance(tz); 
    return String.format("%tF %<tT", cal);
  }

  public String toString() {
    return country+ ", " + city+ ", " + street;
  }

}

import java.util.*;

public class TimeZonesMap {

  private static HashMap<String, TimeZone> map = new HashMap<String, TimeZone>();
  static {
    add("POLAND/WARSAW", "Europe/Warsaw");
    add("INDONESIA/JAKARTA", "Asia/Jakarta");
    add("CUBA/HAVANA", "America/Havana");
    //.. jakieś inne
  }

  private static void add(String cc, String tzo) {
    map.put(cc, TimeZone.getTimeZone(tzo));
  }

  public static TimeZone getTimeZone(String country, String city) {
    return map.get(country.toUpperCase() + "/" + city.toUpperCase());
  }
}

  public String getFirstName() {
    return person.getFirstName();
  }

public class RegisteredUser {

  private Person person;
  private Address address;
  private String email;

  // ...

  public String getCurrentTimeThere() {
    return address.getCurrentTimeThere();
  }

  // ...
}

public class TestRegUser {

  public static void main(String[] args) {
    RegisteredUser usr = new RegisteredUser(
                             new Person("Kuba", "Kowalski"),
                             new Address("Cuba", "Havana", "Malecon 333"),
                             "kuba@Cuba"
                         );
    System.out.printf("Czas serwera (tutaj) : %tF %<tT", Calendar.getInstance());
    System.out.println("\nUżytkownik: " + usr);
    System.out.println(usr.getFirstName() + " ma teraz czas: " + usr.getCurrentTimeThere());
  }

}

6.2. Dziedziczenie

public class AppartmentAddress extends Address {   
 // ... 
}

public class AppartmentAddress extends Address {
  private int floor;
  private int appNr;
  
  public AppartmentAddress(String country, String city, String street,
                           int floor, int appNr) {
    super(country, city, street);
    this.floor = floor;
    this.appNr = appNr;
  }

  public int getFloor() {
    return floor;
  }

  public int getAppNr() {
    return appNr;
  }

}

public class AppartmentAddressTest {
 
  public static void main(String[] args) {
    AppartmentAddress adr = new AppartmentAddress("Thailand", "Bangkok", "Rama V", 29, 3111);
    System.out.println(adr);
    System.out.println("floor: " + adr.getFloor() + " apt: " + adr.getAppNr());
    String time = adr.getCurrentTimeThere();  // korzystamy ze "skomplikowanej" metody klasy Address
    System.out.println(time);
  }

}

1. Wywoływany jest konstruktor klasy pochodnej.
2. Jeśli pierwszą instrukcją jest super(args) wykonywany jest konstruktor klasy bazowej z argumentami args.
3. Jeśli nie ma super(...) wykonywany jest konstruktor bezparametrowy klasy bazowej.
4. Wykonywane są instrukcje wywołanego konstruktora klasy pochodnej.

class s { // ułatwienie dla wypisywania
  static void ay(String s) { System.out.println(s); }  }

class A {
  A() { s.ay("Konstruktor bezparametrowy klasy A"); }
  A(String t) {
    s.ay("Konstruktor klasy A z parametrem String = " + t);
  }
}

class B extends A {
  B() { s.ay("Konstruktor bezparametrowy klasy B"); }
  B(int i) { s.ay("Konstruktor klasy B z parametrem int = " + i); }
  B(String t) {
    super(t);
    s.ay("Konstruktor klasy B z parametrem String = " + t);
  }
}

class C extends B {
}

class Test {
  public static void main(String[] arg) {
     s.ay("Tworzenie obiektu B - B():");
     new B();
     s.ay("Tworzenie obiektu B - B(int)");
     new B(1);
     s.ay("Tworzenie obiektu B - B(String)");
     new B("Ala");
     s.ay("Tworzenie obiektu C:");
    new C();
  }
}

public class AppartmentAddress {
   private Address adres;
   // ...
} 

public class AppartmentAddress {
   private Address adres;
   // ...
   public String getCurrentTimeThere() { 
     return adres.getCurrentTimeThere();
   }
   // ...
} 

• wszystkie klasy pochodzą pośrednio lub bezpośrednio od klasy Object,
• klasa może bezposrednio odziedziczyć tylko jedną klasę.

7. Przedefiniowanie metod

7.1. Pojęcie przedefiniowania metod

• numer rejestracyjny
• użycie paliwa (przy braku paliwa samochód nie może ruszyć)

• dodajmy odpowiednie pola do klasy Car oraz odpowiedni konstruktor,
• dodajmy metodę fill() pozwalającą tankować paliwo,
• przedefiniujmy metodę start(), tak, by bez paliwa samochód nie mógł ruszyć

• wszystkich nieprywatnych (i nieprzedefiniowanych) metod klasy Vehicle,
• przedefiniowanych w klasie Car metod klasy Vehicle,,
• własnych metod klasy Car.

class Cars21 {
	
 static void say(Car c)  { System.out.println(c.toString());  }

 public static void main(String[] args)  {
    Car c = new Car("WA1090",
                    new Person("Janek", "0909090"),
                    100, 100, 100, 100, 50),
        d = new Car("WB7777", new Person("Zbyszek", "0909090"),
                    100, 100, 100, 100, 50);
    c.start();
    say(c);
    c.fill(30);
    c.start();
    say(c);
    d.fill(40);
    d.start();
    say(d);
    c.stop();
    say(c);
    d.crash(c);
    say(c);
    say(d);
 }

}

7.2. Przedefiniowanie i klauzula throws

1. jeżeli metoda z klasy bazowej nie ma klauzuli throws, to metoda przedefiniowująca ją w klasie pochodnej nie może wymienić w swojej klauzuli throws żadnych wyjątków kontrolowanych,
2. jeżeli metoda z klasy bazowej wymienia w swojej klauzuli throws jakieś wyjatki kontrolowane,  to metoda przedefiniowująca ją w klasie pochodnej nie może wymienić żadnej nadklasy tych wyjątków ani żadnych dodatkowych innych klas wyjątków kontrolowanych, może natomiast wymienić dowolne wyjątki pochodzące z podklas wyjątków, zgłaszanych przez metodę z klasy bazowej,
3. niezależnie od  metody z klasy bazowej metoda przedefiniowana w klasie pochodnej może nie zgłaszać żadnych wyjatków i nie mieć klauzuli throws,
4. metoda przedefiniowana w klasie pochodnej zawsze może zgłaszać wyjatki niekontrolowane i ew. wymieniać je w swojej klauzuli throws (co nie jest obowiązkowe).

• wyjątek IOException jest pochodny od Exception,
• wyjątek FileNotFoundException jest pochodny od IOException,
• wyjątek NumberFormatException jest pochodny od RuntimeException.

class A {
  void met1() {}
  void met2() throws FileNotFoundException {}
  void met3() throws IOException {}
  void met4() throws Exception {} 
  void met5() {}
}

class B extends A {
  void met1() throws Exception {}    // błąd: ilustruje pkt. 1
  void met2() throws IOExcepetion {} // błąd: ilustruje pkt. 2
  void met3() throws FileNotFoundException, IOException {} // ok, ilustruje pkt 2
  void met4() {}                                           // ok, ilustruje pkt 3 
  void met5() throws NumberFormatException { }             // ok, ilustruje pkt 4 
}

7.3. Przedefiniowanie a przesłanianie i pokrywanie

• po pierwsze, przeciążone metody mogą należeć do tej samej lub różnych klas (z których jedna pośrednio lub bezpośrednio dziedziczy inną),
• po drugie przeciążanie nie wyklucza przedefiniowania: jeśli np. w klasie A zdefiniowano dwie publiczne metody z tą samą nazwą (co oznacza, że są one przeciążone, bo sygnatury metod deklarowanych w jednej klasie muszą się różnić), to w klasie B dziedziczącej klasę A możemy jedną z nich dodatkowo przeciążyć (czyli podać w deklaracji inny zestaw parametów, a drugą przedefiniować - pozostawiając jej sygnatirę bez zmian i dostarczając innej definicji kodu metody). W tym względzie Java różni się od C++.

7.4. Kowariantne typy wyników

public class Liczba {
  
  private Number n;
  
  public Liczba() {
  }
  
  public Liczba(Integer i) {
    n = i;
  }
  
  public Liczba(Double d) {
    n = d;
  }

  // ... inne konstruktory dla innych typów liczb
  
  public Number getNumber() { 
    return n; 
  }

}

public class Cala extends Liczba {
  
  public Cala(int n) {
    super(n);
  }
  
  public Integer getNumber() {
    return super.getNumber().intValue();
  }

}

public class Rzecz extends Liczba {
  
  public Rzecz(double n) {
    super(n);
  }
  
  public Double getNumber() {
    return super.getNumber().doubleValue();
  }

}

8. Rzutowanie typów referencyjnych

8.1. Konwersje referencyjne

public class Test1 {
  
  static void info(Vehicle v) {
    System.out.println("Pojazd nr. " + v.getNr() + " " + Vehicle.getState(v.getState()));
  }

  public static void main(String[] args) {
    Car c = new Car("WA1090", new Person("Janek", "0909090"),
                     100, 100, 100, 100, 50);
    Kayak k = new Kayak(new Person("Stefan", "0101010"),
                     70, 40, 200, 5);
    info(c);
    info(k);
  }

}

public class Test2 {
  
  static void info(Vehicle[] vehs) {
    for (Vehicle v : vehs) {
      System.out.println("Pojazd nr. " + v.getNr() + " " + Vehicle.getState(v.getState()));  
    }
  }
  
  public static void main(String[] args) {
    Vehicle[] vehs = { new Car(), new Car(), new Kayak(), new Bicycle(), new Car() };
    info(vehs);
  }

}

  static void info(Vehicle ... vehs) {
    for (Vehicle v : vehs) {
      System.out.println("Pojazd nr. " + v.getNr() + " " + Vehicle.getState(v.getState()));  
    }
  }
  
  public static void main(String[] args) {
    Vehicle[] vehs = { new Car(), new Car(), new Kayak(), new Bicycle(), new Car() };
    info(vehs);
    info( new Kayak(), new Car(), new Bicycle() );
    info( new Car() );
  }

public class Serwis {
  
  private ArrayList<Vehicle> toServe;

  public Serwis(ArrayList<Vehicle> toServe) {
     this.toServe = toServe;
  }
  
  public void repairBroken() {
    for (Vehicle v : toServe) {
      if (v.getState() == Vehicle.BROKEN) v.repair();
    }
  }

}

• serwisowi przekazywana jest referencja do listy wszystkich pojazdów (używamy tu klasy ArrayList, bo tylko taki sposób dostępu do list dotąd poznaliśmy),
• metoda repairBroken przegląda tę listę i jeśli stan pojazdu jet BROKEN - naprawia go (zmiana stanu na STOPPED), operujemy tu na referencjach do pojazdów utworzonych w głównym programie i dodanych do listy.

import java.util.*;

public class Test3 {

  static void info(ArrayList<Vehicle> vehs) {
    for (Vehicle v : vehs) {
      System.out.println("Pojazd nr. " + v.getNr() + " " + Vehicle.getState(v.getState()));  
    }
  }
  
  static Random rand = new Random();               // generator 
  static Vehicle badLuck = new Vehicle();  // będziemy zderzać pojazdy z pechem
  
  // Przekazany jako argument pojazd losowo zderza się z pechem (psuje)
  // i jest dodawany do listy
  static void breakRandomly(Vehicle v, ArrayList<Vehicle> list) {
    boolean toBreak = rand.nextBoolean();
    if (toBreak) {
      badLuck.start();    // zaczyna się pech ...
      v.crash(badLuck);
      badLuck.repair();   // po zderzeniu "pech" się odnawia  
    }                     // (będzie gotowy do ponownego losowego startu)
    list.add(v);
  }
  
  
  public static void main(String[] args) {
    ArrayList<Vehicle> list = new ArrayList<Vehicle>();            
    breakRandomly(new Car(), list); 
    breakRandomly(new Kayak(), list); 
    breakRandomly(new Bicycle(), list);
    breakRandomly(new Car(), list);
    breakRandomly(new Kayak(), list);
    info(list);
    System.out.println("Go to service");
    Serwis serv = new Serwis(list);
    serv.repairBroken();
    System.out.println("After service");
    info(list);
  }

}

  public void repairBroken() {
    for (Vehicle v : toServe) {
      if (v.getState() == Vehicle.BROKEN) v.repair();
      ((Car) v).fill(10);
    }
  }

8.2. Stwierdzanie typu

• wyrażenie null instanceof dowolny_typ zawsze ma wartość false,
• wyrażenie x instanceof T, będzie błędne składniowo (wystąpi błąd w kompilacji), jeśli typ referencji x i typ T nie są związane stosunkiem dziedziczenia,
• wyrażenie x instanceof T będzie miało wartość false, jeśli faktyczny typ referencji x jest nadtypem typu T,
• na razie terminy typ, podtyp i nadtyp kojarzyć możemy z pojęciami klasy, podklasy i nadklasy.

class A {
}

class B extends A {
}

class C extends B {
}

class D extends A {
}

class E {
}

public class InstanceOf1 {
  
  static void say(String msg, boolean is) {
    System.out.println(msg + ": " + is );
  }

  public static void main(String[] args) {
    A a = new A();
    B b = new B();
    C c = new C();
    D d = new D();
    E e = new E();
    say("Czy a jest typu A ? ", a instanceof A);
    say("Czy b jest typu A ? ", b instanceof A);
    say("Czy c jest typu A ? ", c instanceof A);
    say("Czy c jest typu B ? ", c instanceof B);
    say("Czy a jest typu B ? ", a instanceof B);
    say("Czy b jest typu C ? ", b instanceof C);
    say("Czy null jest typu A", null  instanceof A);
    say("Czy d jest typu A?", d instanceof A);
    // say("Czy d jest typu B?", d instanceof B);    <- błąd w kompilacji 
    // say("Czy e jest typu A ? ", e instanceof A);  <- błąd w kompilacji 
   }
}

class A {
}

class B extends A {
}

class C extends B {
}

public class InstanceOf1 {
  
  static void say(String msg, boolean is) {
    System.out.println(msg + ": " + is );
  }

  public static void main(String[] args) {
    B b = new B();
    C c = new C();
    A a = b;
    B b1 = c; 
    say("Czy a jest typu B ? ", a instanceof B);
    say("Czy b1 jest typu C ? ", b1 instanceof C);
    
    testTyp(b);
  }

  private static void testTyp(A a) {
    say("Czy przekazany argument jest typu B ?", a instanceof B); 
  }

}

  public void repairBroken() {
    for (Vehicle v : toServe) {
      if (v.getState() == Vehicle.BROKEN) v.repair();
      if (v instanceof Car) ((Car) v).fill(10);
    }
  }

  public void repairBroken() {
    for (Vehicle v : toServe) {
      if (v.getState() == Vehicle.BROKEN) v.repair();
      if (v.getClass() == casts.Car.class) ((Car) v).fill(10);
    }
  }

package casts;

class Truck extends Car {

  public Truck() {  }
  // ... 
}

public class InstDif {
  
  static void reportType(Vehicle v) {
    say("instanceof 1: v jest typu Vehicle? - ", v instanceof Vehicle);
    say("instanceof 2: v jest typu Car? - ", v instanceof Car);  
    say("instanceof 3: v jest typu Truck? - ", v instanceof Truck);
    say("getClass() 1: v jest typu Vehicle? - ", v.getClass() == casts.Vehicle.class);
    say("getClass() 2: v jest typu Car? - ", v.getClass() == casts.Car.class);
    say("getClass() 3: v jest typu Truck? - ", v.getClass() == casts.Truck.class);
  }

  public static void main(String[] args) {
    Truck t = new Truck();
    reportType(t);
  }

  static void say(String msg, boolean is) {
    System.out.println(msg + ": " + is );
  }

  public boolean equals(Object obj) {
    if (this == obj) return true;
    if (obj == null) return false;
    if (getClass() != obj.getClass()) return false;
    // ... porównanie zawartośi obiektów
  }