Por que no Java é necessário especificar o tipo de variável?

Isso é uma caracteristica da linguagem. Comparar o Python com Java é bem complicado mesmo.

O Java é extremamente tipado, mas nas ultimas versões, estão fazendo algumas mudanças nele, onde ao invés de declarar o tipo, vc declara só o var.

Exemplo:

var numero = 1
  var teste = 90
  var oi = "Alguma Coisa"

Java é uma linguagem de programação com tipagem estática, ou seja o tipo de dado da variável é definido em tempo de compilação, por isso precisamos declarar o tipo de dado antes do identificador da variável ou atributo.

A partir do Java 10 foi introduzido a palavra reservada var que permite a tipagem dinâmica, mas apenas em variáveis locais.

Na verdade o Java continua tendo tipagem estática mesmo usando o var.

Acontece que agora o compilador consegue inferir o tipo com base no valor sendo atribuido à variável, por exemplo:

var nome = "João"; // é uma String
var idade = 21; // é um int
var linguagens = List.of("Java", "Python"); // é uma List<String>
var x; // Aqui da erro de compilação

A quarta linha do código acima causa erro de compilação, pois o compilador não pode inferir seu tipo sem um inicializador.

E apesar de parecer que é ruim ter que colocar o tipo da variável, isso é um recurso precioso na minha opinião.

Com isso vc pode saber o tipo da variável só de ler o código e já tem como garantia que se ela é do tipo String ela sempre será do tipo String.

Isso é tão bom que o TypeScript tornou-se bastante popular. Basicamente o TS adiciona tipos ao JavaScript.

E até mesmo o Python 3 trouxe um módulo que permite declarar os tipos, depois procure por *Type Hints". Achei este artigo que fala um pouco sobre essa funcionalidade no Python.

A questão vai muito além de “digitar menos”.

Tanto a tipagem estática (Java), quanto a dinâmica (Python) possuem vantagens e desvantagens.

Não vou falar tudo pra não ficar muito grande, mas 2 links interessantes são esse e esse (leia).

Só pra citar um exemplo, vamos supor que eu tenha esse código em Java:

int x = 1;

// muitas linhas depois 
x = "abc"; // erro, não compila!

Eu tentei atribuir uma string em uma variável do tipo int, por isso o código nem compila.

Em Python não daria erro:

x = 1 

# muitas linhas depois
x = "abc" # ok, funciona

Isso é bom ou ruim? Depende.

Se x for usado depois e espera-se um número ali, então é bom que eu seja avisado de que estou tentando reutilizar indevidamente a variável.

Se x não é mais usado como número dali pra frente e eu só estou “reaproveitando” o nome, não seria um grande problema (talvez só o nome devesse ser melhor).

E se fosse assim em Python:

lucro_liquido = calcula()

# muitas linhas depois
print(lucroliquido)

Eu errei o nome da variável na hora de imprimir, mas só perceberei isso quando o código estiver rodando (ou seja, somente em runtime isso será detectado).

Em Java um erro desse seria detectado pelo compilador, antes do código rodar.

94876582-5813-4739-B2E7-623D86678A95.jpeg640×783 333 KB

Isso é só pra ficar em 2 exemplos, sugiro que leia os links indicados acima para ver mais diferenças - e entenda que no fim, não existe um que é “melhor” que outro, o que temos são características diferentes e consequências de cada abordagem, com as quais você tem que conviver ao escolher uma delas.

Em computação, tudo é trade-off (ou, em bom português: “cada escolha, uma renúncia”).

Momento “ignorância”

Se me permite ser um pouco grosseiro: se a sua escolha por uma delas foi somente para “digitar menos”, então você está no caminho errado. Seu dedo não vai cair se você digitar os tipos das variáveis.

Entenda as diferenças entre as formas de tipagem, os seus pontos fortes e fracos, e aprenda a tirar proveito de ambos.

“Digitar menos” não é necessariamente bom. Muitas vezes, forçar a barra para encurtar o código pode acabar deixando-o mais ilegível e complicado de entender.

Escrever código desnecessário é ruim, mas se todo o código necessário, escrito de forma clara e correta, ficar “maior”, não é um problema em si.

