Java O Guia Completo

De Jideon Francisco Marques

Prefácio “Algumas pessoas pensam que são educadas só porque ainda usam palavras e não punhos.” No começo era a palavra. Muito mais tarde, em 23 de maio de 1995, no SunWorld em San Francisco, o chefe do então Science Office da Sun Microsystems, John Gage, e o co-fundador da Netscape, Marc Andreessen, introduziram a nova linguagem de programação Java com sua integração no navegador Netscape. Este evento foi o início da procissão triunfal de uma linguagem que oferece maneiras elegantes de programar em qualquer plataforma e de expressar seus pensamentos de maneira orientada a objetos (OO). As possibilidades da linguagem e suas bibliotecas não são nada novas em si mesmas, mas foram empacotadas tão bem que o Java é agradável e fluido para programação. Java é agora uma das linguagens de programação mais populares do planeta. Em seus 23 capítulos, este livro trata da tecnologia Java com foco intenso na linguagem de programação Java. Tópicos importantes incluem programação orientada a objetos (OOP), design de classes e a estrutura das bibliotecas padrão de Java. Grupo alvo Os capítulos deste livro são projetados para iniciantes na linguagem de programação Java, bem como para usuários avançados. O conhecimento básico de uma linguagem de programação estruturada, como C, Python, JavaScript ou Visual Basic, e o conhecimento de OOP são úteis porque o livro não aborda explicitamente arquiteturas de computador ou o que realmente é programação. Então, se você já programou em alguma linguagem, este livro é para você! O que este livro não é Este livro não deve ser considerado um livro de programação para iniciantes. Se você nunca programou antes e associa a palavra “tradução” principalmente a “interpretação”, você deve começar com um tutorial básico ou seguir um em paralelo. Muitas áreas da vida de um programador industrial são abordadas neste livro em profundidade geral, mas este livro não pode substituir a Java Language Specification (JLS). As tecnologias Java explodiram nos últimos anos, de modo que sua capacidade de gerenciamento inicial deu lugar a uma forte especialização. Hoje, não é possível cobrir tudo em um livro, e certamente não almejaremos esse objetivo com este. Um livro que trata especificamente da interface gráfica do usuário (GUI) JavaFX ou Swing — ambas partes do Java padrão — pode ser tão extenso quanto o livro que você tem em mãos. Outros tópicos especiais incluem análise/design OO, Unified Modeling Language (UML), programação paralela ou distribuída, Enterprise JavaBeans (EJBs), conectividade de banco de dados, mapeamento objeto-relacional, serviços da web, páginas da web dinâmicas e muitos outros tópicos. Para todos esses tópicos, livros específicos podem ser necessários para satisfazer sua curiosidade. Este livro Java treina você na sintaxe da linguagem de programação, no manuseio de importantes bibliotecas padrão, ferramentas de desenvolvimento e ambientes de desenvolvimento, análise e projeto OO, padrões de projeto e convenções de programa. Mas este livro não pode ajudá-lo a impressionar os geeks legais de TI em uma festa. Desculpe.

• Idioma: Português
• Editora: Clube de Autores
• Data de lançamento: 27 de dez. de 2022

Pré-visualização do livro

Java O guia completo

Por Jideon F. Marques

© Copyright 2022 Jideon Marques - Todos os direitos reservados.

O conteúdo deste ebook não pode ser reproduzido, duplicado ou transmitido sem permissão direta por escrito do autor ou do editor.

Sob nenhuma circunstância qualquer culpa ou responsabilidade legal será imputada ao editor, ou autor, por quaisquer danos, reparações ou perdas monetárias devido às informações contidas neste ebook, direta ou indiretamente.

Notícia legal:

Este ebook é protegido por direitos autorais. É apenas para uso pessoal. Você não pode alterar, distribuir, vender, usar, citar ou parafrasear qualquer parte ou o conteúdo deste ebook sem o consentimento do autor ou editor.

Aviso de isenção de responsabilidade:

Observe que as informações contidas neste documento são apenas para fins educacionais e de entretenimento. Todo esforço foi feito para apresentar informações precisas, atualizadas, confiáveis e completas. Nenhuma garantia de qualquer tipo é declarada ou implícita. Os leitores reconhecem que o autor não está envolvido na prestação de aconselhamento jurídico, financeiro, médico ou profissional. O conteúdo deste ebook foi derivado de várias fontes. Consulte um profissional médico licenciado antes de tentar este programa ou qualquer técnica descrita neste ebook.

Ao ler este documento, o leitor concorda que em nenhuma circunstância o autor é responsável por quaisquer lesões, morte, perdas, diretas ou indiretas, que sejam incorridas como resultado do uso das informações contidas neste documento, incluindo, mas não limitado a a, erros, omissões ou imprecisões. 

1. Introdução

1.1 Antecedentes Históricos

1.2 Sobre a popularidade do Java: os principais recursos

1.2.1 Código de bytes

1.2.2 Executando o Bytecode via Máquina Virtual

1.2.3 Independência da plataforma

1.2.4 Java como linguagem, ambiente de tempo de execução e biblioteca padrão

1.2.5 Orientação a Objetos em Java

1.2.6 Java é difundido e bem conhecido

1.2.7 Java é rápido: otimização e compilação just-in-time

1.2.8 Ponteiros e Referências

1.2.9 Retire o Lixo, Coletor de Lixo!

1.2.10 Tratamento de Exceções

1.2.11 A gama de bibliotecas e ferramentas

1.2.12 Sintaxe comparativamente simples

1.2.13 Abandonando Conceitos Controversos

1.2.14 Java é de código aberto

1.2.15 Para que o Java é menos adequado

1.3 Java versus outras linguagens*

1.3.1 Java e C(++)

1.3.2 Java e JavaScript

1.3.3 Uma palavra sobre Microsoft, Java e J++

1.3.4 Java e C#/.NET

1.4 Desenvolvimento e perdas adicionais

1.4.1 O Desenvolvimento de Java e Suas Perspectivas Futuras

1.4.2 Recursos, aprimoramentos e solicitações de especificação

1.4.3 Miniaplicativos

1.4.4 Java FX

1.5 Plataformas Java

1.5.1 Plataforma Java, Edição Padrão

1.5.2 Plataforma Java, Micro Edition: Java para os mais pequenos

1.5.3 Java para os pequenininhos

1.5.4 Java para os grandes: Jakarta EE (anteriormente Java Platform, Enterprise Edition)

1.5.5 Java em tempo real

1.6 Plataforma Java, Standard Edition, Implementações

1.6.1 OpenJDK

1.6.2 Oracle JDK

1.7 Instalando o Java Development Kit

1.7.1 Instalando o Oracle JDK no Windows

1.8 Compilando e Testando o Primeiro Programa

1.8.1 Um programa de números quadrados

1.8.2 A execução do compilador

1.8.3 O ambiente de tempo de execução

1.8.4 Problemas Comuns do Compilador e do Interpretador

1.9 Ambientes de Desenvolvimento

1.9.1 IDEIA IntelliJ

1.9.2 Ambiente de Desenvolvimento Integrado Eclipse

1.9.3 NetBeans

1.10 Leitura adicional

2 Conceitos Imperativos de Linguagem

2.1 Elementos da Linguagem de Programação Java

2.1.1 Tokens

2.1.2 Codificação de Texto por Caracteres Unicode

2.1.3 Identificadores

2.1.4 Literais

2.1.5 Palavras-chave (reservadas)

2.1.6 Resumo da Análise Lexical

2.1.7 Comentários

2.2 Das Classes às Instruções

2.2.1 O que são declarações?

2.2.2 Declaração de classe

2.2.3 A jornada começa com main(String[])

2.2.4 A primeira chamada de método: println(...)

2.2.5 Declarações Atômicas e Sequências de Afirmações

2.2.6 Mais informações sobre print(...), println(...) e printf(...) para saída de tela

2.2.7 Documentação da Interface de Programação de Aplicativos

2.2.8 Expressões

2.2.9 Declarações de expressão

2.2.10 Primeiros insights sobre orientação a objetos

2.2.11 Modificadores

2.2.12 Agrupando Instruções com Blocos

2.3 Tipos de dados, tipagem, variáveis e atribuições

2.3.1 Visão geral dos tipos de dados primitivos

2.3.2 Declarações de Variáveis

2.3.3 Detecção automática de tipo com var

2.3.4 Variáveis finais e o modificador final

2.3.5 Entradas do console

2.3.6 Valores Verdadeiros

2.3.7 Tipos de dados inteiros

2.3.8 Sublinhados em Números

2.3.9 Caracteres Alfanuméricos

2.3.10 Tipos de dados float e double

2.3.11 Nomes bons, nomes ruins

2.3.12 Sem inicialização automática de variáveis locais

2.4 Expressões, Operandos e Operadores

2.4.1 Operador de Atribuição

2.4.2 Operadores Aritméticos

2.4.3 Unário Menos e Mais

2.4.4 Incremento e Decremento de Prefixo ou Pós-fixo

2.4.5 Atribuição com Operação (Operador de Atribuição Composta)

2.4.6 Operadores Relacionais e Operadores de Igualdade

2.4.7 Operadores Lógicos: NOT, AND, OR e XOR

2.4.8 Operadores de Curto-Circuito

2.4.9 A Classificação dos Operadores na Ordem de Avaliação

2.4.10 Typecasting (Fundição)

2.4.11 Overloaded Plus para Strings

2.4.12 Operadores ausentes*

2.5 Declarações condicionais ou distinções de caso

2.5.1 Ramificação com a instrução if

2.5.2 Escolhendo a alternativa com uma instrução if-else

2.5.3 O operador de condição

2.5.4 A instrução switch fornece uma alternativa

2.5.5 Expressões de Troca

2.6 Sempre o Mesmo com Loops

2.6.1 O loop while

2.6.2 O loop do-while

2.6.3 O loop for

