SCJA

Guia de Estudos paraSun Certified Java Associate (SCJA)
Prof. Rafael Guimarães Sakurai
12/2009
1

Quem sou?
Rafael Guimarães Sakurai (rafael.sakurai@metodista.br)
Possui graduação em Ciência da Computação pela Universidade Metodista de São Paulo (2005), especialista em Engenharia de Componentes com Java Enterprise e Webservices pela Faculdade de Informática e Administração Paulista (2007).
Atualmente é analista desenvolvedor de software da Virginia Surety e docente na Universidade Metodista de São Paulo. Tem experiência na área de Ciência da Computação, com ênfase em Linguagens de Programação.
Possui as seguintes certificações: SCJA 1.0, SCJP 5.0, SCWCD 1.4 e SCSNI.
2
Guia de Estudos para SCJA

Agenda
1º Dia – Apresentação do curso
Conceitos basicos de Orientação a Objetos.
2º Dia – UML e implementação Java
3º Dia – Implementação Java (continuação)
4º Dia – Implementação de algoritmos
Principios básicos de desenvolvimento Java
5º Dia – Plataforma Java e tecnologias de integração
Tecnologia cliente
6º Dia – Tecnologia servidor e simulado
3

Detalhes
Número de Questões: 51
Score: 68% (35 de 51 questões)
Tempo: 115 minutos
4

Sun Academic Initiative
Site (https://sailearningconnection.skillport.com)
Vantagens:
Cursos
Materiais
Simulados
Desconto no voucher
5

Objetivos do exame
1- Conceitos básicos Orientados a Objetos (OO)
2- Representação UML de conceitos OO
3- Implementação Java de conceitos OO
4- Projeto e implementação de algoritmos
5- Princípios básicos do desenvolvimento em Java
6- Plataforma Java e tecnologias de integração
7- Tecnologias de cliente
8- Tecnologias de servidor
6

1- Conceitos Básicos Orientados a Objetos
7

1.1- Descrever, comparar e contrastar primitivas (número inteiro, ponto flutuante, booleano e caractere), tipos de enumeração e objetos.
8

Tipos Primitivos
Os tipos primitivos são representações de dados/valores básicos. Todos são representados por letras minúsculas e estão divididos nos seguintes tipos:
Número Inteiro
Número com Ponto Flutuante
Caractere
Booleano
9

Tipos Inteiros
Representam números inteiros em forma decimal, hexadecimal ou octal.
Recomendado quando o número é muito grande,
capaz de armazenar 64 bits
Tipo inteiro mais utilizado, capaz de armazenar 32 bits
Valor numérico capaz de armazenar 16 bits
Utilizado para representar números pequenos, no intervalo de -128 e 127,
capaz de armazenar 8 bits
10

Tipos Inteiros
Exemplos:
byte:0, 1, 2
short:1, 20, 100
int:10, 100, 2000000
long:1000, 21234300000, 56098001258
11
11

Tipos de Ponto Flutuante
Representam valores reais, ou seja, com parte fracionária.
Exemplos:
float:1.99, 13.14, 100.45
double:1500.27, 409673.90, 12935878423.096675
12

Tipo Caractere
Representa um único caractere incluindo letras, números, caracteres especiais e outros, denominado char.
Exemplos:
char: a, b, c, 4, $, &
13
13

Tipo Booleano
Representa o valor lógico true(verdadeiro)oufalse(falso), denominado boolean.
Exemplos:
boolean:true, false
14

Enumeração
Tipo de classe com valores pré-definidos, ou seja, possui valores padrões previamente estabelecidos.
Exemplo:
public enumDiaSemana {
SEGUNDA-FEIRA,
TERÇA-FEIRA,
QUARTA-FEIRA,
QUINTA-FEIRA,
SEXTA-FEIRA,
SÁBADO,
DOMINGO
}
15
15

Objeto
Características + Ações = Objeto
16

Objeto
Um objeto é a representação de um conjunto de características e funcionalidades para representar algo do mundo real.
Podemos por exemplo representar pessoas como objetos, onde cada pessoa terá suas características próprias como nome, data de nascimento, documento de identidade e outros.
Também podemos representar as ações que uma objeto que é uma pessoa pode ter, como por exemplo andar, pensar, falar e outros.
Na OO as características são chamados de atributos e as ações são chamadas de métodos, onde todos os objetos do mesmo tipo possuem os mesmos métodos, mas cada um pode ter seus atributos com valores diferentes (estado).
17

Objeto
A partir de um modelo ou forma que define os atributos e métodos dos objetos podemos criar vários objetos cada um com um estado diferente:
Objetos com diferentes estados
Modelo
18

1.2 - Descrever, comparar e contrastar classes concretas, classes abstratas e interfaces, e como a herança é aplicada a elas.
19

Classe
Uma Classe define quais as características (atributos) e ações (métodos) para representar as “coisas” do mundo real, podemos dizer que uma classe é um modelo ou forma que define como devem ser os objetos.
Os atributos de uma classe podem ser de tipos primitivos, enumerações ou outro objeto.
Os métodos de uma classe vão representar as ações que aquela classe pode ter, dependendo do estado dos atributos os métodos podem executar de formas diferentes.
20

Classe Concreta
Classe concreta é uma classe que pode ser utilizada como base para a geração de objetos.
Exemplo:
publicclass Aluno {
public String nome;
public String matricula;
public Aluno() { }
public Aluno(String _nome, String _matricula) {
nome = _nome;
matricula = _matricula;
}
}
21

Classe Abstrata
As classes abstratas servem como base para a criação de classes concretas mais especializadas.
A partir das classes abstratas não podemos instanciar objetos, pois ela pode ter métodos que não estão implementados.
Exemplo:
publicabstractclass Pessoa {
public String nome;
public void dizerNome() {
System.out.println("Meunome é:" + nome);
}
public void estudar();
}
22

Interface
É utilizada para definir modelos de especificação de métodos. A partir de uma interface podemos ter diversas classes que seguem este modelo, sendo que obrigatoriamente todas os métodos definidos na interface deverão ser implementados pelas classes.
Exemplo:
publicinterface Transporte {
publicvoidentrarPessoa(Pessoa pessoa);
public void sairPessoa(Pessoa pessoa);
public void transportarPara(String localidade);
}
23

Interface
24

Generalizando Interface
25

Implementando mais de uma Interface
26

Herança
Visando a reutilização de código, a herança permite que classes herdem atributos e métodos de outras classes.
É utilizada em objetos que possuem características e funcionalidades semelhantes.
publicclass Pessoa {
private String nome;
public void setNome(String nome) { this.nome = nome;}
public String getNome() { return this.nome; }
}
publicclass Programador extends Pessoa {
publicvoiddizerProfissao() {
return "Meu nome eh " + getNome() + " eu sou Programador."
}
}
27

Herança
28

1.3 - Descrever, comparar e contrastar composições e associações (incluindo multiplicidade: um-para-um, um-para-vários e vários-para-vários) de classes, bem como a navegação de associações.
29

Associação
Associação é quando uma classe pode utilizar uma outra classe, por exemplo, um cliente possui um endereço.
A associação define que uma classe está relacionada com outra classe, mas elas podem ser utilizadas independente.
publicclass Cliente {
public String nome;
publicEnderecoendereco;
}
publicclassEndereco {
public String estado;
public String cidade;
public String bairro;
public String logradouro;
}
30
30

Composição
Composição é quando uma classe depende de outra classe para poder existir, por exemplo, um estado possui varias cidades.
Caso apaguem um estado do mapa, as cidades dele não devem continuar existindo.
publicclass Cidade {
public String nome;
}
publicclass Estado {
public Cidade[] cidades;
}
31

Multiplicidade
Um-para-um
Um logradouro pode ter apenas um CEP.
Um-para-vários
Exemplo: Um carro tem quatro pneus.
Vários-para-vários
Um programador pode trabalhar em vários projetos, e um projeto pode ter vários programadores.
32

Navegação
Navegação informa qual a direção do relacionamento entre duas classes.
Neste exemplo através da classe Produto podemos chegar até a classe Modelo.
33
publicclass Modelo {
public String nome;
}
publicclass Produto {
public Modelo modelo;
public ModelogetModelo() {
return this.modelo;
}
}

1.4 - Descrever a ocultação de informações (usando métodos e atributos privados), o encapsulamento e a funcionalidade de exposição de objetos usando métodos públicos; e descrever as convenções de JavaBeans para os métodos setter e getter.
34

Ocultação de informações
Quando queremos restringir o acesso a atributos e métodos dentro de uma classe, podemos definir sua visibilidade como privada utilizando a palavra-chave private, desta forma somente dentro da própria classe podem ser alterados os valores de um atributo ou chamado um método.
35

Encapsulamento
Quando temos uma classe com seus atributos com visibilidade publica, esses atributos podem ser alterados a qualquer momento por qualquer outra classe.
36
nome
matricula

Encapsulamento
O Java possui uma convenção para encapsulamento de dados onde definimos a visibilidade private para os atributos de uma classe e adicionamos métodos públicos para obter o valor do atributo e alterar o valor do atributo, que são chamados respectivamente de métodos “get” e “set”.
37

Encapsulamento
Definindo os atributos como privados e criando métodos públicos para manipulação desses atributos podemos então restringir a manipulação desorganizada.
38
Método Privado
Método
Público
nome
matricula
Método
Público
Método Privado

Exemplo encapsulamento
publicclass Aluno {
privateint matricula;
publicvoidsetNome(String _nome) {
nome = _nome;
}
public String getNome() {
return nome;
}
publicvoidsetMatricula(int _matricula) {
matricula = _matricula;
}
publicintgetMatricula() {
return matricula;
}
}
39

Convenções Javabeans
As convenções Javabeans são boas práticas de programação que definem como devem ser criadas as classes, normalmente essas convenções são seguidas pelos desenvolvedores Java.
Nomes de classes são escritos com a primeira letra de cada palavra em maiúsculo.
Possuir um construtor padrão (default)
Todos os atributos são privados (private)
Os atributos são escritos com letras minúsculas, a menos que ele seja composto por mais de uma palavra, a primeira palavra é toda em minúscula e as demais começam com a primeira letra em maiúsculo e o restante da palavra em minúscula.
Todos os atributos devem ser acessíveis através de métodos “get” e “set”.
Nomes de métodos seguem o mesmo padrão de escrita que atributos.
40

Exemplo: Precisamos desenvolver uma classe para representar um produto que pode ter as informações nome, data de validade, preço e ativo.
publicclass Produto {
private String marca;
private Date dataValidade;
privatedoublepreco;
privateboolean ativo;
publicvoidsetNome(String nome) {
this.nome = nome;
}
returnthis.nome;
}
publicvoidsetDataValidade(Date dataValidade) {
this.dataValidade = dataValidade;
}
41

public Date getDataValidade() {
returnthis.dataValidade;
}
publicvoidsetPreco(doublepreco) {
this.preco = preco;
}
publicdoublegetPreco() {
returnthis.preco;
}
publicvoidsetAtivo(boolean ativo) {
this.ativo = ativo;
}
publicbooleangetAtivo() {
returnthis.ativo;
}
// Quando é boolean podemos usar get ou is
publicbooleanisAtivo() {
returnthis.ativo;
}
}
42

1.5 - DESCREVER O POLIMORFISMO CONFORME APLICADO A CLASSES E INTERFACES, BEM COMO DESCREVER E APLICAR O PRINCÍPIO "PROGRAMA PARA UMA INTERFACE".
43

Polimorfismo
O termo polimorfismo vem do grego que significa “muitas formas”.
Na Orientação a Objetos o polimorfismo é a forma de representar um objeto de varias formas.
Podemos aplicar o polimorfismo quando temos uma estrutura de herança de classes (subclasse e superclasse) ou com estrutura de implementação de interface.
44

Polimorfismo
Neste exemplo podemos representar o CarroVoador como um Aereo ou como um Terrestre, pois o CarroVoador segue essas interfaces e tem implementado as funcionalidades que estão definidos nelas.
Da mesma forma podemos representar o CarroVoador como um Transporte.
45

Programe para uma interface
“Programe para uma interface” deve ser entendido como “Programe para um supertipo” dessa forma podemos:
Generalizar o tipo de retorno de método
Generalizar o tipo de um atributo
Generalizar os parâmetros de método
46

2- Representação UML de Conceitos Orientados a Objetos
47

UnifiedModelingLanguage (UML)
Definição:
“É uma família de notações gráficas, apoiada por um metamodelo único, que ajuda na descrição e no projeto de sistemas de software, particularmente daqueles construídos utilizando o estilo orientado a objetos.”
Martin Fowler
48

2.1 - Reconhecer a representação UML de classes (incluindo atributos e operações, classes abstratas e interfaces), a representação UML de herança (implementação e interface) e a representação UML de modificadores da visibilidade dos membros da classe (-/privada e +/pública).
49

Estrutura da Classe
Uma classe em UML possui três partes:
Nome da Classe
Atributos
Operações
Podemos abreviar a declaração da classe, caso não influencie o entendimento do diagrama:
50

Atributos
Um atributo é formado por:
visibilidade nome : tipo [multiplicidade] = valor inicial {propriedades}
51

Operações
Uma operação é formada por:
visibilidade nome (parâmetros) : tipo de retorno {propriedades}
O parâmetro de um método é formado por:
nome : tipo [multiplicidade] = valor inicial
52

Herança
Utilizamos herança quando queremos declarar subclasses, permitindo reutilizar os códigos já declarados na superclasse.
53

Classe Abstrata
Utilizado para informar que uma classe não implementa todos os seus métodos.
54

Interface
Utilizamos interface para definir as operações básicas que uma classe de seu tipo precisa implementar.
ou
55

Interface
Exemplo:
56

Visibilidade
Podemos definir as seguintes visibilidades em atributos e operações:
-private
~ default
#protected
+ public
57

Comentário
Os comentários ou notas são utilizados para adicionar mais informações ao diagrama.
58

Pacote
Utilizamos para organizar as classes:
59

2.2 - Reconhecer a representação UML de associações de classes, composições, indicadores de multiplicidade de associação e indicadores de navegação de associações.
60

Associações
Utilizado para representar o relacionamento entre classes, as associações podem ser:
Associação
Agregação
Composição
Classe de associação
As classes que fazem parte de um relacionamento também são chamadas de TODO (responsável pelo relacionamento) e PARTE (usado pelo relacionamento).
61

Associação
Relacionamento simples entre duas classes:
62

Agregação
Informa que uma classe faz parte de outra classe, mas não de forma exclusiva.
63

Composição
Informa que uma classe faz parte de outra classe de forma exclusiva.
64

Agregação x Composição
A diferença entre ambos é:
Agregação – se excluir a classe responsável pelo relacionamento, não deve excluir a classe que ele possui relacionamento.
Composição – se excluir a classe responsável pelo relacionamento, então deve excluir a classe que ele possui relacionamento.
65

Associação
Podemos também ter uma associação para mesma classe:
66

Navegabilidade
Podemos informar qual a direção do relacionamento:
67

Multiplicidade
A multiplicidade é utilizada para definir a quantidade de objetos devem ser criados:
0 .. 1 (zero ou um)
1 (um)
* (zero ou muitos)
68

Dependência
Utilizado para informar que uma classe depende de outra classe para executar alguma operação:
Palavras - chave de dependência:
<<call>>
<<create>>
<<dependency>>
<<use>>
69

Associação x Dependência
A diferença básica entre ambos:
Associação temos um atributo da classe relacionada.
Dependência utilizamos a classe relacionada, para passar um parâmetro, chamar um método, criar um objeto, etc.
70

Diagrama de Classes
71

3- Implementação Java de Conceitos Orientados a Objetos
72

