Unterschied zwischen Dynamischen und Statischen Typ-Zuweisungen in Java

Angesichts der Folgen Klassenhierarchie, welche die dynamische und statische Typen für die folgenden Aussagen?

Klassenhierarchie:

class Alpha {}

class Beta extends Alpha {}

class Gamma extends Alpha {}

class Epsilon extends Alpha{}

class Fruit extends Gamma{}

class Golf extends Beta {}

class Orange extends Fruit{}

Für jede der folgenden Aussagen, Statische Typ? Dynamische Typ?:

Fruit f = new Fruit();
Alpha a = f;
Beta b = f;
a = b;
Gamma g = f;

Meine Antworten/Fragen
Ich verstehe, dass Fruit f = new Fruit() werden sowohl statische und dynamische Typ-Obst.
Alpha a = f; Typ Alpha zur compile-Zeit (statisch) und geben Sie Obst zur Laufzeit (dynamisch).

Gamma g = f; - Typ Gamma zur compile-Zeit (statisch) und geben Sie Obst zur Laufzeit (dynamisch).

Allerdings weiß ich nicht, die anderen zwei Antworten. Beta b = f ist eine Instanz, die in die zwei Unterklassen der gleichen super-Klasse sind einander zugeordnet, also bin ich nicht sicher, ob es wäre der Typ, Beta-oder Typ Alpha zur compile-Zeit (statisch). Und a = b ist eine Zuordnung nach Deklaration so bin ich nicht sicher, was die Antwort sein würde. Jemand bitte helfen Sie mir danke!

Ich bin verwirrt, wie so etwas sein kann, sowohl statische als auch dynamische, aber vielleicht denke ich in einem anderen Kontext.
Entweder hast du einen Tippfehler im code hast du geschrieben, oder du bist posting uncompilable code. Sollte Gamma erweitern Beta statt Alpha?
Sie nur jemals schaffen, eine Fruit und dieser Typ ist der Typ nur zur Laufzeit, die es jemals geben wird. Es ist nicht zu ändern, es wenn geben Sie Verweise hinzufügen, um es.
hochgeladen Beispiel-code ideone.com/wdk7oa Wie bereits erwähnt, nicht kompilierbare Main.java:15: Fehler: inkompatible Typen Beta b = f;