2.6.4 Condições de loop e comparações com ==*

2.6.5 Terminação do Loop com break e volta ao Test com continue

2.6.6 interromper e continuar com etiquetas*

2.7 Métodos de uma Classe

2.7.1 Componentes de um Método

2.7.2 Descrição da assinatura na documentação da interface de programação de aplicativos Java

2.7.3 Chamando um Método

2.7.4 Declarando Métodos sem Parâmetros

2.7.5 Métodos Estáticos (Métodos de Classe)

2.7.6 Parâmetros, Argumentos e Transferências de Valores

2.7.7 Métodos de finalização prematura com retorno

2.7.8 Código fonte inacessível para métodos*

2.7.9 Métodos com Retornos

2.7.10 Métodos de sobrecarga

2.7.11 Escopo

2.7.12 Valores padrão para argumentos não listados*

2.7.13 Métodos Recursivos*

2.7.14 Torres de Hanói*

2.8 Leitura Adicional

3 Classes e Objetos

3.1 Programação Orientada a Objetos

3.1.1 Por que Programação Orientada a Objetos?

3.1.2 Quando penso em Java, penso em reusabilidade

3.2 Membros de uma Classe

3.3 Modelagem Natural Usando Linguagem de Modelagem Unificada*

3.4 Criando Novos Objetos

3.4.1 Criando uma instância de uma classe usando a nova palavra-chave

3.4.2 Declarando Variáveis de Referência

3.4.3 Vamos direto ao ponto: Acessando métodos e variáveis de objeto

3.4.4 A Conexão entre new, Heap e Garbage Collector

3.4.5 Visão geral dos métodos pontuais

3.4.6 Usando Construtores

3.5 ZZZZZnake

3.6 Pacotes vinculados, importações e unidades de compilação

3.6.1 Pacotes Java

3.6.2 Pacotes na Biblioteca Padrão

3.6.3 Qualificação Completa e Declaração de Importação

3.6.4 Alcançando todos os tipos de um pacote com Type-Import-on-Demand

3.6.5 Estruturas hierárquicas entre pacotes e espelhamento no sistema de arquivos

3.6.6 A Declaração da Embalagem

3.6.7 Pacote Sem Nome (Pacote Padrão)

3.6.8 Unidade de Compilação

3.6.9 Importação Estática*

3.7 Uso de Referências, Diversidade, Identidade e Igualdade

3.7.1 Referências nulas e a Questão da Filosofia

3.7.2 Tudo para null? Referências de teste

3.7.3 Atribuições com Referências

3.7.4 Métodos com Tipos de Referência como Parâmetros

3.7.5 Identidade dos Objetos

3.7.6 Equivalência e o método equals(...)

3.8 Leitura Adicional

4 Arrays e suas áreas de uso

4.1 Trabalho de Campo Simples

4.1.1 Componentes Básicos

4.1.2 Declarando Variáveis de Array

4.1.3 Criando Objetos Array com novos

4.1.4 Arrays com { conteúdo }

4.1.5 Lendo o Comprimento de um Array por meio do Object Variable Length

4.1.6 Acessando os Elementos por meio do Índice

4.1.7 Erros Típicos de Array

4.1.8 Passando Arrays para Métodos

4.1.9 Múltiplos Valores de Retorno*

4.1.10 Arrays pré-inicializados

4.2 O Loop For Estendido

4.2.1 Usando Arrays Anônimos no Loop for Estendido

4.2.2 Exemplo: Pesquisando Arrays com Strings

4.2.3 Criando posições de jogadores aleatórios

4.3 Um Método com Número Variável de Argumentos

4.3.1 System.out.printf(...) Aceita Qualquer Número de Argumentos

4.3.2 Encontrando a Média dos Argumentos Variáveis

4.3.3 Dicas de Projeto Vararg*

4.4 Matrizes Multidimensionais*

4.4.1 Matrizes Não Retangulares*

4.5 Suporte de biblioteca para arrays

4.5.1 A clonagem pode valer a pena: Propagar arrays

4.5.2 Por que os arrays podem fazer tão pouco?

4.5.3 Copiando o conteúdo da matriz

4.6 Usando a classe Arrays para comparar, preencher, pesquisar e classificar

4.6.1 Representação em String de um Array

4.6.2 Ordenação

4.6.3 Ordenação Paralela

4.6.4 Comparando Arrays de Primitivas com Arrays.equals(...) e Arrays.deepEquals(...)*

4.6.5 Comparando arrays de objetos usando Arrays.equals(...) e Arrays.deepEquals(...)*

4.6.6 Pesquisando diferenças usando incompatibilidade (...)*

4.6.7 Matrizes de Preenchimento*

4.6.8 Copiando Seções de Matriz*

4.6.9 Pesquisa Binária*

4.6.10 Comparações de matrizes lexicográficas usando compare(...) e compareUnsigned(...)

4.6.11 Arrays para listas com Arrays.asList(...): Conveniente para pesquisar e comparar*

4.6.12 Uma Cobra Longa

4.7 O Ponto de Entrada para o Sistema Runtime: main(...)

4.7.1 Declaração Correta do Método de Partida

4.7.2 Processamento de argumentos de linha de comando

4.7.3 O tipo de retorno de main(...) e System.exit(int)*

4.8 Leitura Adicional

5 Manipulando caracteres e strings

5.1 De ASCII via ISO-8859-1 para Unicode

5.1.1 ASCII

5.1.2 ISO/IEC 8859-1

5.1.3 Unicode

5.1.4 Codificação de caracteres Unicode

5.1.5 Sequências de Fuga

5.1.6 Notação para caracteres Unicode e escapes Unicode

5.1.7 Versões Java andam de mãos dadas com o padrão Unicode*

5.2 Tipos de dados para caracteres e strings

5.3 A Classe de Personagem

5.3.1 É Isso?

5.3.2 Conversão de caracteres para maiúsculas/minúsculas

5.3.3 Do Caractere à String

5.3.4 De char para int: De Character para Number*

5.4 Cordas

5.5 A classe String e seus métodos

5.5.1 Literais de string como objetos de string para strings constantes

5.5.2 Concatenação com +

5.5.3 Blocos de texto multilinha com "

5.5.4 Comprimento da String e Teste para Strings Vazias

5.5.5 Acessando um Caractere Específico com charAt(int)

5.5.6 Pesquisando caracteres e strings contidos

5.5.7 O jogo da forca

5.5.8 Bem que comparamos

5.5.9 Extraindo Seções de String

5.5.10 Acrescentando Strings, Mesclando Strings, Diferenciando Maiúsculas e Espaços em Branco

5.5.11 Procurado, Encontrado e Substituído

5.5.12 Criando Objetos String com Construtores e de Repetições*

5.6 Strings mutáveis com StringBuilder e StringBuffer

5.6.1 Criando Objetos StringBuilder

5.6.2 Convertendo StringBuilder para outros formatos de string

5.6.3 Solicitando Caracteres ou Strings

5.6.4 Anexando Dados

5.6.5 Definindo, Excluindo e Invertendo Caracteres e Strings

5.6.6 Comprimento e capacidade de um objeto StringBuilder*

5.6.7 Comparação de Instâncias StringBuilder e Strings com StringBuilder

5.6.8 hashCode() com StringBuilder*

5.7 CharSequence como tipo base

5.7.1 Operações Básicas da Interface

5.7.2 Método estático compare(...) em CharSequence

5.7.3 Métodos padrão na interface CharSequence*

5.8 Convertendo Primitivas e Strings

5.8.1 Convertendo Tipos Diferentes em Representações de String

5.8.2 Convertendo Conteúdo de String em um Valor Primitivo

5.8.3 Representação de String em Formatos Binário, Hexadecimal e Octal*

5.8.4 Métodos parse*(...) e print*() no DatatypeConverter*

5.9 Concatenando Strings

5.9.1 Concatenando Strings com StringJoiner

5.10 Strings em Decomposição

5.10.1 Dividindo Strings via split(...)

5.10.2 Sim, podemos, sim, digitalizamos: a classe Scanner

5.11 Saídas de Formatação

5.11.1 Formatação e saída via format()

5.12 Leitura Adicional

6 classes personalizadas de escrita

6.1 Declarando classes personalizadas com membros

6.1.1 Classe Mínima

6.1.2 Declarando Variáveis de Objeto

6.1.3 Declarando Métodos

6.1.4 Variáveis sombreadas

6.1.5 Esta Referência

6.2 Privacidade e Visibilidade

6.2.1 Para o público: público

6.2.2 Não público: as senhas são privadas

6.2.3 Por que não métodos e variáveis livres para todos?

6.2.4 privado não é totalmente privado: depende de quem o vê*

6.2.5 Declarando métodos de acesso para variáveis de objeto

6.2.6 Setters e Getters de acordo com a Especificação JavaBeans

6.2.7 Pacote-Visibilidade

6.2.8 Resumo da Visibilidade

6.3 Um por Todos: Métodos Estáticos e Variáveis de Classe

6.3.1 Por que os membros estáticos são úteis

6.3.2 Membros Estáticos com

6.3.3 Usando membros estáticos por meio de referências?*

6.3.4 Por que a distinção entre maiúsculas e minúsculas é importante*

6.3.5 Variáveis Estáticas para Troca de Dados*

6.3.6 Membros Estáticos e Membros de Objeto*

6.4 Constantes e Enumerações

6.4.1 Constantes via Variáveis Finais Estáticas

6.4.2 Enumerações de tipo inseguro

6.4.3 Tipos de enumeração: Enumerações de tipo seguro com enum

6.5 Criando e Destruindo Objetos

6.5.1 Construtores de Escrita

6.5.2 Relacionamento entre Método e Construtor

6.5.3 O construtor padrão

6.5.4 Construtores Parametrizados e Sobrecarregados

6.5.5 Copiar Construtores

