Warum ist die Instanzerstellung so, wie sie ist?

Ich habe C # in den letzten sechs Monaten oder so gelernt und beschäftige mich jetzt mit Java. Meine Frage bezieht sich auf die Instanzerstellung (in beiden Sprachen) und mehr auf: Ich frage mich, warum sie das so gemacht haben. Nehmen Sie dieses Beispiel

Person Bob = new Person();

Gibt es einen Grund, warum das Objekt zweimal angegeben wird? Würde es jemals eine geben something_else Bob = new Person()?

Es würde scheinen, wenn ich mich an die Konvention halten würde, wäre es eher so:

int XIsAnInt;
Person BobIsAPerson;

Oder vielleicht einer von diesen:

Person() Bob;
new Person Bob;
new Person() Bob;
Bob = new Person();

Ich denke, ich bin neugierig, ob es eine bessere Antwort gibt als "so wird es gemacht".

Wäre da jemals eine etwas_else Bob = neue Person ()?

Ja, wegen der Vererbung. Wenn:

public class StackExchangeMember : Person {}

Dann:

Person bob = new StackExchangeMember();
Person sam = new Person();

Bob ist auch eine Person und will nicht anders behandelt werden als jeder andere.

Außerdem könnten wir Bob mit Superkräften ausstatten:

public interface IModerator { }
public class StackOverFlowModerator : StackExchangeMember, IModerator {}

IModerator bob = new StackOverFlowModerator();

Und so wird er es nicht ertragen, anders behandelt zu werden als jeder andere Moderator. Und er schleicht gerne im Forum herum, um alle in der Reihe zu halten, während er inkognito ist:

StackExchangeMember bob = new StackOverFlowModerator();

Wenn er dann ein schlechtes erstes Poster findet, wirft er seinen Umhang der Unsichtbarkeit ab und stürzt sich.

((StackOverFlowModerator) bob).Smite(sam);

Und danach kann er alles Unschuldige und so weiter tun:

((Person) bob).ImNotMeanIWasJustInstantiatedThatWay();

Lassen Sie uns Ihre erste Codezeile nehmen und untersuchen.

Person Bob = new Person();

Die erste Personist eine Typspezifikation. In C # können wir darauf verzichten, indem wir einfach sagen

var Bob = new Person();

und der Compiler ableiten , die Art des Variablen Bob vom Konstruktoraufruf Person().

Aber vielleicht möchten Sie so etwas schreiben:

IPerson Bob = new Person();

Wenn Sie nicht den gesamten API-Vertrag von Person erfüllen, sondern nur den von der Schnittstelle angegebenen Vertrag IPerson.

1. Diese Syntax ist so ziemlich ein Erbe von C ++, das im Übrigen beides enthält:

   Person Bob;

   und

   Person *bob = new Bob();

   Der erste, um ein Objekt innerhalb des aktuellen Bereichs zu erstellen, der zweite, um einen Zeiger auf ein dynamisches Objekt zu erstellen.

2. Das kannst du auf jeden Fall haben something_else Bob = new Person()

   IEnumerable<int> nums = new List<int>(){1,2,3,4}

   Sie machen hier zwei verschiedene Dinge, geben den Typ der lokalen Variablen an numsund sagen, Sie möchten ein neues Objekt vom Typ 'Liste' erstellen und dort ablegen.

3. C # stimmt mit Ihnen überein, da der Typ der Variablen die meiste Zeit mit dem übereinstimmt, was Sie in die Variable eingegeben haben:

   var nums = new List<int>();

4. In einigen Sprachen tun Sie Ihr Bestes, um die Angabe der Variablentypen wie in F # zu vermeiden :

   let list123 = [ 1; 2; 3 ]

Es gibt einen großen Unterschied zwischen int xund Person bob. Ein intist ein intist ein intund es muss immer ein sein intund kann nie etwas anderes als ein sein int. Auch wenn Sie das intbeim Deklarieren ( int x;) nicht initialisieren , wird es dennoch intauf den Standardwert gesetzt.

