Ist "Parent x = new Child ();" anstelle von "Child x = new Child ();" eine schlechte Praxis, wenn wir die letztere verwenden können?

Zum Beispiel hatte ich einige Codes gesehen, die ein Fragment wie dieses erzeugen:

Fragment myFragment=new MyFragment();

Dies deklariert eine Variable als Fragment anstelle von MyFragment. MyFragment ist eine untergeordnete Klasse von Fragment. Ich bin mit dieser Codezeile nicht zufrieden, da ich der Meinung bin, dass dieser Code wie folgt lauten sollte:

MyFragment myFragment=new MyFragment();

Was ist genauer, ist das wahr?

Oder ist es bei der Verallgemeinerung der Frage eine schlechte Praxis, Folgendes zu verwenden:

Parent x=new Child();

anstatt

Child x=new Child();

können wir das erstere in das letztere umwandeln, ohne kompilierungsfehler?

Es hängt vom Kontext ab, aber ich würde argumentieren, dass Sie den abstraktesten möglichen Typ angeben sollten. Auf diese Weise wird Ihr Code so allgemein wie möglich und hängt nicht von irrelevanten Details ab.

Ein Beispiel wäre ein LinkedListund von ArrayListdem beide abstammen List. Wenn der Code mit jeder Art von Liste gleich gut funktionieren würde, gibt es keinen Grund, ihn willkürlich auf eine der Unterklassen zu beschränken.

JacquesBs Antwort ist richtig, wenn auch ein wenig abstrakt. Lassen Sie mich einige Aspekte klarer hervorheben:

In Ihrem Code-Snippet verwenden Sie explizit das newSchlüsselwort und möchten möglicherweise mit weiteren Initialisierungsschritten fortfahren, die wahrscheinlich spezifisch für den konkreten Typ sind: Dann müssen Sie die Variable mit diesem spezifischen konkreten Typ deklarieren.

Die Situation ist anders, wenn Sie diesen Artikel von einem anderen Ort erhalten, z IFragment fragment = SomeFactory.GiveMeFragments(...);. Hier sollte die Factory normalerweise den abstraktesten Typ zurückgeben, und der Code nach unten sollte nicht von Implementierungsdetails abhängen.

Es gibt möglicherweise Leistungsunterschiede.

Wenn die abgeleitete Klasse versiegelt ist, kann der Compiler virtuelle Aufrufe einbinden und optimieren oder eliminieren. Es kann also einen signifikanten Leistungsunterschied geben.

Beispiel: ToStringist ein virtueller Anruf, ist aber Stringversiegelt. Ein String, ToStringist ein No-Op. Wenn Sie also deklarieren, objectdass dies ein virtueller Aufruf ist, und wenn Sie deklarieren, dass Stringder Compiler weiß, dass keine abgeleitete Klasse die Methode überschrieben hat, weil die Klasse versiegelt ist, ist dies ein No-Op. Ähnliche Überlegungen gelten für ArrayListvs LinkedList.

Wenn Sie den konkreten Typ des Objekts kennen (und es keinen Kapselungsgrund gibt, ihn zu verbergen), sollten Sie diesen Typ deklarieren. Da Sie gerade das Objekt erstellt haben, kennen Sie den konkreten Typ.

Der Hauptunterschied ist die erforderliche Zugriffsebene. Und jede gute Antwort auf die Frage der Abstraktion bezieht Tiere mit ein, wie mir gesagt wurde.

Nehmen wir an, Sie haben ein paar Tiere - Cat Birdund Dog. Nun, diese Tiere haben ein paar gemeinsamen Verhaltensweisen - move(), eat()und speak(). Sie alle essen anders und sprechen anders, aber wenn ich mein Tier zum Essen oder Sprechen brauche, ist es mir egal, wie sie es tun.