6.5.6 Chamando outro construtor da mesma classe via this(...)

6.5.7 Objetos Imutáveis e Métodos Wither

6.5.8 Não sentimos sua falta: o coletor de lixo

6.6 Inicialização de classe e objeto*

6.6.1 Inicializando Variáveis de Objeto

6.6.2 Blocos Estáticos como Inicializadores de Classe

6.6.3 Inicializando Variáveis de Classe

6.6.4 Atribuições compiladas das variáveis de classe

6.6.5 Inicializador de Instância

6.6.6 Definindo Valores Finais nos Blocos Construtores e Estáticos

6.7 Conclusão

7 Relacionamento Orientado a Objetos

7.1 Associações entre Objetos

7.1.1 Tipos de Associação

7.1.2 Relacionamento 1-para-1 Unidirecional

7.1.3 Tornando-se amigos: relacionamentos bidirecionais 1-para-1

7.1.4 Relacionamentos Unidirecionais 1-para-n

7.2 Herança

7.2.1 Herança em Java

7.2.2 Modelando Eventos

7.2.3 A classe base implícita java.lang.Object

7.2.4 Herança Simples e Múltipla*

7.2.5 As crianças veem tudo? A Visibilidade Protegida

7.2.6 Construtores em Herança e super(...)

7.3 Tipos em Hierarquias

7.3.1 Typecasting automático e explícito

7.3.2 O Princípio da Substituição

7.3.3 Tipos de teste com a instância do Operador

7.3.4 Correspondência de padrões para instância de

7.4 Métodos de Substituição

7.4.1 Fornecendo Métodos em Subclasses com um Novo Comportamento

7.4.2 Com super aos Pais

7.5 Testando Vinculações Dinâmicas

7.5.1 Vinculado a toString()

7.5.2 Implementando System.out.println(Object)

7.6 Aulas Finais e Métodos Finais

7.6.1 Aulas Finais

7.6.2 Métodos não substituíveis (finais)

7.7 Classes abstratas e métodos abstratos

7.7.1 Aulas Abstratas

7.7.2 Métodos abstratos

7.8 Mais informações sobre substituição e vinculação dinâmica

7.8.1 Nenhuma vinculação dinâmica para métodos privados, estáticos e finais

7.8.2 Tipos de Retorno Covariante

7.8.3 Tipos de Array e Covariância*

7.8.4 Vinculação Dinâmica mesmo com Chamadas de Construtor*

7.8.5 Nenhuma vinculação dinâmica para variáveis de objeto cobertas*

7.9 Uma Tarefa de Programação

8 Interfaces, Enumerações, Classes Seladas, Registros

8.1 Interfaces

8.1.1 Interfaces são novos tipos

8.1.2 Declarando Interfaces

8.1.3 Métodos Abstratos em Interfaces

8.1.4 Interfaces de Implementação

8.1.5 Um Exemplo de Polimorfismo com Interfaces

8.1.6 Herança Múltipla com Interfaces

8.1.7 Sem Risco de Colisão com Herança Múltipla*

8.1.8 Estendendo Interfaces: Subinterfaces

8.1.9 Declarações Constantes para Interfaces

8.1.10 Implementação Posterior de Interfaces*

8.1.11 Métodos Estáticos Programados em Interfaces

8.1.12 Estendendo e Modificando Interfaces

8.1.13 Métodos Padrão

8.1.14 Declarando e Usando Interfaces Estendidas

8.1.15 Métodos de Interface Pública e Privada

8.1.16 Interfaces estendidas, herança múltipla e ambiguidades*

8.1.17 Criando Blocos de Construção com Métodos Padrão*

8.1.18 Interfaces do marcador*

8.1.19 (Abstrato) Classes e Interfaces em Comparação

8.2 Tipos de Enumeração

8.2.1 Métodos em Objetos Enum

8.2.2 Enumerações com métodos personalizados, construtores e inicializadores*

8.3 Classes Seladas e Interfaces

8.3.1 Classes Seladas e Interfaces

8.3.2 As subclasses são definitivas, lacradas e não lacradas

8.3.3 Notações abreviadas

8.4 Registros

8.4.1 Registros Simples

8.4.2 Registros com Métodos

8.4.3 Personalizando construtores de registro

8.4.4 Adicionando Construtores

8.4.5 Interfaces e Registros Selados

8.4.6 Registros: Resumo

9 Deve haver exceções

9.1 Cercas em áreas problemáticas

9.1.1 Exceções em Java com try e catch

9.1.2 Exceções verificadas e não verificadas

9.1.3 Um NumberFormatException (Exceção não verificada)

9.1.4 Anexando uma Data/Hora a um Arquivo de Texto (Exceção Verificada)

9.1.5 Repetição de Seções Canceladas*

9.1.6 Blocos catch vazios

9.1.7 Capturando Múltiplas Exceções

9.1.8 Combinando Blocos Catch Idênticos com Multi-Catch

9.2 Redirecionando exceções e lançamentos no cabeçalho de métodos/construtores

9.2.1 lançamentos em Construtores e Métodos

9.3 A Hierarquia de Exceções de Classe

9.3.1 Membros do Objeto de Exceção

9.3.2 Tipo base arremessável

9.3.3 A Hierarquia de Exceções

9.3.4 Capturando Super-Exceções

9.3.5 Já Pegou?

9.3.6 Procedimento de Situação Excepcional

9.3.7 Sem captura geral!

9.3.8 Classes RuntimeException Conhecidas

9.3.9 A interceptação é possível, mas não obrigatória

9.4 Manuseio final usando o finalmente

9.4.1 A Versão Ignorante

9.4.2 A tentativa bem-intencionada

9.4.3 A partir de agora o Encerramento Faz Parte da Ordem do Dia

9.4.4 Resumo

9.4.5 Um try sem catch, mas um try-finally

9.5 Acionando Exceções Personalizadas

9.5.1 Acionando Exceções via throw

9.5.2 Conhecendo e usando tipos de exceção de tempo de execução existentes

9.5.3 Parâmetros de teste e boas mensagens de erro

9.5.4 Declarando novas classes de exceção

9.5.5 Exceções Customizadas como Subclasses de Exception ou RuntimeException?

9.5.6 Capturando e redirecionando exceções*

9.5.7 Alterando a Pilha de Chamadas de Exceções*

9.5.8 Exceções aninhadas*

9.6 tente com Recursos (gerenciamento automático de recursos)

9.6.1 tente com Recursos

9.6.2 A interface AutoCloseable

9.6.3 Exceções para close()

9.6.4 Tipos que podem ser fechados e fechados automaticamente

9.6.5 Usando Múltiplos Recursos

9.6.6 Exceções Suprimidas*

9.7 Recursos Especiais de Tratamento de Exceções*

9.7.1 Valores de retorno para exceções lançadas

9.7.2 Exceções e Retornos Desaparecem: A Dupla retorna e finalmente

9.7.3 lançamentos em Métodos Substituídos

9.7.4 Cláusulas de captura inacessíveis

9.8 Erros graves: Erro*

9.9 Afirmações*

9.9.1 Usando Asserções em Programas Personalizados

9.9.2 Ativando asserções e erros de tempo de execução

9.9.3 Habilitando ou Desabilitando Asserções Mais Detalhado

9.10 Conclusão

10 tipos aninhados

10.1 Classes aninhadas, interfaces e enumerações

10.2 Tipos aninhados estáticos

10.2.1 Modificadores e Visibilidade

10.2.2 Registros como Contêineres

10.2.3 Implementando tipos aninhados estáticos*

10.3 Tipos aninhados não estáticos

10.3.1 Criando Instâncias de Classes Internas

10.3.2 Esta Referência

10.3.3 Arquivos de classe gerados pelo compilador*

10.4 Aulas Locais

10.4.1 Exemplo com declaração personalizada

10.4.2 Usando uma Classe Local para um Timer

10.5 Classes Internas Anônimas

10.5.1 Usando uma Classe Interna Anônima para o Timer

10.5.2 Implementando classes internas anônimas*

10.5.3 Construtores de Classes Internas Anônimas

10.5.4 Acessando variáveis locais de classes locais e anônimas*

10.5.5 Classes aninhadas acessam membros privados

10.6 Ninhos

10.7 Conclusão

11 tipos especiais de Java SE

11.1 O objeto é a mãe de todas as classes

11.1.1 Objetos de Classe

11.1.2 Identificação de objetos com toString()

11.1.3 Equivalência de objetos com equals(...) e identidade

11.1.4 Clonando um objeto usando clone()*

11.1.5 Retornando valores de hash via hashCode()*

11.1.6 System.identityHashCode(...) e o problema de referências de objetos não exclusivos*

11.1.7 Sincronização*

11.2 Referências fracas e limpadores

11.3 A classe utilitária java.util.Objects

11.3.1 Testes nulos integrados para equals(...)/hashCode()

11.3.2 Objects.toString(…)

11.3.3 Verificações nulas com manipulação de exceção integrada

11.3.4 Testes para nulo

11.3.5 Verificando a exatidão dos argumentos do programa relacionados ao índice

11.4 Comparando Objetos e Estabelecendo Ordem

11.4.1 Naturalmente Ordenado ou Não?

11.4.2 Método compare*() das Interfaces Comparáveis e Comparadoras

11.4.3 Valores de retorno codificam o pedido

11.4.4 Classificando doces por calorias usando um comparador de amostras

11.4.5 Dicas para comparadores e implementações comparáveis

11.4.6 Métodos Estáticos e Padrão no Comparador

11.5 Classes Wrapper e Autoboxing

11.5.1 Criando Objetos Wrapper

11.5.2 Conversões para uma representação de String

11.5.3 Análise de uma representação de string

11.5.4 A classe base numérica para objetos wrapper numéricos

11.5.5 Fazendo comparações com compare*(...), compareTo(...), equals(...) e valores de hash

