Pourquoi la création d'instance est-elle la même?

J'ai appris le C # au cours des six derniers mois environ et je suis maintenant plongé dans Java. Ma question concerne la création d'instances (dans l'une ou l'autre langue, vraiment) et c'est plus: je me demande pourquoi ils l'ont fait de cette façon. Prenez cet exemple

Person Bob = new Person();

Y a-t-il une raison pour laquelle l'objet est spécifié deux fois? Y en aurait-il jamais something_else Bob = new Person()?

Il semblerait que si je suivais la convention, ce serait plutôt:

int XIsAnInt;
Person BobIsAPerson;

Ou peut-être l'un d'eux:

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

Je suppose que je suis curieux de savoir s'il y a une meilleure réponse que "c'est juste la façon dont cela se fait".

Y aurait-il jamais quelque chose de Bob = new Person ()?

Oui, à cause de l'héritage. Si:

public class StackExchangeMember : Person {}

Alors:

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

Bob est aussi une personne, et par golly, il ne veut pas être traité différemment des autres.

De plus, nous pourrions doter Bob de super pouvoirs:

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

IModerator bob = new StackOverFlowModerator();

Et donc, par golly, il ne supportera pas d'être traité différemment de tout autre modérateur. Et il aime se faufiler autour du forum pour garder tout le monde en ligne tout en incognito:

StackExchangeMember bob = new StackOverFlowModerator();

Puis quand il trouve une mauvaise première affiche, il jette sa cape d'invisibilité et bondit.

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

Et puis il peut agir tout innocent et tout ça après:

((Person) bob).ImNotMeanIWasJustInstantiatedThatWay();

Prenons votre première ligne de code et examinons-la.

Person Bob = new Person();

Le premier Personest une spécification de type. En C #, on peut se passer de cela en disant simplement

var Bob = new Person();

et le compilateur déduira le type de la variable Bob à partir de l'appel du constructeur Person().

Mais vous voudrez peut-être écrire quelque chose comme ceci:

IPerson Bob = new Person();

Lorsque vous ne remplissez pas l'intégralité du contrat API de Person, mais uniquement le contrat spécifié par l'interface IPerson.

1. Cette syntaxe est à peu près un héritage de C ++, qui, en passant, a les deux:

   Person Bob;

   et

   Person *bob = new Bob();

   Le premier pour créer un objet dans la portée actuelle, le second pour créer un pointeur vers un objet dynamique.

2. Vous pouvez certainement avoir something_else Bob = new Person()

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

   Vous faites deux choses différentes ici, en indiquant le type de la variable locale numset vous dites que vous voulez créer un nouvel objet du type 'List' et le mettre là.

3. C # est en quelque sorte d'accord avec vous, car la plupart du temps le type de la variable est identique à ce que vous y mettez donc:

   var nums = new List<int>();

4. Dans certaines langues, vous faites de votre mieux pour éviter d'indiquer les types de variables comme dans F # :

   let list123 = [ 1; 2; 3 ]

Il y a une énorme différence entre int xet Person bob. Un intest un intest un intet il doit toujours être un intet ne peut jamais être autre chose qu'un int. Même si vous n'initialisez pas le intlorsque vous le déclarez ( int x;), c'est toujours unint ensemble à la valeur par défaut.

Person bobCependant, lorsque vous déclarez , il y a une grande flexibilité quant à ce à quoi le nom bobpourrait réellement faire référence à un moment donné. Elle pourrait faire référence à une Person, ou elle pourrait se référer à une autre classe, par exemple Programmer, dérivée de Person; ça pourrait même êtrenull , ne faisant référence à aucun objet.

Par exemple:

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

Les concepteurs de langage auraient certainement pu créer une syntaxe alternative qui aurait accompli la même chose que Person carol = new Person()dans moins de symboles, mais ils auraient quand même dû autoriser Person carol = new Person()(ou rendre une règle étrange rendant ce particulier des quatre exemples ci-dessus illégal). Ils étaient plus soucieux de garder le langage "simple" que d'écrire du code extrêmement concis. Cela a peut-être influencé leur décision de ne pas fournir la syntaxe alternative la plus courte, mais en tout cas, ce n'était pas nécessaire et ils ne l'ont pas fournie.

Les deux déclarations peuvent être différentes mais sont souvent les mêmes. Un modèle courant et recommandé en Java ressemble à ceci:

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

Ces variables listet mapsont déclarées à l'aide des interfacesList et Maptandis que le code instancie des implémentations spécifiques. De cette façon, le reste du code ne dépend que des interfaces et il est facile de choisir une classe d'implémentation différente à instancier, comme TreeMap, car le reste du code ne peut dépendre d'aucune partie de l' HashMapAPI qui se trouve en dehors de l' Mapinterface.

Un autre exemple où les deux types diffèrent est dans une méthode d'usine qui sélectionne une sous-classe spécifique à instancier, puis la renvoie comme type de base afin que l'appelant n'ait pas besoin d'être au courant des détails d'implémentation, par exemple un choix de "politique".

L'inférence de type peut corriger la redondance du code source. Par exemple en Java

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

va construire le bon type de liste grâce à l'inférence de type et à la déclaration

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

Dans certains langages, l'inférence de type va plus loin, par exemple en C ++

auto p = new Person();

Dans les mots du profane:

• Séparer la déclaration de l'instanciation permet de découpler qui utilise les objets de qui les crée
• Lorsque vous faites cela, le polyporphisme est activé car, tant que le type instancié est un sous-type du type de déclaration, tout le code utilisant la variable fonctionnera
• Dans les langages fortement typés, vous devez déclarer une variable en indiquant son type, en faisant simplement, var = new Process()vous ne déclarez pas la variable en premier.

Il s'agit également du niveau de contrôle sur ce qui se passe. Si la déclaration d'un objet / variable appelle automatiquement un constructeur, par exemple, si

Person somePerson;

était automatiquement le même que

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

alors vous ne pourriez jamais utiliser (par exemple) des méthodes d'usine statiques pour instancier des objets plutôt que des constructeurs par défaut, c'est-à-dire qu'il y a des moments où vous ne voulez pas appeler un constructeur pour une nouvelle instance d'objet.

Cet exemple est expliqué dans Joshua Bloch 's Effective Java (Item 1 assez ironiquement!)