Por fim, vale lembrar que a implementação de referência do Python é escrita em C (veja aqui o código fonte), então foi graças a uma linguagem que obriga a declarar os tipos que você pode se dar ao luxo de não declará-los

Realmente não faz cair o dedo, mas faz perder tempo/dinheiro. Por isso mesmo muito tarde, uma linguagem extremamente burocrática como o Java adotou pelo menos inferir o tipo através do valor.

Muita gente afirma isso, principalmente pela verbosidade do Java, mas ninguém consegue quantificar o quanto é essa perda de tempo/dinheiro.

Francamente, acredito que não é isso que faz um projeto perder tempo/dinheiro.

Porque no Java você precisa saber o que está fazendo, no python você não precisa.

Não só isso, mas é uma parcela. Ficar toda hora usando métodos para por exemplo fazer simples comparações diretamente entre datas, é bem mais trabalhoso do que usar simplesmente operadores.

O java é uma linguagem compilada, mesmo rodando sobre uma máquina virtual. Isso a torna portável (pelo bytecode) e rápida. Uma linguagem compilada precisa de tipos em variáveis para que o compilador possa saber alocar a memória necessária para aquele tipo de variável.

Então, sabia que Python na verdade é compilada? E que também roda em uma máquina virtual?

Mas vamos por partes…

Essa história de compilado vs interpretado é um pouco mais complicada do que “linguagem X é isso, linguagem Y é aquilo”.

Uma linguagem de programação nada mais é do que uma especificação: um documento (sim, um texto) que descreve como ela é.

As implementações desta especificação podem ser feitas na forma de um compilador ou interpretador. E só porque uma ou mais implementações são de um jeito, não impede que haja outras de outro jeito.

Só para citar alguns exemplos, existe interpretador de C e existem linguagens com tipagem não-estática que rodam na JVM (como Groovy, que possui optional typing, sem contar que também é possível rodar Python na JVM).

Voltando ao Python, sua implementação de referência (a que vem quando você instala o Python, e portanto a mais amplamente usada) é o CPython, que compila os arquivos .py e gera arquivos de bytecode .pyc ou .pyo (pode procurar, eles ficam na pasta __pycache__, geralmente criada na mesma pasta em que ficam os arquivos .py). E em seguida o mesmo CPython executa esses bytecodes em sua VM (ou seja, ele é tanto o compilador quanto a máquina virtual).

O fato de fazer as duas coisas de uma vez (e não em passos separados, como é no Java) pode dar a impressão de que não é compilado. Mas é sim.

Enfim, tudo isso é pra dizer que o estilo de tipagem de uma linguagem não está diretamente ligado ao fato desta “ser” compilada ou interpretada. São características distintas, não há relação de causa e efeito entre elas (senão o interpretador de C que citei acima seria impossível de ser feito).

Referências:

• https://stackoverflow.com/a/6889798
• https://pt.stackoverflow.com/q/207379/112052
• https://pt.stackoverflow.com/q/77070/112052

Eu não escrevo código python, mas escrevo em JavaScript, php e java. Na resposta acima, estou citando o porquê é necessário especificar o tipo de variável para “java” (não para JavaScript ou php). Agora se existe interpretador de C ou em java é possível fazer atribuições sem especificar o tipo é algo fora a razão da resposta porque sabemos que C não foi desenhado para ser interpretado, ou conhece algum SO que roda sobre um interpretador?

É necessário porque a linguagem foi especificada assim, esse é o único motivo. O compilador e a JVM nada tem a ver com o estilo de tipagem, por isso citei outras linguagens que também rodam na JVM e tem estilos de tipagem diferente do Java. E por isso citei que é possível ter compiladores e interpretadores da mesma linguagem, pois isso não tem relação direta com o estilo de tipagem (se um vai ser mais útil do que outro, aí já é outra questão).

Não estou discordando de você, mas cuidado com

O compilador e a JVM nada tem a ver com o estilo de tipagem

Pode estar enredando as coisas