InformationsquelleAutor user3088470 | 2013-12-10

  1. 12

    Ich Schreibe dies in Eile, also pls entschuldigen Sie mögliche Tippfehler (ich mache später, wenn ich eine chance bekommen).

    Ich verstehe, dass Obst f = new Frucht() werden der statische und dynamische Typ Obst.

    Ich glaube du verwechselst ein wenig die Begriffe static and dynamic - Datentypen mit compile-time und run-time-Typen (oder, wie in C++ bei der Zuweisung der Adresse eines Objekts vom Typ A in einen Zeiger vom Typ B mit B wird die übergeordnete Klasse von A.)

    Sperrung Reflexion tricks, es gibt keine dynamische Typisierung in Java. Alles ist statisch typisiert zur compile-Zeit. Der Typ eines Objektes zur Laufzeit ist die gleiche wie die, die Sie bekam, zusammengestellt.

    Was passiert ist, dass Sie sind verwirrend Objekt-Referenzen (a, b, c, f) mit den tatsächlichen instanziierten Objekte im heap (alles erstellt mit new.)

    In Java f ist eine Referenz auf ein Objekt, nicht das Objekt selbst. Außerdem, der Typ der Referenz von f ist Fruit and sub-classes of it. Das Objekt ( new Fruit() ), die Sie zuordnen, es passiert zu sein, der Typ Fruit.

    Nun alle anderen Verweise in deinem Beispiel-code, den Typ reference to A and sub-classes of it; b ist vom Typ reference to B and sub-classes of it; etc, etc.

    Beachten Sie dies, denn es ist sehr wichtig.

    Alpha a = f; Typ Alpha zur compile-Zeit (statisch) und geben Sie Obst zur Laufzeit (dynamisch).

    einer ist der Typ "Referenz auf type-A und sub-Klassen".
    f ist vom Typ "Referenz auf type-Obst-und sub-Klassen".

    Dem Objekt f ist vom Typ 'Obst'. Wenn Sie sagen, 'a = f' Sie sind nicht die Zuordnung 'f' auf 'ein'. Sie werden sagen: 'jetzt wird die Referenz, die Sache f ist derzeit die Referenzierung'.

    So nach, dass die Zuordnung, was ist a Referenzierung? Das Objekt vom Typ Fruit die Objekt-Referenz f wies auf die zur Zeit der Abtretung.

    Erinnern, a -, b -, g -, f -, Sie sind keine Objekte. Sie sind Referenzen oder handles zu Objekten geschaffen, die eine oder andere Weise mit der new Betreiber.

    Einer Referenz-variable wie a, b oder f sind verschiedene Tiere aus der erstellten Objekte mit new. Aber es ist einfach so passiert, dass der ehemalige kann zu den Punkten später.

    Den Typ des erstellten Objekts mit new zur Laufzeit ist die gleiche wie die ermittelt zur compile-Zeit.

    Gamma g = f; Typ Gamma zur compile-Zeit (statisch) und geben Sie Obst zur Laufzeit (dynamisch).

    Gleiche wie oben. Die variable g ist eine Referenz auf ein Objekt vom Typ reference to type Gamma and sub-classes. In dieser Zuordnung g ist gemacht, um auf das gleiche Objekt zeigen wies durch f. Was ist der Typ des Objekts? Die gleichen zur compile-Zeit: Früchte.

    Allerdings weiß ich nicht, die anderen zwei Antworten. Beta b = f ist eine Instanz
    in die beiden Unterklassen der gleichen super-Klasse zugeordnet werden, um eine
    anderen also ich bin mir nicht sicher, ob es wäre der Typ, Beta-oder Typ Alpha
    compile-Zeit (statisch).

    b ist vom Typ reference to type Beta and sub-classes of it. Das Objekt weist nach der Zuweisung b = f ist der Typ Fruit, der Typ hatte es zur compile-Zeit.

    1. Den Typ von Objekt-Referenzen a, b, g, und f ist bestimmt zur compile-Zeit. Sie sind statisch typisiert und ändern sich nicht im run-time.

    2. Den Typ eines Objekts erstellt mit new ist bestimmt auch zur compile-Zeit. Sie sind auch statisch typisiert und ändern sich nicht im run-time.

    3. Objekte, die in Sachen Objekt-Referenzen a, b, g und f zeigen Sie auf zur Laufzeit, wird festgestellt, ob die Aussagen zu finden sind gilt durch den compiler. Die Zuordnungen können sich ändern, aber das hat nichts damit zu tun, ob der Objekt-Referenzen oder das Objekt selbst sind statisch oder dynamisch typisiert.

    Wenn Sie möchten, um zu sehen, eine klare Unterscheidung zwischen dynamischer und statischer Typisierung Folgendes:

    //Java, statically typed.
int x = 3;
x = 5; //good
x = "hi"; //compiler error

