Garantindo compatibilidade em Java

1. Histórico das versões do Java

A história do Java começa em 1991, quando um grupo de programadores da Sun decidiu criar uma linguagem para pequenos dispositivos: controles remotos de TV, cafeteiras, torradeiras, cartões bancários e assim por diante.

Os fabricantes desses dispositivos usavam processadores muito diferentes para controlar seus produtos, por isso tornou-se muito importante estar vinculado à arquitetura de um determinado processador ou sistema operacional.

Os criadores do Java decidiram dividir o problema em duas partes: seus programas seriam compilados não no código de máquina de um processador específico, mas em um código intermediário especial. Por sua vez, esse código intermediário seria executado por um programa especial chamado máquina virtual .

A maioria dos programadores se refere a um computador como uma máquina.

A primeira versão do Java foi lançada em 1996. Desde então, o Java iniciou sua marcha triunfante pelo mundo, o que, por sua vez, estimulou a evolução e o crescimento da própria linguagem. Hoje, milhões de bibliotecas e bilhões de linhas de código são escritas em Java, e novas versões de Java são lançadas a cada 6 meses:

Embora as versões do Java fossem lançadas regularmente, nem todas carregavam o mesmo significado para os programadores: o Java evoluiu aos trancos e barrancos.

2. Java 2

O primeiro grande avanço ocorreu com o lançamento do JDK 1.2. Ele tinha tantas inovações que os criadores do Java o renomearam como Java 2 Platform Standard Edition ou J2SE 1.2 para abreviar.

As principais inovações foram:

• strictfppalavra-chave
• A biblioteca Swing para trabalhar com gráficos
• O compilador JIT, que acelerou a execução de programas Java
• Um enorme conjunto de coleções
• Suporte completo a Unicode: japonês, chinês e coreano.

Hoje, essas inovações não parecem tão grandes, mas todo grande projeto nasce de um pequeno. Java não seria tão popular hoje se um pequeno grupo de programadores não tivesse melhorado a linguagem 20 anos atrás.

3.Java5

O JDK 1.5 foi lançado em setembro de 2004. Ele também introduziu muitas inovações, então não poderia deixar de merecer um novo nome: em vez das versões 1.5, 1.6 e 1.7, eles decidiram usar 5.0, 6.0 e 7.0. Portanto, o nome completo do JDK 1.5 era Java 2 Standard Edition 5.0

Esta atualização incluiu coisas sem as quais o desenvolvimento da linguagem não teria sido possível.

Anotações . Metade dos principais frameworks modernos são construídos em anotações, desde Spring e Hibernate até JUnit.

Genéricos . Os genéricos levaram o poder das coleções (e muito mais) a novos patamares. O código ficou mais simples, compacto e seguro.

Autoboxing/unboxing é a conversão automática entre tipos primitivos e seus tipos wrapper. Isso tornou muito mais fácil escrever e ler o código e tornou as coleções ainda mais populares.

O foreachloop agora representa pelo menos metade de todos os loops que os programadores escrevem. E, claro, é indispensável quando se trabalha com coleções.

O enum é outro novo recurso interessante. Ele permite que muitas coisas sejam lindamente simplificadas.

Estas não são todas as inovações: centenas de novas classes foram adicionadas. O importante é que eles foram as inovações certas e deram outro impulso poderoso à popularidade do Java.

4.Java6

O Java 6 é lembrado por um grande número de pequenas melhorias e pelo abandono do número 2 no nome: não era mais "Java 2 Standard Edition 6.0", mas simplesmente "Java Standard Edition 6.0".

Aqui estão algumas das inovações interessantes:

A API Java Compiler tornou possível chamar o compilador Java diretamente do código. Isso significa que seu programa agora pode gerar texto representando o código da classe, compilá-lo chamando métodos da API Java Compiler e imediatamente começar a chamar os métodos da classe compilada. Existem áreas inteiras de desenvolvimento em que essa habilidade simplifica muito a vida.

Tornou-se possível executar JavaScript diretamente dentro de um programa Java. Esse recurso apareceu porque o JavaSE 6 incluía o mecanismo Rhino JavaScript.

5. Java 7

O Java 7 foi lançado em julho de 2011. Deveria haver muitas melhorias nele, mas os programadores conseguiram adicionar apenas uma pequena parte do que foi planejado. Em particular, eles adicionaram coisas como:

Uma nova biblioteca para trabalhar com entrada e saída de dados. Conhecida como API New Input Output , ela está localizada no java.niopacote.

A inferência de tipo automática do compilador Java em tempo de compilação permite que os programadores escrevam menos código. O compilador ficou mais inteligente e isso foi apenas o começo.

A instrução switch ganhou a capacidade de usar strings como valores case.

O gerenciamento automático de recursos também melhorou significativamente: com a try-with-resourcesconstrução, um programa Java pode fechar fluxos de dados para você quando eles não forem mais necessários.

Houve muitas outras mudanças, mas elas não são tão importantes em nosso estágio atual de aprendizado de Java.

6.Java8

O Java 8 foi lançado em março de 2014 e foi a atualização recente mais forte do Java.

