Por que a criação de instância é do jeito que é?

Eu aprendi C # nos últimos seis meses ou mais e agora estou investigando Java. Minha pergunta é sobre a criação de instâncias (em qualquer idioma, na verdade) e é mais sobre: ​​Eu me pergunto por que eles fizeram dessa maneira. Veja este exemplo

Person Bob = new Person();

Existe um motivo para o objeto ser especificado duas vezes? Alguma vez haveria um something_else Bob = new Person()?

Parece que se eu estivesse seguindo a convenção, seria mais como:

int XIsAnInt;
Person BobIsAPerson;

Ou talvez um destes:

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

Suponho que estou curioso para saber se há uma resposta melhor do que "é assim que se faz".

Alguma vez haveria algo mais = Bob = new Person ()?

Sim, por causa da herança. E se:

public class StackExchangeMember : Person {}

Então:

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

Bob também é uma pessoa e, caramba, ele não quer ser tratado de maneira diferente de qualquer outra pessoa.

Além disso, poderíamos dotar Bob de super poderes:

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

IModerator bob = new StackOverFlowModerator();

E assim, por Deus, ele não aceitará ser tratado de maneira diferente de qualquer outro moderador. E ele gosta de esgueirar-se pelo fórum para manter todos na fila enquanto estão no modo anônimo:

StackExchangeMember bob = new StackOverFlowModerator();

Então, quando ele encontra um pobre primeiro pôster, ele joga sua capa de invisibilidade e ataca.

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

E então ele pode agir de forma inocente e outras coisas depois:

((Person) bob).ImNotMeanIWasJustInstantiatedThatWay();

Vamos pegar sua primeira linha de código e examiná-la.

Person Bob = new Person();

A primeira Personé uma especificação de tipo. Em C #, podemos dispensar isso simplesmente dizendo

var Bob = new Person();

e o compilador inferirá o tipo da variável Bob da chamada do construtor Person().

Mas você pode escrever algo assim:

IPerson Bob = new Person();

Onde você não está cumprindo todo o contrato da API da Pessoa, mas apenas o contrato especificado pela interface IPerson.

1. Essa sintaxe é praticamente um legado do C ++, que, a propósito, possui os dois:

   Person Bob;

   e

   Person *bob = new Bob();

   O primeiro a criar um objeto dentro do escopo atual, o segundo a criar um ponteiro para um objeto dinâmico.

2. Você definitivamente pode ter something_else Bob = new Person()

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

   Você está fazendo duas coisas diferentes aqui, declarando o tipo da variável local numse diz que deseja criar um novo objeto do tipo 'Lista' e colocá-lo lá.

3. O C # concorda com você, porque na maioria das vezes o tipo da variável é idêntico ao que você coloca nela:

   var nums = new List<int>();

4. Em alguns idiomas, você faz o possível para evitar especificar os tipos de variáveis ​​como em F # :

   let list123 = [ 1; 2; 3 ]

Há uma enorme diferença entre int xe Person bob. An inté um inté um inte deve sempre ser um inte nunca pode ser outra coisa senão um int. Mesmo se você não inicializar intquando o declarar ( int x;), ele ainda será intdefinido como o valor padrão.

Quando você declara Person bob, no entanto, há uma grande flexibilidade quanto ao que o nome bobpode realmente se referir a qualquer momento. Pode se referir a a Person, ou pode se referir a alguma outra classe, por exemplo Programmer, derivada de Person; poderia até ser null, referindo-se a nenhum objeto.

Por exemplo:

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

Os designers de linguagem certamente poderiam ter feito uma sintaxe alternativa que teria conseguido a mesma coisa que Person carol = new Person()em menos símbolos, mas eles ainda teriam que permitir Person carol = new Person() (ou fazer alguma regra estranha que tornasse ilegal esse particular dos quatro exemplos acima). Eles estavam mais preocupados em manter a linguagem "simples" do que em escrever códigos extremamente concisos. Isso pode ter influenciado sua decisão de não fornecer a sintaxe alternativa mais curta, mas, em qualquer caso, não era necessário e eles não a forneceram.

As duas declarações podem ser diferentes, mas geralmente são as mesmas. Um padrão comum recomendado em Java é semelhante a:

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

Estas variáveis liste mapsão declaradas usando as interfaces Liste Mapenquanto o código instancia implementações específicas. Dessa forma, o restante do código depende apenas das interfaces e é fácil escolher diferentes classes de implementação para instanciar, como TreeMap, pois o restante do código não pode depender de nenhuma parte da HashMapAPI que esteja fora da Mapinterface.

Outro exemplo em que os dois tipos diferem é em um método de fábrica que escolhe uma subclasse específica para instanciar e depois a retorna como o tipo base, para que o chamador não precise estar ciente dos detalhes da implementação, por exemplo, uma opção de "política".

A inferência de tipo pode corrigir a redundância do código-fonte. Por exemplo, em Java

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

construirá o tipo certo de lista graças à inferência de tipo e à declaração

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

Em algumas linguagens, a inferência de tipo vai além, por exemplo, em C ++

auto p = new Person();

Nas palavras do leigo:

• Separar a declaração da instanciação ajuda a dissociar quem usa os objetos e quem os cria
• Quando você faz isso, o poliporfismo é ativado, pois, desde que o tipo instanciado seja um subtipo do tipo de declaração, todo o código que usa a variável funcionará
• Em linguagens fortemente tipadas, você deve declarar uma variável declarando seu tipo, simplesmente var = new Process()não declarando a variável primeiro.

É também sobre o nível de controle sobre o que está acontecendo. Se a declaração de um objeto / variável chamar automaticamente um construtor, por exemplo, se

Person somePerson;

era automaticamente o mesmo que

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

nunca seria possível usar (por exemplo) métodos estáticos de fábrica para instanciar objetos em vez de construtores padrão, ou seja, haverá momentos em que você não deseja chamar um construtor para uma nova instância de objeto.

Este exemplo é explicado em Joshua Bloch 's Effective Java (ponto 1 ironicamente!)