Só pra citar alguns exemplos: em Kotlin e Groovy você não precisa declarar o tipo das variáveis, e ambas rodam na JVM. Se a JVM fosse tão dependente do tipo, elas não rodariam - e também não seria possível rodar Python, JavaScript, e tantas outras linguagens (tanto com tipagem estática quanto dinâmina), que também rodam na JVM.

Por que no Java é necessário especificar o tipo de variável?

Primeiramente, porque os idealizadores do projeto quiseram assim.

Segundo, porque java foi criado em 1995 tendo como principal influência o C++. Além disso, o conceito de linguagem com tipagem dinâmica não era tão popular entre os programadores da época. O que acabo percebendo, é que esse conceito se tornou mais popular com as novas versões do Python, javascript, entre outras.

Por isso gostaria de saber por que precisa colocar o tipo no java, pois acho que apenas aumenta e deixa o código mais cansativo

Se você acha isso vai de Python, ou se não, vai de java. Se isso não faz diferença para você, escolhe a linguagem que você achar melhor. O que não falta são linguagens de programação, uma para cada gosto. Tem uns que possuem mais facilidade com Python e mais dificuldade com java, etc.

Python e java foram criadas por pessoas diferentes e com objetivos diferentes, tentar comparar isso não faz muito sentido. E como você pode ver pelos comentários acima, existem alguns prós e contras na utilização de tipagem dinâmica vs tipagem estática e não, o que é ruim ou bom. Saber programar também é saber utilizar da melhor forma possível os recursos da tecnologia que você está usando.

Porque isso vai te evitar um bocado de tempo em não ter que ficar voltando e ter que saber qual foi a ultima atribuição da variavel uma vez que seria mutante.

O que é mais plausível pra você, atribuir um tipo de variável e saber com o que esta lidando ou variavel mutante que força você a ter que ficar dando “find” pra saber onde esta’, como esta’ e então fazer a coisa certa, isso sim pode ser perda de tempo, dependendo das coisas.

Até agora não ví real vantagem na “var” introduzida no Java, não gosto e não uso.

E tambem Python mesmo em JVM terá uma performance pior que em Java, isso deve se a ter que controlar internamente a mutação da variavel.

Idem

É que em alguns contextos a declaração dos tipos é redundante e a verbosidade podia tornar dificil de se ler.

Considerem a linha a seguir.

UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken("user", "pass");

Por que eu tenho que dizer que authToken é do tipo UsernameAndPasswordAuthenticationToken se logo em seguida eu estou instanciando um UsernameAndPasswordAuthenticationToken?

O compilador deveria saber que se trata de um UsernameAndPasswordAuthenticationToken só pela expressão que vem após o = e agora ele sabe!

Vejam como fica melhor:

var authToken = new UsernamePasswordAuthenticationToken("user", "pass");

É muito mais fácil de se ler assim e pra mim faz toda a diferença, eu gostei muito quando saiu!

Mas @j-menezes e @staroski, vcs não vêm vantagem e não usariam, tudo bem, mas se tivessem que trabalhar num código onde o var é usado, vcs acham que atrapalharia vcs de alguma forma? Acham que seria mais díficil de ler e entender? Em outras palavras: Não ajuda, mas acham que atrapalha?

Tudo isso é muito relativo, Eu prefiro dar manutenção sem o var, não gosto.
E se tiver que mexer no codigo vou tirar todos.

Mas em uma linguagem é melhor sobrar opções que faltar.

Assim quem gosta usa, mas não vejo vantagem.

Pegando seu exemplo
UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken("user", "pass");

Prefiro ter classes com as variaveis definidas para uso logo no inicio
UsernamePasswordAuthenticationToken authToken = null;

e depois no processamento
authToken = new UsernamePasswordAuthenticationToken("user", "pass");

Pra mim tá ótimo assim.

Pra mim não atrapalha mas também não ajuda.

Pra mim há outros aspectos em um projeto que são os responsáveis por atrapalhar a produtividade, não é a sintaxe e semântica da linguagem utilizada.

Kkk eu tbm. Alguém vai usar? Só o tempo dirá… Os “véio” aqui, me incluindo nessa, vão continuar com os tipos.