## Ruby, dynamically typed
x = 3 # ok
x = 5 # ok
x = "hi" # still ok

    Dann gibt es die Unterscheidung zwischen stark typisierte und schwach/Ente typisierte Sprachen (sowohl dynamisch typisiert ist.) Es gibt viel Literatur zu diesem Thema gibt.

    Hoffe, es hilft.

    vielen Dank für solch eine gute Antwort : @luis.espinal, können Sie bitte sagen, was genau meinen Sie mit "Referenz auf Typ X und sub-classes" ? vielen Dank im Voraus.
    Obst ist keine Unterklasse von der Beta, also wie funktioniert b = f einen Sinn ? Wie es scheint, sollte nicht kompilieren.

    InformationsquelleAutor luis.espinal

  2. 3

    dem dynamische und statische Typen für die folgenden Aussagen

    Erm, eine Erklärung nicht geben, zumindest gibt es keine solche Vorstellung, in der Java Language Specification. Die Skillung hat zwei unterschiedliche Arten von Typen: die deklarierten Typ der variable, ein Feld oder einen parameter, und die runtime-Klasse eines Objekts.

    Wie der name andeutet, ist die deklarierten Typ der eine variable, ein Feld oder einen parameter ist der Typ, den Sie erwähnen es in der Erklärung. Zum Beispiel die Erklärung Foo bar; deklariert eine variable mit dem Namen bar Typ Foo.

    Den runtime-Klasse eines Objekts ist bestimmt durch die Klasse-Instanz-oder array-creation-expression verwendet, um es zu konstruieren, und bleibt für die gesamte Lebensdauer des Objekts.

    Also der code:

    Integer i = 1;
Number n = i;
Object o = n;

    erklärt 3 Variablen der Typen Integer, Number und Object bzw. alle beziehen sich auf ein einzelnes Objekt mit runtime-Klasse Integer.

    InformationsquelleAutor meriton

  3. 2

    Beton -, Laufzeit-Typ von f ist Obst (wie du richtig angegeben, die in Ihrer Frage).

    So Beta b = f; initilalizes eine variable, deren erklärte, compile-Zeit-Typ ist Beta, und deren Laufzeit-Typ-Obst. Dieser Code wird nicht kompiliert, wenn, weil der compile-Zeit-Typ von f ist Obst und Obst ist keine Unterklasse von der Beta, so f können nicht zugewiesen werden, um eine variable des Typs Beta.

    In a = b;, b, deren runtime-Typ-Obst (siehe oben) wird der Variablen zugewiesen a, erklärt, wie Alpha a. So a's compile-Zeit-Typ ist Alpha und seinen Laufzeit-Typ-Obst.

    Aber Fruit nicht ableiten aus Beta, so Beta b = f; nicht kompilieren
    ja, in der Tat. Ich bearbeitet meine Antwort.

    InformationsquelleAutor JB Nizet

  4. 1

    Zunächst zu klären, "Referenzvariablen" Typ:

    Object obj;

    Punkte, um nichts und die Referenz-Variable obj würde KEINE geben.
    Jetzt

    Object obj = new String();
System.out.println(obj.getClass());//prints class java.lang.String

    obj zeigt auf eine Zeichenkette, und die Referenz-Variable obj Typ String hat.

    Den Punkt, ist Java eine statisch typisierte Sprache, und alle reference-type-Variablen ein Datentyp zugewiesen werden zur compile-Zeit. Die Referenz-variable obj Punkt zu einem anderen Objekt, solange es ist eine Unterklasse von Object. In diesem Fall
    fast alles. Betrachten

    Object obj = new String();
System.out.println(obj.getClass());//prints class java.lang.String
Number num = new Byte((byte)9);
obj = num;
System.out.println(obj.getClass());//prints class java.lang.Byte

    Zur Laufzeit, ebenso wie die Kompilierzeit, die Referenz-variable obj vom Typ Byte.

    Des statischen/dynamischen Typs eines Objekts, für mich, zu tun hat mit Vererbung.
    Insbesondere die übergeordneten Mechanismus. Auch bekannt als Dynamische Polymorphie
    und die Späte Bindung.

    Betrachten Sie das überschreiben der equals() in Klasse Object:

    public class Types {

    @Override
    public boolean equals(Object obj){
        System.out.println("in class Types equals()");
        return false;//Shut-up compiler!
    }

    public static void main(String[] args){
        Object typ = new Types();
        typ.equals("Hi");//can do this as String is a subclass of Object
    }
}

    Nun wissen wir, dass der Typ der Referenz-Variablen-typ ist Arten.

    Object typ = new Types();

    Wenn es um 

    typ.equals("Hi");

    Dies ist, wie ich denke, der compiler denkt.

    Wenn die equals() ist

    1.NICHT statisch und endgültig, was es ist.

    2.Verwiesen wird, die von einer Basisklasse (mehr dazu bald).

    dann der compiler verschiebt die Methode die aufgerufen wird, um den JVM. Die genaue Methode, die aufgerufen wird, hängt von der Dynamische Typ(bald mehr) der variable, der die Methode aufruft. In unserem Fall die Referenz-variable typ.
    Dies ist bekannt als Dynamic Method Invocation.

    Nun Verwiesen wird, die von einer Basisklasse:
    Aus dem obigen code

    Object typ = new Types();
