Baixe Introdução à Programação Java: Capítulos 2 a 8 e outras Notas de estudo em PDF para Informática, somente na Docsity!
Caelum - Java e Orientação a Objetos
- Capítulo 1: Como aprender Java......................................................................... Índice
- 1.1 - Falando em Java......................................................................................
- 1.2 - O que é realmente importante?..............................................................
- 1.3 - Sobre os exercícios.................................................................................
- 1.4 - Tirando dúvidas.......................................................................................
- 1.5 - Sobre o curso..........................................................................................
- 1.6 - Sobre os autores.....................................................................................
- Capítulo 2: O que é Java.....................................................................................
- 2.1 - Java..........................................................................................................
- 2.2 - Máquina Virtual......................................................................................
- 2.3 - Instalando o Java.....................................................................................
- 2.4 - Compilando o primeiro programa...........................................................
- 2.5 - Executando seu primeiro programa........................................................
- 2.6 - O que aconteceu?....................................................................................
- 2.7 - Exercícios................................................................................................
- 2.8 - O que pode dar errado?..........................................................................
- 2.9 - Um pouco mais......................................................................................
- 2.10 - Exercícios............................................................................................
- Capítulo 3: Variáveis primitivas e Controle de fluxo........................................
- 3.1 - Declarando e usando variáveis.............................................................
- 3.2 - Tipos primitivos e valores.....................................................................
- 3.3 - Exercícios..............................................................................................
- 3.4 - Casting e promoção..............................................................................
- 3.5 - O If-Else.................................................................................................
- 3.6 - O While..................................................................................................
- 3.7 - O For.....................................................................................................
- 3.8 - Exercícios..............................................................................................
- 3.9 - Controlando loops.................................................................................
- 3.10 - Escopo das variáveis...........................................................................
- 3.11 - Um bloco dentro do outro...................................................................
- 3.12 - Um pouco mais....................................................................................
- 3.13 - Exercícios............................................................................................
- 3.14 - Desafios...............................................................................................
- Capítulo 4: Orientação a objetos básica...........................................................
- 4.1 - O problema............................................................................................
- 4.2 - Criando um tipo....................................................................................
- 4.3 - Uma classe em Java..............................................................................
- 4.4 - Criando e usando um objeto.................................................................
- 4.5 - Métodos com retorno............................................................................
- 4.6 - O método transfere().............................................................................
- 4.7 - Objetos são acessados por variáveis referências!................................
- 4.8 - Continuando com atributos...................................................................
- 4.9 - Uma Fábrica de Carros.........................................................................
- 4.10 - Um pouco mais....................................................................................
- 4.11 - Exercícios............................................................................................
- 4.12 - Desafios...............................................................................................
- 4.13 - Fixando o conhecimento.....................................................................
- Capítulo 5: Um pouco de arrays.......................................................................
- 5.1 - O problema............................................................................................ Caelum - Java e Orientação a Objetos
- 5.2 - Arrays de referências............................................................................
- 5.3 - Percorrendo uma array.........................................................................
- 5.4 - Percorrendo uma array no Java 5.0......................................................
- 5.5 - Um pouco mais......................................................................................
- 5.6 - Exercícios..............................................................................................
- 5.7 - Desafios.................................................................................................
- 5.8 - Testando o conhecimento.....................................................................
- Capítulo 6: Modificadores de acesso e atributos de classe..............................
- 6.1 - Controlando o acesso............................................................................
- 6.2 - Getters e Setters...................................................................................
- 6.3 - Exercícios..............................................................................................
- 6.4 - Construtores..........................................................................................
- 6.5 - O Motivo................................................................................................
- 6.6 - Atributos de classe................................................................................
- 6.7 - Um pouco mais......................................................................................
- 6.8 - Exercícios..............................................................................................
- 6.9 - Desafios.................................................................................................
- Capítulo 7: Orientação a Objetos – herança, reescrita e polimorfismo............
- 7.1 - Repetindo código?.................................................................................
- 7.2 - Reescrita de método.............................................................................
- 7.3 - Polimorfismo.........................................................................................
- 7.4 - Um exemplo mais completo..................................................................
- 7.5 - Um pouco mais......................................................................................
- 7.6 - Exercícios..............................................................................................
- Capítulo 8: Orientação a Objetos – Classes Abstratas......................................
- 8.1 - Repetindo mais código?........................................................................
- 8.2 - Classe abstrata......................................................................................
- 8.3 - Métodos abstratos.................................................................................
- 8.4 - Um outro exemplo.................................................................................
- 8.5 - Para saber mais.....................................................................................
- 8.6 - Exercícios..............................................................................................
- Capítulo 9: Orientação à Objetos – Interfaces..................................................
- 9.1 - Aumentando nosso exemplo..................................................................
- 9.2 - Interfaces..............................................................................................
- 9.3 - Dificuldade no aprendizado de interfaces............................................
- 9.4 - Um pouco mais......................................................................................
- 9.5 - Exercícios..............................................................................................
- Capítulo 10: Exceções – Controlando os erros.................................................
- 10.1 - Exceção...............................................................................................
- 10.2 - Matemático profissional?....................................................................
- 10.3 - Abusando de uma array......................................................................
- 10.4 - Outro tipo de exceção: Checked Exceptions.......................................
- 10.5 - Mais de um erro..................................................................................
- 10.6 - E finalmente........................................................................................
- 10.7 - Criando novas exceções......................................................................
- 10.8 - Um pouco mais....................................................................................
- 10.9 - Exercícios............................................................................................
- 10.10 - Desafios.............................................................................................
- Capítulo 11: Pacotes – Organizando suas classes e bibliotecas....................... Caelum - Java e Orientação a Objetos
- 11.1 - Organização........................................................................................
- 11.2 - Import.................................................................................................
- 11.3 - Import Estático...................................................................................
- 11.4 - Acesso aos atributos, construtores e métodos....................................
- 11.5 - Arquivos, bibliotecas e versões...........................................................
- 11.6 - Um pouco mais....................................................................................
- 11.7 - Exercícios............................................................................................
- 11.8 - Desafios...............................................................................................
- Capítulo 12: O pacote padrão...........................................................................
- 12.1 - Documentação do Java........................................................................
- 12.2 - Pacote padrão.....................................................................................
- 12.3 - Um pouco sobre a classe System e Runtime......................................
- 12.4 - java.lang.Object..................................................................................
- 12.5 - Casting de referências........................................................................
- 12.6 - Integer.................................................................................................
- 12.7 - Autoboxing no Java 5.0.......................................................................
- 12.8 - Alguns métodos do java.lang.Object...................................................
- 12.9 - java.lang.String...................................................................................
- 12.10 - java.lang.Math..................................................................................
- 12.11 - Um pouco mais..................................................................................
- 12.12 - Exercícios..........................................................................................
- 12.13 - Desafio..............................................................................................
- Capítulo 13: Pacote java.io.............................................................................
- 13.1 - Orientação a objeto...........................................................................
- 13.2 - Lendo bytes e caracteres..................................................................
- 13.3 - Lendo Strings....................................................................................
- 13.4 - Fluxo de saída...................................................................................
- 13.5 - Um pouco mais..................................................................................
- 13.6 - Exercícios..........................................................................................
- 13.7 - Desafios.............................................................................................
- Capítulo 14: Collections framework...............................................................
- 14.1 - Arrays................................................................................................
- 14.2 - Principais interfaces.........................................................................
- 14.3 - Como ficamos no Java 5.0.................................................................
- 14.4 - Classe de exemplo.............................................................................
- 14.5 - Lista...................................................................................................
- 14.6 - Uma Lista no Java 5.0.......................................................................
- 14.7 - Mapas................................................................................................
- 14.8 - Mapas no Java 5.0.............................................................................
- 14.9 - Conjunto............................................................................................
- 14.10 - Iterando sobre coleções..................................................................
- 14.11 - Iterando coleções no java 5.0.........................................................
- 14.12 - Ordenação.......................................................................................
- 14.13 - Exercícios........................................................................................
- 14.14 - Desafios...........................................................................................
- Capítulo 15: Threads.......................................................................................
- 15.1 - Linhas de execução...........................................................................
- 15.2 - Criando uma subclasse da classe Thread.........................................
- 15.3 - Garbage Collector............................................................................. Caelum - Java e Orientação a Objetos
- 15.4 - Compartilhando objetos entre Threads............................................
- 15.5 - Usando um lock.................................................................................
- 15.6 - Um pouco mais..................................................................................
- 15.7 - Exercícios..........................................................................................
- Capítulo 16: E agora?.....................................................................................
- 16.1 - Exercício prático...............................................................................
- 16.2 - Certificação.......................................................................................
- 16.3 - Web...................................................................................................
- 16.4 - J2EE...................................................................................................
- 16.5 - Frameworks......................................................................................
- 16.6 - Revistas.............................................................................................
- 16.7 - Grupo de Usuários............................................................................
- 16.8 - Falando em Java................................................................................
- Capítulo 17: Apêndice A - Sockets..................................................................
- 17.1 - Protocolo...........................................................................................
- 17.2 - Porta..................................................................................................
- 17.3 - Socket................................................................................................
- 17.4 - Servidor.............................................................................................
- 17.5 - Cliente...............................................................................................
- 17.6 - Exercícios..........................................................................................
- 17.7 - Desafios.............................................................................................
- 17.8 - Solução..............................................................................................
- Data desta edição: 18/10/
1 Como aprender Java
“Homens sábios fazem provérbios, tolos os repetem” Samuel Palmer - Como o material está organizado e dicas de como estudar em casa.
1.1 - Falando em Java
Esta é a apostila da Caelum que tem como intuito ensinar Java de uma maneira elegante, mostrando apenas o que é necessário no momento correto e poupando o leitor de assuntos que não costumam ser de seu interesse em determinadas fases do aprendizado. O material aqui contido pode ser publicamente distribuído desde que não seja alterado e seus créditos sejam mantidos. Ele não pode ser usado para ministrar qualquer curso. Caso você esteja interessado em usá-lo para este fim, entre em contato através do email [email protected].
1.2 - O que é realmente importante?
Muitos livros, ao passar os capítulos, mencionam todos os detalhes da linguagem juntamente com os princípios básicos dela. Isso acaba criando muita confusão, em especial pois o estudante não consegue distinguir exatamente o que é importante aprender e reter naquele momento daquilo que será necessário mais tempo e principalmente experiência para dominar. Se uma classe abstrata deve ou não ter ao menos um método abstrato, se o if só aceitar argumentos booleanos e todos os detalhes de classes internas realmente não devem ser preocupações para aquele que possui como objetivo primário aprender Java. Esse tipo de informação será adquirida com o tempo, e não é necessário até um segundo momento. Neste curso separamos essas informações em quadros especiais, já que são informações extras. Ou então apenas citamos num exercício e deixamos para o leitor procurar informações se for de seu interesse. Algumas informações não são mostradas e podem ser adquiridas em tutoriais ou guias de referência, normalmente são detalhes que para um programador experiente em Java é algo importante. Por fim falta mencionar sobre a prática, que deve ser tratada seriamente: todos os exercícios são muito importantes e os desafios podem ser feitos quando o curso acabar. De qualquer maneira recomendamos aos alunos estudar em casa, principalmente aqueles que fazem os cursos intensivos.
O curso
Capítulo 1 - Como aprender Java - Página 1
capítulo 1
na Alemanha, e vários outros projetos Java, onde trabalhou como consultor sênior. Foi instrutor Java pela Sun, cofundador do GUJ e criador do framework vRaptor. É formado em ciência da computação pela USP, onde realiza seu mestrado. Sérgio Lopes ([email protected]) é programador e desenvolvedor Java desde 2002. É moderador do Grupo de Usuários Java – GUJ - e estuda Ciência da Computação na USP. Capítulo 1 - Como aprender Java - Página 3
PLATAFORMA JAVA SUN
2 O que é Java
“Computadores são inúteis, eles apenas dão respostas”
- Picasso Chegou a hora de responder as perguntas mais básicas sobre Java. Ao término desse capítulo você será capaz de:
- responder o que é Java;
- mostrar as vantagens e desvantagens de Java;
- compilar e executar um programa simples.
2.1 - Java
Muitos associam Java com uma maneira de deixar suas páginas da web mais bonitas, com efeitos especiais, ou para fazer pequenos formulários na web. O que associa as empresas ao Java? Já iremos chegar neste ponto, mas antes vamos ver o motivo pelo qual as empresas fogem das outras linguagens: Quais são os seus maiores problemas quando está programando?
- ponteiros?
- liberar memória?
- organização?
- falta de bibliotecas boas?
- ter de reescrever parte do código ao mudar de sistema operacional?
- custo de usar a tecnologia? Java tenta amenizar esses problemas. Alguns desses objetivos foram atingidos muito tempo atrás, porque, antes do java 1.0 sair, a idéia é que a linguagem fosse usada em pequenos dispositivos, como tvs, aspiradores, liquidificadores e outros. Apesar disso a linguagem teve seu lançamento mirando o uso dela nos clientes web (browsers) para rodar pequenas aplicações (applets). Hoje em dia esse não é mais o foco da linguagem. O Java é desenvolvido e mantido pela Sun (http://www.sun.com) e seu site principal é o http://java.sun.com. (java.com é um site mais institucional, voltado ao consumidor de produtos e usuários leigos, não desenvolvedores).
A história do Java
Você pode ler a história da linguagem Java em: http://java.sun.com/java2/whatis/1996/storyofjava.html No Brasil, diversos grupos de usuários se juntaram para tentar disseminar o conhecimento da linguagem. Um deles é o GUJ (www.guj.com.br), uma comunidade Capítulo 2 - O que é Java - Página 4
capítulo 2
BYTECODE CLASSPATH Mas para isso, precisamos de um “ bytecode ”. Bytecode é o termo dado ao código binário gerado pelo compilador Java (pois existem menos de 255 códigos de operação dessa linguagem, e cada “opcode” gasta um byte, dando origem ao nome bytecode). O compilador Java gera esse bytecode que, diferente das linguagens sem máquina virtual, vai servir para diferentes sistemas operacionais, já que ele vai ser “traduzido” pela máquina virtual.
Write once, run anywhere
Esse é um slogan que a Sun usa para o Java, já que você não precisa reescrever parte da sua aplicação toda vez que quiser mudar de sistema operacional. Muitas pessoas criticam ou criam piadas em cima desse slogan, por acreditarem que nem sempre uma aplicação Java pode rodar em duas plataformas diferentes sem problemas.
2.3 - Instalando o Java
Antes de instalar, baixe o J2SDK 5.0 ou superior, do site do Java da Sun, em http://java.sun.com. Pegue a versão internacional e cuidado para não baixar o que tem mais de 90 megas, que é a primeira opção na página de download: esta versão vem com o Netbeans, que é uma ferramenta da Sun, e não nos interessa no momento. Mais para baixo da página existe uma versão menor, algo em torno de 45 megas, sem essa ferramenta. Esse software disponível na Sun é gratuito, assim como as principais bibliotecas Java e ferramentas. É interessante você também baixar a documentação do J2SDK 5.0, o link se encontra na mesma página e possui outros 40 megas. O procedimento de instalação no Windows é muito simples: basta você executar o arquivo e seguir os passos. Instale-o no diretório desejado. Depois disso, é necessário configurar algumas variáveis de ambiente, para que você possa executar o compilador Java e a máquina virtual de qualquer diretório. Em cada Windows você configura as variáveis de ambiente de uma maneira diferente. São duas as variáveis que você deve mudar: CLASSPATH=. PATH=;c:\diretorioDeInstalacaoDoJava\bin A variável PATH provavelmente já tem muita coisa e você só precisa acrescentar. Já a variável CLASSPATH deve ser criada. No Linux, são as mesmas variáveis, mas o PATH é separado por :. Nos Windows velhos, como o 98, você deve alterar isso no autoexec.bat. Nos Windows mais novos, como NT, 2000, e XP, procure onde você pode adicionar novas variáveis de ambiente (em Iniciar - Painel de Controle – Sistema – Avançado Variáveis de Sistema). Se você possui dúvidas sobre a instalação e configuração geral do ambiente, consulte o tutorial no site do guj: http://www.guj.com.br.
Versões do Java
Existe uma quantidade assombrosa de siglas e números ao redor do Java. No começo isso pode ser bastante confuso, ainda mais porque cada biblioteca do Java mantém seu próprio versionamento. Capítulo 2 - O que é Java - Página 6
Talvez, o que seja mais estranho é o termo “Java 2”. Sempre que você for ler alguma coisa sobre Java, vai ouvir falar em Java2 ou J2 como prefixo de alguma sigla. Na verdade não existe Java 2.0, acontece que quando a Sun lançou a versão 1.2 do Java fizeram uma jogada de marketing e decidiram chamá-la de Java 2. Hoje em dia, o Java está na versão 1.5, mas o marketing utiliza “Java2 5.0”.
Java 5.0 e Java 1.
Muitas pessoas estão migrando para o Java 5.0, mas como ele é muito novo, algumas empresas vão se prender ao Java 1.4 durante muito tempo. Houve uma mudança significativa na linguagem entre essas duas versões, com certeza a mais significativa). No decorrer do curso, todos os recursos e classes que forem exclusivamente do Java 5.0 terão este fato destacado. A versão Java 6.0 já está em desenvolvimento e com provável lançamento em meados de 2006. Apesar do nome, não há mudança na linguagem prevista, apenas melhorias na JVM e novas bibliotecas. Além disso o número 2 da sigla ira cair: Java2 de volta para Java. Confuso não?
J2EE?
Se você está começando agora com Java, não deverá começar pelo J2EE. Isso não importa agora. Quando você ouvir falar em Servlets , JSP e EJB , isso tudo faz parte do J2EE. Apesar da esmagadora quantidade de vagas de emprego para Java estarem no J2EE , ela é apenas uma especificação, algo relativamente simples de aprender depois que você firmar bem os conceitos do Java. Novamente, não comece aprendendo Java através do J2EE.
2.4 - Compilando o primeiro programa
Vamos para o nosso primeiro código! O programa que imprime uma linha simples!
- class MeuPrograma {
- public static void main(String[] args) {
- System.out.println(“Minha primeira aplicação Java!!”);
- }
- }
Notação
Todos os códigos apresentados na apostila estão formatados com recursos visuais para auxiliar a leitura e compreensão dos mesmos. Quando for digitar os códigos no computador, trate os códigos como texto simples. A numeração das linhas não faz parte do código e não deve ser digitada; é apenas um recurso didático. O java é case sensitive: tome cuidado com maiusculas e minusculas. Após digitar o código acima, grave-o como MeuPrograma.java em algum diretório. Para compilar, você deve pedir para que o compilador de Java da Sun, chamado javac, gere o bytecode correspondente do seu código Java. Capítulo 2 - O que é Java - Página 7
método main. Ainda não sabemos o que é método, mas veremos no capítulo 4. Até lá, não se preocupe com essas declarações. Sempre que um exercício for feito, o código sempre estará nesse miolo. No caso do nosso código, a linha do System.out.println faz com que o conteúdo entre aspas seja colocado na tela.
2.7 - Exercícios
1-) Altere seu programa para imprimir uma mensagem diferente. 2-) Altere seu programa para imprimir duas linhas de texto usando duas linhas de código System.out. 3-) Sabendo que os caracteres \n representam uma quebra de linhas, imprima duas linhas de texto usando uma única linha de código System.out.
2.8 - O que pode dar errado?
Muitos erros podem ocorrer no momento que você rodar seu primeiro código. Vamos ver alguns deles: Código: public class X { public static void main (String[] args) { System.out.println("Falta ponto e vírgula") } } Erro: X.java:4: ';' expected } ^ 1 error Esse é o erro de compilação mais comum: aquele onde um ponto e vírgula fora esquecido. Outros erros de compilação podem ocorrer se você escreveu palavras chaves (a que colocamos em negrito) em maiúsculas, esqueceu de abrir e fechar as {}, etc. Durante a execução, outros erros podem aparecer:
- Se você declarar a classe como X, compilá-la e depois tentar usá-la como x minúsculo (java x), o Java te avisa: Exception in thread "main" java.lang.NoClassDefFoundError: X (wrong name: x)
- Se tentar acessar uma classe no diretório ou classpath errado, ou se o nome estiver errado, ocorrerá o seguinte erro: Exception in thread "main" java.lang.NoClassDefFoundError: X
- Se esquecer de colocar static ou o argumento String[] args no método main: Capítulo 2 - O que é Java - Página 9
Exception in thread "main" java.lang.NoSuchMethodError: main Por exemplo: public class X { public void main (String[] args) { System.out.println("Faltou o static"); } }
- Se não colocar o método main como public: Main method not public. Por exemplo: public class X { static void main (String[] args) { System.out.println("Faltou o public"); } }
2.9 - Um pouco mais...
1-) Procure um colega, ou algum conhecido, que esteja em um projeto Java. Descubra porque Java foi escolhido como tecnologia. O que é importante para esse projeto e o que acabou fazendo do Java a melhor escolha? 2-) Se o software relacionado ao Java que a Sun deixa disponível é gratuito, como a Sun ganha dinheiro?
2.10 - Exercícios
1-) A máquina virtual parece sempre estar traduzindo o seu programa para o sistema operacional em uso, isso faz com que alguns digam que o Java é interpretado. Porém, desde o Java 1.2 , a máquina virtual faz algo a mais que apenas interpretar: ela compila parte do código que considerar “quente” em tempo de execução. É o que chamamos de compilação dinâmica, pois além disso ela pode mudar a forma de como otimizou aquele trecho de código se não achou o resultado satisfatório. Pesquise sobre isso (as palavras chave são JIT compiler e HotSpot ). 2-) Um arquivo fonte Java deve sempre ter a extensão .java, ou o compilador o rejeitará. Além disso, existem algumas outras regras na hora de dar o nome de um arquivo Java. Experimente gravar o código deste capítulo com OutroNome.java ou algo similar. Compile e verifique o nome do arquivo gerado. Como executar a sua aplicação agora?
Curiosidade
Tente compilar um arquivo sem nada dentro, nem uma letra, nem uma quebra de linha. O que acontece? Capítulo 2 - O que é Java - Página 10
OPERADORES ARITMÉTICOS // imprime a idade System.out.println(idade); Por fim, podemos utilizar o valor de uma variável para algum outro propósito, como alterar ou definir uma segunda variável. O código a seguir cria uma variável chamada idadeNoAnoQueVem com valor de idade mais um. // gera uma idade no ano seguinte int idadeNoAnoQueVem; idadeNoAnoQueVem = idade + 1; Você pode usar os operadores +, -, / e * para operar com números, sendo eles responsáveis pela adição, subtração, divisão e multiplicação, respectivamente. Além desses operadores básicos, há o operador % (módulo) que nada mais mais é que o resto de uma divisão inteira. Veja alguns exemplos: int quatro = 2 + 2; int tres = 5 – 2; int oito = 4 * 2; int dezesseis = 64 / 4; int um = 5 % 2; // 5 dividido por 2 dá 2 e tem resto 1; // o operador % pega o resto da divisão inteira
Onde testar esses códigos?
Você deve colocar esses trechos de código dentro do método main, que vimos no capítulo anterior. Isto é, isso deve ficar no miolo do programa. Use bastante System.out.println, dessa forma você pode ver algum resultado, caso contrário, ao executar a aplicação, nada aparecerá. Por exemplo, para imprimir a idade e a idadeNoAnoQueVem podemos escrever o seguinte programa de exemplo:
- class TestaIdade {
- public static void main(String[] args) {
- // declara a idade
- int idade;
- idade = 15;
- // imprime a idade
- System.out.println(idade);
- // gera uma idade no ano seguinte
- int idadeNoAnoQueVem;
- idadeNoAnoQueVem = idade + 1;
- // imprime a idade
- System.out.println(idadeNoAnoQueVem);
- }
- } No momento que você declara uma variável, também é possível inicializá-la por praticidade: Capítulo 3 - Variáveis primitivas e Controle de fluxo - Página 12
DOUBLE BOOLEAN CHAR ATRIBUIÇÃO int idade = 15; Representar números inteiros é fácil, mas como guardar valores reais, como frações de números inteiros e outros? Outro tipo de variável muito utilizado é o double, que armazena um número com ponto flutuante. double d = 3.14; double x = 5 * 10; O tipo boolean armazena um valor verdadeiro ou falso, e só. boolean verdade = true ; O tipo char guarda um e apenas um caractere. Esse caractere deve estar entre aspas simples. Não se esqueça dessas duas características de uma variável do tipo char! Por exemplo, ela não pode guardar um código como ‘’ pois o vazio não é um caractere! char letra = ‘a’; System.out.println(letra);
3.2 - Tipos primitivos e valores
Esses tipos de variáveis são tipos primitivos do Java: o valor que elas guardam são o real conteúdo da variável. Quando você utilizar o operador de atribuição = o valor será copiado. int i = 5; // i recebe uma cópia do valor 5 int j = i; // j recebe uma cópia do valor de i i = i + 1; // i vira 6, j continua 5 Aqui, i fica com o valor de 6. Mas e j? Na segunda linha, j está valendo 5. Quando i passa a valer 6, será que j também fica valendo? Não, pois o valor de um tipo primitivo sempre é copiado. Apesar da linha 2 fazer j = i, a partir desse momento essas variáveis não tem relação nenhuma: o que acontecer com uma não reflete em nada com a outra,
Outros tipos primitivos
Vimos aqui os tipos primitivos que mais aparecem. O Java tem outros, que são o byte, short, long e float. Cada tipo possui características especiais que, para um programador avançado, podem fazer muita diferença.
3.3 - Exercícios
1-) Na empresa onde trabalhamos, há tabelas com o quanto foi gasto em cada mês. Para fechar o balanço do primeiro trimestre, precisamos somar o gasto total. Sabendo que, em Janeiro foi gasto 15000 reais, em Fevereiro, 23000 reais e em Março, 17000 reais, faça um programa que calcule e imprima o gasto total no trimestre. Siga esses passos:
- Crie uma classe chamada BalancoTrimestral com um bloco main, como nos exemplos anteriores;
- Dentro do main (o miolo do programa), declare uma variável inteira chamada gastosJaneiro e inicialize-a com 15000; Capítulo 3 - Variáveis primitivas e Controle de fluxo - Página 13
CASTING Ás vezes, precisamos que um número quebrado seja arredondado e armazenado num número inteiro. Para fazer isso sem que haja o erro de compilação, é preciso ordenar que o número quebrado seja moldado (casted) como um número inteiro. Esse processo recebe o nome de casting. double d3 = 3.14; int i = ( int ) d3; O casting foi feito para moldar a variável d3 como um int. O valor dela agora é 3. O mesmo ocorre entre valores int e long. long x = 10000; int i = x; // nao compila, pois pode estar perdendo informação E, se quisermos realmente fazer isso, fazemos o casting: long x = 10000; int i = ( int ) x;
Casos não tão comuns de casting e atribuição
Alguns castings aparecem também: float x = 0.0; O código acima não compila pois todos os literais com ponto flutuante são considerados double pelo Java. E float não pode receber um double sem perda de informação, para fazer isso funcionar podemos escrever o seguinte: float x = 0.0f; A letra f indica que aquele literal deve ser tratado como float. Outro caso, que é mais comum: double d = 5; float f = 3; float x = ( float ) d + f; Você precisa do casting porque o Java faz as contas e vai armazenando sempre no maior tipo que apareceu durante as operações, no caso o double. E no mínimo, o Java armazena em um int. Até casting com variáveis do tipo char podem ocorrer. O único tipo primitivo que não pode ser atribuído a nenhum outro tipo é o boolean.
Castings possíveis
Abaixo estão relacionados todos os casts possíveis na linguagem Java, mostrando quando você quer converter de um valor para outro. A indicação Impl. quer dizer que aquele cast é implícito e automático, ou seja, você não precisa indicar o cast explicitamente. (lembrando que o tipo boolean não pode ser convertido para nenhum outro tipo) Capítulo 3 - Variáveis primitivas e Controle de fluxo - Página 15
IF CONDIÇÃO BOOLEANA ELSE
PARA:
DE:
byte short char int long float double byte ---- Impl. (char) Impl. Impl. Impl. Impl. short (byte) ---- (char) Impl. Impl. Impl. Impl. char (byte) (short) ---- Impl. Impl. Impl. Impl. int (byte) (short) (char) ---- Impl. Impl. Impl. long (byte) (short) (char) (int) ---- Impl. Impl. float (byte) (short) (char) (int) (long) ---- Impl. double (byte) (short) (char) (int) (long) (float) ----
Tamanho dos tipos
Na tabela abaixo, estão os tamanhos de cada tipo primitivo do Java. TIPO TAMANHO boolean 1 bit byte 1 byte short 2 bytes char 2 bytes int 4 bytes float 4 bytes long 8 bytes double 8 bytes
3.5 - O If-Else
A sintaxe do if no Java é a seguinte if (condicaoBooleana) { codigo; } Uma condição booleana é qualquer expressão que retorne true ou false. Para isso, você pode usar os operadores <, >, <=, >= e outros. Um exemplo: int idade = 15; if (idade < 18) { System.out.println(“Não pode entrar”); } Além disso, você pode usar a cláusula else para indicar o comportamento que deve ser executado no caso da expressão booleana ser falsa:
- int idade = 15;
- if (idade < 18) {
- System.out.println(“Não pode entrar”);
- }
- else {
- System.out.println(“Pode entrar”);
- } Você pode concatenar expressões booleanas através dos operadores lógicos Capítulo 3 - Variáveis primitivas e Controle de fluxo - Página 16