A linguagem Java
1991- A linguagem Oak surgiu através do projeto Green financiado pela Sun Microsystems.
1995 – Divulgação do Java 1.0 – SunWorld
1998 – Lançamento da versão 1.2 – Java 2
Versão 1.3 e 1.4 - Java 2
2004 – Lançamento da versão 1.5 – Java 5 – Tiger
2006 – Lançamento da versão 1.6 – Java 6 – Mustang
JCP (Java CommunityProcess) – Diversas empresas responsáveis pelo Java.
73

A linguagem Java
Os conceitos chaves da linguagem Java são:
Programação Orientada a Objetos
Independente de plataforma
Seguro
Distribuído
Multi-thread
O tema principal do Java é “escreva uma vez, rode em qualquer lugar” (writeonce, runanywhere).
74

JRE x JDK
Há dois principais produtos dentro da plataforma Java SE:
- Java RuntimeEnvironment (JRE)‏
Fornece a Java Virtual Machine, bibliotecas Java e outros componentes para executar aplicações escritas em Java.
- Java Development Kit (JDK)
Contém tudo que tem na JRE, mais ferramentas adicionais para criar Java Archive (JAR) e desenvolver (compilar e depurar) aplicações feitas em Java.
75

Java Virtual Machine (JVM)
A Java Virtual Machine é uma maquina imaginaria que é implementada através da emulação em software.
Existe uma JVM diferente para cada Sistema Operacional.
Uma vez que sua aplicação é criada, a mesma pode ser executada em diversos Sistemas Operacionais sem precisar recompilar.
76
.java
.classbytecode
JVM
JVM
JVM
Linux
Windows
Outros

Compilando e executando um arquivo java
Fases da programação Java:
Editor
Java Compiler
Java Interpreter
PrimeiraClasse.class
PrimeiraClasse.java
77

Criando um arquivo .java
Crie um arquivo com a extensão .java com o seguinte código:
78
/**
* Exemplo de uma classe simples em Java.
*/
public class PrimeiraClasse {
public static void main(String[] args) {
System.out.println("Hello world !!!");
}
}

Compilando um arquivo .java
A aplicação javac é responsável por compilar o arquivo .java.
Após a execução deste comando, um arquivo com a extensão .class contendo bytecode Java será criado em disco, com o seguinte nome: PrimeiraClasse.class.
A aplicação java é utilizada para executar um arquivo .class.
79

Comentário em Java
// -> Comentário de uma única linha

/* Comentário longo com mais
de uma linha */

/**
*Javadoc
* @author Rafael Guimarães Sakurai
*/
80

Comentário em Java
81
/**
* Classe utilizada para demonstrar o uso de comentários.
*
* Depois que uma classe Java é compilada, os comentários não vão
* para os códigos compilados .class, dessa forma os comentários
* não interferem no tamanho final do projeto.
*
* @author Rafael Guimarães Sakurai
*/
public class ExemploComentario {
//Imprime uma mensagem para o usuario.
System.out.println("Demonstrando o uso dos comentarios.");
/* Podemos utilizar esta forma quando queremos escrever um
comentário mais longo para exemplicar o código. */
}
}

Palavras-chave da linguagem Java
82

3.1 - Desenvolver código que utilize primitivas, tipos de enumeração e referências a objetos, e reconhecer literais desses tipos.
83

Tipos Primitivos
Uma variável é a forma de representar valores primitivos ou objetos:

Variáveis primitivas: podem ser do tipo byte, short, int, long, float, double, char ou boolean.
Variáveis de referência: usada para referenciar um objeto. Quando usamos uma variável de referencia definimos qual o tipo do objeto ou um subtipo do tipo do objeto (veremos isso mais para frente).
84

Lista de Tipos Primitivos
85

Tipos Inteiros (byte, short, int, long)
Tipos inteiros trabalham apenas com números inteiros, positivos ou negativos. Os valores podem ser representados nas bases octal, decimal e hexadecimal.
Inteiro em octal
Qualquer valor escrito utilizando números de 0 a 7 começando com 0 é um valor na base octal, exemplo:

short s = 010; // Equivale ao valor 8 em decimal.
int i = 025; // Equivale ao valor 21 em decimal.
86

Inteiro em decimal
Qualquer valor escrito utilizando números de 0 a 9 é um valor decimal, este é o tipo de representação mais comum, pois é utilizada no dia a dia, exemplo:
int i = 9;
long b = 9871342132;
87

Inteiro em hexadecimal
Qualquer valor escrito utilizando números de 0 a 9 e A a F começando com 0x ou 0X é um valor hexadecimal, exemplo:

long a = OxCAFE; // Equivale ao valor 51966 em decimal
int b = 0X14a3; // Equivale ao valor 5283 em decimal
88

Quando um número é maior que o tamanho de um tipo inteiro precisamos especificar o tipo como um long, para isso devemos adicionar a letra l ou L depois do seu valor, exemplo:
long a = 0Xcafel;
long b = 0752L;
long c = 987654321L;
89

Exemplo tipo primitivo inteiro
90
/**
* Exemplo de utilização dos tipos primitivos byte, short, int e long.
*/
public class ExemploTipoPrimitivo {
//Inicializando atributos primitivos com valores na base octal.
byte a = 077;
short b = 010;
int c = 025;
System.out.println(a); // Imprime 63
System.out.println(b); // Imprime 8
System.out.println(c); // Imprime 21
//Inicializando atributos primitivos com valores na base decimal.
int d = 9;
long e = 9871342132L;
System.out.println(d); // Imprime 9
System.out.println(e); // Imprime 9871342132

91
//Inicializando atributos primitivos com valores na base hexadecimal.
long f = 0XCAFE;
long g = 0Xcafel;
int h = 0X14a3;
long i = 0752L;
long j = 987654321L;
System.out.println(f); // Imprime 51966
System.out.println(g); // Imprime 51966
System.out.println(h); // Imprime 5283
System.out.println(i); // Imprime 490
System.out.println(j); // Imprime 987654321
}
}

Compilar e executar o arquivo ExemploTipoPrimitivo. java
92

Tipos Ponto Flutuante (float e double)
Tipos de ponto flutuante servem para representar números com casas decimais, tanto negativos quanto positivos. Todos números com ponto flutuante são por padrão do tipo double.
float f = 10.99f;
double b = 10.3D;
double c = 10.3;
// Erro de compilação, pois o padrão do valor é double.
floaf c = 1.99;
OBS: Números com ponto flutuante devem ser escritos com ponto final ( . ).
93

Exemplo tipo primitivo inteiro com ponto flutuante
94
/**
* Exemplo de utilização dos tipos primitivos float e double.
*/
public class ExemploTipoPrimitivo2 {
//Definindo explicitamente que o valor é float.
float a = 10.99f;
//Definindo explicitamente que o valor é double.
double b = 10.3D;
//Atribuindo o valor inteiro para um tipo double.
double c = 5;
//Atribuindo um valor double, por padrão todos números
// com casas decimais são do tipo double.
double d = 7.2;
System.out.println(a); // Imprime 10.99
System.out.println(b); // Imprime 10.3
System.out.println(c); // Imprime 5.0
System.out.println(d); // Imprime 7.2
}
}

Exemplo tipo primitivo inteiro com ponto flutuante
Compilar e executar o arquivo ExemploTipoPrimitivo2. java
95

Tipo caractere (char)
O tipo caractere, como o próprio nome já diz, serve para representar um valor deste tipo. Sua inicialização permite 3 modelos:
char a = ‘a’; //Inicialização usual com 1 caractere.
char a = 97; //Inicialização com código ASCII.
char u = ‘u0025’; //Equivale ao caractere ‘%’
Os caracteres podem ser representados por números e possuem o mesmo tamanho de um atributo short.
O unicode é no formato hexadecimal, portanto o exemplo anterior ‘0025’ equivale a 37 na base decimal.
96

Exemplo tipo primitivo caractere
97
/**
* Exemplo de utilização do tipo primitivo char.
*/
public class ExemploTipoPrimitivo3 {
//Definindo explicitamente um valor caracter.
char a = 'a';
//Definindo explicitamente um valor numerico.
char b = 97;
//Definindo explicitamente um valor unicode.
char c = 'u0025';
System.out.println(a); // Imprime a
System.out.println(b); // Imprime a
System.out.println(c); // Imprime %
}
}

Exemplo tipo primitivo caractere
Compilar e executar o arquivo ExemploTipoPrimitivo3. java
98

Tipo booleano (boolean)
Tipo que representa valores lógicos true (verdadeiro) ou false (falso), exemplo:
boolean a = true;
boolean b = false;
99

Casting
100

Casting
Para fazer um casting, basta sinalizar o tipo para o qual se deseja converter entre parênteses, da seguinte forma:

float f = (float) 5.0;
Conversão do double 5.0 para float.
int b = (int) 5.1987;
Conversão de double para int.

float c = 100;
Conversão de int para float é implícito, não precisa de casting.

int d = ‘d’;
Conversão de char para int é implícito, não precisa de casting.
101

Exemplo casting
102
/**
* Exemplo de conversão de tipos primitivos utilizando casting.
*/
public class ExemploCasting {
//Casting feito implicitamente, pois o valor possui um
// tamanho menor que o tipo da variável que irá recebe-lo.
char a = 'a';
int b = 'b';
float c = 100;
System.out.println(a); // Imprime a
System.out.println(b); // Imprime 98
System.out.println(c); // Imprime 100.0
//Casting feito explicitamente, pois o valor possui um tamanho
// maior que o tipo da variável que irá recebe-lo.
int d = (int) 5.1987;
int e = (char) (a + 5);
char f = (char) 110.5;
System.out.println(d); // Imprime 5
System.out.println(e); // Imprime 102
System.out.println(f); // Imprime n
}
}

Exemplo casting
Compilar e executar o arquivo ExemploCasting.java
103

Vetor (array)
Segundo a definição mais clássica da informática, um vetor é uma estrutura de dados homogenia, ou seja, todos os elementos de um vetor são do mesmo tipo.
A estrutura básica de um vetor é representada por seu nome e um índice, que deve ser utilizado toda a vez que se deseja acessar um determinado elemento dentro de sua estrutura.
Todo vetor possui um tamanho fixo, ou seja, não é possível redimensionar um vetor ou adicionar a ele mais elementos do que este pode suportar.
Em Java a posição inicial do vetor é definida pelo valor zero.
104

Vetor (array)
Um vetor é composto de três partes:
Declaração
Criação
Inicialização
Podemos também criar e inicializar o vetor da seguinte forma:
105
int[] valores; // ou int valores[];
String[] nomes; // ou String nomes[];
int[] valores = newint[100];
String[] nomes = new String[50];
valores[0] = 5;
nomes[10] = "Rafael";
int[] valores = {2, 5, 4, 8, 5};

Vetor (array)
Exemplo de utilização de array:
106
publicclassExemploVetor {
publicstaticvoidmain(String[] args) {
int[] vetor = {2, 5, 4, 8, 5};
System.out.println("Elemento do indice 2 = " + vetor[2]);
System.out.println("Elemento do indice 4 = " + vetor[4]);
System.out.println(" Percorrendo todos os elementos do vetor");
for(int i = 0; i < vetor.length; i++) {
System.out.println("Indice[" + i + "]= " + vetor[i]);
}
}
}

Vetor (array)
Todo vetor em Java é um objeto, mesmo que ele possua apenas atributos primitivos.
Quando os vetores são criados eles já são inicializado com os valores padrões para os tipos que eles guardam.
O primeiro índice do vetor é sempre zero, logo, seu último elemento é sempre igual ao tamanho do vetor menos um.
Se acessar uma posição do vetor que não existe será lançado uma java.lang.ArrayIndexOutOfBoundsException.
107

Enumeration
Enumeration ou enum é uma alternativa ao uso de valores constantes.
O enum criado pode ser criado em um arquivo separado ou dentro de outra classe.
Podem conter:
Variáveis de instância, métodos e construtores.
Problemas na utilização de constante:
As constantes não oferecem segurança.
Não há um domínio estabelecido.
Fragilidade de modelo.
Seus valores impressos são pouco informativos
108

Enumeration
Exemplo de utilização de constantes:
109
/**
* Classe utilizada para demonstrar as fragilidades das contantes.
*/
public class ExemploUsarEnums {
publicstatic final int CONCEITO_RUIM = 1;
publicstatic final int CONCEITO_BOM = 2;
publicstatic final int CONCEITO_OTIMO = 3;
public void calcularAprovacao(int conceito) {
if(conceito == CONCEITO_OTIMO) {
System.out.println("Aprovado com louvor!");
} else if (conceito == CONCEITO_BOM) {
System.out.println("Aprovado!");
} else if (conceito == CONCEITO_RUIM) {
System.out.println("Reprovado!");
}
}
}

Enumeration
Exemplo de criação de enum:
110
/**
* Enum para conceitos de avaliação de disciplinas.
*/
public enum ConceitoEnum {
RUIM,
BOM,
REGULAR,
OTIMO;
public void calcularAprovacao(ConceitosEnum conceito) {
if(conceito == OTIMO) {
System.out.println("Aprovado com louvor!");
} else if (conceito == REGULAR) {
System.out.println("Regular!");
} else if (conceito == BOM) {
System.out.println("Aprovado!");
} else if (conceito == RUIM) {
System.out.println("Reprovado!");
}
}
}

Enumeration
Exemplo de enum com atributo e construtor:
111
/**
* Enum para conceitos de avaliação de disciplinas.
*/
public enumConceitoEnumComConstrutor {
RUIM("Reprovado!"),
BOM("Aprovado!"),
REGULAR("Regular"),
OTIMO("Aprovado com louvor");
private final String mensagem;
//O construtor de um enum pode ser default ou private.
privateConceitoEnumComConstrutor(String mensagem) {
this.mensagem = mensagem;
}
public String calcularAprovacao() {
return this.mensagem;
}
}

Enumeration
Compilando e executando a classe PrincipalTesteEnum. java
112
/**
* Classe para testar o uso de enum.
*/
public class PrincipalTesteEnum {
System.out.println("Conceito..:" +
ConceitoEnumComConstrutor.OTIMO.calcularAprovacao();
}
}

Outros informações das enums:
Enumeration
113
publicclass PrincipalTesteEnum2 {
//Percorrendo todas as enums
for(ConceitoEnumComConstrutor conceito : ConceitoEnumComConstrutor.values())
System.out.println(conceito);
//Buscando um enum pelo seu nome.
System.out.println(ConceitoEnumComConstrutor.valueOf("BOM"));
//método name() que retorna o nome da propriaenum.
System.out.println(ConceitoEnumComConstrutor.OTIMO.name());
//método ordinal() retorna a posição da ordem em que a enum foi declarada.
System.out.println(ConceitoEnumComConstrutor.OTIMO.ordinal());
}
}

Referência a objeto
Como Java é uma linguagem orientada a objetos é muito comum declararmos atributos ou variáveis que possuem referência a objetos em memória.
Exemplo:
114
Produto prod = new Produto();
Pessoa paulo = new Pessoa("Paulo");
String texto = new String("Explicação de referência de objeto");
int[] valores = new int[100];

Referência a objeto
115
public class ExemploReferencia{
Produto prod = new Produto();
prod.setNome("Duke");
prod.setPreco(75.90);
Pessoa paulo = new Pessoa("Paulo");
paulo.setIdade(40);
paulo.setCpf("111.111.111-11");
}
}
Heap
115

3.2 - Desenvolver código que declare classes concretas, classes abstratas e interfaces, código que ofereça suporte a herança de interface e implementação, código que declare métodos e atributos de instâncias e código que utilize modificadores de acesso Java: privados e públicos.
116

