Nosso primeiro programa Java

Nosso primeiro programa Java

• Um aplicativo Java é executado quando você usa o comando java para iniciar a JVM.
• Comentários documentam programas e melhoram sua legibilidade, sendo ignorados pelo compilador.
• Um comentário de fim de linha começa com // e termina no final da linha.
• Comentários tradicionais delimitados por /* e */ podem se estender por várias linhas.
• Comentários Javadoc, delimitados por /** e */, permitem incorporar documentação no código, e o utilitário javadoc gera páginas HTML com base nesses comentários.
• Erro de sintaxe (ou de compilação) ocorre quando o compilador encontra um código que viola as regras do Java, semelhante a um erro gramatical.
• Linhas em branco, espaços e tabulações são conhecidos como espaço em branco, o qual facilita a leitura dos programas e não é ignorado pelo compilador.
• Palavras-chave são reservadas para uso do Java, sempre escritas em minúsculas.
• A palavra-chave class introduz uma declaração de classe.
• Por convenção, nomes de classes Java começam com maiúscula e apresentam cada palavra com inicial maiúscula (ex: SampleClassName).
• O nome de uma classe Java é um identificador, consistindo em letras, dígitos, sublinhados (_) e cifrões ($), não iniciando com dígito nem contendo espaços.
• Java distingue entre maiúsculas e minúsculas.
• O corpo de cada declaração de classe é delimitado por chaves { e }.
• Uma declaração de classe public deve ser salva em um arquivo com o mesmo nome da classe seguido por “.java”.
• O método main é o ponto de partida de cada aplicativo Java, devendo iniciar com public static void main(String[] args); caso contrário, a JVM não executa o aplicativo.
• Métodos realizam tarefas e retornam informações ao concluí-las; void indica que um método não retorna informação.
• As instruções instruem o computador a realizar ações.
• Uma string entre aspas duplas é chamada de string de caracteres ou string literal.
• O objeto de saída padrão (System.out) exibe caracteres na janela de comando.
• O método System.out.println exibe o argumento na janela de comando seguido por um caractere de nova linha.
• Um programa é compilado com javac; se não houver erros de sintaxe, um arquivo de classe com os bytecodes Java é criado, sendo estes interpretados pela JVM ao executar o programa.
• Para executar um aplicativo, digite java seguido pelo nome da classe que contém main.

Modificando nosso primeiro programa Java

• System.out.print exibe seu argumento e posiciona o cursor de saída imediatamente após o último caractere exibido.
• A barra invertida () em uma string é um caractere de escape; a sequência \n representa uma nova linha.

Exibindo texto com printf

• System.out.printf (f significa “formatado”) exibe os dados formatados.
• O primeiro argumento do método printf é uma string de formato contendo texto fixo e/ou especificadores de formato.
• Especificadores de formato indicam o tipo de dado a ser gerado e reservam espaço para argumentos correspondentes, começando com o sinal de porcentagem (%) seguido por um caractere que representa o tipo de dado.
• O especificador de formato %s é um espaço reservado para uma string de caracteres.
• O especificador de formato %n é um separador de linha portável.

Outra aplicação: adicionando inteiros

• Uma declaração import ajuda o compilador a localizar uma classe usada em um programa.
• O conjunto de classes predefinidas do Java é agrupado em pacotes, referidos como biblioteca de classes Java ou Interface de Programação de Aplicativo Java (API Java).
• Uma variável é uma posição na memória do computador para armazenar um valor para uso posterior, devendo ser declarada com um nome e um tipo antes de ser utilizada.
• O nome de uma variável permite que o programa acesse seu valor na memória.
• Um Scanner (pacote java.util) permite ler os dados que um programa utilizará; antes de usar um Scanner, o programa deve criá-lo e especificar a origem dos dados.
• Variáveis devem ser inicializadas para serem preparadas para uso em um programa.
• A expressão new Scanner(System.in) cria um Scanner que lê a partir do objeto de entrada padrão (System.in), normalmente o teclado.
• O tipo de dado int é usado para declarar variáveis que conterão valores inteiros, com intervalo de -2.147.483.648 a +2.147.483.647.
• Os tipos float e double especificam números reais com pontos decimais.
• Variáveis do tipo char representam caracteres individuais, como letras maiúsculas, dígitos, caracteres especiais ou sequências de escape.
• Tipos como int, float, double e char são primitivos, e seus nomes devem aparecer em letras minúsculas.
• Um prompt direciona o usuário a tomar uma ação específica.
• O método Scanner nextInt obtém um inteiro para uso em um programa.
• O operador de atribuição, =, permite atribuir um valor a uma variável e é chamado de operador binário, pois tem dois operandos.
• Partes das declarações que contêm valores são chamadas expressões.
• O especificador de formato %d é um marcador de lugar para um valor int.