typ.equals("Hi");

    Art Objekt betrachtet werden könnte als der Basis-Typ, der typ, auch bekannt als die Statischen Typ einer Referenz-Variablen und die equals() verwiesen wird, wird von der Basis-Typ, in diesem Fall Objekt.

    hätten wir 

    Types typ = new Types();

    Gäbe es keine Referenz von einem Basis-Typ und somit kein Dynamic Method Invocation.

    Nun zu den Dynamische Typ einer Referenz-variable.

    Object typ = new Types();
typ.equals("Hi");

    Den Dynamische Typ der typ ist Typen und nach Dynamic Method Invocation, die equals() in Klasse-Typen würde zur Laufzeit aufgerufen werden.

    Können auch sagen, wir hatten eine Klasse, die erweitert die Arten, TypesSubClass.
    Und TypesSubClass hatte auch einen überschriebenen equals(). Dann

    Object typ = new TypesSubClass();
typ.equals("Hi");

    Machen würde, die Dynamische Typ der typ TypesSubClass und TypesSubClass ist
    equals() würde zur Laufzeit aufgerufen werden.

    Um ehrlich zu sein, ich persönlich wusste nicht, warum, wir brauchten alle dieses und gebucht haben Sie eine Frage bezüglich dieser. überprüfen Sie

    Was ist der Grund hinter der Dynamischen Methode Auflösung in einem staticlly typisierte Sprache wie Java

    InformationsquelleAutor Clive Ferreira

  5. 0

    Sollten Sie einen Blick auf diese Artikel: http://www.sitepoint.com/typing-versus-dynamic-typing/

    Statische Typisierung ist es, wenn eine Sprache nicht erforderlich, die Variablen initialisiert werden.

    zB. 

    /* C code */ 
static int num, sum; //explicit declaration 
num = 5; //now use the variables 
sum = 10; 
sum = sum + num;

    Dynamische Typisierung ist, wenn eine Sprache benötigt die variable initialisiert werden.

    zB.

    /* Python code */ 
num = 10 //directly using the variable
    So, denn Java ist eine lokale variable, die definitiv zugeteilt werden, bevor es verwendet wird, ist es nicht statisch typisiert?
    Java ist eine statische Sprache. So in einer dynamischen Sprache, die Sie können einfach sagen num = 10 im Gegensatz zu einer statischen Sprache, wo Sie zu sagen haben int num; num = 10 Aber die Tatsache, dass man nur sagen int num; und geben Sie ihm den Wert später macht es statisch. Denken Sie an es auf diese Weise... wenn Sie sagen int num; Ihr Programm setzt eine bestimmte Stelle im Speicher und bezeichnet, die als variable num so jetzt, wenn Sie einen Wert zuweisen num es wird immer in diesem Raum der Speicher reserviert wurde. Daher statische
    Ich denke du meinst zu sagen, dass eine statische Typ-system erfordert ein Typ angegeben werden, für jede variable in der Deklaration. Das ist nicht ganz wahr. Eine statische Typ-system erfordert, dass jede variable eine Art, wie der compiler bestimmt, der Typ ist irrelevant. Insbesondere, C# gilt als eine statisch typisierte Sprache, obwohl Sie können den compiler folgern der Typ einer variable, indem Sie die var Schlüsselwort.

    InformationsquelleAutor Adjit

Schreibe einen Kommentar