11.5.6 Métodos de Redução Estática em Classes Wrapper

11.5.7 Constantes para o Tamanho de um Tipo Primitivo*

11.5.8 Lidando com Números Sem Sinal*

11.5.9 As Classes Inteiras e Longas

11.5.10 As Classes Double e Float para Floats

11.5.11 A Classe Booleana

11.5.12 Autoboxing: Boxing e Unboxing

11.6 Iterador, Iterável*

11.6.1 A interface do iterador

11.6.2 O Fornecedor do Iterador

11.6.3 A interface iterável

11.6.4 Estendido para e iterável

11.6.5 Iteração Interna

11.6.6 Implementando um Iterável Personalizado*

11.7 Anotações na plataforma Java, Standard Edition

11.7.1 Locais para Anotações

11.7.2 Tipos de anotação de java.lang

11.7.3 @Deprecated

11.7.4 Anotações com Informações Adicionais

11.7.5 @SuppressWarnings

11.8 Leitura Adicional

12 Genéricos

12.1 Introdução aos Genéricos Java

12.1.1 Homem versus Máquina: Verificação de Tipo do Compilador e do Ambiente de Execução

12.1.2 Foguetes

12.1.3 Declarando Tipos Genéricos

12.1.4 Usando Genéricos

12.1.5 Os diamantes são para sempre

12.1.6 Interfaces Genéricas

12.1.7 Métodos/Construtores Genéricos e Inferência de Tipos

12.2 Implementando Generics, Type Erasure e Raw Types

12.2.1 Opções de Implementação

12.2.2 Apagamento de Tipo

12.2.3 Problemas com apagamento de tipo

12.2.4 Tipos Brutos

12.3 Restringindo tipos por meio de limites

12.3.1 Restrições simples com extensões

12.3.2 Outros supertipos com &

12.4 Parâmetros de tipo na cláusula throws*

12.4.1 Declarando uma Classe com Variável de Tipo

12.4.2 Tipo Parametrizado para Variável de Tipo

12.5 Herança e Invariância com Genéricos

12.5.1 Arrays são covariantes

12.5.2 Genéricos não são covariantes, mas invariantes

12.5.3 Curingas com ?

12.5.4 Curingas Delimitados

12.5.5 Tipos curinga limitados e variáveis de tipo limitado

12.5.6 O Princípio PECS

12.6 Consequências do apagamento de tipo: tokens de tipo, matrizes*

12.6.1 Tokens de Tipo

12.6.2 Tokens de Supertipo

12.6.3 Genéricos e Arrays

12.7 Leitura Adicional

13 Expressões Lambda e Programação Funcional

13.1 Interfaces Funcionais e Expressões Lambda

13.1.1 Classes Implementam Interfaces

13.1.2 Interfaces de Implementação de Expressões Lambda

13.1.3 Interfaces Funcionais

13.1.4 O tipo de uma expressão lambda depende do tipo de destino

13.1.5 Anotações @FunctionalInterface

13.1.6 Sintaxe para Expressões Lambda

13.1.7 O Ambiente de Expressões Lambda e Acessos Variáveis

13.1.8 Exceções em Expressões Lambda

13.1.9 Classes com Método Abstrato como Interface Funcional?*

13.2 Referências de Método

13.2.1 Motivação

13.2.2 Referências de Método com ::

13.2.3 Variações de Referências de Método

13.3 Referências do Construtor

13.3.1 Escrevendo Referências do Construtor

13.3.2 Construtores sem parâmetros e parametrizados

13.3.3 Interfaces predefinidas úteis para referências de construtor

13.4 Programação Funcional

13.4.1 Código = Dados

13.4.2 Paradigmas de Programação: Imperativo ou Declarativo

13.4.3 Princípios de Programação Funcional

13.4.4 Programação Imperativa e Programação Funcional

13.4.5 Comparador como exemplo de funções de ordem superior

13.4.6 Visualizando Expressões Lambda como Mapeamentos ou Funções

13.5 Interfaces funcionais do pacote java.util.function

13.5.1 Blocos com Código e Interface Funcional Consumidor

13.5.2 Fornecedor

13.5.3 Predicados e java.util.function.Predicate

13.5.4 Funções via Interface Funcional java.util.function.Function

13.5.5 Eu pego dois

13.5.6 Interfaces Funcionais com Primitivas

13.6 Opcional não é um não inicializador

13.6.1 Usando nulo

13.6.2 O Tipo Opcional

13.6.3 Iniciando Interfaces Funcionais com Opcional

13.6.4 Classes Primitivas-Opcional com Opcionais Especiais*

13.7 O que é tão funcional agora?

13.7.1 Reciclabilidade

13.7.2 Sem estado, imutável

13.8 Leitura Adicional

14 Arquitetura, Design e Orientação a Objetos Aplicada

14.1 Modelagem de SÓLIDOS

14.1.1 Três Regras

14.1.2 SÓLIDO

14.1.3 Não seja ESTÚPIDO

14.2 Arquitetura, Projeto e Implementação

14.3 Padrões de Projeto

14.3.1 Motivação para Padrões de Projeto

14.3.2 Singleton

14.3.3 Métodos de Fábrica

14.3.4 Implementando o padrão Observer com ouvintes

14.4 Leitura Adicional

15 Sistema de módulos da plataforma Java

15.1 Carregador de Classe e Módulo/Classpath

15.1.1 Classes de Carregamento por Solicitação

15.1.2 Observando o carregador de classe em funcionamento

15.1.3 Arquivos JMOD e Arquivos JAR

15.1.4 De onde vêm as classes: locais de busca e carregadores de classes especiais

15.1.5 Definindo o caminho de pesquisa

15.2 Importando Módulos

15.2.1 Quem vê quem?

15.2.2 Módulos de Plataforma e um Exemplo de JMOD

15.2.3 Usando recursos internos da plataforma: --add-exports

15.2.4 Integrando Novos Módulos

15.3 Desenvolvendo Módulos Personalizados

15.3.1 Módulo com.tutego.candytester

15.3.2 Declaração de Módulo com module-info.java e Exportações

15.3.3 Módulo com.tutego.main

15.3.4 Arquivo de informações do módulo com requer

15.3.5 Escrevendo insersores de módulo: Java Virtual Machine Switches -p e -m

15.3.6 Experimentos com o arquivo de informações do módulo

15.3.7 Módulos Automáticos

15.3.8 Módulos Sem nome

15.3.9 Legibilidade e Acessibilidade

15.3.10 Migração de Módulo

15.4 Leitura Adicional

16 A Biblioteca de Classes

16.1 A Filosofia da Classe Java

16.1.1 Módulos, Pacotes e Tipos

16.1.2 Visão Geral dos Pacotes da Biblioteca Padrão

16.2 Medição Simples de Tempo e Perfil*

16.2.1 Perfiladores

16.3 A Classe Classe

16.3.1 Obtendo um Objeto de Classe

16.3.2 Uma classe é um tipo

16.4 O Sistema de Classes de Utilidade e Membros

16.4.1 Memória da Máquina Virtual Java

16.4.2 Número de CPUs ou Núcleos

16.4.3 Propriedades do Sistema do Ambiente Java

16.4.4 Definindo propriedades personalizadas no console*

16.4.5 Caracteres de nova linha e line.separator

16.4.6 Variáveis de Ambiente do Sistema Operacional

16.5 Os idiomas de diferentes países

16.5.1 Idiomas Regionais por meio de Objetos de Localidade

16.6 Visão geral das classes de datas importantes

16.6.1 Horário do Unix: 1º de janeiro de 1970

16.6.2 System.currentTimeMillis()

16.6.3 Conversões de Tempo Simples via TimeUnit

16.7 API Data-Hora

16.7.1 Visão Geral Inicial

16.7.2 Tempo Humano e Tempo de Máquina

16.7.3 A classe de data LocalDate

16.8 Registrando com Java

16.8.1 Interfaces de programação de aplicativo de registro

16.8.2 Registrando com java.util.logging

16.9 Maven: resolvendo gerenciamento de compilação e dependências

16.9.1 Dependência a ser aceita

16.9.2 Repositório Local e Remoto

16.9.3 Ciclos de vida, estágios e plug-ins Maven

16.10 Leitura Adicional

17 Introdução à Programação Concorrente

17.1 Simultaneidade e Paralelismo

17.1.1 Multitarefa, Processos e Threads

17.1.2 Threads e Processos

17.1.3 Como programas simultâneos podem aumentar a velocidade

17.1.4 Como o Java pode oferecer simultaneidade

17.2 Gerando Threads Existentes e Novos Threads

17.2.1 Tópico Principal

17.2.2 Quem sou eu?

17.2.3 Implementando a interface executável

17.2.4 Iniciando Thread com Runnable

17.2.5 Parametrizando Executável

17.2.6 Estendendo a Classe de Rosca*

17.3 Membros e Estados do Tópico

17.3.1 O Nome de um Thread

17.3.2 Os Estados de um Thread*

17.3.3 Procuram-se travessas

17.3.4 Quando as Threads São Finalizadas

17.3.5 Encerrando um thread educadamente usando interrupções

17.3.6 Exceções não tratadas, Thread End e UncaughtExceptionHandler

17.3.7 O stop() de Fora e o Resgate com ThreadDeath*

17.3.8 Parando e Retomando o Trabalho*

17.3.9 Prioridade*

17.4 Digite o Executor

17.4.1 A Interface do Executor

17.4.2 Happy as a Group: The Thread Pools

17.4.3 Threads com retorno via Callable

17.4.4 Memórias do Futuro: O Futuro Retorno

17.4.5 Processando Múltiplos Objetos Chamáveis

17.4.6 CompletionService e ExecutorCompletionService

17.4.7 ScheduledExecutorService: tarefas repetitivas e controles de tempo

17.4.8 Programação Assíncrona com CompletableFuture (CompletionStage)

17.5 Leitura Adicional