Conceitos de memória

• Nomes de variável correspondem a posições na memória do computador, cada variável tendo um nome, tipo, tamanho e valor.
• Um valor colocado em uma posição de memória substitui o valor anterior dessa posição.

Aritmética

• Os operadores aritméticos são + (adição), - (subtração), * (multiplicação), / (divisão) e % (resto).
• A divisão de inteiros produz um quociente inteiro.
• O operador de resto, %, fornece o resto de uma divisão.
• Expressões aritméticas devem ser escritas em forma de linha reta.
• Se uma expressão contém parênteses aninhados, o conjunto mais interno é avaliado primeiro.
• Java aplica os operadores a expressões aritméticas em uma sequência precisa determinada pelas regras de precedência de operador.
• Quando dizemos que operadores são aplicados da esquerda para a direita, estamos nos referindo à sua associatividade; alguns operadores associam da direita para a esquerda.
• Parênteses redundantes podem tornar uma expressão mais clara.

Tomada de decisão: operadores de igualdade e operadores relacionais

• A instrução if toma uma decisão baseada no valor de uma condição (verdadeiro ou falso).
• As condições em instruções if podem ser formadas utilizando os operadores de igualdade (== e !=) e relacionais (>, <, >= e <=).
• Uma instrução if começa com a palavra-chave if, seguida por uma condição entre parênteses, e espera uma instrução no seu corpo.
• A instrução vazia não realiza qualquer tarefa.

Variáveis de instância, métodos set e métodos get

• Cada classe criada torna-se um novo tipo que pode ser utilizado para declarar variáveis e elaborar objetos.
• Novos tipos de classe podem ser declarados conforme necessário, sendo essa uma razão pela qual o Java é conhecido como uma linguagem extensível.
• Toda declaração de classe que inicia com o modificador de acesso public deve ser armazenada em um arquivo com o mesmo nome que a classe e termina com a extensão .java.
• Cada declaração de classe contém a palavra-chave class seguida imediatamente do nome da classe.
• Nomes de classe, método e variável são identificadores, usando nomes na notação camelo por convenção, com nomes de classe começando com letra maiúscula, e os de método e variável, com uma letra minúscula.
• Um objeto tem atributos que são implementados como variáveis de instância que eles mantêm ao longo de sua vida.
• Variáveis de instância existem antes que os métodos sejam chamados em um objeto, enquanto os métodos são executados e depois que essa ação foi concluída.
• Uma classe normalmente contém um ou mais métodos que manipulam as variáveis de instância que pertencem a objetos específicos da classe.
• Variáveis de instância são declaradas dentro de uma declaração de classe, mas fora do corpo das instruções de método da classe.
• Cada objeto (instância) da classe tem sua própria cópia de cada uma das variáveis de instância da classe.
• A maioria das declarações de variável de instância é precedida pela palavra-chave private, que é um modificador de acesso.
• Variáveis ou métodos declarados com o modificador de acesso private só são acessíveis a métodos da classe em que são declarados.
• Os parâmetros são declarados em uma lista de itens separados por vírgula, que está localizada entre os parênteses que vêm depois do nome do método na declaração dele.
• Múltiplos parâmetros são separados por vírgulas, cada um especificando um tipo seguido por um nome de variável.
• As variáveis declaradas no corpo de um método particular são conhecidas como locais e só podem ser utilizadas nesse método, e seus valores são perdidos quando ele termina.
• Os parâmetros de um método são variáveis locais dele.
• O corpo de todos os métodos é delimitado pelas chaves esquerda e direita ({ e }).
• O corpo de cada método contém uma ou mais instruções que executam a(s) tarefa(s) desse método.
• O tipo de retorno do método especifica o tipo de dado retornado para o chamador; a palavra-chave void indica que um método realizará uma tarefa, mas não retornará nenhuma informação.
• Parênteses vazios que seguem um nome de método indicam que ele não requer nenhum parâmetro para realizar sua tarefa.
• Quando um método que especifica um tipo de retorno diferente de void for chamado e completar sua tarefa, ele retornará um resultado para seu método de chamada.
• A instrução return passa um valor a partir de um método chamado de volta para seu chamador.
• As classes costumam fornecer métodos public para permitir aos clientes da classe set (configurar) ou get (obter) variáveis de instância private.
• Os nomes desses métodos não precisam começar com set ou get, mas essa convenção de nomenclatura é recomendada.