Classe Concreta
Nome da Classe
Carro, Pessoa, ContaCorrente, CaixaCorreio
Atributos
idade, nome, listaMensagens, notaAluno
Métodos
getPessoa, consultarAluno, enviarMensagemEmail
117

Classe Concreta
118
/**
* Classe utilizada para demonstrar a estrutura de uma classe.
*/
public class NovaClasse {
/* Declaração dos atributos da classe. */
public int atributo1;
public float atributo2;
public boolean atributo3;
/* Declaração dos métodos da classe. */
public void metodo1() {
//Comandos
System.out.println("Chamando o metodo 1.");
}
public void metodo2() {
//Comandos
}
}

Classe Concreta
publicclass Livro {
private String titulo;
private String autor;
privatedoublepreco;
public Livro() {
}
publicvoidsetTitulo(String _titulo) { titulo = _titulo; }
public String getTitulo() { return titulo; }
publicvoidsetAutor(String _autor) { autor = _autor; }
public String getAutor() { return autor; }
publicvoidsetPreco(double _preco) { preco = _preco; }
public String getPreco() { returnpreco; }
}
119

Atributo de instância
Atributos de instância são “variáveis” declaradas a nível de classe, que são utilizados para representar as propriedades (estado) que o objeto desta classe pode ter.
Por convenção, costuma-se escrever o atributo com letras minúsculas, a menos que ele seja composto por mais de uma palavra, a primeira palavra é toda em minúscula e as demais começam com a primeira letra em maiúsculo e o restante da palavra em minúscula.
Exemplo:
idade, nome, listaMensagens, notaAlunoTurma, etc
120

Atributo de instância
Exemplo de declaração de atributo:
121
/**
* Classe utilizada para demonstrar a utilização de atributos.
*/
public class Atributo {
/* Declaração dos atributos da classe. */
public float atributo2;
public boolean atributo3;
}

Métodos
São blocos de códigos que representam as funcionalidades (ações) que a classe apresentará.
Por convenção, costuma-se escrever o método com letras minúsculas, a menos que ele seja composto por mais de uma palavra, a primeira palavra é toda em minúscula e as demais começam com a primeira letra em maiúsculo e o restante da palavra em minúscula.
Exemplo:
getPessoa, consultarDadosAluno, enviarMensagemEmail, etc
122

Métodos
Os métodos podem ou não retornar algum valor no final de sua execução, esta informação deve constar na assinatura do método.
Quando não desejamos retornar valor devemos a palavra chave void.
Podemos também informar o tipo de retorno que pode ser um tipo primitivo ou referencia de objeto, lembrando que quando informamos o tipo de retorno então é obrigatório que esse retorno aconteça.
123

Métodos
124
/**
* Classe utilizada para demonstrar o uso de métodos com retorno de valor.
*/
public class MetodoRetorno {
/**
* Método utilizado para retornar o atributo1.
* @return int com o valor do atributo1.
*/
public int metodo1() {
System.out.println("Chamou o metodo 1.");
return atributo1;
}
/**
* Método que verificar se o atributo1 é maior ou igual a 0 (zero).
* @return boolean informando se o atributo1 é positivo
*/
public boolean metodo2() {
System.out.println("Chamou o metodo 2.");
return atributo1 >= 0;
}
}

Métodos
Os métodos também podem receber valores para serem utilizados durante sua execução, esses valores são chamados parâmetros.
Exemplo:
125
/**
* Classe utilizada para demonstrar o uso de métodos que recebem parâmetros.
*/
publicclassMetodoParametro {
publicint atributo1;
/**
* Método utilizado para atribuir o valor do atributo1.
*/
publicvoid metodo1(int valor) {
atributo1 = valor;
System.out.println("O valor do atributo1 eh: " + atributo1);
}

Métodos
126
/**
* Método que recebe uma quantidade de parâmetros variados e imprime todos os
* valores recebidos. Essa possibilidade de receber uma quantidade de
* parâmetros variados é chamado de varargs e foi implementado a partir
* da versão 5.0 do java.
*/
publicvoid metodo2(int... valores) {
if(valores.length > 0) {
/* Para cada argumento recebido como parâmetro, imprime seu valor. */
for(intcont = 0; cont < valores.length; cont++) {
int valor = valores[cont];
System.out.print(valor + " ");
}
System.out.println(" ");
/* Este for faz a mesma coisa que o anterior, este novo tipo de for
chamado foreach foi implementado a partir da versão 5.0 do java. */
for(int valor : valores) {
System.out.print(valor + " ");
}
}
}
}

Métodos com passagem de parâmetro
127
Stack
publicclassVendaLivro {
int quantidade = 3;
Livro livro = new Livro();
livro.setTitulo("Java com Aveia");
livro.setAutor("Sakurai");
livro.setPreco(35.90);
Comprovante c = new Comprovante();
c.emitir(quantidade, livro);
}
}
Heap
publicclass Comprovante {
publicvoid emitir(int qtd, Livro l) {
/* utiliza o qtd e o l para emitir
comprovante. */
}
}

Métodos com passagem de parâmetro
128
Stack
publicclassVendaLivro {
int quantidade = 3;
Livro livro = new Livro();
livro.setTitulo("Java com Aveia");
livro.setAutor("Sakurai");
livro.setPreco(35.90);
Comprovante c = new Comprovante();
c.emitir(quantidade, livro);
}
}
Heap
publicclass Comprovante {
publicvoid emitir(int qtd, Livro l) {
/* utiliza o qtd e o l para emitir
comprovante. */
}
}

Métodos
Para construirmos uma classe precisamos chamar um método construtor, exemplo:
Livro livro = newLivro();
O método construtor é especial pois através dele é criado um objeto da classe.
Um construtor tem a seguinte assinatura:
visibilidade NomeClasse(parâmetros)
Note que neste exemplo o método construtor Livro() não recebe nenhum parâmetro, também chamado de construtor padrão.
Quando não declaramos nenhum construtor na classe, o compilador do Java adiciona um construtor padrão.
129

Classe Abstrata
Define um modelo (template) para representar entidades e conceitos abstratos.
Utilizada como classe pai (base) para criação de outras classes.
Pode ter métodos implementados de forma genérica
Pode definir métodos abstratos que devem ser implementados pelas subclasses concretas.
Em Java para criarmos uma classe abstrata utilizamos a palavra-chave abstract.
130

Exemplo UML de classe abstrata
131

Exemplo de classe Abstrata
132
/**
* Classe abstrata que possui os métodos básicos para
* as telas do computador de bordo de um veiculo.
*/
publicabstractclass Tela {
publicvoidsetTitulo(String titulo) {
this.titulo = titulo;
}
public abstract String obterInformacao();
publicvoid imprimir() {
System.out.println(this.titulo);
System.out.println(" " + obterInformacao());
}
}

133
/**
* Tela que mostra a kilometragem percorrida por um veiculo.
*/
publicclassTelaKilometragemextends Tela {
/* Atributo que guarda o valor da km atual do veiculo. */
int km = 0;
/* Construtor que iniciliza o titulo da tela. */
publicTelaKilometragem() {
/* Atribui o valor do titulo desta tela. */
super.setTitulo("Km Atual");
}
/**
* Implementa o método abstrato da classe Tela,
* neste método buscamos a km atual do veiculo.
* @return Texto com a km atual.
*/
@Override
public String obterInformacao() {
km += 10;
return String.valueOf(km) + " km";
}
}

134
/**
* Classe utilizada para testar a Tela Kilometragem.
*/
public class TesteTelaKm {
TelaKilometragem tk = new TelaKilometragem();
tk.imprimir();
System.out.println(" ------------ ");
tk.imprimir();
}
}

Compilar os arquivos Tela.java, TelaKilometragem.java e TesteTelaKm e executar o arquivo TesteTelaKm.class.
135

Interface
A interface é utilizada para definir assinaturas de métodos que todas as classes que forem implementá-la devem seguir.
Podemos associar uma interface a um contrato onde todas as classes que querem ter esse contrato precisam implementar seus métodos.
Para criar uma interface em Java utilizamos a palavra-chave interface.
136

Interface
A interface pode:
uma interface pode extender outra interface
declarar atributos como constantes
declarar assinatura de métodos públicos
A interface não pode:
implementar método
declarar construtor
extender classe
implementar outra interface
não pode ser final
não pode ter métodos com visibilidade private, protected ou default (padrão)
137

Exemplo de Interface
138

139
/**
* Classe utilizada para representar uma Conta bancaria.
*/
publicclass Conta {
// Nome do proprietário da Conta.
private String nomeProprietario;
// Número da Conta.
privateint numero;
// Saldo da Conta.
privatedouble saldo;
public String getNomeProprietario() { returnnomeProprietario; }
publicvoidsetNomeProprietario(String nomeProprietario) {
this.nomeProprietario = nomeProprietario;
}
publicintgetNumero() { return numero; }
publicvoidsetNumero(int numero) { this.numero = numero; }
publicdoublegetSaldo() { return saldo; }
publicvoidsetSaldo(double saldo) { this.saldo = saldo; }
}

140
/**
* Interface utilizada para representar os métodos mínimos que
* os bancos precisam implementar.
*/
publicinterface Banco {
public abstractvoidmanutencaoConta(Conta conta);
public abstractboolean saque(Conta conta, double valor);
public abstractboolean deposito(Conta conta, double valor);
public abstractvoid extrato(Conta conta);
}

141
/**
* Classe utilizada para representar o Banco Sakurai
*/
public class BancoSakurai implements Banco {
// Conta que representa o Banco Sakurai.
private Conta contaBancoSakurai = null;
/**
* Construtor padrão da classe.
* Cria uma conta para o banco sakurai.
*/
public BancoSakurai() {
this.contaBancoSakurai = new Conta();
this.contaBancoSakurai.setNomeProprietario("Banco Sakurai");
this.contaBancoSakurai.setNumero(0);
this.contaBancoSakurai.setSaldo(0d);
}
publicvoidmanutencaoConta(Conta conta) {
booleantemSaldo = conta.getSaldo() >= 0.25;

142
//Verifica se tem saldo para realizar a manutenção da conta.
if(temSaldo) {
doublenovoSaldo = conta.getSaldo() - 0.25;
conta.setSaldo(novoSaldo);
//Deposita o dinheiro da manutenção na conta do banco sakurai.
deposito(this.contaBancoSakurai, 0.25);
} else {
System.out.println("Não conseguiu cobrar a manutenção da conta " +
conta.getNumero() + " !!!");
}
}
public boolean saque(Conta conta, double valor) {
//Verifica se tem saldo suficiente para fazer o saque
if(conta.getSaldo() >= valor) {
//Realiza o saque na conta.
double novoValor = conta.getSaldo() - valor;
conta.setSaldo( novoValor );
System.out.println("Saque efetuado!!!");
//Toda vez que fizer um saque faz cobra a manutenção da conta.
manutencaoConta(conta);
return true;

143
} else {
System.out.println("Não conseguiu fazer o saque!!!");
//Se não conseguir fazer o saque, mostra o extrato da conta.
extrato(conta);
returnfalse;
}
}
public boolean deposito(Conta conta, double valor) {
//Realiza o deposito na conta.
double novoValor = conta.getSaldo() + valor;
conta.setSaldo(novoValor);
System.out.println("Deposito efetuado!!!");
return true;
}
public void extrato(Conta conta) {
System.out.println(" -- BANCO SAKURAI -- ");
System.out.println("-> EXTRATO CONTA ");
System.out.println("Nome: " + conta.getNomeProprietario());
System.out.println("Numero: " + conta.getNumero());
System.out.println("Saldo: " + conta.getSaldo());
System.out.println(" --------------------- ");
}

144
public boolean transferencia(Conta contaOrigem, Conta contaDestino, double valor) {
boolean fezSaque = saque(contaOrigem, valor);
//Verifica se conseguiu sacar dinheiro na conta de origem.
if(fezSaque) {
//Faz o deposito na conta de destino.
deposito(contaDestino, valor);
System.out.println("Transferencia efetuada.");
return true;
} else {
System.out.println("Não conseguiu fazer a transferencia.");
return false;
}
}
}

145
/**
* Classe utilizada para representar o Banco Cristiano.
*/
publicclassBancoCristianoimplements Banco {
private Conta contaBancoCristiano = null;
publicBancoCristiano() {
this.contaBancoCristiano = new Conta();
this.contaBancoCristiano.setNomeProprietario("Banco Cristiano");
this.contaBancoCristiano.setNumero(0);
this.contaBancoCristiano.setSaldo(0d);
}
publicvoidmanutencaoConta(Conta conta) {
//Sempre executa o saque na conta bancaria.
doublenovoSaldo = conta.getSaldo() - 0.01;
conta.setSaldo(novoSaldo);
//Deposita o dinheiro da manutenção na conta do Banco Cristiano.
doublesaldoBanco = this.contaBancoCristiano.getSaldo() + 0.01;
this.contaBancoCristiano.setSaldo(saldoBanco);
}

146
publicboolean saque(Conta conta, double valor) {
//Verifica se tem saldo suficiente para fazer o saque
if(conta.getSaldo() >= valor) {
//Realiza o saque na conta.
doublenovoValor = conta.getSaldo() - valor;
conta.setSaldo( novoValor );
System.out.println("Saque efetuado!!!");
//Toda vez que fizer um saque faz cobra a manutenção da conta.
returntrue;
} else {
System.out.println("Não conseguiu fazer o saque!!!");
//Se não conseguir fazer o saque, mostra o extrato da conta.
extrato(conta);
returnfalse;
}
}

147
publicboolean deposito(Conta conta, double valor) {
//Realiza o deposito na conta.
doublenovoValor = conta.getSaldo() + valor;
conta.setSaldo(novoValor);
System.out.println("Deposito efetuado!!!");
//Toda vez que fizer um deposito faz cobra a manutenção da conta.
returntrue;
}
publicvoid extrato(Conta conta) {
System.out.println(" -- BANCO CRISTIANO -- ");
System.out.println("-> EXTRATO CONTA ");
System.out.println("Nome: " + conta.getNomeProprietario());
System.out.println("Numero: " + conta.getNumero());
System.out.println("Saldo: " + conta.getSaldo());
System.out.println(" --------------------- ");
}
}

148
/**
* Classe utilizada para testar a interface Banco, e as
* classes BancoCristiano e BancoSakurai.
*/
publicclassBancoTeste {
Banco bancoCristiano = newBancoCristiano();
Conta contaC = new Conta();
contaC.setNomeProprietario("Cristiano Camilo");
contaC.setNumero(1); contaC.setSaldo(1000);
bancoCristiano.deposito(contaC, 150.50);
bancoCristiano.saque(contaC, 500);
bancoCristiano.extrato(contaC);
Banco bancoSakurai = newBancoSakurai();
Conta contaS = new Conta();
contaS.setNomeProprietario("Rafael Sakurai");
contaS.setNumero(1); contaS.setSaldo(500);
bancoSakurai.deposito(contaS, 40.99);
bancoSakurai.saque(contaS, 300);
bancoSakurai.extrato(contaS);
}
}

149

Comparativo Classe Abstrata x Interface
150

Herança
Em Java, podemos criar classes que herdam atributos e métodos de outras classes, evitando reescrita de código. Este tipo de relacionamento é chamado de Herança.
Para representarmos este tipo de relacionamento na linguagem, devemos utilizar a palavra reservada extends, de forma a apontar para qual classe a nossa nova classe deve herdar seus atributos e métodos.
Utilizando herança podemos também guardar instâncias de objetos de subclasses em variáveis do tipo das superclasses.
151