Wenn Sie jedoch deklarieren Person bob, gibt es eine große Flexibilität, worauf sich der Name bobzu einem bestimmten Zeitpunkt tatsächlich beziehen kann. Es könnte sich auf eine beziehen Person, oder es könnte sich auf eine andere Klasse beziehen, zB Programmerabgeleitet von Person; es könnte sogar sein null, sich überhaupt auf kein Objekt zu beziehen.

Beispielsweise:

  Person bob   = null;
  Person carol = new Person();
  Person ted   = new Programmer();
  Person alice = personFactory.functionThatReturnsSomeKindOfPersonOrNull();

Die Sprachdesigner hätten sicherlich eine alternative Syntax entwickeln können, die das Gleiche bewirkt hätte wie Person carol = new Person()bei weniger Symbolen, aber sie hätten es dennoch zulassen müssen Person carol = new Person() (oder eine seltsame Regel festlegen müssen, die dieses bestimmte der vier obigen Beispiele als illegal erklärt). Es ging ihnen mehr darum, die Sprache "einfach" zu halten, als extrem präzisen Code zu schreiben. Das mag ihre Entscheidung beeinflusst haben, die kürzere alternative Syntax nicht bereitzustellen, aber es war auf jeden Fall nicht notwendig und sie haben es nicht bereitgestellt.

Die beiden Deklarationen können unterschiedlich sein, sind jedoch häufig gleich. Ein allgemein empfohlenes Muster in Java sieht folgendermaßen aus:

List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();

Diese Variablen listundmap werden mithilfe der Schnittstellen deklariert, Listund Mapwährend der Code bestimmte Implementierungen instanziiert. Auf diese Weise hängt der Rest des Codes nur von den Schnittstellen ab, und es ist einfach, verschiedene Implementierungsklassen für die Instanziierung auszuwählen TreeMap, da der Rest des Codes nicht von einem Teil der HashMapAPI abhängen kann , der sich außerhalb der MapSchnittstelle befindet.

Ein weiteres Beispiel, bei dem sich die beiden Typen unterscheiden, ist eine Factory-Methode, die eine bestimmte Unterklasse zum Instanziieren auswählt und sie dann als Basistyp zurückgibt, sodass der Aufrufer die Implementierungsdetails nicht kennen muss, z.

Typinferenz kann die Quellcode-Redundanz beheben. ZB in Java

List<String> listOne = Collections.emptyList();

wird dank der Typinferenz und der Deklaration die richtige Art von Liste erstellen

static <T> List<T> emptyList(); 

In einigen Sprachen geht die Typinferenz weiter, z. B. in C ++

auto p = new Person();

Mit den Worten des Laien:

• Das Trennen der Deklaration von der Instanziierung hilft zu entkoppeln, wer die Objekte verwendet und wer sie erstellt
• Wenn Sie dies tun, wird der Polyporphismus aktiviert, da, solange der instanziierte Typ ein Subtyp des Deklarationstyps ist, der gesamte Code, der die Variable verwendet, funktioniert
• In stark typisierten Sprachen müssen Sie eine Variable deklarieren, die ihren Typ angibt, indem var = new Process()Sie einfach nicht zuerst die Variable deklarieren.

Es geht auch um die Kontrolle darüber, was passiert. Wenn die Deklaration eines Objekts / einer Variablen automatisch einen Konstruktor aufruft, z. B. if

Person somePerson;

war automatisch das gleiche wie

Person somePerson = new Person(blah, blah..);

Dann könnten Sie (zum Beispiel) niemals statische Factory-Methoden verwenden, um Objekte zu instanziieren, anstatt Standardkonstruktoren zu verwenden. Das heißt, es gibt Zeiten, in denen Sie keinen Konstruktor für eine neue Objektinstanz aufrufen möchten.

Dieses Beispiel ist in erklärt Joshua Bloch ‚s Effective Java (Punkt 1 ironisch genug!)