Classe AccountTest que cria e usa um objeto da classe Account

• Uma classe que cria um objeto de outra classe, e então chama os métodos do objeto, é uma driver.
• O método Scanner nextLine lê os caracteres até um caractere de nova linha ser encontrado, depois retorna os caracteres como um método String.
• O método Scanner next lê os caracteres até qualquer um de espaço em branco ser encontrado, então retorna os caracteres como uma String.
• A expressão de criação de instância de classe começa com a palavra-chave new e estabelece um novo objeto.
• Um construtor é semelhante a um método, mas é chamado implicitamente pelo operador new para inicializar as variáveis de instância de um objeto no momento em que ele é criado.
• Para chamar um método de um objeto, o nome da variável deve ser seguido de um ponto separador, do nome de método e de um conjunto de parênteses que contém os argumentos do método.
• Variáveis locais não são inicializadas automaticamente, enquanto cada variável de instância tem um valor inicial padrão fornecido pelo Java quando você não especifica o valor inicial dela.
• O valor padrão para uma variável de instância do tipo String é null.
• Uma chamada de método fornece valores conhecidos como argumentos para cada um dos parâmetros dele, e o valor de cada argumento é atribuído ao parâmetro correspondente no cabeçalho do método.
• O número de argumentos na chamada de método deve corresponder ao de itens na lista de parâmetros da declaração do método.
• Os tipos de argumento na chamada de método devem ser consistentes com os dos parâmetros correspondentes na declaração do método.

Compilação e execução de um aplicativo com múltiplas classes

• O comando javac pode compilar múltiplas classes ao mesmo tempo, basta listar os nomes dos arquivos do código-fonte após o comando com cada um deles separado do próximo por um espaço.
• Se o diretório contendo o aplicativo incluir apenas os arquivos de um único aplicativo, todas as classes podem ser compiladas com o comando javac *.java; o asterisco (*) em *.java indica que todos os arquivos no diretório atual que têm a extensão .java devem ser compilados.

Diagrama de classe UML de Account com uma variável de instância e os métodos set e get

• Na UML, cada classe é modelada em um diagrama de classe como um retângulo com três compartimentos.
• O compartimento na parte superior contém o nome da classe centralizado horizontalmente em negrito.
• O compartimento do meio exibe os atributos da classe, que correspondem às variáveis de instância em Java.
• O inferior inclui as operações da classe, que correspondem a métodos e construtores em Java.
• A UML representa variáveis de instância como um nome de atributo, seguido por dois-pontos e o tipo.
• Atributos privados são precedidos por um sinal de subtração (–) na UML.
• UML modela operações listando o nome delas seguido por um conjunto de parênteses, com um sinal de adição (+) na frente do nome da operação indicando que é do tipo public na UML (isto é, um método public em Java).
• UML modela um parâmetro de uma operação listando o nome dele, seguido por um caractere de dois-pontos e o tipo dele entre parênteses depois do nome de operação.
• UML indica o tipo de retorno de uma operação colocando dois-pontos e ele depois dos parênteses que seguem ao nome da operação.
• Diagramas de classe UML não especificam tipos de retorno para operações que não retornam valores.
• Declarar variáveis de instância private é conhecido como ocultar dados ou informações.