Herança
Uma classe pode herdar apenas de uma classe (superclasse). Quando uma classe não define explicitamente que está herdando outra classe então esta classe é filha de java.lang.Object, ou seja, a classe Object é a classe pai de todas as classes.
Por Object ser pai de todas as classes, todas as classes herdam os seguintes métodos dela:
152

Herança
Quando lidamos com classes que possuem a relação de herança, podemos fazer uso de duas palavras-chave que servem para identificar se estamos utilizando um método e ou atributo da classe atual ou de sua super classe, estes comandos são:
thisDefine que o recurso pertence à classe atual.
super Define que o recurso pertence à super classe.
153

Herança
Neste exemplo temos a superclasse Pessoa, e três subclasses Funcionario, Aluno e Coordenador.
154

Herança
155
/**
* Classe utilizada para representar a Pessoa.
*/
privateint matricula;
/**
* Construtor que recebe o nome da pessoa.
* @param nome
*/
public Pessoa(String nome, int matricula) {
this.nome = nome;
this.matricula = matricula;
}
publicintgetMatricula() { return matricula; }
publicvoidsetMatricula(int matricula) { this.matricula = matricula; }
public String getNome() { return nome; }
publicvoidsetNome(String nome) { this.nome = nome; }
}

Herança
156
/**
* Classe utilizada para representar um Funcionario que é uma Pessoa.
*/
publicclassFuncionarioextends Pessoa {
private String departamento;
publicFuncionario(String nome, int matricula, String departamento) {
super(nome, matricula);
this.departamento = departamento;
}
public String getDepartamento() {
return departamento;
}
publicvoidsetDepartamento(String departamento) {
this.departamento = departamento;
}
}

Herança
157
/**
* Classe utilizada para representar um Coordenador que é uma Pessoa.
*/
publicclass Coordenador extends Pessoa {
private String cursoCoordenado;
public Coordenador(String nome, int matricula, String cursoCoordenado) {
super(nome, matricula);
this.cursoCoordenado = cursoCoordenado;
}
public String getCursoCoordenado() {
returncursoCoordenado;
}
publicvoidsetCursoCoordenado(String cursoCoordenado) {
this.cursoCoordenado = cursoCoordenado;
}
}

Herança
158
/**
* Classe utilizada para testar a Herança da classe Funcionario.
*/
publicclassTesteFuncionario {
/* Declarações comuns. */
Pessoa camilo = new Pessoa("Camilo", 123);
Funcionariorafael = newFuncionario("Rafael", 111, "informatica");
/* Todo Funcionario é uma Pessoa. */
Pessoa sakurai = newFuncionario("Sakurai", 222, "telecomunicação");
/* Erro de compilação, porque nem toda Pessoa é um Funcionario. */
Funcionariocristiano = new Pessoa("Cristiano", 456);
}
}

Herança
Com a declaração acima, temos as classe Funcionario e Coordenador como classes filha ou subclasses da classe paiPessoa. Com isso podemos dizer que as subclasses Funcionario e Coordenador herdam todos os atributos e métodos da sua superclasse Pessoa.
Por isso lembre-se, o FuncionarioÉ UMAPessoa, pois é uma subclasse, logo apenas possui algumas características a mais do que Pessoa, porém podemos sempre manuseá-lo como uma Pessoa.
159

Modificador de acesso
Os modificadores de acesso são utilizados para proteger o acesso a um atributo, método ou uma classe de outras classes, em Java temos os seguintes modificadores:
private (Restringe totalmente o acesso do atributo ou método da classe de todas as demais classes)
default (Apenas classes do mesmo pacote tem acesso a classe, método ou atributo que possui este modificador)
protected (Um atributo ou método é visível apenas para as classes do mesmo pacote ou para as subclasses daquela classe)
public (classes, métodos e atributos podem ser acessados a partir de qualquer outra classe)
Dentro de um arquivo .java, só pode existir uma classe do tipo public e esta classe precisa obrigatoriamente ter o mesmo nome que o nome do arquivo .java.
160

Modificadores de acesso
161

3.3 - Desenvolver código que implemente associações de classes simples e código que implemente multiplicidade usando matrizes; e reconhecer código que implemente composições em oposição a associações simples e código que implemente corretamente a navegação de associações.
162

Associação de classe simples
Associação é quando uma classe possui um relacionamento com outra classe, exemplo:
A classe Usuario possui um atributo chamado perfil que é do tipo da classe Perfil e um atributo chamado endereco que é do tipo da classe Endereco.
163

A implementação em Java fica da seguinte forma:
Associação de classe simples
164
publicclass Perfil {
}
publicclassEndereco {
private String estado;
private String cidade;
private String bairro;
private String logradouro;
private String cep;
}
publicclassUsuario{
private String cpf;
private String login;
private String senha;
private Perfil perfil;
privateEnderecoendereco;
}

Composição
Uma composição é um relacionamento mais forte que a associação, pois uma classe depende da outra para existir, exemplo:
A classe DetalheUsuario depende da classe Usuario para ser criada, sem a classe Usuario não tem porque ela existir.
165

Composição
166
publicclassUsuario{
private String login;
private String senha;
private Perfil perfil;
privateDetalheUsuario detalhe;
}
publicclassDetalheUsuario {
private String endereco;
private String telefone;
private String email;
}

Navegação
A navegação informa a direção entre os relacionamentos.
A partir da classe Venda podemos chegar nas classes Funcionario, Produto e Cliente.
167

Navegação
168
publicclassFuncionario { private String nome; }
publicclass Cliente {
}
publicclass Produto{
privatedoublepreco;
}
publicclass Venda {
private Cliente cliente;
private Produto produto;
privateFuncionariofuncionario;
public Cliente getCliente() { returnthis.cliente; }
public Produto getProduto() { returnthis.produto; }
publicFuncionariogetFuncionario() { returnthis.funcionario; }
}

Multiplicidade com matrizes
Quando uma classe pode guardar mais de uma referencia para outra classe, podemos utilizar uma estrutura de vetor, matriz, lista e outros, exemplo:
A classe Pagamento possui um conjunto da classe Servico, através do relacionamento da UML sabemos que é no mínimo 1 e não tem limite de quantidade máxima.
169

Multiplicidade com matrizes
170
publicclass Pagamento{
private Prestador prestador;
privateServico[] servicos;
privatelong numero;
publicServico[] getServicos() {
returnthis.servicos;
}
}
publicclassServico {
privateBigDecimalpreco;
privatechar status;
}

3.4 - Desenvolver código que utilize polimorfismo para classes e interfaces, bem como reconhecer código que utilize o princípio "programa para uma interface".
171

Polimorfismo
Polimorfismo é a capacidade de um objeto ser referenciado de diversas formas e com isso realizar as mesmas tarefas (ou chamadas de métodos) de diferentes formas.
Durante a execução do programa, a JVM verifica qual a classe de origem do objeto e chama o método desta classe.
172

Polimorfismo com herança
173

174
/**
* Classe utilizada para representar uma Pessoa.
*/
return nome;
}
publicvoidsetNome(final String nome) {
this.nome = nome;
}
}

175
/**
* Classe utilizada para representar uma Pessoa Fisica
* que É UMA subclasse de Pessoa.
*/
publicclassPessoaFisicaextends Pessoa {
private String cpf;
public String getCpf() {
returncpf;
}
publicvoidsetCpf(String cpf) {
this.cpf = cpf;
}
return "Pessoa Fisica: " + super.getNome() + " - CPF: " + this.getCpf();
}
}

176
/**
* Classe utilizada para representar uma Pessoa Fisica
* que É UMA subclasse de Pessoa.
*/
publicclassPessoaJuridicaextends Pessoa {
private String cnpj;
public String getCnpj() {
returncnpj;
}
publicvoidsetCnpj(String cnpj) {
this.cnpj = cnpj;
}
return "Pessoa Juridica: " + super.getNome() + " - CNPJ: " +
this.getCnpj();
}
}

177
/**
* Classe utilizada para demonstrar o uso do polimorfismo, vamos criar um vetor
* de Pessoa e adicionar nele objetos do tipo PessoaFisica e PessoaJuridica.
*/
publicclassTestePessoa {
PessoaFisicafisica = newPessoaFisica();
fisica.setNome("Cristiano");
fisica.setCpf("12345678901");
PessoaJuridicajuridica = newPessoaJuridica();
juridica.setNome("Rafael");
juridica.setCnpj("010101010101010101");
Pessoa[] pessoas = new Pessoa[2];
pessoas[0] = fisica;
pessoas[1] = juridica;
for(Pessoa pessoa : pessoas) {
System.out.println(pessoa.getNome());
}
}
}

Durante o laço for, mesmo as variáveis sendo do tipo Pessoa, o método getNome() foi chamado da classe PessoaFisica e PessoaJuridica, porque durante a execução do programa, a JVM percebe de qual classe foi criada o objeto que está guardado na variável pessoa.
178

Polimorfismo com Interface
179

180
/**
* Interface que deve ser implementada por todas as classes que devem
* ser ordenadas.
*/
publicinterfaceComparavel {
/**
* Assinatura de método que toda classe que quer permitir
* a comparação entre seus objetos precisa implementar.
*
* @param o - Objeto que será comparado.
* @return 0 se os objetos forem iguais
* > 0 se o objeto recebido é menor que o objeto que será comparado.
* < 0 se o objeto recebido é maior que o objeto que será comparado.
*/
public abstract int comparar(Object o);
}

181
/**
* Classe utilizada para ordenar qualquer tipo de classe
* que implementa a interface Comparavel.
*/
publicclass Ordenar {
/**
* Método que utiliza o algoritmo de bubblesort
* para ordenar um vetor de objetos do tipo <code>Comparavel</code>.
* @param objetos - Vetor de objetos que ordenados.
*/
publicvoid ordenar(Comparavel[] objetos) {
for (int i = 0; i < objetos.length; i++) {
for (int j = i + 1; j < objetos.length; j++) {
/* Verifica se os objetos não estão na ordem. */
if(objetos[i].comparar(objetos[j]) > 0) {
/* Troca os objetos de lugar no vetor. */
Comparaveltemp = objetos[i];
objetos[i] = objetos[j];
objetos[j] = temp;
}
}
}
}
}

182
/**
* Classe utilizada para representar um Livro, esta classe
* implementa a interface Comparavel.
*/
publicclass Livro implementsComparavel {
private String autor;
public Livro(String autor, String titulo) {
this.autor = autor;
}
public String getAutor() {
return autor;
}
publicvoidsetAutor(String autor) {
this.autor = autor;
}
public String getTitulo() {
return titulo;
}

183
public void setTitulo(String titulo) {
}
publicint comparar(Object o) {
intcomparacao = 0;
//Verifica se o objeto que vai comparar é do tipo Livro.
if (o instanceof Livro) {
Livro livro = (Livro) o;
comparacao = this.getAutor().compareTo(livro.getAutor());
//Se os autores forem iguais, compara o titulo dos livros.
if (comparacao == 0) {
comparacao = this.getTitulo().compareTo(livro.getTitulo());
}
}
returncomparacao;
}
}

184
/**
* Classe utilizada para testar a ordenação genérica.
*/
publicclassTestarOrdenacao {
/* Cria uma vetor de livros. */
Livro[] livros = new Livro[4];
livros[0] = new Livro("Sakurai", "Almoçando com Java");
livros[1] = new Livro("Cristiano", "Classes Java em fila indiana");
livros[2] = new Livro("Sakurai", "Java em todo lugar");
livros[3] = new Livro("Cristiano", "Viajando no Java");
/* Ordena os livros */
Ordenar o = new Ordenar();
o.ordenar(livros);
/* Imprime os livros ordenados. */
for(intcont = 0; cont < livros.length; cont++) {
System.out.println("Autor: " + livros[cont].getAutor());
System.out.println("Livro: " + livros[cont].getTitulo());
System.out.println(" --------- ");
}
}
}

Polimorfismo
Quando utilizamos polimorfismo estamos restringindo os métodos baseado no tipo de referencia do objeto, exemplo:
O tipo de referencia do objeto é Comparavel e através dela podemos chamar apenas o método comparar(), não podemos chamar os métodos que foram declarados na classe Livro.
185
Comparavel livro = new Livro("Java com Aveia", "Rafael");
Livro onlyJava = new Livro("Only Java", "Sakurai");
livro.comparar(onlyJava);
livro.getNome(); //Erro de compilação

DinamicBinding
Mas porque quando chamamos o método comparar() da interface Comparavel é chamado o método comparar() da classe Livro?
Em tempo de execução a JVM verifica qual o objeto está sendo referenciado e chama seu método, isto é chamado DinamicBinding.
186
Comparavel livro = new Livro("Java com Aveia", "Rafael");
Livro onlyJava = new Livro("Only Java", "Sakurai");
livro.comparar(onlyJava);

Casting de objeto
Vimos anteriormente que uma Pessoa (superclasse) nem sempre É UMAPessoaFisica (subclasse), mas quando estamos trabalhando com uma superclasse e temos a certeza de qual o tipo de subclasse ele está representando podemos fazer o casting de objetos, para guardar o objeto em sua classe, funciona de forma similar ao casting de atributos primitivos.
No exemplo abaixo vamos criar duas variáveis do tipo Pessoa com objetos do tipo PessoaFisica e PessoaJuridica, depois vamos também criar uma variável do tipo Object (que é a superclasse de todas as classes) e guardar nela um objeto do tipo String.
187

Casting de objeto
188
/**
* Classe utilizada para demonstrar o uso do polimorfismo, vamos criar duas
* variáveis do tipo Pessoa e adicionar nele objetos do tipo PessoaFisica e
* PessoaJuridica.
*/
publicclass TestePessoa4 {
Pessoa pessoa1 = newPessoaFisica();
pessoa1.setNome("Cristiano");
Pessoa pessoa2 = newPessoaJuridica();
pessoa2.setNome("Rafael");
PessoaFisicafisica = (PessoaFisica) pessoa1;
fisica.setCpf(12345678901L);
PessoaJuridicajuridica = (PessoaJuridica) pessoa2;
juridica.setCnpj(1000100012345678L);
System.out.println(fisica.getNome());
System.out.println(juridica.getNome());
Object objeto = "Programacao Orientada a Objetos";
String texto = (String) objeto;
System.out.println(texto);
}
}

Casting de objeto
Compilar e executar o arquivo TestePessoa4.java.
189

Programe para uma interface
Programando para implementação
Programando para interface
190
OrdenarLivroordenadorDeLivros = new OrdenadorLivro();
Livro[] livros = new Livros[] { new Livro("Only Java", "Sakurai"),
new Livro("Java com Aveia", "Rafael") };
ordenadorDeLivros.ordenarLivro(livros);
OrdenarPessoaordenadorDePessoas = newOrdenarPessoa();
Pessoa[] pessoas = new Pessoa[] { newPessoaFisica("Sakurai"),
newPessoaJuridica("Rafael") };
ordenadorDePessoas.ordenar(pessoas);
Ordenar o = new Ordenar();
Livro[] livros = new Livros[] { new Livro("Only Java", "Sakurai"),
new Livro("Java com Aveia", "Rafael") };
o.ordenar(livros);
Pessoa[] pessoas = new Pessoa[] { new PessoaFisica("Sakurai"),
new PessoaJuridica("Rafael") };
o.ordenar(pessoas);

4- Projeto e Implementação de Algoritmos
191

4.1 - Descrever, comparar e contrastar estes três tipos de instruções fundamentais: atribuição, condicional e iteração; com base na descrição de um algoritmo, selecionar o tipo apropriado de instrução para projetar o algoritmo.
192

Instruções fundamentais
Quando queremos guardar o valor de um tipo primitivo ou uma referência para um objeto, podemos guardá-los em variáveis, isto também é chamado de atribuição.
193