18 Introdução a Estruturas de Dados e Algoritmos

18.1 Listas

18.1.1 Exemplo da Primeira Lista

18.1.2 Critério de Seleção ArrayList ou LinkedList

18.1.3 A interface da lista

18.1.4 ArrayList

18.1.5 LinkedList

18.1.6 O Adaptador de Array Arrays.asList(...)

18.1.7 ListIterator*

18.1.8 Entendendo toArray(...) de Collection: Reconhecendo Traps

18.1.9 Gerenciando Elementos Primitivos em Estruturas de Dados

18.2 Conjuntos

18.2.1 Um Primeiro Exemplo de Conjunto

18.2.2 Métodos da Interface Set

18.2.3 HashSet

18.2.4 TreeSet: O Conjunto Ordenado

18.2.5 As Interfaces NavigableSet e SortedSet

18.2.6 LinkedHashSet

18.3 Memória Associativa

18.3.1 As classes HashMap e TreeMap e os métodos de mapa estático

18.3.2 Inserindo e Consultando a Memória Associativa

18.4 A API de fluxo

18.4.1 Programação Declarativa

18.4.2 Iteração interna versus externa

18.4.3 O que é um fluxo?

18.5 Criando um fluxo

18.5.1 Stream.of*(…)

18.5.2 Stream.generate(…)

18.5.3 Stream.iterate(…)

18.5.4 Fluxos Paralelos ou Sequenciais

18.6 Operações do Terminal

18.6.1 Número de Elementos

18.6.2 E Agora Todos: forEach*(…)

18.6.3 Obtendo elementos individuais do fluxo

18.6.4 Testes de Existência com Predicados

18.6.5 Reduzindo um fluxo ao seu menor ou maior elemento

18.6.6 Reduzindo um Stream com Suas Próprias Funções

18.6.7 Gravando Resultados em um Contêiner, Parte 1: collect(...)

18.6.8 Gravando Resultados em um Contêiner, Parte 2: Coletor e Coletores

18.6.9 Gravando Resultados em um Contêiner, Parte 3: Agrupamentos

18.6.10 Transferindo elementos de fluxo para um array ou um iterador

18.7 Operações intermediárias

18.7.1 Visualizações de elementos

18.7.2 Elementos Filtrantes

18.7.3 Operações intermediárias com estado

18.7.4 Operações de prefixo

18.7.5 Imagens

18.8 Leitura Adicional

19 Arquivos e fluxos de dados

19.1 Velho e Novo Mundo em java.io e java.nio

19.1.1 Pacote java.io com a classe File

19.1.2 NIO.2 e o pacote java.nio

19.2 Sistemas de arquivos e caminhos

19.2.1 Sistema de Arquivos e Caminho

19.2.2 A classe de utilitário de arquivos

19.3 Arquivos de acesso aleatório

19.3.1 Abrindo um RandomAccessFile para Leitura e Escrita

19.3.2 Lendo de RandomAccessFile

19.3.3 Escrevendo com RandomAccessFile

19.3.4 O comprimento do RandomAccessFile

19.3.5 Indo e voltando dentro do Arquivo

19.4 Classes Base para Entrada/Saída

19.4.1 As quatro classes básicas abstratas

19.4.2 A Classe Base Abstrata OutputStream

19.4.3 A Classe Base Abstrata InputStream

19.4.4 O Escritor da Classe Base Abstrata

19.4.5 A Interface Anexável*

19.4.6 O leitor de classe base abstrata

19.4.7 As Interfaces Closeable, AutoCloseable e Flushable

19.5 Lendo de arquivos e gravando em arquivos

19.5.1 Obtendo Fluxos de Dados Orientados a Byte por meio de Arquivos

19.5.2 Obtenção de fluxos de dados orientados a caracteres por meio de arquivos

19.5.3 A função de OpenOption nos métodos Files.new*(...)

19.5.4 Carregando recursos do caminho do módulo e de arquivos JAR

19.6 Leitura Adicional

20 Introdução ao gerenciamento de banco de dados com JDBC

20.1 Bancos de Dados Relacionais e Acesso Java

20.1.1 O Modelo Relacional

20.1.2 Interfaces de programação de aplicativos Java para acessar bancos de dados relacionais

20.1.3 API JDBC e implementações: o driver JDBC

20.1.4 H2 é a ferramenta em Java

20.2 Uma Consulta de Exemplo

20.2.1 Etapas para consultar o banco de dados

20.2.2 Acessando o banco de dados relacional com Java

20.3 Leitura Adicional

21 Bits e Bytes, Matemática e Dinheiro

21.1 Bits e Bytes

21.1.1 Os operadores de bit: Complement, AND, OR e XOR

21.1.2 Representação de inteiros em Java: complemento de dois

21.1.3 Os sistemas de valor posicional binário, octal e hexadecimal

21.1.4 Efeito do Typecasting em Padrões de Bits

21.1.5 Trabalho sem Sinais

21.1.6 Os Operadores de Turno

21.1.7 Definindo, limpando, revertendo e testando um bit

21.1.8 Métodos de Bit das Classes Inteira e Longa

21.2 Aritmética de Ponto Flutuante em Java

21.2.1 Valores Especiais para Infinito, Zero e Não é um Número

21.2.2 Notação Padrão e Notação Científica para Flutuantes*

21.2.3 Mantissas e Expoentes*

21.3 Os Membros da Classe de Matemática

21.3.1 Variáveis de Objeto da Classe Math

21.3.2 Valores Absolutos e Sinais

21.3.3 Máximos/Mínimos

21.3.4 Valores de Arredondamento

21.3.5 Resto de uma divisão inteira*

21.3.6 Divisão com Arredondamento para Infinito Negativo e Restos Alternativos*

21.3.7 Multiplicar-Acumular

21.3.8 Raiz quadrada e métodos exponenciais

21.3.9 O Logaritmo*

21.3.10 Métodos de Ângulo*

21.3.11 Números Aleatórios

21.4 Precisão e Faixa de Valor do Tipo e Controle de Transbordamento*

21.4.1 Os Maiores e Menores Valores

21.4.2 Transbordamento e Tudo Totalmente Exato

21.4.3 O que diabos o método ulp faz?

21.5 Números aleatórios: Random, ThreadLocalRandom e SecureRandom

21.5.1 A Classe Aleatória

21.5.2 ThreadLocalRandom

21.5.3 A Classe SecureRandom*

21.6 Números Grandes*

21.6.1 A Classe BigInteger

21.6.2 Exemplo: Fatoriais bastante longos com BigInteger

21.6.3 Grandes floats com BigDecimal

21.6.4 Configurando convenientemente a precisão do cálculo via MathContext

21.6.5 Calculando ainda mais rápido com implementações mutáveis

21.7 Dinheiro e Moeda

21.7.1 Representando Quantias de Dinheiro

21.7.2 ISO 4217

21.7.3 Representando Moedas em Java

21.8 Leitura Adicional

22 Testando com JUnit

22.1 Testes de Software

22.1.1 Procedimento para Escrever Casos de Teste

22.2 A estrutura de teste JUnit

22.2.1 Versões JUnit

22.2.2 Integrando o JUnit

22.2.3 Desenvolvimento Orientado a Testes e a Abordagem Test-First

22.2.4 Teste, implemente, teste, implemente, teste, regozije-se

22.2.5 Executando testes JUnit

22.2.6 Métodos assert*(...) da Classe Assertions

22.2.7 Exceções de Teste

22.2.8 Definindo Limites para Tempos de Execução

22.2.9 Rótulos com @DisplayName

22.2.10 Testes Aninhados

22.2.11 Ignorando Testes

22.2.12 Cancelamento de Testes com Métodos da Classe de Suposições

22.2.13 Testes Parametrizados

22.3 Bibliotecas de Asserção Java e AssertJ

22.3.1 AssertJ

22.4 Estrutura de Grandes Casos de Teste

22.4.1 Acessórios

22.4.2 Coleções de classes de teste e organização de classes

22.5 Um bom design permite testes eficazes

22.6 Simulado, falso, toco e simulado

22.7 Extensões JUnit e Complementos de Teste

22.7.1 Testes da Web

22.7.2 Testando a interface do banco de dados

22.8 Leitura Adicional

23 As ferramentas do JDK

23.1 Visão geral

23.1.1 Estrutura e Chaves Comuns

23.2 Traduzindo fontes Java

23.2.1 O compilador Java do Java Development Kit

23.2.2 Compiladores Nativos

23.3 O Java Runtime Environment

23.3.1 Chaves da Máquina Virtual Java

23.3.2 A diferença entre java.exe e javaw.exe

23.4 Comentários de Documentação com Javadoc

23.4.1 Definindo um comentário de documentação

23.4.2 Criando documentação com a ferramenta javadoc

23.4.3 Tags HTML em comentários de documentação*

23.4.4 Arquivos Gerados

23.4.5 Comentários da Documentação em Relance*

23.4.6 Javadoc e Doclets*

23.4.7 Tipos e membros obsoletos

23.4.8 Verificação Javadoc com DocLint

23.5 O formato de arquivo JAR

23.5.1 Usando o utilitário jar

23.5.2 O Manifesto

23.5.3 Iniciando aplicativos em arquivos Java: arquivos JAR executáveis

23.6 Leitura Adicional

Prefácio

Algumas pessoas pensam que são educadas só porque ainda usam palavras e não punhos.

No começo era a palavra. Muito mais tarde, em 23 de maio de 1995, no SunWorld em San Francisco, o chefe do então Science Office da Sun Microsystems, John Gage, e o co-fundador da Netscape, Marc Andreessen, introduziram a nova linguagem de programação Java com sua integração no navegador Netscape. Este evento foi o início da procissão triunfal de uma linguagem que oferece maneiras elegantes de programar em qualquer plataforma e de expressar seus pensamentos de maneira orientada a objetos (OO). As possibilidades da linguagem e suas bibliotecas não são nada novas em si mesmas, mas foram empacotadas tão bem que o Java é agradável e fluido para programação. Java é agora uma das linguagens de programação mais populares do planeta. Em seus 23 capítulos, este livro trata da tecnologia Java com foco intenso na linguagem de programação Java. Tópicos importantes incluem programação orientada a objetos (OOP), design de classes e a estrutura das bibliotecas padrão de Java.