Notas adicionais sobre a classe AccountTest

• A maioria dos métodos devem ser chamados explicitamente (exceto main) para instruí-los a fazer suas tarefas.
• Uma parte fundamental da ativação da JVM para localizar e chamar o método main a fim de começar a execução do aplicativo é a palavra-chave static, que indica que main é um método static que pode ser chamado sem antes criar um objeto da classe em que esse método é declarado.
• A maioria das outras classes que você utilizará nos programas Java precisa ser importada explicitamente.
• Há um relacionamento especial entre as classes compiladas no mesmo diretório, que são consideradas como estando no mesmo pacote (pacote padrão); classes do mesmo pacote são importadas implicitamente para os arquivos de código-fonte de outras classes desse mesmo pacote.
• Uma declaração import não é necessária quando uma classe em um pacote utiliza outra no mesmo pacote.
• Uma declaração import não é necessária se você sempre se referir a uma classe com um nome totalmente qualificado, que inclui o nome do pacote e o nome da classe.

Engenharia de software com variáveis de instância private e métodos set e get public

• Declarar variáveis de instância private é conhecido como ocultar dados ou informações.

Tipos primitivos versus tipos por referência

• Tipos no Java são divididos em duas categorias: primitivos e por referência. Tipos primitivos são boolean, byte, char, short, int, long, float e double; outros são por referência (classes, que especificam os tipos de objeto).
• Uma variável de tipo primitivo pode armazenar exatamente um valor de seu tipo declarado por vez.
• Variáveis de instância de tipo primitivo são inicializadas por padrão: tipos byte, char, short, int, long, float e double são inicializados como 0, e tipo boolean é inicializado como false.
• Variáveis de tipo por referência (chamadas referências) armazenam o local de um objeto na memória do computador; variáveis referenciam objetos e o objeto referenciado pode conter muitas variáveis de instância e métodos.
• Variáveis de instância de tipo por referência são inicializadas por padrão como valor null.
• Uma referência a um objeto é necessária para chamar seus métodos; uma variável de tipo primitivo não referencia um objeto, e portanto não pode ser utilizada para invocar um método.

Classe Account: inicialização de objetos com construtores

• Cada classe declarada pode fornecer um construtor com parâmetros para inicializar os objetos da classe quando eles forem criados.
• Java requer uma chamada de construtor para cada objeto criado.
• Construtores podem especificar parâmetros, mas não tipos de retorno.
• Se uma classe não definir construtores, o compilador fornecerá um construtor padrão sem parâmetros, e as variáveis de instância da classe serão inicializadas com seus valores padrão.
• Se você declarar um construtor para uma classe, o compilador não criará um construtor padrão para ela.
• UML modela construtores no terceiro compartimento de um diagrama de classe, colocando a palavra “constructor” entre aspas francesas (« e ») antes do nome do construtor para distingui-lo das operações.

A classe Account com um saldo; números de ponto flutuante

• Um número de ponto flutuante tem um ponto decimal.
• Java fornece dois tipos primitivos para armazenar números de ponto flutuante na memória: float e double.
• Variáveis do tipo float representam números de ponto flutuante de precisão simples e têm sete dígitos significativos.
• Variáveis do tipo double indicam números de ponto flutuante de dupla precisão, requerendo duas vezes mais memória que variáveis float e fornecendo 15 dígitos significativos.
• Literais de ponto flutuante são do tipo double por padrão.
• O método nextDouble de Scanner retorna um valor double.
• O especificador de formato %f é utilizado para gerar saída de valores de tipo float ou double.
• O especificador de formato %.2f especifica que dois dígitos da precisão devem ser gerados à direita do ponto decimal no número de ponto flutuante.
• O valor padrão para uma variável de instância do tipo double é 0.0, e o valor padrão para uma variável de instância do tipo int é 0.

Introdução

• Antes de escrever um programa para resolver um problema, você deve entender completamente o problema e ter uma abordagem cuidadosamente planejada para resolvê-lo, entendendo os blocos de construção que estão disponíveis e empregando técnicas de construção do programa comprovadas.