Quando queremos executar um determinado conjunto de instruções, em uma determinada condição ou situação, podemos utilizar estruturas do tipo condicional.
194

Quando queremos executar um certo conjunto de instruções n vezes, durante uma determinada condição ou situação, podemos utilizar estruturas do tipo iteração.
195

4.2 - Com base em um algoritmo como pseudo-código, determinar o escopo correto de uma variável usada no algoritmo e desenvolver código para declarar variáveis em qualquer um dos seguintes escopos: variável de instância, parâmetro de método e variável local.
196

Escopo de variável
Variáveis de instânciasão criadas em nível de classe que podem ser utilizadas para guardar informações (estado) para cada objeto que estiver em memória.
Este tipo de variável tem um escopo de vida igual a vida do objeto onde ele está referenciado.
197

Escopo de variável
Parâmetros de método são variáveis recebidas por parâmetro de método. Todo parâmetro é passado por cópia, ou seja:
Se o parâmetro for do tipo primitivo, então é copiado o valor da variável de origem para o parâmetro do método.
Se o parâmetro for um objeto, então é copiado o valor da referência ao objeto original.
Este tipo de variável tem o escopo de vida igual ao tempo da chamada do método.
198

Escopo de variável
Variável local é criada dentro de blocos de chave { }, este tipo de variável tem um escopo de vida limitado ao bloco.Estas variáveis são criadas para serem utilizadas para executar uma determinada instrução e depois são descartadas.
199

4.3 - Com base em um algoritmo como pseudo-código, desenvolver código de método que implemente o algoritmo usando instruções condicionais (if e switch), instruções de iteração (for, for-each, while e do-while), instruções de atribuição e instruções break e continue para controlar o fluxo dentro das instruções switch e de iteração.
200

Instruções condicionais (if / else)
A instrução condicionais if, é utilizada para executar alguns comandos apenas se sua condição for true (verdadeira).
O else pode ou não acompanhar o if, mas o else não pode ser usado sozinho, e é utilizado para executar alguns comandos caso a condição do if for false (falso).
201
if (condição) {
//Comandos executados caso a condição verdadeira.
}
if (condição) {
//Comandos executados caso a condição verdadeira.
} else {
//Comandos executados caso a condição falsa.
}

Podemos também utilizar vários if / else aninhados:
202
if (condição1) {
//Comandos executados caso a condição1 verdadeira.
} else if (condição2) {
} else if (condição3) {
} else {
//Comandos executados caso nenhuma das condições for verdadeira.
}

Exemplo:
203
/**
* Exemplo de estrutura de controle IF.
*/
public class ExemploIf {
int idade = 15;
if(idade >= 18) {
System.out.println("PermissÃ£o para dirigir");
} else {
System.out.println("Idade minima para dirigir eh 18 anos");
}
}
}

Instruções condicionais (switch)
A instrução condicional switch é utilizada quando queremos testar se o valor de uma variável pode atender um determinado caso.
204
switch(variável) {
case<possível valor da constante> :
< instruções >
break;
case<possível valor da constante> :
< instruções >
break;
default:
< instruções >
break;
}

A instrução switch aceita apenas variáveis do tipo: byte, short, int, char e enumeração.
Cada case é um caso onde os comandos dentro dele são executados se o valor constante dele for o mesmo que o valor da variável recebida no switch.
O bloco de comandos default representa uma condição geral de execução caso nenhuma das anteriores tenha sido atendida, sendo a sua utilização também é opcional.
O comando break é utilizado para bloquear a execução de blocos cases de forma desnecessária.
205

206
/**
* Exemplo de estrutura de seleção SWITCH.
*/
public class ExemploSwitch {
char nota = 'D';
switch(nota) {
case 'A':
System.out.println("Aluno aprovado. Conceito excelente!");
break;
case 'B':
System.out.println("Aluno aprovado. Conceito bom!");
break;
case 'C':
System.out.println("Aluno aprovado. Conceito medio!");
break;
default:
System.out.println("Aluno reprovado!");
break;
}
}
}

Instruções de iteração (for)
Utilizamos a instrução for quando queremos executar um bloco de instruções n vezes.
for(<inicialização>; <condição de execução>; <pós-instruções>) {
<< instruções >>
}
Utilizamos a área inicialização para criar variáveis ou atribuir valores para variáveis já declaradas, mas todas as variáveis precisam ser do mesmo tipo, está área é executada antes de começar a estrutura de repetição do for.
Utilizamos a área condição de execução para definir a lógica de parada da estrutura de repetição for.
Utilizamos a área pós-instruções para executar alguma ação que deve ocorrer cada vez que as instruções dentro for forem executados.
207

Exemplo1:
208
/**
* Exemplo de estrutura de repetição FOR
*/
public class ExemploFor {
for(int i = 0; i <= 10; i++) {
if(i % 2 == 0) {
System.out.println(i + " e um numero par.");
} else {
System.out.println(i + " e um numero impar.");
}
}
}
}

Exemplo2:
209
/**
* Exemplo de estrutura de repetição FOR
*/
public class ExemploFor2 {
for(int i = 0, j = 10; i <= 10; i++, j--) {
if(i == j) {
System.out.println("i " + i + " eh igual a j " + j);
}
}
}
}

Instruções de iteração (for-each)
Muitas vezes o for é utilizado para percorrer um array ou uma coleção de objetos, para facilitar seu uso foi adicionado na versão 5 do Java o for-each.
210
for(<Tipo> <identificador> : <expressão>) {
<instruções>
}

Instruções de iteração (for-each)
211
import java.util.ArrayList;
import java.util.List;
/**
* Exemplo de estrutura de repetição For Each.
*/
public class ExemploForEach {
String[] nomes = {"Altrano", "Beltrano", "Ciclano", "Deltrano"};
//Percorre um array.
for(String nome : nomes) {
System.out.println(nome);
}
List<Integer> valores = new ArrayList<Integer>();
valores.add(100);
valores.add(322);
valores.add(57);
//Percorre uma coleção.
for(Integer numero : valores) {
System.out.println(numero);
}
}
}

Instruções de iteração (while)
A instrução while executa um bloco de instruções enquanto uma determinada condição for verdadeira (true).
212
while(condição) {
< instruções >
}

Instruções de iteração (while)
Exemplo:
213
/**
* Exemplo de estrutura de repetição WHILE
*/
public class ExemploWhile {
int i = 0;
while(i < 10) {
System.out.println(++i);
}
}
}

Instruções de iteração (do / while)
A estrutura do / while tem seu bloco de instruções executados pelo menos uma vez, então se a condição ao final das instruções for verdadeira (true), então o bloco de instruções é executado novamente.
214
do {
< instruções >
} while(condição);

Instruções de iteração (do / while)
Exemplo:
215
import java.util.Scanner;
/**
* Exemplo de estrutura de repetição DO / WHILE
*/
public class ExemploDoWhile {
Scanner entrada = new Scanner(System.in);
int opcao = 0;
do {
System.out.println("Escolha uma opcao:");
System.out.println("1 - Iniciar jogo");
System.out.println("2 - Ajuda");
System.out.println("3 - Sair");
System.out.println("OPCAO: ");
opcao = entrada.nextInt();
} while (opcao != 3);
}
}

Instrução break
O comando break é uma instrução de interrupção imediata de qualquer laço, seja ele qual for e independente de sua condição de parada ter sido atendida.
216
/**
* Exemplo do comando break.
*/
public class ExemploBreak {
System.out.println("Digite um numero de 1 a 9 exceto o 5:");
int numero = entrada.nextInt();
System.out.println("Contando de 1 ate o numero que voce digitou... ");
for(int cont = 1; cont <= numero; cont++) {
if(numero == 5 || numero < 1 || numero > 9) {
System.out.println("Um numero invalido foi digitado!!!");
break;
}
System.out.println(cont + " ");
}
}
}

Instrução continue
O comando continue faz com que o laço salte para sua próxima iteração. Este comando pode ser utilizado com qualquer laço.
217
/**
* Exemplo do comando continue.
*/
public class ExemploContinue {
System.out.println("Digite um numero de 1 a 9: (saltaremos o 5)");
int numero = entrada.nextInt();
System.out.println("Contando de 1 ate o numero que voce digitou...");
for(int cont = 0; cont <= numero; cont++) {
if(cont == 5) {
System.out.println("# PULANDO O 5 #");
continue;
}
System.out.println(cont + " ");
}
}
}

4.4 - Com base em um algoritmo como pseudo-código, desenvolver código que aplique corretamente os operadores apropriados, incluindo operadores de atribuição (limitados a: =, +=, -=), operadores aritméticos (limitados a: +, -, *, /, %, ++, --), operadores relacionais (limitados a: <, <=, >, >=, ==, !=) e operadores lógicos (limitados a: !, &&, ||) para produzir o resultado desejado. Além disso, escrever código que determine a igualdade de dois objetos ou duas primitivas.
218

Operadores de atribuição
Símbolo = é chamado de atribuição, utilizado para atribuir o valor de um operando a uma variável.
219
/**
* Classe utilizada para demonstrar o uso do operador de atribuição ( = ).
*/
public class OperadorAtribuicao {
int x;
x = 25;
System.out.println(x);
}
}

Símbolo += é utilizado para atribuir a uma variável o valor desta variável somada ao valor de um operando.
220
/**
* Classe utilizada para demonstrar o uso do operador de atribuição
* junto com o operador de adição ( += ).
*/
public class OperadorAtribuicaoAdicao {
int x = 4;
x += 2;
}
}

Símbolo -= é utilizado para atribuir a uma variável o valor desta variável subtraindo o valor de um operando.
221
/**
* Classe utilizada para demonstrar o uso do operador de atribuição
* junto com o operador de subtração ( -= ).
*/
public class OperadorAtribuicaoSubtracao {
int x = 4;
x -= 2;
}
}

Operadores relacionais
Símbolo > é chamado de maior que.
<operando1> > <operando2>
Retorna true se o valor do operando1 for maior que o valor do operando2, caso contrario retorna false.
222
/**
* Classe utilizada para demonstrar o uso do operador
* relacional maior que ( > ).
*/
public class OperadorMaiorQue {
int a = 5;
int b = 3;
System.out.println(a > b);
}
}

Símbolo < é chamado de menor que.
<operando1> < <operando2>
Retorna true se o valor do operando1 for menor que o valor do operando2, caso contrario retorna false.
223
/**
* Classe utilizada para demonstrar o uso do operador relacional menor que ( < ).
*/
public class OperadorMenorQue {
int a = 5;
int b = 3;
System.out.println(a < b);
}
}

Símbolo >= é chamado de maior ou igual que.
<operando1> >= <operando2>
Retorna true se o valor do operando1 for maior ou igual que o valor do operando2, caso contrario retorna false.
224
/**
* relacional maior ou igual que ( >= ).
*/
public class OperadorMaiorIgualQue {
int a = 5;
int b = 3;
System.out.println(a >= b);
int c = 5;
System.out.println(a >= c);
}
}

Símbolo <= é chamado de menor ou igual que.
<operando1> <= <operando2>
Retorna true se o valor do operando1 for menor ou igual que o valor do operando2, caso contrario retorna false.
225
/**
* relacional menor ou igual que ( <= ).
*/
public class OperadorMenorIgualQue {
int a = 5;
int b = 5;
System.out.println(a <= b);
}
}

Símbolo != é chamado de diferente.
<operando1> != <operando2>
Retorna true se o valor do operando1 for diferente do valor do operando2, caso contrario retorna false.
226
/**
* relacional diferente ( != ).
*/
public class OperadorDiferente {
int a = 5;
int b = 3;
System.out.println(a != b);
int c = 3;
System.out.println(b != c);
}
}

Operadores aritméticos
Símbolo + é chamado de adição, utilizado para somar o valor de dois operandos.
227
/**
* Classe utilizada para demonstrar o uso do operador de adição ( + ).
*/
public class OperadorAdicao {
System.out.println(3 + 7);
//ou
int a = 3;
int b = 7;
System.out.println(a + b);
}
}

Símbolo - é chamado de subtração, utilizado para subtrair o valor de dois operandos.
228
/**
* Classe utilizada para demonstrar o uso do operador de subtração ( - ).
*/
public class OperadorSubtracao {
System.out.println(5 - 2);
//ou
int a = 5;
int b = 2;
System.out.println(a - b);
}
}

Símbolo * é chamado de multiplicação, utilizado para multiplicar o valor de dois operandos.
229
/**
* Classe utilizada para demonstrar o uso do operador de multiplicação ( * ).
*/
public class OperadorMultiplicacao {
System.out.println(3 * 2);
//ou
int a = 3;
int b = 2;
System.out.println(a * b);
}
}

Símbolo / é chamado de divisão, utilizado para dividir o valor de dois operandos.
OBS: Divisão de números inteiro retorna um int, divisão com pelo menos um número com ponto flutuante retorna um double.
Divisão por zero lança um erro java.lang.ArithmeticException.
230
/**
* Classe utilizada para demonstrar o uso do operador de divisão ( / ).
*/
public class OperadorDivisao {
System.out.println(3.0 / 2);
//ou
int a = 3;
int b = 2;
System.out.println(a / b);
}
}

Símbolo % é chamado de módulo, utilizado para saber qual o resto da divisão de dois operandos.
231
/**
* Classe utilizada para demonstrar o uso do operador de modulo ( % ).
*/
public class OperadorModulo {
System.out.println(4.5 % 2);
//ou
int a = 5;
int b = 3;
System.out.println(a % b);
}
}

Símbolo ++ é utilizado para incrementar em 1 o valor de uma variável, podendo ser feita das seguintes formas:
++ <variável>
Primeiro incrementa a variável depois devolve seu valor.
<variável> ++
Primeiro devolve o valor da variável depois incrementa seu valor.
232

Operador de incremento
233
/**
* Classe utilizada para demonstrar o uso do operador de incremento ( ++ ).
*/
public class OperadorIncremento {
int a = 1;
int b = 1;
System.out.println(++a);
System.out.println(b++);
System.out.println(a);
System.out.println(b);
}
}

Símbolo -- é utilizado para decrementar em 1 o valor de uma variável, podendo ser feita das seguintes formas:
-- <variável>
Primeiro decrementa o valor da variável, depois devolve seu valor.

<variável> --
Primeiro devolve o valor da variável, depois ela é decrementada.
234

Operador de decremento
235
/**
* Classe utilizada para demonstrar o uso do operador de decremento ( -- ).
*/
public class OperadorDecremento {
int a = 1;
int b = 1;
System.out.println(--a);
System.out.println(b--);
System.out.println(a);
System.out.println(b);
}
}

Operadores lógicos
Símbolo && é chamado de E. Este operador retorna true somente se os dois operandos forem true.
<operando1> && <operando2>
Se o valor do operando1 for false, então o operador && não verifica o valor do operador2, pois sabe que o resultado já é false.
Tabela verdade:

236

Operadores lógicos
Operador Lógico E ( && )
237
/**
* Classe utilizada para demonstrar o uso do operador logico E ( && ).
*/
public class OperadorLogicoE {
boolean a = true;
boolean b = false;
boolean c = true;
System.out.println(a && b);
System.out.println(a && c);
}
}

Operadores lógicos
Símbolo || é chamado de OU. Este operado retorna true caso tenha pelo menos um operando com o valor true.
<operando1> || <operando2>
Se o valor do operando1 for true, então o operador || não verifica o valor do operando2, pois já sabe que o resultado é true.
Tabela verdade:
238

Operadores lógicos
Operador Lógico OU ( || )
239
/**
* Classe utilizada para demonstrar o uso do operador logico OU ( || ).
*/
public class OperadorLogicoOU {
boolean a = true;
boolean b = false;
boolean c = false;
System.out.println(a || b);
System.out.println(b || c);
}
}