Acima de tudo, os programadores se lembram dele por sua adição de expressões lambda e interfaces funcionais (a @FunctionalInterfaceanotação). Vamos examiná-los no nível 21. Seu código nunca mais será o mesmo.

Streams também foram adicionados para coleções, o que, em combinação com expressões lambda, tornou possível escrever código de forma muito mais compacta. Embora nem sempre muito mais legível.

7. Java 9

O Java 9 foi lançado em setembro de 2017. Desde então, os criadores do Java decidiram lançar novas versões com mais frequência — a cada seis meses. Eles provavelmente ficaram impressionados com a abordagem adotada pelos desenvolvedores do navegador Google Chrome.

O lançamento do Java 9 se concentrou mais nas partes internas da máquina Java. A coisa mais significativa que trouxe para os programadores comuns foi a capacidade de dividir um programa em módulos. Isso é muito conveniente quando você tem dezenas de milhares de classes ou quando seu código descarrega plug-ins dinamicamente.

Mas provavelmente será de pouca utilidade para nós no futuro próximo.

8. Java 11

Seis meses após o lançamento do Java 9, o Java 10 foi lançado e outros seis meses depois, o Java 11 foi lançado.

Muitas pequenas melhorias foram feitas durante esse período, mas você provavelmente se lembrará de apenas duas:

Ele adicionou suporte para Unicode 10. Agora você pode usar emojis em seus programas Java. Você pode trabalhar com eles da mesma forma que trabalha com o tipo booleano:

A inferência de tipos foi aprimorada e a varpalavra-chave , da qual você certamente gostará, apareceu.

Agora você pode escrever o seguinte:

var str = "Hello";

E o compilador converte isso para:

String str = "Hello";

Mas também houve algumas perdas. Os criadores de Java descartaram bibliotecas como JavaFX, Java EE e CORBA do JDK 11.

9. Importância da compatibilidade

Quando uma nova versão é lançada, os programadores geralmente querem começar do zero. Afinal, quem quer consertar um monte de bugs antigos quando tem certeza absoluta de como o código deveria ter sido escrito desde o início?

Mas a história não apóia tal abordagem. Cada vez que os programadores lançam uma nova versão de um programa, 90% de seus usuários estão usando uma versão antiga. Eles podem usar ou ignorar os novos recursos do programa, mas o que os usuários odeiam é quando algo que costumava funcionar bem para de funcionar.

Muitos grandes produtos morreram quando os programadores lançaram novas versões que não eram compatíveis. Ou simplesmente quando fizeram grandes mudanças. Por exemplo, a ideia de abandonar o botão Iniciar no Windows 8 não agradou aos usuários. O lançamento do Windows 10 trouxe de volta metade do que foi removido no Windows 8.

Além do mais, o Windows permite que você execute programas escritos há 20 anos para o Windows 95 ou mesmo escritos há 30 anos para o MS DOS 3.0 — eles funcionarão. Esta é uma das razões pelas quais o Windows continua popular.

E o Java não seria tão popular quanto é se seus desenvolvedores não se preocupassem com a compatibilidade. Sempre que há uma nova versão da máquina Java, uma nova versão do SDK ou grandes mudanças nas classes, todo o código Java escrito desde janeiro de 1996 continua funcionando.

Isso geralmente é obtido apenas adicionando novos métodos, classes e pacotes, sem remover nada. Essa abordagem tem seus prós e contras.

Por um lado, Java arrasta um monte de bagagem na forma de código antigo, abaixo do ideal e desnecessário. Por outro lado, seu projeto escrito em Java 11 sempre pode usar uma biblioteca escrita em Java 8 que usa bibliotecas escritas em Java 5 e Java 2. Essa miscelânea de código funcionará perfeitamente.

Com a linguagem C++, as bibliotecas compiladas para plataformas de 32 e 64 bits não podem ser utilizadas no mesmo projeto. E você terá uma dor de cabeça enorme se de repente descobrir que o chartipo usado em uma biblioteca usa um byte, enquanto outra usa dois bytes.

10. Obsoleto

Assim, os criadores do Java decidiram não remover nada, mas apenas adicionar novas classes e pacotes. Mas como eles permitem que os programadores saibam que existe uma nova alternativa valiosa para uma solução abaixo do ideal existente?

Para fazer isso, eles criaram a @Deprecatedanotação.

Se algum método ou classe for obsoleto, essa anotação é adicionada ao lado de sua declaração. Isso significa que os programadores são desencorajados a usar o código.

Você ainda pode usar uma classe ou método obsoleto, mas não é recomendado.

E com que frequência as pessoas fazem coisas que não são recomendadas? Quase sempre 🙂

Muitas classes foram descontinuadas por 20 anos — elas foram usadas e ainda estão sendo usadas. As pessoas estão familiarizadas com eles ou são apenas convenientes. Mas existe o risco de serem removidos em algum momento, por isso é melhor não usá-los.

Todos os IDEs modernos, incluindo o IntelliJ IDEA, podem lidar com a @Deprecatedanotação. Os nomes de classes e métodos obsoletos são exibidos usando a formatação tachada . Algo assim:

Date date = new Date();
int day = date.getDay();

As classes obsoletas são muito populares e freqüentemente encontradas no código, então veremos algumas delas em breve.