Algoritmos

• Qualquer problema de computação pode ser resolvido executando uma série de ações em uma ordem específica.
• O procedimento para resolver um problema em termos das ações a serem executadas e da ordem em que são executadas é chamado algoritmo.
• Especificar a ordem em que as instruções são executadas em um programa chama-se controle de programa.

Pseudocódigo

• Pseudocódigo é uma linguagem informal que ajuda a desenvolver algoritmos sem se preocupar com os estritos detalhes da sintaxe da linguagem Java.
• O pseudocódigo do livro é simples, conveniente e fácil de usar, mas não é uma linguagem de programação de computador real; você pode usar seu próprio idioma nativo para desenvolver seu pseudocódigo.
• Pseudocódigo ajuda a “estudar” um programa antes de tentar escrevê-lo em uma linguagem de programação como Java.
• Pseudocódigo cuidadosamente preparado pode ser facilmente convertido em um programa Java correspondente.

Estruturas de controle

• Normalmente, instruções em um programa são executadas uma após a outra na ordem em que são escritas, processo chamado execução sequencial.
• Várias instruções Java permitem especificar que a próxima instrução a executar não seja necessariamente a próxima na sequência, o que é chamado transferência de controle.
• Bohm e Jacopini demonstraram que todos os programas podem ser escritos em termos de somente três tipos de estruturas de controle: estrutura de sequência, estrutura de seleção e estrutura de repetição.
• O termo “estruturas de controle” vem do campo das ciências da computação, e a Java Language Specification refere-se a “estruturas de controle" como “instruções de controle”.
• A estrutura de sequência está incorporada ao Java; a não ser que seja instruído de outra forma, o computador executa as instruções Java uma depois da outra na ordem em que elas são escritas (isto é, em sequência).
• Qualquer lugar que uma ação única pode ser colocada, várias ações podem ser colocadas em sequência.
• Diagramas de atividades fazem parte da UML, modelando o fluxo de trabalho (ou atividade) de uma parte de um sistema de software.
• Diagramas de atividades são compostos de símbolos como símbolos de estado de ação, losangos e pequenos círculos, que são conectados por setas de transição representando o fluxo da atividade.
• Estados de ação contêm expressões de ação que especificam determinadas ações a serem realizadas.
• As setas em diagramas de atividades representam transições, que indicam a ordem em que ocorrem as ações representadas pelos estados da ação.
• O círculo sólido localizado na parte superior de um diagrama de atividade representa o estado inicial da atividade (o começo do fluxo de trabalho antes de o programa realizar as ações modeladas).
• O círculo sólido cercado por um círculo vazio que aparece na parte inferior do diagrama representa o estado final (o fim do fluxo de trabalho depois que o programa realizar suas ações).
• Retângulos com o canto superior direito dobrados são notas da UML, contendo observações explicativas que descrevem o objetivo dos símbolos no diagrama.
• Java tem três tipos de instruções de seleção.
• A instrução de seleção única if escolhe ou ignora uma ou mais ações.
• A instrução de seleção dupla if...else seleciona entre duas ações ou grupos de ações.
• A instrução switch é chamada de instrução de seleção múltipla, pois seleciona entre muitas ações diferentes (ou grupos de ações).
• Java fornece as instruções de repetição while, do...while e for (também chamada iteração ou loop), que permitem que programas executem instruções repetidamente enquanto uma condição de continuação de loop permanece verdadeira.
• As instruções while e for realizam a(s) ação(ões) no seu zero de corpos ou mais horas – se a condição de continuação do loop for inicialmente falsa, a(s) ação(ões) não serão executadas.
• A instrução do...while realiza a(s) ação(ões) no seu corpo uma ou várias horas.
• As palavras if, else, switch, while, do e for são palavras-chave Java, e não podem ser utilizadas como identificadores (ex: nomes de variáveis).
• Cada programa é formado combinando o número de instruções de sequência, seleção e de repetição, conforme apropriado no algoritmo que o programa implementa.
• As instruções de controle de entrada única/saída única são anexadas umas às outras conectando o ponto de saída de uma instrução ao ponto de entrada da instrução seguinte, processo conhecido como empilhamento de instruções de controle.
• Uma instrução de controle também pode ser aninhada dentro de outra instrução de controle.