Operadores lógicos
Símbolo ! é chamado de negação. Este operador retorna true se o operando tem o valor false, e retorna false se o operando o valor true.
! <operando>
Tabela verdade:
240

Operadores lógicos
Operador Lógico Negação ( ! )
241
/**
* Classe utilizada para demonstrar o uso do operador logico negação ( ! ).
*/
public class OperadorLogicoNegacao {
boolean a = true;
boolean b = false;
boolean c = false;
System.out.println(!a);
System.out.println(!(b || c));
}
}

Igualdade de tipos primitivos
Símbolo == é chamado de igualdade.
<operando1> == <operando2>
Retorna true se o valor do operando1 for igual ao valor do operando2, caso contrario retorna false.
242
/**
* relacional de igualdade ( == ).
*/
public class OperadorIgualdade {
int a = 3;
int b = 3;
System.out.println(a == b);
}
}

Igualdade de objetos
Quando criamos um novo objeto precisamos utilizar a palavra-chave new, que cria um novo objeto em memória e fornece o seu “endereço” a variável declarada.
A variável que então obtém uma referência a um objeto.
Exemplo:
A variável manuel é uma referência a um objeto do tipo Pessoa.
243
Pessoa manuel = new Pessoa();

Exemplo:
244
/**
* Classe utilizada para mostrar identidade de objeto.
*/
public class TestePessoa {
Pessoa paulo = new Pessoa();
paulo.setIdade(24);
Pessoa pedro = paulo;
pedro.setIdade(pedro.getIdade() + 1);
System.out.println("A idade de Paulo eh: " + paulo.getIdade());
System.out.println("A idade de Pedro eh: " + pedro.getIdade());
}
}

Neste exemplo as variáveis paulo e pedro possuem a referência ao mesmo objeto na memória.
245

Quando queremos comparar se duas variáveis apontam para o mesmo objeto podemos usar a igualdade ( == ), exemplo:
246
/**
* Classe utilizada para mostrar igualdade de objeto.
*/
public class TestePessoa2 {
Pessoa paulo = new Pessoa();
paulo.setIdade(24);
Pessoa pedro = paulo;
if(paulo == pedro) {
System.out.println("Eh a mesma pessoa!!!");
} else {
System.out.println("Sao pessoas diferentes!!!");
}
}
}

Quando queremos saber se o conteúdo de dois objetos são iguais devemos utilizar o método equals(), todas as classes recebem este método através de herança da classe java.lang.Object.
O método equals(), que existe na classe java.lang.Object, tem a mesma função que a igualdade ( == ). Caso precisemos saber se duas instancias desta mesma classe são iguais, então temos de sobrescrever o método equals().
247

248
/**
* Classe utilizada para representar uma Pessoa, sobrescrevendo o
* metodo equals() para comparar objetos deste tipo.
*/
public class Pessoa {
private int idade;
public Pessoa(String nome, int idade) {
this.nome = nome;
this.idade = idade;
}
public boolean equals(Object obj) {
if(obj != null && obj instanceof Pessoa) {
Pessoa pessoa = (Pessoa) obj;
if(this.nome == null || pessoa.nome == null ||
!this.nome.equals(pessoa.nome)) {
return false;
}
if(this.idade != pessoa.idade) {
return false;
}
}
return true;
}
}

Testando a comparação de objetos através da igualdade e método equals():
249
/**
* Comparação de objetos através do método equals().
*/
public class TestePessoa2 {
Pessoa rafael1 = new Pessoa("Rafael", 20);
Pessoa rafael2 = new Pessoa("Rafael", 20);
System.out.println(rafael1 == rafael2);
System.out.println(rafael1.equals(rafael2));
}
}

Na memória será criado dois objetos do tipo Pessoa:
Portanto:
rafael1 == rafael2 é false.
rafael1.equals(rafael2) é true.
250

4.5- Desenvolver código que utilize o operador de concatenação (+) e os seguintes métodos da classe String: charAt, indexOf, trim, substring, replace, length, startsWith e endsWith.
251

java.lang.String
A classe java.lang.String é utilizada para representar textos (sequência de caracteres), portanto todo texto em Java é considerado um objeto.
Para criarmos uma String podemos fazer das seguintes formas:
252
String nome = ""
String nome = new String("Rafael");
// ou
String sobrenome = "Sakurai";

java.lang.String
Alguns caracteres não podem ser adicionados a uma String:
Aspas duplas ( “ ), pois é utilizado para definir o inicio e fim de uma String
Para definir uma aspas duplas dentro de uma String precisamos usar a barra invertida como escape de caracteres.
253

java.lang.String
Abaixo temos uma tabela com alguns escapes de caracteres e o que eles representam dentro da String:
254

java.lang.String
Para concatenarmos (unir) objetos Strings podemos usar o símbolo + ou o método concat, exemplo:
255
String nomeCompleto = nome + " " + sobrenome;
// ou
String sobrenome = "Cristiano".concat(" Camilo");

java.lang.String
O objeto String é imutável portanto quando fazemos a seguinte operação:
Estamos na verdade criando 3 Strings:
“Cris”
“tiano”
“Cristiano”
256

java.lang.String
A classe String possui alguns métodos para trabalhar com textos (http://java.sun.com/javase/6/docs/api/java/lang/String .html), por exemplo:
public char charAt(int index)
Retorna o valor char a partir de um indice especificado.
public int indexOf(int char)
Retorna o indice da String onde tem a primeira ocorrencia do caractere especificado.
public int indexOf(int char, int fromIndex)
Retorna o indice da String onde tem a primeira ocorrencia do caractere especificado, iniciando a procura a partir de um indice especificado.
257

java.lang.String
public int indexOf(String string)
Retorna o indice da String onde tem a primeira ocorrencia da String especificada.
public int indexOf(String string, int fromIndex)
Retorna o indice da String onde tem a primeira ocorrencia da String especificada, iniciando a procura a partir de um indice especificado.
public String trim()
Retorna uma copia da String, omitindo os espaços em branco do começo e fim do texto.
public String substring(int beginIndex)
Retorna uma nova String contendo os caracteres do indice inicial até o final da String.
258

java.lang.String
public String substring(int beginIndex, int endIndex)
Retorna uma nova String contendo os caracteres do indice inicial até o indice final.
public String replace(char oldChar, char newChar)
Retorna uma nova String resultado da atualização dos caracteres antigos pelo novo caractere.
public int length()
Retorna o tamanho da String.
public boolean startsWith(String prefix)
Testa se a String inicia com um especifico prefixo.
public boolean endsWith(String suffix)
Teste se a String termina com um especifico sufixo.
259

java.lang.String
Exemplos:
Converter 2009.07.22 para 2009/07/22
Converter 2009/07/22 para 22/07/2009
Validar se um texto é referente ao nome de um arquivo com a extensão .txt
260
String data = "2009.07.22";
data = data.replace('.', '/');
System.out.println(data);
data = data.substring(8, 10) + "/"+ data.substring(5, 7) + "/" + data.substring(0, 4);
System.out.println(data);
String arquivo = "C:/scja/documentos/guiaSCJA.txt";
System.out.println(arquivo.endsWith(".txt"));

5- Princípios Básicos do Desenvolvimento em Java
261

5.1 - Descrever o objetivo de pacotes desenvolvidos na linguagem Java e reconhecer o uso apropriado das instruções import e package.
262

Package
Quando precisamos organizar as classes de uma aplicação Java, podemos separá-las em diversos pacotes (pastas), para isto utilizamos a palavra-chave package.
A organização de classes em pacotes ocorre do forma semelhante a um diretório de arquivos, onde será criado uma estrutura de pastas para armazenar as classes Java.
263
package pacote.subPacote.subSubPacote;

Package
No exemplo abaixo vamos criar a estrutura de pacotes br.metodista.telas e dentro deste pacote vamos colocar a classe CadastroLivro:
Note que na hierarquia de package, temos um pacote chamado br, dentro dele temos outro pacote chamado biblioteca, que dentro dele temos outro pacote chamado telas, que dentro dele criamos o arquivo CadastroLivro.java.
264

Package
No arquivo da classe devemos declarar o nome do pacote ao qual ela pertence. Esta declaração deve ser feita obrigatoriamente na primeira linha do arquivo:
Note que na declaração acima separamos os packages por ponto.
265
//Declaração do pacote onde está a classe.
package br.biblioteca.telas;
/**
* Classe utilizada para demonstrar o uso de package.
*/
public class CadastroLivro {
//código
}

Package
Boas praticas
Utilizar apenas uma palavra no nome do package.
Escrever o nome do package em minúsculo.
Agrupar classes por funcionalidade ou assunto em comum.
Restrição
O nome do package não pode ser o nome de nenhuma palavra-chave do Java e não pode começar com números ou caracteres especiais (exceto $ e _).
A declaração do package deve ser feita na primeira linha do arquivo Java (sem contar comentários).
266

Package
Depois de organizar as classes em packages podemos ter classes com o mesmo nome mas em packages diferentes:
Neste exemplo temos as classes Pessoa com o mesmo nome mas em packages diferentes.
Note que seguimos o padrão de escrita de nome do package e da classe, facilitando a identificação dos mesmos.
267
br
|--- metodista
| |--- modelo
| | |--- Pessoa
| |--- relatorio
| |--- Pessoa

Package
A linguagem Java traz muitos packages, exemplos:
268

Import
Quando desejamos utilizar alguma classe que está em um package diferente, precisamos informar sua utilização através da palavra-chave import.
Quando queremos importar alguma classe precisamos informar o nome completo desta classe, incluindo sua hierarquia de packages.
269
import pacote.subPacote.NomeClasse;

Import
Neste exemplo declaramos que a classe CadastroLivro irá utilizar a classe Livro do package “br.metodista.modelo”, e as classes MostrarTela e XmlConvert do package “br.metodista.util”.
270
package br.biblioteca.telas;
//Declaração dos imports.
import br.biblioteca.Livro;
import br.biblioteca.util.MostrarTela;
import br.biblioteca.util.XmlConverter;
/**
* Classe utilizada para demonstrar o uso de imports.
*/
public class CadastroLivro2 {
//código
}

Import
A declaração do import precisa ser obrigatoriamente após a declaração do package (se o mesmo existir) e antes da declaração da classe ou interface.
Quando queremos utilizar muitas classes de um mesmo package, podemos importar o package inteiro utilizando o caractere asterisco ( * ) no lugar do nome das classes, exemplo:
Assim a classe pode utilizar todas as classes que existirem dentro do package br.metodista.util.
271
importbr.metodista.util.*;

Import
A linguagem Java possui um package chamado java.lang que possui as classes básicas para o desenvolvimento em Java, este package é importado automaticamente por todas as classes, portanto para utilizar as classes String, System, Math e outros, não precisamos declarar seu import.
OBS: Durante o processo de compilação do arquivo .java para .class, o compilador primeiro importa as classes que estão com o package completo e depois procura pelas classes que tiveram o package inteiro importado, então normalmente é utilizado o nome inteiro do package e da classe, assim as classes são compiladas um pouco mais rápido.
272

Import
Quando importamos mais de uma classe com o mesmo nome, precisamos declarar o nome completo da classe quando vamos utilizá-la.
273
package br.metodista.teste;
//Declaração dos imports.
import br.metodista.modelo.Pessoa;
import br.metodista.relatorio.Pessoa;
/**
* Classe utilizada para demonstrar o uso de imports com mesmo nome.
*/
public class TesteImports {
br.metodista.modelo.Pessoa p1 = new br.metodista.modelo.Pessoa();
br.metodista.relatorio.Pessoa p2 = new br.metodista.relatorio.Pessoa();
}
}

5.2 - Demonstrar o uso adequado do comando "javac" (incluindo as opções da linha de comando -d e –classpath) e demonstrar o uso apropriado do comando "java" (incluindo as opções da linha de comando -classpath, -D e –version).
274

javac
javac é um comando utilizada para invocar o compilador Java.
Este comando pode receber diversos parâmetros, como por exemplo:
-classpath <path> Especifica onde encontrar os arquivos de classes e anotações
-d <directory> Especifica o local onde gerar os arquivos .class.
-help Imprime todas as opções disponíveis.
275
javac <opções> <ClasseJava.java>

javac (compilando com -d)
Por padrão todas as classes compiladas (.class) são criadas no mesmo diretório que suas classes .java.
A opção –d permite especificar o local onde o arquivo .class deve ser gerado, dessa forma podemos organizar melhor os arquivos.
No exemplo abaixo vamos compilar a classe MinhaClasse.java que está na pasta fonte e gerar o compilado na pasta classes:
276
javac –d classes fonteMinhaClasse.java

Exemplo: Compilar a classe MinhaClasse.java que está no package metodista dentro da pasta fonte e gerar o compilado na pasta classes:
OBS: Neste exemplo executamos o comando javac a partir da pasta fonte.
277
javac –d ..classes metodistaMinhaClasse.java

Quando utilizamos a opção –d e não temos a estrutura de packages, então o javac cria os diretórios:
Este comando vai criar a pasta metodista dentro da pasta classes.
OBS: se não tivermos a pasta de destino (ex: classes), o javac lançará um erro. (No such file ordirectory).
278
javac –d ..classes metodistaMinhaClasse.java

javac (compilando com –classpath)
Classpath é o caminho onde podemos encontrar as classes do Java que são necessárias para compilar ou executar um programa.
As vezes precisamos utilizar classes que não estão dentro das classes fornecidas pelo J2SE, para usar estas classes é necessário declará-las no classpath.
Podemos informar o classpath através de variável de ambiente no sistema operacional, ou declarado em linha de comando através da opção –classpath.
O classpath declarado através da linha de comando sobrescrevem o classpath declarado via variável de ambiente.
279

O classpath é composto por vários diretórios
No windows separamos os diretórios por ponto e virgula ( ; ) e as pastas dos diretórios separamos com barra invertida ().
No linux separamos os diretórios por dois pontos ( : ) e as pastas dos diretórios separamos com barra normal ( / ).
280
javac -classpath <diretórios> NomeClasse.java
javac –classpath metodistamodelo;metodista elatoriometodista esteRelatorioAluno.java
javac –classpath metodista/modelo:metodista/relatorio/metodista/teste/RelatorioAluno.java

Exemplo: Temos a seguinte estrutura de diretorio:
281
C:
|- SCJA
| |- codigos
| ||- metodista
| |||- modelo
| ||||- Pessoa.java
| |||- relatorio
| ||||- Relatorio.java
| |||- teste
| ||||- Teste.java

package metodista.modelo;
public class Aluno {
public Aluno(String nome) {
this.nome = nome;
}
return this.nome;
}
}
282

Para compilar a classe Aluno.java podemos fazer da seguinte forma:
Se compilarmos a partir da pasta C:SCJA
OBS: Note que a classe Aluno não tem relacionamento com nenhuma outra classe.
283
C:SCJA>javac codigosmetodistamodeloAluno.java

package metodista.relatorio;
import metodista.modelo.Aluno;
public class Relatorio {
public void imprimir(List<Aluno> alunos) {
System.out.println("Lista de alunos");
for(Aluno aluno : alunos) {
System.out.println(aluno.getNome());
}
}
}
284

Para compilar a classe Relatorio.java podemos fazer da seguinte forma:
OBS: Note que a classe Relatorio tem referencia para a classe Aluno, portanto vamos adicionar no classpath o diretorio codigos.
285
C:SCJA>javac -classpathcodigoscodigosmetodista elatorioRelatorio.java