Grupo alvo

Os capítulos deste livro são projetados para iniciantes na linguagem de programação Java, bem como para usuários avançados. O conhecimento básico de uma linguagem de programação estruturada, como C, Python, JavaScript ou Visual Basic, e o conhecimento de OOP são úteis porque o livro não aborda explicitamente arquiteturas de computador ou o que realmente é programação. Então, se você já programou em alguma linguagem, este livro é para você!

O que este livro não é

Este livro não deve ser considerado um livro de programação para iniciantes. Se você nunca programou antes e associa a palavra tradução principalmente a interpretação, você deve começar com um tutorial básico ou seguir um em paralelo. Muitas áreas da vida de um programador industrial são abordadas neste livro em profundidade geral, mas este livro não pode substituir a Java Language Specification (JLS), disponível em https://docs.oracle.com/javase/specs .

As tecnologias Java explodiram nos últimos anos, de modo que sua capacidade de gerenciamento inicial deu lugar a uma forte especialização. Hoje, não é possível cobrir tudo em um livro, e certamente não almejaremos esse objetivo com este. Um livro que trata especificamente da interface gráfica do usuário (GUI) JavaFX ou Swing — ambas partes do Java padrão — pode ser tão extenso quanto o livro que você tem em mãos. Outros tópicos especiais incluem análise/design OO, Unified Modeling Language (UML), programação paralela ou distribuída, Enterprise JavaBeans (EJBs), conectividade de banco de dados, mapeamento objeto-relacional, serviços da web, páginas da web dinâmicas e muitos outros tópicos. Para todos esses tópicos, livros específicos podem ser necessários para satisfazer sua curiosidade.

Este livro Java treina você na sintaxe da linguagem de programação, no manuseio de importantes bibliotecas padrão, ferramentas de desenvolvimento e ambientes de desenvolvimento, análise e projeto OO, padrões de projeto e convenções de programa. Mas este livro não pode ajudá-lo a impressionar os geeks legais de TI em uma festa. Desculpe.

Minha vida e Java, ou Por que um livro de Java?

Meu envolvimento com Java começou há mais de 20 anos e está relacionado a um curso universitário obrigatório. Em 1997, nosso grupo de projeto lidou com uma especificação de diálogo OO. Uma máquina de estado tinha que ser programada, e surgiu a questão de qual linguagem de programação usar. Como queria apresentar o Java aos participantes do seminário, preparei um conjunto de slides para nossa apresentação. Paralelamente aos slides, o professor esperava uma elaboração na forma de um trabalho de seminário. Trabalhar com Java foi divertido e algo completamente diferente do que eu estava acostumado até então. Antes de Java, eu codificava em Assembler por cerca de 10 anos; depois, usei as linguagens de alto nível Pascal e C e construí principalmente compiladores. Experimentei e testei o código, anotei minhas experiências e aprendi sobre Java e suas bibliotecas. O trabalho cresceu com a minha experiência. Durante o tempo neste projeto de grupo, um colega me abordou para dar um treinamento em Java como palestrante. Tive vontade de fazer, mas não tinha nenhum documento. Então, continuei escrevendo materiais de treinamento para o curso. Quando o professor pediu o trabalho do seminário no final do projeto do grupo, o manuscrito preliminar do livro atual já era tão extenso que essa introdução se tornou mais ou menos o trabalho do seminário.

Isso foi em 1997 e, claro, eu poderia ter parado de escrever imediatamente depois de entregar o jornal. Mas até hoje ainda gosto de Java e fico ansioso por cada nova versão. E não estou sozinho em meu otimismo: as previsões para Java continuam promissoras porque o uso de Java agora está tão estabelecido quanto o de COBOL em bancos e seguros. É por isso que as pessoas continuam falando que Java é o novo COBOL.

Após cerca de duas décadas, agora considero este livro um recurso Java multifacetado para desenvolvedores ambiciosos que desejam ver os bastidores. Seu nível de detalhamento não é alcançado por nenhum outro livro sobre os fundamentos de Java em inglês — pelo menos que eu saiba! Gostei de estender o livro, mesmo que muitos tópicos dificilmente sejam abordados em um curso normal de Java.

Software e Versões

A base para este livro é a Java Platform Standard Edition (Java SE) versão 17 usando a implementação gratuita do OpenJDK, que é uma espécie de Java Development Kit (JDK). O JDK consiste essencialmente em um compilador e um ambiente de tempo de execução — a máquina virtual Java (JVM) — e está disponível para as plataformas Windows, macOS, Linux e Solaris.

Uma interface gráfica de desenvolvimento, chamada de ambiente de desenvolvimento integrado (IDE), não faz parte do JDK. Embora eu não defenda a dependência de um fornecedor (porque os fornecedores atraem diferentes grupos de desenvolvedores), este livro apresenta os ambientes de desenvolvimento IntelliJ com um pouco mais de detalhes. Nossos programas de exemplo podem basicamente ser inseridos em qualquer outro ambiente de desenvolvimento ou editor de texto — como o Microsoft Visual Studio Code (VS Code) ou vi — e compilados na linha de comando. No entanto, os editores de texto puro estão desatualizados no desenvolvimento e uma abordagem de linha de comando gráfica simplifica a criação do programa.

Qual versão do Java usar

Desde que a Oracle (então ainda liderada pela Sun) introduziu a linguagem de programação Java em 1995 com a versão 1.0, a espiral de versões mudou inexoravelmente. Uma nova versão é lançada a cada 6 meses, e a cada 2 anos, um Long-Term-Support-Release (LTS), com atualizações por um longo período de tempo, é lançado. O LTS mais recente é o Java 17. Especialmente para autores que escrevem livros sobre Java, surge a dúvida sobre qual versão do Java o texto deve ser baseado e quais bibliotecas devem ser descritas. Neste livro, sempre descrevemos os recursos da versão mais recente, que era o Java 18 no momento em que este livro foi escrito. Para a didática da OOP, a questão da versão felizmente é irrelevante.

Os exemplos neste livro são consistentemente baseados no Java 17.

Usando este livro para aprender

Este livro é ideal para auto-estudo. O primeiro capítulo é para aquecimento. Se você não possui um ambiente de desenvolvimento instalado em seu computador, você deve primeiro instalar o JDK da Oracle. Como o JDK só instala ferramentas de linha de comando, todo desenvolvedor deve instalar um IDE gráfico porque um IDE torna o desenvolvimento de programas Java muito mais confortável. Um IDE oferece várias vantagens sobre a linha de comando bruta, como as seguintes:

No desenvolvimento de software, a documentação das interfaces API é essencial. A documentação geralmente pode ser visualizada no ambiente de desenvolvimento com o toque de um botão ou encontrada online. O Capítulo 1 também fornece URLs para a documentação disponível.

Tudo realmente começa com o Capítulo 2 e, a partir daí, iremos passo a passo. Qualquer pessoa com conhecimento de JavaScript, C, C# ou C++ pode facilmente folhear o Capítulo 2 . Aqueles mais familiarizados com OOP em C# ou C++ podem ler rapidamente o Capítulo 3 e continuar. O Capítulo 6 e o Capítulo 7 formam o centro OO do livro: Esses capítulos ensinam os conceitos OO de classe, método, associação, herança e vinculação dinâmica. Depois do Capítulo 7 , o treinamento básico OO está completo e, com o Capítulo 15 , você será apresentado a todos os conceitos básicos de Java.

Estratégias de Aprendizagem Pessoal

Se usar este livro em auto-estudo, uma estratégia de aprendizagem bem-sucedida pode ser descrita. A chave para a compreensão, como costuma acontecer, é a psicologia da aprendizagem, que examina as condições de leitura sob as quais um texto pode ser otimamente compreendido. O método que gostaria de apresentar é chamado de método PQ4R , que significa as seguintes etapas:

[+] Dica

Explicar em voz alta ajuda em muitos tipos de solução de problemas - basta bater um papo. Ainda mais legal é aprender com alguém e explicar os procedimentos um para o outro. Uma técnica de visualização interessante é o mapa mental, que pode ser usado para organizar o conteúdo.

O método PQ4R facilita a aquisição de conhecimento. No entanto, como todas as coisas aprendidas, se você não atualizar seu conhecimento regularmente, você o esquecerá. O método PQ4R deve, portanto, receber um R adicional para sucesso a longo prazo: R para repetir ou atualizar. Como regra, as pessoas lêem demais no começo e prestam pouca atenção aos detalhes. Mais tarde, quando mais conhecimento básico estiver disponível, até mesmo coisas básicas podem aparecer sob uma nova luz e se encaixar no quadro geral. Os leitores devem, portanto, pegar o livro de novo e de novo e virar suas páginas.

Focando no Essencial

Algumas seções são escritas para programadores experientes ou cientistas da computação. Os recém-chegados podem precisar se desviar do caminho sequencial dos capítulos em alguns pontos, pois alguns capítulos podem exigir mais informações básicas e familiaridade com linguagens de programação. As comparações com outras linguagens de programação visam a descontração e comparação e não são necessárias para o entendimento de Java.

Seções especiais

O universo Java é rico em sutilezas e muitas vezes confunde os recém-chegados. Por esse motivo, o livro pondera o conhecimento de duas maneiras. Em primeiro lugar, as caixas destacadas do texto fornecem informações especializadas e avançadas. Além disso, alguns títulos terminam com um asterisco (*), o que significa que esta seção pode ser pulada sem que o leitor perca nada essencial para capítulos posteriores.