A instrução de seleção única if

• Programas utilizam instruções de seleção para escolher entre cursos alternativos de ações.
• O diagrama de atividade da instrução if de seleção única contém o símbolo de losango, que indica que uma decisão deve ser tomada.
• O fluxo de trabalho segue um caminho determinado pelas condições de guarda associadas do símbolo; se uma condição de guarda for verdadeira, o fluxo de trabalho entra no estado de ação para o qual a seta de transição correspondente aponta.
• A instrução if é uma instrução de controle de uma única entrada e uma única saída.

Instrução de seleção dupla if...else

• A instrução if de seleção única só realiza uma ação indicada quando a condição for true.
• A instrução de seleção dupla if...else executa uma ação quando a condição é verdadeira e outra ação quando a condição é falsa.
• Um programa pode testar múltiplos casos com instruções if...else aninhadas.
• O operador condicional (?:) é único operador ternário do Java — ele leva três operandos, e juntos, operandos e o símbolo ?: formam uma expressão condicional.
• O compilador Java sempre associa um else com o if imediatamente precedente, a menos que seja instruído a fazer de outro modo pela colocação de chaves ({}).
• O enunciado if espera uma instrução no seu corpo; para incluir várias instruções no corpo de um if (ou no corpo de um else de uma instrução if...else), inclua as instruções dentro de chaves ({ e }).
• Um bloco de instruções pode ser colocado em qualquer lugar em que uma instrução única pode ser inserida.

Instrução de repetição while

• Instrução de repetição permite especificar que um programa deve repetir uma ação enquanto alguma condição permanecer verdadeira.
• Símbolo de agregação da UML une dois fluxos de atividade em um único.
• Símbolos de decisão e agregação podem ser distinguidos pelo número de setas de transição que entram e saem.
• Um símbolo de decisão contém uma seta de transição apontando para o losango e duas ou mais setas de transição apontando a partir do losango para indicar possíveis transições a partir desse ponto, e cada seta de transição tem uma condição de guarda.
• Um símbolo de agregação contém duas ou mais setas de transição apontando para o losango e somente uma seta de transição apontando a partir do losango, para indicar a conexão de múltiplos fluxos de atividades a fim de continuar a atividade, e nenhuma das setas de transição associadas contém uma condição de guarda.

Formulando algoritmos: repetição controlada por contador

• Repetição controlada por contador utiliza uma variável chamada contador (ou variável de controle) para controlar o número de vezes que um conjunto de instruções é executado.
• A repetição controlada por contador costuma ser chamada de repetição definida, porque o número de repetições é conhecido antes de o loop começar a executar.
• Um total é uma variável utilizada para acumular a soma de vários valores, e geralmente são inicializadas como zero antes de serem utilizadas em um programa.
• A declaração de uma variável local deve aparecer antes de a variável ser utilizada nesse método, e uma variável local não pode ser acessada fora do método em que é declarada.
• Quando a divisão de um inteiro por outro resulta em um número fracionário, a parte fracionária do cálculo é truncada.

Formulando algoritmos: repetição controlada por sentinela

• Repetição controlada por sentinela usa um valor especial chamado valor de sentinela para indicar o “fim da entrada de dados”.
• Deve-se escolher um valor de sentinela que não possa ser confundido com um valor aceitável de entrada.
• O refinamento passo a passo de cima para baixo é essencial para o desenvolvimento de programas bem estruturados.
• A divisão por zero é um erro de lógica.
• Para realizar um cálculo de ponto flutuante com valores inteiros, faça a coerção (conversão) de um dos números inteiros para o tipo double.
• O Java sabe como avaliar somente expressões aritméticas nas quais os tipos dos operandos são idênticos; para assegurar isso, o Java realiza uma operação chamada de promoção em operandos selecionados.
• O operador de coerção unário é formado colocando parênteses em torno do nome de um tipo.

Operadores de atribuição compostos