package metodista.teste;
import metodista.modelo.Aluno;
import metodista.relatorio.Relatorio;
public class Teste {
List<Aluno> alunos = new ArrayList<Aluno>();
alunos.add(new Aluno("Rafael"));
alunos.add(new Aluno("Maria"));
alunos.add(new Aluno("Jose"));
Relatorio rel = new Relatorio();
rel.imprimir(alunos);
}
}
286

Para compilar a classe Teste.java podemos fazer da seguinte forma:
OBS: Note que a classe Teste tem referencia para a classe Aluno e Relatorio, portanto vamos adicionar no classpath o diretorio codigos.
OBS2: Se precisarmos compilar uma classe que utiliza alguma classe que está dentro de um arquivo .jar, podemos também utilizar a opção –classpath.
287
C:POO>javac -classpathcodigoscodigosmetodista esteTeste.java

java
java é um comando utilizada para invocar a JVM para executar um arquivo .class com os bytecodes Java.
Este comando deve receber pelo menos o nome da classe que precisa ser executado e está classe deve possuir um método com a seguinte assinatura:
A partir deste método main que será executado a aplicação.
Este comando pode também receber argumentos:
Os argumentos são passados através de um vetor (array) de Strings para o método main.
288
java [-opções] class [argumentos...]
publicstaticvoidmain(String[] args)
javaMinhaClasse arg1 arg2 arg3

java – Exemplo
No exemplo abaixo criamos um programa que recebe alguns nomes como parâmetro:
289
/**
* Classe utilizada para mostrar a passagem de parametros para o método main.
*/
public class ParametrosMain {
if(args.length > 0) {
for(String nome : args) {
System.out.println(nome);
}
} else {
System.out.println("Nenhum nome foi passado como parametro.");
}
}
}

java – Exemplo
Se executarmos esta classe sem passar parâmetros imprime a seguinte mensagem:
290

java - Exemplo
Quando executamos a aplicação passando os nomes como parâmetro, estes nomes são impressos no console.
Note que quando precisamos passar um parâmetro que possua espaços em brancos, devemos utilizar as aspas duplas para delimitar a área do parâmetro, exemplo “Rafael Sakurai”.
291

java
Este comando pode receber diversas opções, como por exemplo:
-classpath (ou -cp) <path> Especifica onde encontrar os arquivos de classes e anotações.
-D <name>=<value> Passa propriedades de sistema para aplicação.
-help Imprime todas as opções disponíveis.
-version – Imprime a versão do Java instalado.
292

java (executado com -version)
A opção –version permite visualizar a versão da JVM que esta instalada.
293

java (executado com –D)
Com a opção –D podemos passar uma propriedade de sistema para a aplicação, exemplo:
Dentro da aplicação Java podemos pegar as propriedades do sistema utilizando a classe java.util.Properties, exemplo:
294
java –Dconfig=C:SCJAconfig.txt NomeClasse
import java.util.Properties;
public class TestePropriedades {
Properties props = System.getProperties();
System.out.println("config = " + props.getProperty("config"));
props.list(System.out);
}
}

java (executado com –D)
C:POOcodigos>java -Dconfig=C:SCJAconfig.txt TestePropriedades
config = C:SCJAconfig.txt
-- listing properties --
java.runtime.name=Java(TM) SE Runtime Environment
java.vm.version=11.0-b16
java.vm.vendor=Sun Microsystems Inc.
java.vendor.url=http://java.sun.com/
path.separator=;
java.vm.name=Java HotSpot(TM) Client VM
user.country=BR
295

java (executado com –classpath)
Para executar classes Java que utilizam outras classes também precisamos informa o classpath, exemplo:
A classe Teste tem referencia para as classes Aluno e Relatorio que estão em uma estrutura de packages dentro do diretorio codigos.
296
C:POO>java -classpathcodigos metodista.teste.Teste
Lista de alunos
Rafael
Maria
Jose

5.3 - Descrever o objetivo e os tipos de classes dos seguintes pacotes Java: java.awt, javax.swing, java.io, java.net, java.util.
297

java.awt
O Abstract Window Toolkit (AWT) é utilizado para desenvolvimento de GraphicalUser Interface (GUI), composto por:
Um conjunto nativo de componentes de interfaces de usuário.
Um modelo robusto de tratamento de eventos.
Ferramentas de gráfico e imagem, incluindo classes de formas, cores e fontes.
Gerenciamento de layout para flexibilizar os layouts de telas que não depende de um tamanho particular de tela ou resolução de janela.
Classes para transformação de dados para cortar-e-colar
Mais informações: http://java.sun.com/javase/6/docs/technotes/guides/awt/index.html
298

java.awt
Exemplo de Tela utilizando AWT
299

javax.swing
As classes swing implementam um conjunto de componentes para construir GraphicalUser Interface (GUI) e adicionar ricas funcionalidades gráficas e interatividade para aplicações Java.
O lookandfeel permite criar GUIs com variadas formas de interface gráfica ou pode assumir a forma do Sistema Operacional utilizado.
Permite a internacionalização de diversos idiomas e convenções culturais.
Desenvolver gráficos, imagens e textos em 2D.
Permite que leitores de tela aumentem a acessibilidade do usuários.
Mais informações: http://java.sun.com/javase/6/docs/technotes/guides/swing/index.html
300

javax.swing
Exemplo de aplicação SWING
301

java.net
O package net fornece diversas interfaces e classes para trabalho com networking.
Endereçamento
Conexões TCP
Enviar / receber pacotes via UDP
Localizar / identificar recursos de rede
Segurança (Autenticação e Permissão)
Mais informações: http://java.sun.com/javase/6/technotes/guides/net/overview/overview.html
302

java.net
Saída do servidor:
Aplicação Cliente:
303

java.io
Suporte ao pacote de entrada / saída (input / output) de informações :
Arquivo e dispositivo de entrada e saída.
Serialização de objetos.
Buffer para dados de tipos primitivos.
Conjunto de codificadores e decodificadores de caracteres.
Interface de arquivos com suporte a bloqueio e mapeamento de memória.
Mais informações: http://java.sun.com/javase/6/docs/technotes/guides/io/index.html
304

java.io
Exemplo de aplicação que lê todos os arquivos de um diretório:
305

java.util
Pacote que fornece utilitários básicos para todas as aplicações:
Framework de coleções
Facilidades de data e tempo
Internacionalização
Classes utilitárias (String tokenizer, gerador de números randômicos e array)
Mais informações: http://java.sun.com/javase/6/docs/technotes/guides/lang/index.html
306

java.util
java.util.Collection
307

java.util
Exemplo de utilização de lista
308
package colecao.lista;
/**
* Exemplo de utilização de lista.
*/
public class ExemploLista {
List nomes = new ArrayList();
nomes.add("Zezinho");
nomes.add("Luizinho");
nomes.add("Joãozinho");
for(int i = 0; i < nomes.size(); i++) {
System.out.println(nomes.get(i));
}
}
}
Lista

java.util
Exemplo de utilização de mapa
309
package colecao.mapa;
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.Iterator;
importjava.util.Map;
/**
* Exemplo de utilização de Mapa.
*/
publicclassExemploMapa {
Map mapa = newHashMap();
mapa.put("nome", "Rafael");
mapa.put(2, new Pessoa());
mapa.put("lista", newArrayList());
for (Iterator it = mapa.keySet().iterator(); it.hasNext();) {
System.out.println(mapa.get(it.next()));
}
}
}
Mapa

java.util
Exemplo de utilização de conjunto
310
Conjunto
package colecao.conjunto;
importjava.util.HashSet;
importjava.util.Iterator;
importjava.util.Set;
publicclassExemploConjunto {
Set nomes = newHashSet();
nomes.add("Zezinho");
nomes.add("Luizinho");
nomes.add("Joãozinho");
for (Iterator it = nomes.iterator(); it.hasNext();) {
System.out.println(it.next());
}
}
}
Joãozinho
Luizinho
Zezinho

java.util
Exemplo de Date e Calendar
Exemplo de Arrays
Exemplo de geração de número randômico
311
Date d = new Date();
//Mon Jul 13 20:48:44 BRT 2009
Calendar c = newGregorianCalendar();
//java.util.GregorianCalendar[time=1247528924422,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="America/Sao_Paulo",...]
int[] valores = newint[] {5, 10, 9 ,1 ,3, 8, 2};
Arrays.sort(valores);
for(int v : valores)
System.out.println(v); //1 2 3 5 8 9 10
Random r = new Random();
//Gera um número randômico entre 0 e 9
System.out.println(r.nextInt(10));

6- Plataformas Java e Tecnologias de Integração
312

6.1 - Distinguir as características básicas das três plataformas Java: J2SE, J2ME e J2EE; com base em uma meta de arquitetura de alto nível, selecionar as plataformas Java apropriadas.
313