Aber manchmal mache ich. Ich habe nie eine Wachkatze oder einen Wachvogel hart, aber ich habe einen Wachhund. Wenn jemand in mein Haus einbricht, kann ich mich nicht einfach darauf verlassen, dass ich spreche, um den Eindringling abzuschrecken. Ich brauche wirklich meinen Hund zum Bellen - das ist anders als sein Sprechen, das ist nur ein Schuss.

In Code, der einen Eindringling erfordert, muss ich das wirklich tun Dog fido = getDog(); fido.barkMenancingly();

Aber die meiste Zeit kann ich Tiere glücklich dazu bringen, Tricks zu machen, bei denen sie nach Leckereien weinen, miauen oder twittern. Animal pet = getAnimal(); pet.speak();

Genauer gesagt, ArrayList hat einige Methoden, die Listdies nicht tun . Vor allem trimToSize(). In 99% der Fälle interessiert uns dies nicht. Das Listist fast nie groß genug, um uns zu kümmern. Aber es gibt Zeiten, in denen es so ist. Daher müssen wir gelegentlich ausdrücklich darum bitten ArrayList, dass a ausgeführt wird trimToSize()und das Backing-Array kleiner wird.

Beachten Sie, dass dies nicht bei der Erstellung gemacht werden muss - es könnte über eine Rückgabemethode oder sogar eine Besetzung erfolgen, wenn wir absolut sicher sind.

Im Allgemeinen sollten Sie verwenden

var x = new Child(); // C#

oder

auto x = new Child(); // C++

für lokale Variablen, es sei denn, es gibt einen guten Grund dafür, dass die Variable einen anderen Typ als den hat, mit dem sie initialisiert wird.

(Hier ignoriere ich die Tatsache, dass der C ++ - Code höchstwahrscheinlich einen intelligenten Zeiger verwenden sollte. Es gibt Fälle, in denen nicht und ohne mehr als eine Zeile, die ich eigentlich nicht kennen kann.)