• Os operadores de atribuição compostos abreviam expressões de atribuição.
• Instruções da forma variável = variável operador expressão;, em que operador é um dos operadores binários +, -, *, / ou %, podem ser escritas na forma variável operador= expressão;
• O operador += adiciona o valor da expressão à direita do operador ao valor da variável à esquerda do operador e armazena o resultado na variável à esquerda do operador.

Operadores de incremento e decremento

• O operador de incremento unário, ++, e operador de decremento unário, --, adicionam 1 ao, ou subtraem 1 do, valor de uma variável numérica.
• O operador de decremento ou incremento que é prefixado a uma variável é o operador de incremento de prefixo ou decremento de prefixo.
• O operador de incremento ou decremento que é pós-fixado a uma variável é o operador de incremento pós-fixo ou decremento pós-fixo, respectivamente.
• Utilizar o operador de pré-incremento ou pré-decremento para adicionar ou subtrair 1 é conhecido como pré-incrementar ou pré-decrementar, respectivamente.
• Pré-incrementar (ou pré-decrementar) uma variável faz com que a variável seja incrementada ou decrementada por 1, e então o novo valor da variável é utilizado na expressão em que ela aparece.
• Utilizar o operador de incremento ou decremento pós-fixo para adicionar ou subtrair 1 é conhecido como pós-incrementar ou pós-decrementar, respectivamente.
• Pós-incrementar ou pós-decrementar a variável faz com que seu valor seja utilizado na expressão em que ele aparece, e então o valor da variável é incrementado ou decrementado por 1.
• Ao incrementar ou decrementar uma variável em uma instrução isolada, o pré-incremento ou o pós-incremento têm o mesmo efeito, assim como o pré-decremento ou o pós-decremento.

Tipos primitivos

• O Java requer que todas as variáveis tenham um tipo, sendo conhecido como uma linguagem fortemente tipada, e utiliza caracteres de Unicode e números de ponto flutuante IEEE 754.

Princípios básicos de repetição controlada por contador

• Repetição controlada por contador requer uma variável de controle, o valor inicial da variável de controle, o incremento pelo qual a variável de controle é modificada a cada passagem pelo loop (também conhecido como cada iteração do loop) e a condição de continuação do loop, que determina se um loop deve continuar.
• Uma variável pode ser declarada e inicializada na mesma instrução.

Instrução de repetição for

• A instrução while pode ser utilizada para implementar qualquer loop controlado por contador.
• A instrução for especifica todos os detalhes do contador — repetição controlada no cabeçalho.
• Quando a instrução for começa a ser executada, sua variável de controle é declarada e inicializada.
• Se inicialmente a condição de continuação do loop for verdadeira, o corpo será executado.
• Depois de executar o corpo do loop, a expressão de incremento é executada, e então, o teste de continuação do loop é realizado novamente para determinar se o programa deve continuar com a próxima iteração do loop.
• O formato geral da instrução for é for (inicialização; condiçãoDeContinuaçãoDoLoop; incremento) instrução
• A expressão inicialização nomeia a variável de controle do loop e fornece seu valor inicial
• condiçãoDeContinuaçãoDoLoop é a condição que determina se o loop deve continuar executando
• incremento modifica o valor da variável de controle, para que a condição de continuação do loop por fim se torne falsa, e os dois pontos e vírgulas no cabeçalho for são necessários.
• A maioria das instruções for pode ser representada com instruções while equivalentes como: inicialização; while (condiçãoDeContinuaçãoDoLoop) { instrução incremento; }
• Em geral, as instruções for são utilizadas para repetição controlada por contador e as instruções while, para repetição controlada por sentinela.
• Se a expressão de inicialização no cabeçalho for declarar a variável de controle, esta só poderá ser utilizada nessa instrução for — ela não existirá fora da instrução for.
• As expressões em um cabeçalho for são opcionais; se a condiçãoDeContinuaçãoDoLoop for omitida, o Java irá supor que ela sempre é verdadeira, criando assim um loop infinito; você poderia omitir a expressão inicialização se a variável de controle for inicializada antes do loop; você poderia omitir a expressão incremento se o incremento fosse calculado com instruções no corpo do loop ou se nenhum incremento fosse necessário.
• A expressão incremento em uma instrução for atua como se ela fosse uma instrução independente no fim do corpo de for.
• Uma instrução for pode contar para baixo utilizando um incremento negativo (isto é, um decremento); se a condição de continuação do loop for inicialmente false, o corpo da instrução for não executa.