Entendi, gente, valeu.

Mas nossa, como nossas preferencias diferem, @j-menezes. Eu odeio quando vejo coisas como vc exemplificou:

UsernamePasswordAuthenticationToken authToken = null;
/* algumas linhas depois */
authToken = new UsernamePasswordAuthenticationToken("user", "pass");

Eu gosto de instanciar no escopo mais fechado possível e saio botando final em tudo que é possível, pois me dá mais segurança pra trabalhar no código:

final UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken("user", "pass");

Isso nos meus projetos pessoais, porque ainda não trabalho profissionalmente com Java.

Minha maior queixa trabalhando com PHP é não poder contar com um let ou um var, um const ou um final.

É questão de evoluir ou parar no tempo. Pelo menos nesse ponto de inferir o tipo baseado no valor o Java evoluiu. É muito mais ágil enquanto estamos escrevendo, que é a maior parte do tempo gasto. Por ter ganhado isso muito tarde complica adoção e cria resistência por quem está viciado na forma clássica do Java. Fora a mistura, onde o pessoal mais fora da caixa do Java usa o var e o pessoal mais velho fica colocando diretamente o tipo.

var, não é evolução do Java coisa nenhuma tão pouco variavel dinamica ou mutavel seja algo moderno.
Programei assim em DBase/Clipper por bom tempo em sistemas comerciais, que já tinham variaveis dinamicas e eram chamadas de linguagens de 4a geração.

O que determina a velocidade de construção do programa não são usar ou não “var(s)”, isso tem a ver com o conhecimento em sí, logica de programação, algoritimos, experiencia,
enfim…

Vish, mas variável dinâmica (no sentido de o tipo poder mudar durante a execução do programa), se um dia tiver, seria uma coisa péssima no Java.

Mas por que vc citou isso? É que uma das principais características do Java é a tipagem forte e estática, isso não vai mudar nunca eu acho.

Se não fosse evolução, nao teriam decidido introduzir o var, pra inferir o tipo através do valor. Nao estou falando de variavel dinamica. E olha que isso só entrou a partir do Java 10.

Evolução é a modularização, inline, não var nem record

Isso na visão de quem acha isso. Pra quem mantem a linguagem não.

Sim, mas é que antes estava me referindo a python.

E sobre as switch expressions e o instanceof pattern matching?

Isso são coisinhas, que não quebram a essencia da linguagem em si, mas, precisa ver se compensa pegar um onibus ou um carro pra ir daqui até na esquina.

Isso multiplicado pela quantidade de variáveis em um projeto.

Isso nunca me atrapalhou, pra mim não fede nem cheira. Tem coisas mais importantes para me preocupar.
É que não sofro de neurose como parece ser seu caso, mas se Eu for contar aqui quantos
switch e instanceof tem no programa, é uma quantidade ridicula.

No meu caso, eu gasto muito mais tempo lendo e entendendo código alheio. Mas cada caso é um caso, e nem acho que é o var que vai ser a grande solução (pode ajudar, mas acho que o peso disso será bem pequeno - no meu caso mudaria bem pouco).

O pior mesmo é quando preciso rodar npm install, isso sim me faz perder muito tempo…

Isso se chama costume, entendo isso. Assim como muitos não percebem o quanto o Java é burocrático pra comparar diretamente datas e números decimais com precisão, tendo que usar métodos ao invés de simples operadores como na maioria das linguagens.

Escuta, ninguem aqui tem culpa de voce ser ruim de Java ou preguiçoso.
Escrevo tudo isso em Java com os olhos fechados e rapidamente.

Eu duvidei quando vc disse que “a maioria das linguagens consegue comparar datas só com operadores simples”, aí eu fui ver aqui, mas não sei se é bem assim.

De qualquer forma a API de datas é super robusta e permite fazer bem mais que só dizer se uma data é maior, menor ou igual a outra.

Vc consegue somar ou subtrair qualquer unidade de tempo, consegue converter as time zones, ela leva em consideração as diversas Locales, é incrivel!

Sei que você não respondeu pra mim esse topico, mas somente pra reforçar já tive serios problemas em outras linguagens nessa questão,