Tarefas

Com este livro e um ambiente de desenvolvimento confiável, você pode desenvolver seus primeiros programas. No entanto, a leitura não é suficiente para aprender uma nova linguagem de programação. Se você quer aprender uma linguagem de programação, você deve praticá-la e falar como uma língua estrangeira.

Acompanhando este livro estão exercícios práticos disponíveis online em https://tutego.de/javabuch/aufgaben/index_en.html . Nesse site, você encontrará links para soluções completas. O site é atualizado periodicamente com novas tarefas e soluções.

Estrutura deste livro

O Capítulo 1 destaca os recursos especiais da linguagem Java. Neste capítulo, faço algumas comparações com outras linguagens OO populares. Este capítulo não é particularmente técnico e também descreve o curso histórico da evolução do Java. O capítulo não é estruturado didaticamente, de modo que alguns conceitos não são abordados em profundidade até os capítulos posteriores; iniciantes devem folheá-lo. Também mostraremos como obter e instalar um JDK para que seus primeiros programas possam ser compilados e executados. O aprendizado será mais divertido com um ambiente de desenvolvimento, portanto, também é fornecida uma introdução aos IDEs.

As coisas realmente acontecem no Capítulo 2 . Este capítulo descreve variáveis, tipos e elementos de linguagem imperativa, descrevendo instruções e expressões que formam a base de qualquer programa. Descrições de instruções case, tipos de loop e métodos também podem ser encontradas neste capítulo. Esses recursos ainda são possíveis sem muita orientação a objetos.

As coisas realmente se tornam OO no Capítulo 3 . Primeiro exploraremos as classes disponíveis na biblioteca padrão e desenvolveremos nossas próprias classes mais tarde porque nosso foco está primeiro nos conceitos básicos, como a palavra-chave new , referências, referência nula e comparações de referência. A biblioteca padrão é tão rica que, com classes predefinidas e apenas com esse conhecimento básico, muitos programas podem ser desenvolvidos. As estruturas de dados fornecidas podem ser usadas de várias maneiras.

Vários tipos de dados podem ser combinados em um array, que é apresentado no Capítulo 4 . Arrays também formam a base de alguns conceitos de Java, como listas de argumentos variáveis e extensões para .

A razão por trás de muitos problemas é a mudança na manipulação de caracteres e strings, que apresentaremos no Capítulo 5 . Neste capítulo, os tipos importantes Character (o tipo de dados para caracteres únicos), String , e StringBuilder (tipos de dados para strings) serão introduzidos. Com relação às cordas, às vezes, as partes devem ser recortadas, reconhecidas e convertidas. Um split(...) da classe String é possível, e a classe Scanner pode dividir strings em substrings usando separadores. Objetos de formato colocam qualquer saída no formato desejado, incluindo a saída de números decimais.

Com esse conhecimento sobre a criação de objetos e referências, a próxima etapa pode ocorrer: o Capítulo 6 trata da criação de classes personalizadas. Usando jogos e salas, modelaremos propriedades de objetos. Conceitos importantes como construtores, propriedades estáticas e enumerações são descritos neste capítulo.

Relacionamentos de objeto, isto é, associações entre objetos (também chamados de relacionamentos de usos-A) e relacionamentos de herança são os assuntos do Capítulo 7 . Este capítulo apresenta a OOP real e aborda vinculação dinâmica, classes abstratas e visibilidade.

Java suporta vários tipos, e além das classes, outro tipo importante é a interface. O Capítulo 8 apresenta esse tipo específico, bem como dois outros tipos: tipos de enumeração e registros.

As exceções, que são discutidas no Capítulo 9 , formam uma importante espinha dorsal para todos os programas, pois os erros dificilmente podem ser evitados. Por esta razão, aconselha-se o suporte ativo de seu manuseio, pois isso obriga um programador a cuidar dos erros e corrigi-los.

O Capítulo 10 descreve como as classes podem ser aninhadas umas nas outras. Esse aninhamento pode melhorar o encapsulamento porque as implementações também podem ser locais.

O Capítulo 11 descreve classes que são centrais para a biblioteca Java, como classes de comparação, classes wrapper e a classe Object , que é a superclasse de todas as classes Java.

Os genéricos podem ser usados para declarar classes, interfaces e métodos com uma espécie de marcador de posição de tipo, onde o tipo concreto é definido posteriormente. O Capítulo 12 fornece informações sobre essa tecnologia.

As expressões lambda existem desde o Java 8; eles simplificam a programação funcional em particular. Dedicamos o Capítulo 13 às propriedades da linguagem. Neste capítulo, você também aprenderá sobre muitos tipos padrão usados na programação funcional.

Neste ponto, as bases foram lançadas e os capítulos restantes se baseiam no conhecimento já adquirido. O Capítulo 14 apresenta princípios SOLID, mostra aplicações de boa OOP e apresenta padrões de projeto. Com base em vários exemplos, este capítulo demonstra como interfaces e hierarquias de classes podem ser usadas efetivamente em Java. A chave é pensar pequeno, mas escrever grandes aplicativos.

O Capítulo 15 descreve como, em Java, componentes individuais ou sistemas de componentes podem ser usados de forma flexível para outros aplicativos.

Após os primeiros 15 capítulos, os leitores estarão quase totalmente familiarizados com a linguagem Java. No entanto, como Java não é apenas uma linguagem, mas também um conjunto de bibliotecas padrão, a segunda metade do livro se concentra nas APIs básicas. No final de cada capítulo, uma seção de Leitura adicional fornece referências a recursos online interessantes. Nesse ponto, os leitores podem deixar o caminho sequencial e se concentrar em tópicos individuais, pois os tópicos restantes geralmente não são diretamente interdependentes.

A biblioteca Java consiste em mais de 4.000 classes, interfaces, enumerações, exceções e anotações. O Capítulo 16 fornece uma visão geral dos pacotes mais importantes e seleciona algumas classes da biblioteca, como carregar classes. Neste capítulo, você também encontrará classes para configurar aplicativos ou maneiras de executar programas externos.

O Capítulo 17 ao Capítulo 22 fornece uma visão geral das APIs Java SE selecionadas. O Capítulo 17 fornece uma introdução à programação concorrente, enquanto o Capítulo 18 mostra estruturas de dados comuns, como listas, conjuntos e memória associativa de maneira prática. O Capítulo 19 fornece uma visão geral de como você pode ler e escrever em arquivos. Se quiser usar um banco de dados relacional para armazenar dados, você encontrará informações úteis no Capítulo 20 . O Capítulo 21 apresenta a classe Math , que fornece métodos matemáticos típicos para realizar cálculos trigonométricos, por exemplo. Com outra classe, você pode gerar números aleatórios. O capítulo também cobre a manipulação de números inteiros ou floats arbitrariamente longos.

O teste automático de aplicativos ajuda a detectar erros no código, especialmente se alterações tolas de código forem introduzidas posteriormente e o programa não se comportar mais de acordo com a especificação. O Capítulo 22 apresenta o conceito de casos de teste e demonstra como executá-los de forma fácil e automática. Além disso, este capítulo enfoca o projeto de aplicativos testáveis.

Por fim, o Capítulo 23 fornece uma breve visão geral das ferramentas de linha de comando como javac para compilar programas Java e java para iniciar a JVM e executar programas Java.

Convenções

As seguintes convenções são usadas neste livro:

bilderklein/klein00_001.png

Listagens de programas

Listagens inteiras de programas são estruturadas da seguinte maneira:

classe doces {

}

Listagem 1 Candy.java

O código fonte mostrado está localizado no arquivo Candy.java. Se o tipo (classe, enumeração, interface ou anotação) estiver em um pacote, a especificação do caminho será colocada com o nome do arquivo:

pacote com.tutego.island;

classe doces { }

Listagem 2 com/tutego/island/Candy.java

Para economizar espaço, o livro geralmente apresenta trechos de código-fonte. O código-fonte completo está disponível na Internet ( www.rheinwerk-computing.com/5557 ). Caso seja exibido um trecho de um arquivo do tipo Person.java, indicaremos essa edição na legenda, por exemplo, das seguintes formas:

Person.java (trecho)

Pessoa.java, main(), Parte 1

Se programas de amostra forem fornecidos para determinadas classes, os nomes de classe desses programas geralmente terminam em Demo . Portanto, para a classe Java DateFormat , um programa de amostra que demonstra a funcionalidade da classe DateFormat é denominado DateFormatDemo .

Documentação da interface de programação de aplicativos neste livro

Variáveis de classe/objeto, construtores e métodos são encontrados em uma listagem especial que facilita a localização no livro e o uso como trabalho de referência.

classe abstrata java.text.

DateFormat

estende Format

implementa Cloneable, Serializable

O retângulo contém a classe totalmente qualificada ou o nome da interface (como a classe DateFormat no pacote java.text ) ou o nome da anotação ou tipo de enumeração. As linhas a seguir listam a superclasse ( DateFormat herda de Format ) e as interfaces implementadas ( DateFormat implementa Cloneable e Serializable ). Como qualquer classe que não possui uma superclasse explícita herda automaticamente de Object , essa herança não é especificada separadamente. A visibilidade é pública , a menos que especificado de outra forma, o que é comum para métodos de biblioteca. Se uma interface for descrita, os métodos serão automaticamente abstratos e públicos, e as palavras-chave abstract e public não serão especificadas adicionalmente. As variáveis de classe/objeto de enumeração subsequentes são seguidas por construtores e métodos. A menos que especificado de outra forma, a visibilidade é pública . Se os erros forem especificados com throws , eles não serão RuntimeExceptions, mas apenas exceções verificadas. Métodos obsoletos não estão listados, mas podem ser mencionados se não houver alternativa.

Programas executáveis