Exemplos com a estrutura for

• O Java trata as constantes de ponto flutuante como 1000.0 e 0.05 como tipo double, e as constantes de número inteiro como 7 e -22 como tipo int.
• O especificador de formato %4s gera saída para uma String em um tamanho de campo de 4 – isto é, printf exibe o valor com pelo menos 4 posições de caractere; se o valor a ser enviado para a saída for menor do que a largura de 4 posições de caractere, o valor é alinhado à direita no campo por padrão; se a largura tiver um valor maior do que 4 posições de caractere, o tamanho do campo é expandido para acomodar o número apropriado de caracteres; para alinhar o valor à esquerda, utilize um número inteiro negativo para especificar o tamanho do campo.
• Math.pow(x, y) calcula o valor de x elevado à y-ésima potência, recebendo dois argumentos double e retornando um valor double.
• O flag de formatação vírgula (,) em especificador de formato indica que um valor de ponto flutuante deve ser gerado com um separador de agrupamento (específico à localidade do usuário).
• Em um especificador de formato, o número inteiro à direita é a precisão do número.

Instrução de repetição do...while

• A instrução do...while é semelhante à instrução while; no while, o programa testa a condição de continuação do loop no início do loop, antes de executar seu corpo (se a condição for falsa, o corpo nunca será executado); a instrução do...while testa a condição de continuação do loop depois de executar o corpo do loop (portanto, o corpo sempre executa pelo menos uma vez).

A estrutura de seleção múltipla switch

• A instrução switch realiza diferentes ações com base nos valores possíveis de uma expressão integral (byte, short, int ou char, mas não long) ou uma String.
• O indicador de fim de arquivo é uma combinação de pressionamento de tecla dependente do sistema que termina a entrada de usuário.
• Nos sistemas UNIX/Linux/Mac OS X, o fim de arquivo é inserido digitando a sequência <Ctrl> d em uma linha separada.
• Nos sistemas Windows, insira o fim de arquivo digitando <Ctrl> z.
• O método Scanner determina se há mais dados a inserir quando retorna o valor boolean true se houver mais dados, e false caso contrário.
• Enquanto o indicador de fim do arquivo não tiver sido digitado, o método hasNext retornará true.
• A instrução switch consiste em um bloco que contém uma sequência de rótulos case e um caso default opcional.
• Em um switch, o programa avalia a expressão de controle e compara seu valor com cada rótulo case; se ocorrer uma correspondência, o programa executará as instruções para esse case.
• Listar casos consecutivamente sem instruções entre eles permite aos casos executar o mesmo conjunto de instruções.
• Cada valor que você deseja testar em um switch deve ser listado em um rótulo case separado.
• Cada case pode ter múltiplas instruções, e essas não precisam ser colocadas entre chaves.
• As instruções de um case geralmente terminam com uma instrução break que termina a execução do switch.
• Sem as instruções break, toda vez que ocorre uma correspondência nas instruções switch, as instruções para esse caso e casos subsequentes são executadas até que uma instrução break ou o fim do switch seja encontrado.
• Se não ocorrer nenhuma correspondência entre o valor da expressão controladora e um rótulo case, o caso default opcional é executado.
• Se não ocorrer nenhuma correspondência e o switch não contiver um caso default, o controle de programa simplesmente continua com a primeira instrução depois do switch.

Instruções break e continue

• A instrução break, quando executada em um while, for, do...while ou switch, ocasiona a saída imediata dessa instrução.
• A instrução continue, quando executada em while, for ou do...while, pula as instruções do corpo remanescentes do loop e passa para a próxima iteração; nas instruções while e do...while, o programa avalia o teste de continuação do loop imediatamente, e em uma instrução for, a expressão incremento é executada, então o programa avalia o teste de continuação do loop.

Operadores lógicos

• Condições simples são expressas em termos dos operadores