Jawny przykład odlewania typu w Javie

Masz rację. Można z powodzeniem wysłać obiekt tylko do jego klasy, niektórych klas nadrzędnych lub do interfejsu, który implementuje lub jego rodzice. Jeśli przypisano go do niektórych klas nadrzędnych lub interfejsów, można go przypisać z powrotem do oryginalnego typu.

W Przeciwnym Razie (chociaż możesz mieć go w źródle), spowoduje to wywołanie klasy runtime ClassCastException.

Casting jest zazwyczaj używany, aby umożliwić przechowywanie różnych rzeczy (tego samego interfejsu lub klasy nadrzędnej, np. wszystkie Twoje samochody) w tym samym polu lub kolekcji tego samego typu (np. Pojazd), dzięki czemu można z nimi pracować w ten sam sposób.

Jeśli chcesz uzyskać pełny dostęp, możesz je oddać z powrotem (np. Pojazd do ciężarówki)

W przykładzie jestem prawie pewien, że ostatnia wypowiedź jest nieprawidłowa, a komentarz jest po prostu błędny.

Kiedy wykonujesz odlew z przedmiotu ciężarówki do ciężkiego pojazdu w taki sposób:

Truck truck = new Truck()
HeavyVehicle hv = truck;

Obiekt jest nadal ciężarówką, ale masz dostęp do metod i pól heavyVehicle tylko za pomocą referencji HeavyVehicle. Jeśli ponownie przejdziesz do ciężarówki, możesz ponownie użyć wszystkich metod i pól Ciężarówki.

Truck truck = new Truck()
HeavyVehicle hv = truck;
Truck anotherTruckReference = (Truck) hv; // Explicit Cast is needed here

Jeśli rzeczywisty obiekt nie jest ciężarówką, ClassCastException zostanie rzucony jak w poniższym przykładzie:

HeavyVehicle hv = new HeavyVehicle();
Truck tr = (Truck) hv;  // This code compiles but will throw a ClasscastException

Wyjątek jest wyrzucany, ponieważ obiekt rzeczywisty nie jest poprawną klasą, jest obiektem superklasy (HeavyVehicle)

Ostatnia linia kodu kompiluje się i działa pomyślnie bez żadnych WYJĄTKÓW. To co robi jest całkowicie legalne.

1. HV początkowo odnosi się do obiektu typu HeavyVehicle (nazwijmy ten obiekt h1):

   static HeavyVehicle hV = new HeavyVehicle(); // hV now refers to h1.
   

2. Później sprawiamy, że HV odnosi się do innego obiektu, typu Truck (nazwijmy ten obiekt t1):

   hV = T; // hV now refers to t1.
   

3. Wreszcie, t odnosi się do t1.

   T = (Truck) hV; // T now refers to t1.
   

T odnosi się już do t1, więc to stwierdzenie się nie zmieniło cokolwiek.

Jeśli hv została już przypisana instancja klasy HeavyVehicle, która jest super klasą klasy Truck, w jaki sposób to pole może być przypisane do bardziej specyficznej podklasy o nazwie Truck, która rozciąga się od klasy HeavyVehicle?

Zanim dotrzemy do ostatniego wiersza, hV nie odnosi się już do instancji HeavyVehicle. Odnosi się do przykładu Ciężarówki. Odlewanie instancji ciężarówki do typu Ciężarówki nie stanowi problemu.

Oznacza to, że obiekt może być tylko cast jako superklasa lub ta sama klasa co klasa, z której została faktycznie utworzona. Czy to prawda, czy się mylę?

Zasadniczo tak, ale nie myl samego obiektu ze zmienną, która odnosi się do obiektu. Patrz poniżej.

Czy jawne odlewanie zmienia w jakiś sposób rzeczywisty typ obiektu (nie tylko deklarowany Typ), tak że ten obiekt nie jest już instancją klasy HeavyVehicle, ale teraz staje się instancją klasy Truck?

Powtarzam, nic się nie zmieniło w ostatniej linijce. T odnosi się do t1 przed tą linią, a następnie odnosi się do t1.

Więc dlaczego w ostatniej linijce jest potrzebna wyraźna Obsada (Ciężarówka)? W zasadzie pomagamy tylko kompilatorowi.

wiemy, że w tym punkcie hV odnosi się do obiektu typu Truck, więc można przypisać ten obiekt typu Truck do zmiennej T. Ale kompilator nie jest wystarczająco mądry, aby to wiedzieć. Kompilator chce naszego zapewnienia, że kiedy dotrze do tej linii i spróbuje wykonać przypisanie, znajdzie instancję Trucka czekającą na nią.

Powyższy kod będzie kompilowany i uruchamiany poprawnie. Teraz zmień powyższy kod i dodaj następujący wiersz System. out. println(T.name);

To upewni się, że nie używasz obiektu T po downcastingu obiektu hV jako Ciężarówki.

Obecnie w kodzie nie używasz T po downcast więc wszystko jest w porządku i działa.

Dzieje się tak dlatego, że przez jawne rzucenie hV jako Truck, kompilator skarży się, że programista jako rzucił obiekt i jest świadomy tego, jaki obiekt został oddany do czego.

Ale podczas wykonywania JVM nie jest w stanie uzasadnić rzucania i rzuca ClassCastException "HeavyVehicle nie może być rzucany na ciężarówkę".

Aby lepiej zilustrować niektóre punkty powyżej, zmodyfikowałem dany kod i dodałem do niego więcej kodów z komentarzami inline (w tym rzeczywistymi wyjściami) w następujący sposób:

class Vehicle {

        String name;
        Vehicle() {
                name = "Vehicle";
        }
}

class HeavyVehicle extends Vehicle {

        HeavyVehicle() {
                name = "HeavyVehicle";
        }
}

class Truck extends HeavyVehicle {

        Truck() {
                name = "Truck";
        }
}

class LightVehicle extends Vehicle {

        LightVehicle() {
                name = "LightVehicle";
        }
}

public class InstanceOfExample {

        static boolean result;
        static HeavyVehicle hV = new HeavyVehicle();
        static Truck T = new Truck();
        static HeavyVehicle hv2 = null;
        public static void main(String[] args) {

                result = hV instanceof HeavyVehicle;
                System.out.print("hV is a HeavyVehicle: " + result + "\n"); // true

                result = T instanceof HeavyVehicle;
                System.out.print("T is a HeavyVehicle: " + result + "\n"); // true
//      But the following is in error.              
//      T = hV; // error - HeavyVehicle cannot be converted to Truck because all hV's are not trucks.                               

                result = hV instanceof Truck;
                System.out.print("hV is a Truck: " + result + "\n"); // false               

                hV = T; // Sucessful Cast form child to parent.
                result = hV instanceof Truck; // This only means that hV now points to a Truck object.                            
                System.out.print("hV is a Truck: " + result + "\n");    // true         

                T = (Truck) hV; // Sucessful Explicit Cast form parent to child. Now T points to both HeavyVehicle and Truck. 
                                // And also hV points to both Truck and HeavyVehicle. Check the following codes and results.
                result = hV instanceof Truck;                             
                System.out.print("hV is a Truck: " + result + "\n");    // true 

                result = hV instanceof HeavyVehicle;
                System.out.print("hV is a HeavyVehicle: " + result + "\n"); // true             

                result = hV instanceof HeavyVehicle;
                System.out.print("hV is a HeavyVehicle: " + result + "\n"); // true 

                result = hv2 instanceof HeavyVehicle;               
                System.out.print("hv2 is a HeavyVehicle: " + result + "\n"); // false

        }

}