Os programas executáveis na linha de comando podem ser reconhecidos por um cifrão no início (mesmo que outros sistemas operacionais e linhas de comando exibam um prompt diferente). Os caracteres a serem digitados pelo usuário são colocados em negrito; a saída não é, como no exemplo a seguir:

$

java Joke

Onde os peixes dormem? No leito do rio.

Agradecimentos

Eu tinha 9 anos quando meus pais abriram o mundo dos computadores para mim com o Commodore 64. Como não tinha um meio para salvar programas e dados, não tive escolha a não ser reinserir tudo após a reinicialização - a maneira como aprendi a programa. Aos meus pais, um grande obrigado pelo computador, pelo amor e por confiarem em mim.

Agradecimentos à Sun Microsystems, que iniciou o desenvolvimento em Java em 1991. Sem a Sun, não haveria Java e, sem Java, não haveria este livro. Obrigado também à Oracle, como compradora da Sun, porque talvez sem a aquisição o Java teria sido finalizado.

Java vive – talvez eu deva dizer, sobrevive – por meio de muitas ferramentas gratuitas e uma comunidade ativa de código aberto. Um grande obrigado vai para todos os desenvolvedores que escrevem e mantêm as muitas ferramentas, bibliotecas e estruturas Java disponíveis hoje, como Eclipse, Maven, JUnit e Spring Tomcat. Sem eles, o Java não estaria onde está hoje.

Por fim, gostaria de expressar meus agradecimentos à Rheinwerk Publishing por me ajudar a publicar este livro. Agradeço a colaboração do meu editor.

Recursos para este livro

Todos os programas de amostra estão disponíveis para download no site do livro: Acesse www.rheinwerk-publishing.com/5557 . Clique na guia Recursos para visualizar os arquivos para download com uma breve descrição do conteúdo de cada arquivo. Clique no botão Download para iniciar o processo de download. Dependendo do tamanho do arquivo (e da sua conexão com a internet), pode ser necessário algum tempo para que o download seja concluído.

Opinião

Não importa o quão cuidadosamente passamos pelos capítulos deste livro, as discrepâncias são prováveis em mais de 1.100 páginas, assim como qualquer software pode ter erros puramente estatísticos. Se você tiver comentários, sugestões, correções ou perguntas sobre pontos específicos ou didática geral, não hesite em me enviar um e-mail para [e-mail] . Estou sempre aberto a sugestões, elogios e repreensões.

Agora, estamos prontos para explorar a vida entre as chaves e seguir o filósofo grego Platão, que disse: O começo é a parte mais importante do trabalho.

1 Introdução

Estamos produzindo informações em massa hoje, assim como os carros costumavam ser.

—John Naisbitt (1929–2021)

Após 20 anos, o Java finalmente se estabeleceu como uma plataforma. Milhões de desenvolvedores de software em todo o mundo ganham a vida com a linguagem, bilhões de dispositivos executam programas Java (por exemplo, todos os reprodutores de Blu-ray). Toda semana, o ambiente de execução da Oracle é baixado milhões de vezes. Neste capítulo, vamos apresentá-lo ao Java, discutir seus recursos, compará-lo com outras linguagens de programação e explorar suas plataformas e ambientes de desenvolvimento.

bilderklein/klein01_001.png

Figura 1.1 Muitos dispositivos falam Java

1.1 Antecedentes Históricos

Na década de 1970, quando os hippies ainda dançavam ao som da música de Jimi Hendrix, Bill Joy queria criar uma linguagem de programação que combinasse todas as vantagens do MESA [ 1 ] e C. Joy, co-fundador da Sun Microsystems, inicialmente não conseguiu realizar esse desejo, e somente na década de 1990 ele pôde descrever como seria uma nova linguagem orientada a objetos (OO), em seu artigo Further. Para Joy, seus princípios básicos devem ser baseados em C++ . Só mais tarde ele percebeu que o C++ não era adequado como linguagem base e muito difícil de manejar para programas grandes.

Naquela época, James Gosling estava trabalhando na Standard Generalized Markup Language (SGML) . Ele desenvolveu em C++ e também não gostou dessa linguagem. A nova linguagem Oak nasceu desse desagrado. O nome veio à mente de Gosling quando ele olhou pela janela e viu um carvalho, mas talvez seja apenas uma lenda, porque Oak também significa Object Application Kernel .

Patrick Naughton lançou o projeto Green em dezembro de 1990 , envolvendo Gosling e Mike Sheridan . Um resquício do projeto Green é o Duke, que se tornou um símbolo bem conhecido. [ 2 ]

bilderklein/klein01_002.png

Figura 1.2 Duke: o mascote para Java

A ideia por trás deste projeto era desenvolver software para televisão interativa e outros dispositivos eletrônicos de consumo. Os componentes deste projeto foram o sistema operacional Green-OS , o interpretador de Gosling, Oak, e alguns componentes de hardware. Joy mostrou aos membros do projeto Green seu ensaio Further e começou a implementar uma interface gráfica do usuário (GUI). Gosling escreveu o compilador original em C e, em seguida, Naughton, Gosling e Sheridan projetaram o interpretador de tempo de execução em C também. Em última análise, a linguagem C++ nunca foi usada. A Oak executou seus primeiros programas em agosto de 1991. Assim, a Green Dream Team desenvolveu um dispositivo chamado *7 ( (Star Seven ), introduzido internamente no outono de 1992. O ex-CEO da Sun, Scott McNealy (que deixou a empresa após a aquisição da Oracle em janeiro de 2010) ficou impressionado com *7, e a equipe se tornou First Person, Inc., em novembro daquele ano. Agora, era uma questão de marketing *7.

No início de 1993, a equipe ouviu que a Time Warner estava procurando um sistema para decodificadores , que são dispositivos eletrônicos de usuário final que se conectam a um aparelho de TV. A First Person voltou sua atenção do mercado de consumo para os decodificadores. Infelizmente, a Time Warner não estava mais interessada, mas First Person continuou a se desenvolver. Depois de muitas mudanças de direção, seu trabalho de desenvolvimento se concentrou na rede mundial de computadores(referido como web para abreviar). A linguagem de programação deveria receber o código do programa pela rede e os programas defeituosos não deveriam causar nenhum dano. Com esse desenvolvimento, a maioria dos conceitos de C(++) já pode ser verificada - o acesso por meio de ponteiros inválidos que gravam descontroladamente na memória são um exemplo. Os membros da equipe do projeto original perceberam que o Oak tinha todos os recursos necessários para uso na web – perfeito, mesmo tendo sido originalmente desenvolvido para uma finalidade completamente diferente. A linguagem Oak foi renomeada para Java em 1994 porque o nome Oak já estava registrado pela Oak Technology. Segundo a tradição, a decisão pelo nome Java foi tomada em uma cafeteria. Em Java, Patrick Naughton demonstrou um protótipo do navegador WebRunner, supostamente criado em um único fim de semana. Após pequenas revisões por Jonathan Payne, o navegador foi batizado de HotJava e apresentado ao público em maio no SunWorld '95.

No início, apenas alguns usuários podiam fazer amizade com o HotJava. Então, um momento verdadeiramente feliz ocorreu quando a Netscape decidiu licenciar a tecnologia Java. O Java foi implementado na versão 2.0 do Netscape Navigator, lançado em dezembro de 1995. Em 23 de janeiro de 1996, foi lançado o Java Development Kit (JDK) 1.0, que pela primeira vez forneceu uma maneira de programar aplicativos Java e applets da web (com applet definido como uma mini-aplicação). Pouco antes da conclusão do JDK 1.0, os membros restantes da equipe Green fundaram a empresa JavaSoft , iniciando o progresso triunfante do Java.

["]  Onde esta o sol? Oracle adquire a Sun Microsystems em 2010

Java foi originalmente desenvolvido pela Sun Microsystems , uma empresa com uma longa história em sistemas operacionais e hardware. A Sun estabeleceu muitas bases para sistemas de TI modernos, mas muitos só estão familiarizados com ela por meio do Java.

A Sun Microsystems nunca se saiu tão bem como empresa. Conhecida e respeitada por seus produtos, a Sun não tinha habilidade para transformar seus produtos e serviços em dinheiro. Após grandes perdas de receita, a Oracle Corporation adquiriu a Sun Microsystems por US$ 7,4 bilhões, junto com todos os direitos e patentes para Java, MySQL, Solaris, OpenOffice, VirtualBox e outros produtos. Desde então, a Oracle descontinuou alguns projetos de código aberto, mas os grandes e comercialmente viáveis ainda estão em boa forma.

1.2 Sobre a popularidade do Java: os principais recursos

Java é uma linguagem OOP caracterizada por vários recursos importantes para torná-la universalmente aplicável e interessante para empresas como uma linguagem de programação robusta. Como o Java permite OOP, os desenvolvedores podem criar componentes de software modernos e reutilizáveis.

Em parte, Java parece bastante conservador, mas isso ocorre porque os projetistas da linguagem Java não incorporam imediatamente tudo o que está na moda no momento. Java sempre incorporou ao núcleo da linguagem o que provou ser útil e bom em outras linguagens de programação. No entanto, a Sun e depois a Oracle evitaram incluir coisas na linguagem que eram usadas apenas por alguns programadores ou que levavam a erros frequentes. Nos primeiros dias, C++ era um modelo, mas hoje, Java está olhando de soslaio para C# e linguagens de script.

Vamos agora examinar algumas propriedades centrais de Java e destacar alguns termos-chave e modos de operação.

1.2.1 Código de bytes

Primeiro, Java é uma linguagem de programação como qualquer outra. Mas diferentemente dos interpretadores convencionais de uma linguagem de programação, que costumam gerar código de máquina para um processador específico (por exemplo, para microprocessadores x86 ou processadores da arquitetura ARM) e uma plataforma específica (como Linux ou Windows), o compilador Java gera o que chamamos de bytecode de seus arquivos de código-fonte. Esse código de programa é binário e serve como