Die allgemeine Idee dabei ist, Sprachen zu verwenden, die die automatische Typerkennung von Variablen unterstützen, die das Lesen des Codes erleichtern und das Richtige tun (das heißt, das Typsystem des Compilers kann so weit wie möglich optimieren und die Initialisierung so ändern, dass sie neu ist Typ funktioniert auch, wenn der größte Teil der Zusammenfassung verwendet wurde.

Gut, weil dieser Code einfach zu verstehen und zu ändern ist:

var x = new Child(); 
x.DoSomething();

Gut, weil es Absicht kommuniziert:

Parent x = new Child(); 
x.DoSomething(); 

Ok, weil es allgemein und leicht zu verstehen ist:

Child x = new Child(); 
x.DoSomething(); 

Die eine Option, die wirklich schlecht ist, ist zu verwenden, Parentwenn nur Childeine Methode hat DoSomething(). Es ist schlecht, weil es Absicht falsch kommuniziert:

Parent x = new Child(); 
(x as Child).DoSomething(); // DON'T DO THIS! IF YOU WANT x AS CHILD, STORE x AS CHILD

Lassen Sie uns nun etwas näher auf den Fall eingehen, zu dem folgende Fragen gestellt werden:

Parent x = new Child(); 
x.DoSomething(); 

Formatieren wir dies anders, indem wir die zweite Hälfte als Funktionsaufruf ausführen:

WhichType x = new Child(); 
FunctionCall(x);

void FunctionCall(WhichType x)
    x.DoSomething(); 

Dies kann verkürzt werden auf:

FunctionCall(new Child());

void FunctionCall(WhichType x)
    x.DoSomething();

Ich gehe davon aus, dass es allgemein anerkannt ist, dass es WhichTypesich um den grundlegendsten / abstraktesten Typ handelt, mit dem die Funktion ausgeführt werden kann (sofern keine Leistungsprobleme vorliegen). In diesem Fall wäre der richtige Typ entweder Parentoder es Parentergibt sich etwas daraus.

Diese Argumentation erklärt, warum die Verwendung des Typs Parenteine gute Wahl ist, aber es spielt keine Rolle, ob die anderen Entscheidungen schlecht sind (sie sind es nicht).

tl; dr - Die Verwendung vonChildoverParentist im lokalen Bereich vorzuziehen. Dies trägt nicht nur zur Lesbarkeit bei, sondern auch dazu, dass die überladene Methodenauflösung ordnungsgemäß funktioniert und eine effiziente Kompilierung ermöglicht.

Im lokalen Bereich,

Parent obj = new Child();  // Works
Child  obj = new Child();  // Better
var    obj = new Child();  // Best

Konzeptionell geht es darum, die bestmöglichen Typinformationen zu erhalten. Wenn wir auf downgraden Parent, streichen wir im Wesentlichen nur Typinformationen heraus, die nützlich gewesen sein könnten.

Das Beibehalten der vollständigen Typinformationen hat vier Hauptvorteile:

1. Stellt dem Compiler weitere Informationen zur Verfügung.
2. Bietet dem Leser weitere Informationen.
3. Sauberer, standardisierter Code.
4. Macht die Programmlogik veränderlicher.

Vorteil 1: Mehr Informationen zum Compiler

Der scheinbare Typ wird bei überladener Methodenauflösung und bei der Optimierung verwendet.

Beispiel: Überladene Methodenauflösung

main()
{
    Parent parent = new Child();
    foo(parent);

    Child  child  = new Child();
    foo(child);
}
foo(Parent arg) { /* ... */ }  // More general
foo(Child  arg) { /* ... */ }  // Case-specific optimizations

Im obigen Beispiel funktionieren beide foo()Aufrufe , aber in einem Fall erhalten wir die bessere Auflösung für überladene Methoden.

Beispiel: Compileroptimierung

main()
{
    Parent parent = new Child();
    var x = parent.Foo();

    Child  child  = new Child();
    var y = child .Foo();
}
class Parent
{
    virtual         int Foo() { return 1; }
}
class Child : Parent
{
    sealed override int Foo() { return 2; }
}

Im obigen Beispiel .Foo()rufen beide Aufrufe letztendlich dieselbe zurückgegebene overrideMethode auf 2. Im ersten Fall gibt es eine virtuelle Methodensuche, um die richtige Methode zu finden. Diese Suche nach virtuellen Methoden ist im zweiten Fall nicht erforderlich, da diese Methoden vorhanden sind sealed.

Dank an @Ben, der in seiner Antwort ein ähnliches Beispiel lieferte .

Vorteil 2: Mehr Informationen für den Leser

Wenn Sie den genauen Typ kennen, dh wissen Child, wer den Code liest, erhalten Sie mehr Informationen, damit Sie besser sehen können, was das Programm tut.

Sicher, vielleicht ist es für den eigentlichen Code nicht wichtig, da beide parent.Foo();und child.Foo();Sinn machen, aber für jemanden, der den Code zum ersten Mal sieht, sind mehr Informationen einfach nur hilfreich.

Abhängig von Ihrer Entwicklungsumgebung kann die IDE möglicherweise hilfreichere QuickInfos und Metadaten bereitstellen Childals Parent.

Vorteil 3: Saubererer, standardisierterer Code

Die meisten C # -Codebeispiele, die ich in letzter Zeit gesehen habe, verwenden vardiese Abkürzung Child.

Parent obj = new Child();  // Sub-optimal
Child  obj = new Child();  // Optimal, but anti-pattern syntax
var    obj = new Child();  // Optimal, clean, patterned syntax "everyone" uses now

Das Anzeigen einer nicht vardeklarationspflichtigen Anweisung sieht einfach nicht so aus. Wenn es einen situationsbedingten Grund dafür gibt, ist es großartig, aber ansonsten sieht es nicht nach Muster aus.

// Clean:
var foo1 = new Person();
var foo2 = new Job();
var foo3 = new Residence();

// Staggered:
Person foo1 = new Person();
Job foo2 = new Job();
Residence foo3 = new Residence();   

Vorteil 4: Mehr veränderbare Programmlogik für das Prototyping

Die ersten drei Vorteile waren die großen; Das hier ist weitaus situativer.

Für Leute, die Code wie andere verwenden, die Excel verwenden, ändern wir jedoch ständig unseren Code. Möglicherweise müssen wir keine Methode aufrufen, die Childin dieser Version des Codes eindeutig ist , aber wir können den Code später erneut verwenden oder überarbeiten.

Der Vorteil eines starken Typsystems besteht darin, dass es uns bestimmte Metadaten über unsere Programmlogik liefert, wodurch die Möglichkeiten leichter ersichtlich werden. Dies ist beim Prototyping unglaublich nützlich, daher ist es am besten, es so weit wie möglich beizubehalten.

Zusammenfassung

Wenn Sie Parentdie überladene Methodenauflösung durcheinander bringen, werden einige Compiler-Optimierungen verhindert, Informationen aus dem Reader entfernt und der Code wird hässlicher.

Verwenden varist wirklich der richtige Weg. Es ist schnell, sauber, strukturiert und hilft dem Compiler und der IDE, ihre Arbeit richtig zu machen.

Wichtig : Diese Antwort bezieht sich aufParentvs.Childim lokalen Bereich einer Methode. Das Problem vonParentvs.Childist für Rückgabetypen, Argumente und Klassenfelder sehr unterschiedlich.

Vorausgesetzt parentType foo = new childType1();, Code kann nur übergeordnete Methoden verwenden foo, kann jedoch in fooeinem Verweis auf jedes Objekt parentgespeichert werden, dessen Typ von --nicht nur Instanzen von - abgeleitet ist childType1. Wenn die neue childType1Instanz die einzige Instanz ist, auf die foojemals Bezug genommen wird, ist es möglicherweise besser, den fooTyp als zu deklarieren childType1. Auf der anderen Seite können fooVerweise auf andere Typen erforderlich sein , wenn dies deklariert parentTypewird, um dies zu ermöglichen.

Ich schlage vor, mit

Child x = new Child();

anstatt

Parent x = new Child();

Letzterer verliert Informationen, Ersterer nicht.

Sie können alles mit dem ersteren machen, was Sie mit dem letzteren machen können, aber nicht umgekehrt.

Um den Zeiger weiter zu erläutern, haben Sie mehrere Vererbungsebenen.

Base-> DerivedL1->DerivedL2

Und Sie möchten das Ergebnis new DerivedL2()einer Variablen initialisieren . Bei Verwendung eines Basistyps haben Sie die Möglichkeit, Baseoder zu verwenden DerivedL1.

Sie können verwenden

Base x = new DerivedL2();

oder

DerivedL1 x = new DerivedL2();

Ich sehe keinen logischen Weg, das eine dem anderen vorzuziehen.

Wenn du benutzt

DerivedL2 x = new DerivedL2();

es gibt nichts zu streiten.

Ich würde vorschlagen, Variablen immer als den spezifischsten Typ zurückzugeben oder zu speichern, aber Parameter als den allgemeinsten Typ zu akzeptieren.

Z.B

<K, V> LinkedHashMap<K, V> keyValuePairsToMap(List<K> keys, List<V> values) {
   //...
}

Die Parameter sind List<T>sehr allgemein gehalten. ArrayList<T>, LinkedList<T>und andere könnten alle von dieser Methode akzeptiert werden.

Wichtig ist, dass der Rückgabetyp LinkedHashMap<K, V>nicht ist Map<K, V>. Wenn jemand das Ergebnis dieser Methode einem zuweisen möchte Map<K, V>, kann er das tun. Es wird deutlich, dass dieses Ergebnis mehr als nur eine Karte ist, sondern eine Karte mit einer definierten Reihenfolge.

Angenommen, diese Methode wird zurückgegeben Map<K, V>. Wenn der Anrufer eine wünschte LinkedHashMap<K, V>, müsste er eine Typprüfung, Besetzung und Fehlerbehandlung durchführen, was wirklich umständlich ist.