A plataforma Java
314
Plataforma Java (http://www.javaman.com.br/apres/java&jini/index.html)

Java 2 Platform, Standard Edition (J2SE)
A plataforma Java Standard Edition possui todas as APIs que são base para o desenvolvimento em Java, com seu foco principal em desenvolvimento de aplicações Desktop, mas também possui funcionalidades para:
Applets
Conexão ao banco de dados
Rede, chamada de método remotos e outros
Interface Gráfica
Diversas ferramentas para segurança, monitoramento, publicação e outros
315

Java 2 Platform, Standard Edition (J2SE)
316
Tecnologias J2SE (http://java.sun.com/javase/technologies/index.jsp)

Java 2 Platform, Enterprise Edition (J2EE)
A plataforma Java Enterprise Edition é composta por todas as APIs do J2SE e também adiciona novas APIs para desenvolvimento de aplicações corporativas.
Dentro desta plataforma podemos encontrar:
Tecnologias para Web Services
JAX-RPC, SOAP e outros
Tecnologias para Aplicações Web
JSF, JSP, Servlet, JSTL e outros
Tecnologias para Aplicações Comerciais
EJB, JTA, JMS, JavaMail e outros
Tecnologias de Gerenciamento e Segurança
JAAS, J2EE Management, J2EE AplicationDevelopment e outros
317

Java 2 Platform, Micro Edition (J2ME)
A plataforma Java Micro Edition foi criada para desenvolver aplicações para dispositivos pequenos como celular, PDA, set-top boxes de TV digital e aplicações embarcadas.
Por rodar em dispositivos de pouca memória, tamanho de tela e capacidade de processamento, as bibliotecas incluídas dentro da J2ME são limitadas.
O J2ME é dividido em configuração, profile e APIs opcionais, que fornecem informações especificas sobre qual tipo de aparelho será utilizada a aplicação
318

A aplicação J2ME pode ter dois tipos de configurações:
ConnectedLimitedDeviceConfiguration (CLDC)
ConnectedDeviceConfiguration (CDC)
Utilizando aplicações J2ME podemos:
Utilizar arquivos de áudio e vídeo
Armazenar informações nos dispositivos.
319

Mais informações: http://java.sun.com/javame/technology
320

321
Profiles e configurações comuns do J2ME adaptado de Li & Knudsen (pág. 2).

Extensões de programas feitos em Java
Dependendo da aplicação que estamos desenvolvendo precisamos agrupar todas as classes e documentos adicionais da aplicação.
JAR – Java Archive
Para aplicações desktop, mobile ou componentes java
WAR – Web Archive
Para aplicações web
EAR – Enterprise Archive
Para aplicações que utilizam war + jar
JAD – Java Application Descriptor
Para aplicações mobile
322

6.2 - Descrever, em alto nível, os benefícios e as características básicas da RMI.
323

RemoteMethodInvocation (RMI)
O objetivo do RMI é promover uma camada de comunicação em rede de forma transparente.
Possibilita a chamada remota a um método.
Toda parte de comunicação entre os componentes EJB é feito automaticamente pelo container EJB, usando RMI.
Quando chamamos um método utilizando RMI podemos enviar parâmetros ou receber retorno do método de tipos primitivos, objetos serializáveis, vetor ou coleções.
324

RemoteMethodInvocation (RMI)
Uma chamada de método RMI funciona da seguinte forma:
O objeto cliente chama o método a partir do Stub.
O Stub por sua vez irá chamar o método no Skeleton.
O Skeleton chama o método do objeto no servidor.
325

6.3 - Descrever, em alto nível, os benefícios e as características básicas das tecnologias JDBC, SQL e RDBMS.
326

Banco de Dados
327
Container Web
Container EJB
Servidor Enterprise
Session Bean
JavaServer Pages
Cliente
Message-Driven Bean
HTML
Servlet
Entity Bean
JavaScript
Banco de Dados
SQL
RDBMS

Relational Database Management System (RDBMS)
RDBMS é um Sistema Gerenciador de Banco de Dados Relacional composto por diversos programas responsáveis por manipular informações no banco de dados.
O RDBMS controla:
Criação de estruturas para armazenar os dados.
Armazenamento e manipulação dos dados.
Integridade dos dados.
Segurança as informações.
Exemplo de RDBMS:
Oracle
Microsoft SQLServer
MySQL
328

StructuredQueryLanguage (SQL)
SQL é uma Linguagem de Consulta Estruturada utilizada para viabilizar o uso do banco de dados.
Através do SQL podemos:
Manipular os dados
Definir estrutura de armazenamento de dados
Controle de permissão
Transação
Consulta de dados
329

Java Database Connectivity (JDBC)
A linguagem Java implementa um conceito de ponte para realizar a conexão com o banco de dados, que implementa todas as funcionalidades que um banco de dados padrão deve nos fornecer.
O relacionamento da JDBC com o banco de dados depende também da extensão desta ponte que é representada pela implementação JDBC escolhida. Esta implementação depende do banco de dados com o qual queremos nos comunicar e a ela damos o nome de Driver.
330

6.4 - Descrever, em alto nível, os benefícios e as características básicas das tecnologias JNDI, JMS e de mensagens.
331

Java NamingandDirectory Interface (JNDI)
API para acesso ao serviço de nomes e diretórios.
Para criar uma conexão com o serviço de nomes e diretórios utilizamos a classe java.naming.InitialContext.
Utilizamos o método lookup() do InitialContext para localizar algum objeto.
332

Mensagem (mensageria)
Mensageria é utilizado para realizar a comunicação entre aplicações e componentes.
Esta forma de comunicação fornece um baixo acoplamento, pois o componente remetente envia uma mensagem para um agente de mensageria e o receptor pode a qualquer momento pegar na fila a mensagem.
333

Java MessageService (JMS)
JMS é uma API Java que permite criar, enviar, receber e ler mensagens.
Através desta API podemos diminuir o acoplamento entre as aplicações ou componentes
Trabalha de forma síncrona e assíncrona onde podemos consumir a mensagem no momento que for mais apropriado e também garante que não haverá mensagens duplicas.
334

7- Tecnologias de Cliente
335

Arquitetura
Durante a década de 80 as aplicações eram centralizadas, tinham apenas uma camada de aplicação que era responsável por todo processamento, tratava dos dados e a interface com usuário era de difícil utilização.
Depois começou a surgir as aplicações com 2 camadas, onde em uma camada temos a parte visual juntamente com a lógica de negocio e a outra camada é a base de dados, também chamado (aplicação cliente / servidor). Utilizando esta arquitetura poderíamos aproveitar melhor os Pcs, oferecendo uma interface mais visual mais dinâmica e deixar os servidores tratarem dos dados.
Mas a aplicação de 2 camadas tinha seus problemas, era realmente difícil dar manutenção na telas, porque a lógica de negocio estava espalhada por toda aplicação.
Com isso começou a separar as telas do negocio criando duas camadas diferentes e mais uma terceira camada para parte de banco de dados.
Na arquitetura de n camadas, começamos a utilizar a mesma camada de negocio para diferentes tipos de aplicações, temos camada de telas para desktop, web ou mobile, camada de servidor web, camada de negocio, camada de banco de dados, dessa forma ficam bem separas as camadas da aplicação facilitando o reaproveitamento dos componentes.
336

7.1 - Descrever, em alto nível, as características básicas, os benefícios e as desvantagens da criação de thin-clients usando HTML e JavaScript, bem como os problemas de implantação relacionados e as soluções.
337

Cliente web
338
Container Web
Container EJB
Servidor Enterprise
Session Bean
JavaServer Pages
Message-Driven Bean
Cliente
Servlet
Entity Bean
HTML
Banco de Dados
JavaScript
SQL
RDBMS

HyperText Markup Language (HTML)
339
HTML é uma linguagem de marcação de hipertexto utilizado para criar páginas web.
O HTML é baseado em tags entre sinal de menor < e maior >, através dessas tags podemos formatar textos, criar tabelas, visualizar imagens, criar hiperlinks para outras páginas ou recursos da web e outros.
O código HTML na página web diz para o browser tudo o que precisa ser apresentado na tela.

HyperText Markup Language (HTML)
340

JavaScript
JavaScript é uma linguagem de script que pode ser utilizada para atualizar informações dinamicamente da página web, validar formulários, apresentar mensagens e outros.
JavaScript é uma linguagem tipada dinamicamente e interpretada pelo browser.
Os códigos JavaScript podem ser declarados em arquivos com a extensão .js ou declarados na página web HTML.
341
<script type="text/javascript">
/* Código javascript */
</script>

7.2 - Descrever, em alto nível, as características básicas, os benefícios, as desvantagens e os problemas de implantação relacionados à criação de clientes usando midlets J2ME.
342

Midlet
Midlet são aplicações para pequenos dispositivos moveis que possuem limitação de processamento, memória e conectividade, como por exemplo aparelhos celulares.
A vantagem de utilizar Midlet é desenvolver aplicações como jogos ou programas que podem ser criados e compilados uma única vez e executado em diversos dispositivos moveis com suporte a MIDP.
MIDP também fornece segurança para os dispositivos moveis. As aplicações midlets possuem algumas limitações como por exemplo não podem usar memória que não faz parte da JVM, permissão de acesso para escrever no dispositivo e outros.
343

Midlet
Exemplo de aplicação mobile:
344

7.3 - Descrever, em alto nível, as características básicas, os benefícios, as desvantagens e os problemas de implantação relacionados à criação de fat-clients usando applets.
345

Applet
Applet é uma aplicação Java que pode ser utilizada através de um browser. Os applets podem ser adicionados dentro de páginas web através da tag<applet>.
O applet foi desenvolvido com o intuito de distribuir de forma mais flexível as aplicações stand-alone, através de um browser e o JRE instalado o cliente poderia usar o applet.
Como a web ainda estava no começo e a grande maioria dos sites eram apenas com informações estáticas, utilizando o applet os clientes poderiam obter informações dinâmicas realizando a comunicação com um servidor.
346

Applet
As desvantagens de utilizar applet são:
O cliente precisa ter instalado o JRE no computador.
O cliente precisa fazer download do applet, se o mesmo for grande pode demorar para iniciar.
Possuem algumas restrições de memória e segurança.
347

Applet
Exemplos de Applet que pode ser encontrado dentro da pasta demo, dentro da pasta onde o Java foi instalado:
348

7.4 - Descrever, em alto nível, as características básicas, os benefícios, as desvantagens e os problemas de implantação relacionados à criação de fat-clients usando Swing.
349

Swing
Swing é uma API do Java que fornece os componentes para criação de interfaces gráficas para o usuário. Podemos desenvolver aplicações desktop onde os componentes visuais possuem a aparência de acordo com o Sistema Operacional.
Desenvolver uma aplicação utilizando Swing fornece:
Independente de plataforma
Os componentes não precisam delegar para o Sistema Operacional para eles serem pintados na tela, como é o caso do AWT.
Fácil troca da aparência dos componentes
Extensível, customizado e fracamente acoplado
350

Swing
As desvantagens de utilizar Swing são:
A distribuição da aplicação deve ser feita manualmente em todos os clientes.
A atualização da aplicação também precisa ser feita manualmente em todos os clientes.
As aplicações feitas em Swing costumam ser um pouco mais lentas que as aplicações desktops feitas para um único sistema operacional.
351

Swing
Exemplo de aplicação Swing:
352

8- Tecnologias de Servidor
353

8.1 - Descrever, em alto nível, as características básicas de: EJB, servlets, JSP, JMS, JNDI, SMTP, JAX-RPC, Serviços da Web (incluindo SOAP, UDDI, WSDL e XML) e JavaMail.
354

APIs da plataforma J2EE
355
APIs da plataforma J2EE: http://java.sun.com/j2ee/1.4/docs/tutorial/doc/Overview7.html

Enterprise JavaBeans (EJB)
EJB é um framework que simplifica o processo de desenvolvimento de componentes de aplicações distribuídas em Java.
Utilizando EJB o desenvolvedor pode utilizar mais seu tempo na lógica de negocio, preocupando-se menos com transação, persistência, serviços de rede, etc.
Serviços disponibilizados por um container EJB.
Gerenciamento de transação
Segurança
Concorrência
Serviço de rede
Gerenciamento de recursos
Persistência de dados
Serviço de mensageria
356

Javaserver Pages (JSP)
Permite criar paginas web com conteúdo estático e dinâmico utilizando HTML com Java.
Pode utilizar expressionlanguage para acessar objetos do servidor.
Pode criar tags customizadas para o desenvolvimento das páginas.
357

A JMS pode ser utilizada de duas formas:
Point to Point
onde um programa envia mensagens para uma fila e serão armazenadas nesta fila até que outro programa consuma estas mensagens.
Se for necessário podemos ter mais um programa ou processo esperando pelas mensagens na fila.
358
Conceitos básicos da API JMS: http://java.sun.com/j2ee/1.4/docs/tutorial/doc/JMS3.html

Publish / Subscribe
Um programa envia as mensagens para um tópico e todos os programas clientes desse tópico vão receber as mensagens.
359
Conceitos básicos da API JMS: http://java.sun.com/j2ee/1.4/docs/tutorial/doc/JMS3.html

Utilizando JMS podemos desenvolver aplicações que executam um grande processamento de informações de forma assíncrona, exemplo:
Geração de relatórios com informações referente ao estoque de todos os produtos no centro de distribuição X. O usuário pode entrar na aplicação e solicitar a geração desse relatório mas pode continuar a utilizar a aplicação normalmente, durante a geração do relatório.
Podemos utilizar JMS para integrar diversas aplicações, exemplo:
Um portal de cursos on-line pode oferecer uma interface para novas pessoas se cadastrarem, e o cadastro desses novos clientes pode enviar uma mensagem para um outro sistema por exemplo um ERP da empresa processar e gerar o boleto de mensalidade.
360

Java Naming and Directory Interface (JNDI)
Quando desenvolvemos aplicações muitas vezes precisamos obter alguns componentes ou recursos adicionais como por exemplo componentes EJB, conexão com banco de dados, filas de mensagerias e outros.
Utilizando JNDI podemos especificar um contexto informando onde os componentes ou recursos estão e através de seus nomes podemos obter seus objetos.
361

Web Service
Web Services são aplicações baseadas na web que utilizam XML para trocar informações e protocolos para transporte dos dados XML.
Simple Object Access Protocol (SOAP)
Envelope baseado em XML que define o que é a mensagem e como processá-la.
Universal Description, Discovery andIntegration (UDDI)
Forma de publicar os web services na internet para deixar disponivel globalmente.
Web Service Definition Language (WSDL)
Padrão no formato XML que descreve o serviço.
Extensible Markup Language (XML)
Forma de escrita de arquivo texto composto de tags.
362

Java API for XML-BasedRemoteProcedureCall (JAX-RPC)
JAX-RPC é uma tecnologia para construir Web Services e clientes que utiliza chamada de funções remotas utilizando mensagens XML baseadas no protocolo SOAP.
A API JAX-RPC facilita a utilização de Web Services, pois oculta a conversão da chamadas e resposta das mensagens SOAP.
363
Criando um Web Service e seu cliente com JAX-RPC: http://java.sun.com/j2ee/1.4/docs/tutorial/doc/JAXRPC3.html

SimpleMailTransferProtocol (SMTP)
SMTP é um protocolo para enviar e receber emails.
Este protocolo utiliza a porta 25 do TCP.
364

JavaMail
API que fornece o serviço de envio e recebimento de email.
Faz uso dos protocolos de envio e recebimento de email (SMTP, POP3, MIME e IMAP).
Lida com envio e recebimento de anexos, trabalha com mensagens em HTML e procura por termos em mensagens.
365

8.2 - Descrever, em alto nível, as características básicas do suporte a JSP e a servlet para thin-clients HTML.
366

Container Web
367
Container Web
Container EJB
Servidor Enterprise
Session Bean
JavaServer Pages
Cliente
Message-Driven Bean
HTML
Servlet
Entity Bean
JavaScript
Banco de Dados
SQL
RDBMS

Servidor Web
Software que fica aguardando requisições HTTP (Hypertext TransferProtocol).
Seu cliente normalmente é um browser como por exemplo: Mozilla, Opera, Internet Explorer, etc.
Existem diversos servidores web que possuem suporte ao Java: Tomcat, Jboss, GlassFish, IAS, WebSphere, etc.
368

Servlet
A tecnologia Servlet permite processar requisições e gerar respostas HTTP para atender um cliente (browser).
Através da requisição HTTP o cliente pode solicitar alguma informação ou enviar informações para a aplicação web.
Através da resposta HTTP o Servlet pode enviar um código HTML que representa uma pagina web, pode enviar parâmetros ou atributos.
O ciclo de vida de um Servlet é controlado através de um container web.
369

Servlet
370

Javaserver Pages (JSP)
A tecnologia JSP permite desenvolver paginas web em HTML de forma dinâmica, pois podemos utilizar código Java junto com código HTML.
Com o JSP podemos desenvolver páginas web para enviar informações para Servlets, apresentar as informações que são recebidas pelas Servlets gerando código HTML de forma dinâmica.
371

Exemplo de aplicação JSP + Servlet
372

8.3 - Descrever, em alto nível, o uso e as características básicas de beans controlados por mensagens, de entidade e de sessão EJB.
373

Container EJB
374
Container Web
Container EJB
Servidor Enterprise
Session Bean
JavaServer Pages
Cliente
Message-Driven Bean
HTML
Servlet
Entity Bean
JavaScript
Banco de Dados
SQL
RDBMS

Existem três tipos de EJBs que podemos utilizar:
SessionBean – Utilizado para guardar a lógica de negocio da aplicação.
Message Drive Bean – Utilizado para troca de mensagens.
EntityBean – Utilizado para representar as entidades do banco de dados.
375

Entity Bean
São componentes reutilizaveis que representam as entidades do banco de dados.
376

Container-managedpersistence (CMP)
O container fica responsável por gerenciar o estado das entidades com o banco de dados, ou seja, o container pode salvar, atualizar, consultar ou excluir uma entidade do banco de dados.
Podemos escrever EJB-QL para dizer para o container como fazer as consultas.
Bean-managedpersistence (BMP)
O desenvolvedor fica responsável por sincronizar (inserir, atualizar, consultar, excluir) as entidades e gerenciar a transação das entidades do banco de dados.
Pode solicitar uma conexão com o banco de dados, enviar comandos JDBC.
377

SessionBean
São componentes reutilizáveis que contém a lógica do negocio.
O container EJB é responsável por criar e destruir o sessionbean.
StatelessSessionBean
Não mantém o estado.
O StatelessSessionBean tem seu ciclo de vida durante o tempo de uma simples chamada de método.
O problema do StatelessSessionBean é que a cada requisição um novo bean pode ser criado.
StatefulSessionBean
Mantém o estado durante as chamadas dos métodos.
O ciclo de vida do StatefulSessionBean pode durar no máximo o mesmo tempo que o sessão do cliente.
O problema do StatefulSessionBean é que pode haver um número muito grande de instancias na memória.
378

Message Drive Bean
São componentes reutilizáveis que permitem a execução de mensagens de forma assíncrona.
Esse componente fica aguardando até que recebe alguma mensagem para processar.
São stateless portanto não guardam o estado dos atributos.
379

8.4 - Descrever, em alto nível, as principais vantagens e desvantagens de usar tecnologias de servidor J2EE, além de descrever e comparar as características básicas do nível Web, do nível de negócios e do nível EIS.
380

Vantagens e Desvantagens J2EE
No nível Web podemos desenvolver aplicações que podem ser executadas em browsers diferentes, onde através de uma conexão com a internet o usuário pode acessar a aplicação.
No nível Negocio podemos desenvolver componentes que podem ser reutilizados por outras aplicações, criar serviços disponíveis pela web, ter clientes que podem ser aplicações desktop ou web e outros.
No nível EIS (Enterprise Information System) podemos integrar as aplicações com outras aplicações que podem ser até de outra plataforma utilizando serviços web ou mensageria.
381

Bibliografia
[MUCHOW] John W. Muchow, Core J2ME , Pearson, 2004
[HORSTMANN & CORNELL] Cay S. Horstmann & Gary Cornell, Core Java, 8º Ed. Prentice Hall, 2008
[SIERRA & BATES] Kathy Sierra & Bert Bates, Head First EJB, O’Reilly – 2003
[BASHAM, SIERRA & BATES] Bryan Basham, Kathy Sierra & Bert Bates, Head First Servlet & JSP, O’Reilly, 2004
[FOWLER] Martin Fowler, UML Essencial, 3ª Ed. Bookman, 2005.
[LI & KNUDSEN]Sing Li & Jonathan Knudsen, Beginning J2ME: FromNovice to Professional, 3ª Ed. Apress, 2005.
382

Bibliografia
Documentação Java SE - http://java.sun.com/javase/6/docs
Java EE - http://java.sun.com/javaee
Java ME - http://java.sun.com/javame
Java SE - http://java.sun.com/javase
SCJA – Sun Certified Java Associate http://www.sun.com/training/certification/java/scja.xml
The J2EE 1.4 Tutorial - http://java.sun.com/j2ee/1.4/docs/tutorial/doc/index.html
UML - http://www.uml.org
UML for the Java Associate - http://www.esnips.com/doc/bf534606-bf87-4107-a884-efc791c80fc5/hfoo-associateuml
383

Simulados
SCJA Certification Mock Exam Questions – SCJA - http://www.scja.de/
SCJA Mock Exam 1 - Q1 - http://www.cafe4java.com/mockexams/scja/mock1/q1.php
SCJA Mini Mock Exam - http://www.ejavaguru.com/scjafreemockexam.php
384

E agora?
Agora é só estudar, faça vários simulados, marque a aprova e boa sorte.
PS: Se você passar na prova depois me manda pelo menos um email falando PASSEI.
385

http://jujo00obo2o234ungd3t8qjfcjrs3o6k-a-sites-opensocial.googleusercontent.com	1570
http://rafaelsakurai.blogspot.com	877
http://rafaelsakurai.blogspot.com.br	142
https://jujo00obo2o234ungd3t8qjfcjrs3o6k-a-sites-opensocial.googleusercontent.com	59
http://ranierisantos.com	35
http://www.slideshare.net	22
http://www.techgig.com	11
http://rafaelsakurai.blogspot.pt	3
http://translate.googleusercontent.com	1
http://rafaelsakurai.blogspot.in	1
http://webcache.googleusercontent.com	1
http://rafaelsakurai.blogspot.fr	1

SCJA

by Rafael Sakurai on Dec 20, 2009

Accessibility

Categories

Tags

Upload Details

Usage Rights

12 Embeds 2,723

Statistics

SCJA — Presentation Transcript