Digo comparações simples como >=, que é o mais corriqueiro.

O problema que na hora do vamos ver, somente isso nem sempre basta e nem faz tanta diferença assim.
d.compareTo(d2) >= 0 // aproveita e conta quantas letrinhas a mais foram usadas na digitação e não esqueça de antes deitar no divã do seu psicologo ou psiquiatra.

Independente do que outras linguagens fazem, isso é consequência de terem decidido não adicionar sobrecarga de operadores no Java, então a culpa é do James Gosling:

“I left out operator overloading as a fairly personal choice because I had seen too many people abuse it in C++.”

Ou seja: “Deixei de fora a sobrecarga de operadores como uma escolha bem pessoal, porque já vi muita gente abusar deste recurso em C++”.

E como tudo em computação, isso não é necessariamente “bom” ou “ruim”, é simplesmente algo que tem os seus prós e contras (ver também aqui).

trade-offs-trade-offs-everywhere.jpg914×508 182 KB

E eu não acho que isso é o fator mais determinante para o sucesso de uma linguagem ou de qualquer projeto que a utilize. Uma equipe mal preparada, por exemplo, fará um sistema ruim independente da linguagem. Uma empresa com má gestão, burocracia e sem diretrizes definidas sempre perderá tempo e dinheiro, e não é a escolha da linguagem de programação que a salvará…

Até porque, se formos cínicos/ranzinzas o suficiente, todas as linguagens serão ruins.

d >= d2 é bem mais simples, apenas fatos.

Talvez pra sua cabeça
d.compareTo(d2) >= 0
seja um bicho de 7 cabeças, verdade, voce tem que ficar longe mesmo do Java, sua mente não suporta.

Não é um bicho de 7 cabeças, mas é mais burocrático do que usar o operador da linguagem.

E assim
d.ge(d2)
Continua burocratico ?
basta fazer a Classe com o metodo, já sei, tem que escrever, e escrever dá trabalho ne’!
Mas veja as vantagens, dá pra colocar uma serie de outros controles para uso de Datas.

Sim continua usando método, a diferença que agora ficou ilegível.

E agora preguicinha ?
d.greaterOrEqual(d2) // Tá legivel ?

Dá no mesmo, chamando método pra fazer uma simples comparação.

Não sei que IDE voce usa, mas pelo visto tá programando na mão num editorzinho de texto e ainda se diz da nova era dos programadores, faça-me rir.

Aqui no NetBeans somente chamo o nome da variavel e aparece uma lista com todos os metodos, seleciono dou um enter e pronto, pimba, opa ! nem precisei digitar, caracas !!

E o caboclo contando letrinha.

É muito mais ágil usar operador da linguagem do que gastar tempo selecionado método pra determinada operação. Fora a poluição que fica no Java com tantas chamadas de métodos para fazer operações simples.

Se tá mau mesmo heim, gastar tempo digitando o ponto decimal depois da variavel ou colocando o apenas a primeira letra do metodo, caramba !!!, pensei que gastar tempo fosse ter que ficar com um facao cortando cana o dia inteiro no sol e na chuva pra ganhar 1 salario minimo, ou na fila do postão esperando pelo remedio e na hora do atendimento a atendente diz, não tem esse remedio.

“Você coa mosquito e engole camelo.”

Esse tempo e poluição multiplicados pela quantidade de comparações feitas no sistema. Nas linguagens mais evoluídas basta usar o operador da linguagem para esses casos mais corriqueiros.

Essa foi ridícula.
Tô mais é preocupado com qualidade de software, segurança, manutençao, numero de apis e ferramentas disponíveis e não com letrinhas.

De vez em quando a dona fifi ataca, alias de vez e sempre.

O mais importante é ganhar dinheiro rápido.

Fico imaginando do que voce vive.
Sei bem que vender droga dá dinheiro.

Ok, obrigado pela ajuda de todos, entendi agora

Desculpa poluir seu tópico com coisas que não tem nada a ver.
Se algum moderador desejar apagar minhas postagens e meus excessos fica a vontade.