Programação Orientada a Objetos parte 3

PROGRAMAÇÃO
ORIENTADA A OBJETOS
INTRODUÇÃO À
LINGUAGEM JAVA
03/06/2016Prof.ªM.ªEng.ªElaineCecíliaGatto
DesenvolvimentodeSoftwarepareaWeb2016

TIPOS DE DADOS

TIPOS DE DADOS
• Java é uma linguagem fortemente tipada
• FORTEMENTE TIPADA:
– Característica de uma linguagem de
programação em relação aos seus tipos de
dados;
– Permite que todas as operações tenham
compatibilidade de seus tipos verificada
pelo compilador
– Operações inválidas não são compiladas

TIPOS DE DADOS
• Verificação minuciosa e cuidadosa dos tipos de
dados
– Diminui a ocorrência de erros
– Melhora a confiabilidade
• Todas as variáveis tem tipos
• Todas as expressões tem tipos
• Todos os valores tem tipo
• O tipo de um valor determina as operações que
podem ser executadas nele

TIPOS DE DADOS
• Cada tipo de dado – de qualquer linguagem de
programação – exige um espaço adequado para
seu armazenamento.
• PORTABILIDADE DE TIPOS DE DADOS:
– em JAVA os tipos de dados tem sempre a
mesma dimensão de armazenamento
(intervalo de bits), independente da
arquitetura do conjunto de instruções do
microprocessador a qual está sendo
executada

TIPOS DE DADOS
• DESVANTAGEM DA PORTABILIDADE DE TIPOS DE
DADOS:
– Em alguns ambientes de execução, o desempenho pode
ser um pouco mais baixo, por conta da especificação
rígida dos intervalos, que é inflexível em Java.
• Dois tipos de dados internos gerais:
– Orientado a objetos
– Não orientado a objetos:
• Oito tipos de dados primitivos ou dados elementares
ou dados simples
• São valores binários comuns

TIPOS DE DADOS
TIPOS DE DADOS PRIMITIVOS INTERNOS
TIPO SIGNIFICADO
Boolean Representa valores verdadeiro ou falso
Byte Representa um valor inteiro de 8 bits
Char Representa um caractere (uma letra, símbolo, pontuação, etc)
Double Representa um valor de ponto flutuante de precisão dupla
Float Representa um valor de ponto flutuante de precisão simples
Int Representa um valor inteiro
Long Representa um valor inteiro longo
Short Representa um valor inteiro curto

TIPOS DE DADOS
TIPOS DE DADOS INTEIROS
TIPO BITS INTERVALO
byte 8 -128 a +127
short 16 32.768 a +32.767
int 32 -2.147.483.648 a +2.147.483.648
long 64 -9.223.372.036.854.775.808 a +9.223.372.036.854.775.808
Java não suporta inteiros sem sinal
BYTE  dados binários brutos, nem sempre compatíveis com outros tipos
internos Java

TIPOS DE DADOS
TIPOS DE DADOS DE PONTO FLUTUANTE
TIPO BITS INTERVALO
float 32 1.40239846e-46 a é 3.40282347e+38
Tamanho do maior literal float: 3,4x1038
Norma IEEE 754
Ponto flutuante com sinal de precisão simples
Números positivos e negativos
double 64 4.94065645841246544e-324 a 1.7976931348623157e+308
Tamanho do maior literal double: 1,8x10308
Norma IEEE 754
Ponto flutuante com sinal com precisão dupla
Números positivos e negativos
DOUBLE é o tipo mais usado
DOUBLE é usado na biblioteca matemática MATH

TIPOS DE DADOS
TIPOS DE DADOS CARACTERE
TIPO BITS INTERVALO
char 16 0 a 65.536
Pode ser usado como tipo inteiro de 16 bits sem sinal
‘u0000’ a ‘uFFFF’
Java suporta caracteres UNICODE
UNICODE: todos os caracteres de todos os idiomas
ASCII é um subconjunto de UNICODE (8 BITS)
Operações aritméticas podem ser aplicadas ao tipo CHAR

TIPOS DE DADOS
TIPOS DE DADOS BOOLEAN
TIPO BITS INTERVALO
boolean 8 True ou false
Verdadeiro ou falso
Operações lógicas e relacionais podem ser usadas com o tipo boolean

LITERAIS

LITERAIS
• São valores fixos representados em sua forma
legível
• Literais = constantes
• Podem ser de qualquer tipo primitivo
• Literais caracteres: ‘a’, ‘b’, ‘c’
• Literais inteiros: 10, -100, 200, -1
• Literais double: 11,23; 52,7
• Literais float: 51,4f; 78,9F
• Literais long int: 12L; 14l
• Literais string: “isto é uma string”

LITERAIS
• Notação Científica:
– 1,2345E2 = 123,4
– 1,2345E-2 = 0,01234
• Literais inteiros hexadecimais
– começa com 0x ou 0X
– 0xFF; 0X1A
• Literais inteiros octais
– começa com zero
– 011; 087
• Literais inteiros binários:
– Começa com 0b ou 0B
– 0b1100; 0B0101

SEQUENCIAS DE ESCAPE

SEQUENCIAS DE ESCAPE
SEQUENCIA DESCRIÇÃO
’ Aspas simples
” Aspas duplas
Barra invertida
r Retorno de carro
n Nova linha
f Avanço de página
t Tabulação horizontal
b Retrocesso
ddd Constante octal
uxxxx Constante hexadecimal

PALAVRAS RESERVADAS

PALAVRAS RESERVADAS
• Modificadores de acesso:
– Private: Um método ou variável só pode ser
acessado de dentro da própria classe;
– Protected: Um método ou variável só pode ser
acessado por classes do mesmo pacote ou
subclasses da classe;
– Public: Uma classe, método ou variável pode ser
acessado a partir de qualquer outra classe.

PALAVRAS RESERVADAS
• Controle de fluxo:
– Break: Força o fluxo do programa a sair do bloco
do código onde a palavra foi inserida;
– Case: Executa um bloco de código que é
dependente da instrução switch;
– Continue: Força o código existente, após essa
instrução, a não ser executado em um loop,
indicando a próxima interação do loop;

PALAVRAS RESERVADAS
– Default: Executa o bloco de código se nenhuma
das instruções switch/case for atendida;
– Do: Executa um bloco de código um vez e, em
seguida, junto com a instrução while, processa
um teste para determinar se o bloco deve ser
executado novamente;
– For: Executa um loop condicional em um bloco
de código;

PALAVRAS RESERVADAS
– Return: Força o fluxo do programa a sair de um
método sem executar nenhum código que esteja
após a instrução podendo retornar uma variável;
– Switch: Indica a variável a ser comparada com
as instruções case;
– While: Executa um bloco de código
repetidamente, enquanto um certa condição for
verdadeira;

PALAVRAS RESERVADAS
– Else: Executa um bloco de código alternativo se
uma condição if for falsa;
– If: Executa um teste lógico verdadeiro ou falso;
– Instanceof: Determina se um objeto é a instancia
de uma classe, superclasse ou interface.

PALAVRAS RESERVADAS
• Modificadores de classe, método e variável:
– Abstract: Usada para declarar uma classe que não
pode ser instanciada ou um método que deve ser
implementado por subclasses concretas;
– Implements: Usada para indicar a uma interface
que uma classe a implementará;
– Extends: Usada para estender uma classe a outra.
Indica uma superclasse que uma subclasse está
estendendo (herança);

PALAVRAS RESERVADAS
– Final: usada para tornar impossível estender
uma classe, sobrepor um método ou reiniciar
uma variável;
– Class: Usada para identificar uma classe;
– Interface: Usada para identificar uma interface;
– Transient: Impede que os campos sejam

PALAVRAS RESERVADAS
– Native: Indica que um método foi escrito em uma
linguagem que só pode ser usada em uma
plataforma, exemplo: C#;
– New: Usada para instanciar um objeto;
– Static: Indica que o método ou a variável
pertence à classe e não à instancia;

PALAVRAS RESERVADAS
– Strictfp: Usada na frente de um método para
indicar que os números de ponto flutuante
seguirão regras restritas de ponto flutuante em
todas as expressões;
– Syncronized: Indica que um método só pode ser
acessado por um seguimento de cada vez;
– Volatile: Indica que a variável pode não ficar
sincronizada por ser usada em fragmentos.

PALAVRAS RESERVADAS
• Controle de Pacotes:
– Import: importação de pacotes ou classes
para o código;
– Package: Especifica a que pacote todas as
classes de um arquivo fonte pertence.

PALAVRAS RESERVADAS
• Palavra void para tipos retornados:
– Void: Indica que não há um tipo de retorno para o
método.
• Palavras reservadas não utilizadas:
– Const: Não use esta palavra para declarar
constantes use public static final;
– Goto: Não foi implementada na linguagem Java por
ser considerada perigosa.

PALAVRAS RESERVADAS
• Tratamento de Erros:
– Throws: Indica o método que passará uma
execução para o método que o chamou;
– Try: Bloco de código que será executado,
podendo, porém, causar uma exceção;
– Assert: Avalia uma expressão condicional para
verificar as alternativas do programador;

PALAVRAS RESERVADAS
• Tratamento de Erros:
– Catch: Declara o bloco de código usado para tratar
uma execução;
– Finally: Bloco de código, geralmente após uma
instrução try-catch, que vai ser executado
independente de que fluxo do programa for usado
no tratamento de uma exceção;
– Throw: Usada para passar uma execução para o
método que chamou o método atual.

PALAVRAS RESERVADAS
• Palavras chaves de variáveis:
– Super: Variável de referência que diz respeito
a superclasse imediata;
– This: Variável de referência que diz respeito a
instancia atual de um objeto;
– Null: Rrepresenta “algo” sem valor definido;
referência de um objeto nulo.

VARIÁVEIS

DEFINIÇÃO DE VARIÁVEIS
• É um tipo de identificador;
• É um nome dado pelo programador para um tipo de
dado o qual deseja armazenar;
• Um identificador é a LOCALIZAÇÃO na memória capaz
de armazenar o valor de um certo tipo de dado;
• Pode ter um ou mais endereços na memória;
• Todo identificador deve ser declarado antes de ser
utilizado.

DECLARAÇÃO DE VARIÁVEIS
• Nomes de variáveis podem começar com
– LETRA: preco, nome;
– SUBLINHADO (_): _preco, _nome;
– CIFRÃO ($): $preco, $nome.
• PADRÃO DE NOMENCLATURA:
– Nome de variável simples: preco, nome, etc.
– Nome de variável composto: valorVenda,
codigoFornecedor, etc.

DECLARAÇÃO DE VARIÁVEIS
SINTAXE: TIPO NOME;
int idade;
float valor;
boolean teste;
char sexo;
double preco;

INICIALIZAÇÃO DE
VARIÁVEIS
• Valores padrão são atribuídos às variáveis declaradas:
– CHAR, BYTE, SHORT, INT, LONG, FLOT e DOUBLE:
valor zero é o padrão;
– BOOLEAN: false é o valor padrão;
• Quando uma variável é declarada, uma instância de seu tipo
é criada;
• Boa prática: inicializar as variáveis no momento da
declaração
• LEMBRE-SE: JAVA É CASE SENSITIVE!
• O comando de atribuição é usado para atribui um valor à uma
variável: o sinal de igual é este comando!

INICIALIZAÇÃO DE
VARIÁVEIS
SINTAXE: TIPO NOME = VALOR;
int idade = 20;
float valor = 10f;
boolean teste = true;
char sexo = ‘f’;
double preco = 20;
String nome = “Joana”;

INICIALIZAÇÃO DINÂMICA DE
VARIÁVEIS
SINTAXE: TIPO NOME = VALOR;
A inicialização dinâmica permite que seja
atribuído um valor, a uma variável, em tempo
de execução
Double volume = 3.14 * height;

CONSTANTES
• É um tipo de variável que não pode alterar
seu conteúdo depois de ter sido
inicializada;
• O conteúdo deve permanecer o mesmo
durante toda a execução do programa;
• Em JAVA não existe constante, existe um
tipo de variável com um comportamento
parecido

CONSTANTES
• Usa-se a palavra chave FINAL no inicio da
declaração da variável para se obter uma
constante em Java
final double pi = 3.145;

ESCOPO E TEMPO DE VIDA
• Variáveis podem ser declaradas dentro de
qualquer bloco;
• Cada bloco de programa, em JAVA, é
determinado pelas chaves { } ;
• Cada bloco é um escopo;
• Um escopo determinada que objetos estarão
visíveis para outras partes de seu programa,
assim como o tempo de vida desses objetos;

• Escopos em JAVA: classes e métodos;
• Regra geral: as variáveis declaradas
dentro de um escopo NÃO podem ser
acessadas por um código do programa
fora deste escopo;
• Regras de escopo: são a base do conceito
de ENCAPSULAMENTO;

• Dentro de um bloco, variáveis podem ser
declaradas em qualquer ponto, entretanto
só serão válidas após a declaração;
• Variáveis são destruídas fora do seu
escopo, elas só mantem o seu valor,
enquanto estiverem dentro do seu escopo
• O tempo de vida de uma variável está
atrelado ao seu escopo

• ATENÇÃO: Se dentro do bloco, a variável
for inicializada, então, toda vez que se
entrar nesse bloco, a variável sempre será
inicializada
• Nenhuma variável declarada dentro de um
escopo interno pode ter o mesmo nome
de uma variável declarada por um escopo
externo

COMENTÁRIOS

COMENTÁRIOS
• Comentários de uma linha: //
• Comentários de mais de uma linha: /* */

OPERADORES

OPERADORES
• DEFINIÇÃO: é um símbolo que solicita ao
compilador que execute uma operação
matemática ou lógica específica
• Quatro classes gerais de operadores em JAVA:
– Aritmético
– Bitwise
– Relacional
– Lógico

OPERADORES ARITMÉTICOS
OPERADOR SIGNIFICADO
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Módulo
++ Incremento (soma um)
-- Decremento (tira um)
Observações:
DIVISÃO: quando aplicado a um inteiro, o resto gerado é truncado. O resto da
divisão pode ser obtido usando o %
% pode ser usado para tipos inteiros ou de ponto flutuante

INCREMENTO E
DECREMENTO
OPERAÇÃO OPERADOR EM JAVA
a++ Pré-incremento
Soma o valor de a com 1 e utiliza o novo valor
de a na expressão em que está
++a Pós-incremento
Utiliza o valor de a na expressão em que está
e só depois soma o valor de a com 1
a-- Pré-decremento
Subtrai o valor de a com 1 e utiliza o novo
valor de a na expressão em que está
--a Pós-decremento
Utiliza o valor de a na expressão em que está
e só depois subtrai o valor de a com 1

OPERADORES RELACIONAIS
== Igual
!= Diferente
> Maior que
< Menor que
>= Maior ou igual que
<= Menor ou igual que
Respostas dos operadores relacionais: verdadeiro ou falso
Relacional: refere-se aos relacionamentos que os valores podem ter uns
com os outros
Podem ser aplicados a todos os tipos numéricos e também o char

OPERADORES LÓGICOS
& And
| Or
^ Xor
! Not
Respostas dos operadores lógicos: verdadeiro ou falso
Lógicos: refere-se às maneiras como os valores boolean podem estar
conectados
Os operandos devem ser do tipo boolean

OPERADORES LÓGICOS
P Q P & Q P | Q P ^ Q ! P
F F F F F V
V F F V V F
F V F V V V
V V V V F F
Tabela verdade para as operações lógicas

OPERADORES LÓGICOS DE
CURTO CIRCUITO
• A versão de AND e OR comum sempre avalia cada operando
da operação
• A versão AND e OR de curto circuito avalia somente o
segundo operando quando necessário
|| Or (curto-circuito)
&& And (curto-circuito)

PRECEDÊNCIA DE
OPERADORES
X ++ X --
++ x -- x ~ Unário + Unário - coerção
* / %
+ -
>> >>> <<
> >= < <= instanceof
== !=
&
^
|
&&
||
?:
=

ATRIBUIÇÃO

ATRIBUIÇÕES ABREVIADAS
+ =
- =
* =
/ +
% =
& =
| =
^=

CONVERSÕES

CONVERSÕES EM
ATRIBUIÇÕES
• Um tipo de variável pode ser atributo a outro
int a;
float b;
a =120;
b= a;
• Nesse caso, a conversão ocorre de forma
IMPLICITA pois os tipos de dados são
compatíveis
• O valor do lado direito da atribuição é

CONVERSÕES EM
ATRIBUIÇÕES
• Uma conversão automática de tipos ocorrerá se:
– Os dois tipos de dados forem compatíveis;
– O tipo de dado de destino for maior que o tipo de
dado da origem;
• Conversão ampliadora:
– Int é grande o suficiente para conter a faixa de
valores do tipo byte;
– Int e byte são tipos inteiros;
– Tipos numéricos e de ponto flutuante são
compatíveis;
– Não há conversão de double para long.

COERÇÃO - CAST
• É uma instrução dada ao compilador para a
conversão de um tipo em outro;
• Conversão de tipos EXPLICITA;
• SINTAXE: (tipo-destino) expressão;

COERÇÃO - CAST
Exemplo Converter para Conversão
Int x = 10; Float Float y = (float) x;
Int x = 10; Double Double y = (double) x;
Float x = 10.5; Int Int y = (int) x;
String x = “10”; Int int y = Integer.parseInt(x);
String x = “20.54”; Float Float y = Float.parseFloat(x);
String x = “Java”; Double Double y = Double.parseDouble(x);
String x = “Java”; Vetor de bytes Byte b[] = x.getBytes();
Int x = 10; String String y = String.valueOf(x);
Float x = 10.35; String String y = String.valueOf(x);
Double x = 254.34; String String y = String.valueOf(x);
Byte x[]; String String y = new String(x);

EXPRESSÕES

EXPRESSÕES
• Operadores, variáveis e literais são
componentes de expressões;
• Toda expressão é avaliada;
• Dois ou mais tipos de dados diferentes
podem ser usados dentro de uma
expressão, desde que sejam compatíveis.

EXPRESSÕES
• Regras de promoção de tipos:
– Char, byte e short são promovidos a INT;
– Se um dos operandos da expressão for LONG,
então toda a expressão será promovida para
LONG;
– Se um dos operandos da expressão for FLOAT,
a expressão toda será promovida para FLOAT;
– Se algum dos operandos da expressão for

EXPRESSÕES
• A promoção de tipos só afeta a avaliação da
expressão;
• Cuidados:
– Alguns resultados inesperados podem ser
gerados na promoção de tipos na avalição da
expressão;
– Nesses casos é necessário usar coersão;

EXPRESSÕES
byte b;
int i;
b = 10;
i = b * b; //promoção de tipo para int –
sem coersão
b = 10;
b = (byte) ( b * b ) //precisa de
coersão para atribuir um int a um byte

EXPRESSÕES
Char ch1 = ‘a’, ch2=‘b’;
Ch1 = (char) (ch1 + ch2);
//ch1 e ch2 são promovidos a INT
//coersão necessária de volta para byte

OBSERVAÇÕES SOBRE O
MÉTODO MAIN

MÉTODO MAIN
• MAIN:
– É o nome do método que indica ao
compilador o ponto inicial da execução da
classe. É o método principal, em que todas
as variáveis, argumentos e instruções são
interpretados e processados para a
execução do programa

MÉTODO MAIN
• STRING [] ARGS:
– É o argumento do método principal;
– É um vetor de strings responsável por
receber valores que podem ser processados
internamente à classe;
– ARGS é a porta de entrada a partir da qual as
classes podem se comunicar com outras
classes;

OBTENDO DADOS COM
SCANNER

OBTENDO DADOS COM
SCANNER
• https://docs.oracle.com/javase/8/docs/api/
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();

OBTENDO DADOS COM
SCANNER
Comando Objetivo
nextShort() Para ler tipos SHORT
nextLong() Para ler tipos LONG
nextLine() Para pular uma linha
nextInt() Para ler tipos INT
nextDouble() Para ler tipos DOUBLE
nextFloat() Para ler tipos FLOAT
nextByte() Para ler tipos BYTE
nextBoolean() Para ler tipos BOOLEAN
nextBigInteger() Para ler tipos BIG INTEGER
nextBigDecimal() Para ler tipos BIG DECIMAL
next() Para Strings

INSTRUÇÕES DE CONTROLE
DE PROGRAMA

INSTRUÇÕES DE SELEÇÃO

INSTRUÇÕES DE CONTROLE:
SIMPLES
if(condição) {
comandos;
}
COMPOSTA SIMPLES
if(condição) {
comandos;
}
else {
comandos;
}

COMPOSTA
ANINHADA
if(condição) {
comandos;
}
else if(condição) {
comandos;
}
else {
comandos;
SWITCH/CASE
int i;
switch(i) {
case 1: lista de
comandos;
break;
case 2: lista de
comandos;
break;
default: lista de
comandos;

INSTRUÇÕES DE ITERAÇÃO

FOR
for ( i = valor_inicial;
condição; incremento
ou decremento de i ) {
comandos;
}
WHILE
while (condição) {
comandos;
}

DO-WHILE
do {
comandos;
}
while(condição);
WHILE
while (condição) {
comandos;
}

ARRAYS

CONCEITO E DEFINIÇÃO DE
ARRAYS
• Variável composta homogênea
multidimensional;
• Conjunto de variáveis de mesmo tipo;
• Índice: referencia sua localização dentro
da estrutura. No caso de matrizes,
precisamos de tantos índices quantos
forem seu dimensionamento.

DECLARAÇÃO E INICIALIZAÇÃO
DE ARRAYS
float x[ ][ ];
f = new float[2][10];
char [ ][ ]MAT;
MAT = new char[4][3];
int [ ][ ]Y[ ];
Y = new char[2][4][3];
float x[ ][ ] = new float[2][6];
char [ ][ ]MAT = new char[4][3];

DECLARAÇÃO E INICIALIZAÇÃO
DE ARRAYS
int [ ][ ]Y[ ] = new int[2][4][3];
int y[][];
y = new int[2][];
y[0] = new int[5];
y[1] = new int[2];
int y[][]; //matriz bidimensional
y = new int[2][];
y[0] = new int[5];
y[1] = new int[2];

ATRIBUINDO VALORES AO
ARRAY
x[ 1 ][ 4 ] = 5;
MAT[ 3 ][ 2 ] = ‘D’;
y[ 0 ][ 3 ][ 1 ] = 12;
y[ 0 ][ 3 ][ 1 ] = 12;
MAT[ 3 ][ 2 ] = ‘D’;

POPULANDO UM ARRAY
int x[ ][ ] = new int[7][3];
Scanner e = new Scanner(System.in);
//preenche a linha
for( i = 0; i<7; i++ ) {
//preenche a coluna
for( j=0; j<3; j++ ) {
//preenche a célula
x[ i ][ j ] = e.nextInt();
}
}

POPULANDO UM ARRAY
int MAT[ ][ ];
MAT = new int[ 3 ][ ] ;
MAT[ 0 ] = new int[ 2 ];
MAT[ 1 ] = new int[ 5 ];
MAT[ 2 ] = new int[ 3 ];
Scanner e = new Scanner(System.in);
//preenche a linha
for( i = 0; i<MAT.length; i++ ) {
//preenche a coluna
for( j=0; j<MAT[i].length; j++ ) {
//preenche a célula
x[ i ][ j ] = e.nextInt();
}
}

IMPRIMINDO UM ARRAY
//obtem índice da linha
for( i=0; i<10; i++) {
//obtem índice da coluna
for( j=0; j<6; j++) {
//imprime o conteúdo da célula que está
na
linha-coluna obtida
System.out.println( x[ i ][ j ] );
}

IMPRIMINDO UM ARRAY
//obtem o tamanho da dimensão
for( i=0; i<MAT.length; i++) {
//obtem o tamanho da linha
for( j=0; j<MAT[ i ].length; j++) {
//imprime o conteúdo da linha-
coluna
System.out.println( MAT[ i ][ j ] );
}
}

PERCORRENDO UM ARRAY
//quantidade de linhas é 3
for ( i=0; i<3; i++) {
System.out.println( “Elementos da linha” +
i );
//quantidade de colunas é 4
for( j=0; j<4; j++) {
System.out.println( x[ i , j ] );
}
}

PERCORRENDO UM ARRAY
for ( j=0; j<4; j++) {
//quantidade de colunas é 4
System.out.println( “Elementos da coluna”
+ i );
for( i=0; i<3; i++) {
//quantidade de linhas é 4
System.out.println( x[ j , i ] );
}
}

FOR EACH: CONCEITO
• Usado para examinar um array do início ao fim,
elemento a elemento;
• Exemplos:
– Somar todos os elementos do array;
– Calcular a média
– Buscar um valor
– Copiar um array
– Etc

FOR EACH: DEFINIÇÃO
• FOR-EACH é um FOR melhorado, otimizado
• Esse LAÇO percorre um conjunto de objetos
de maneira rigorosamente sequencial
• Recurso adicionado no JDK 5.0
• FORMA (SINTAXE):
for(tipo var-iter: conjunto)
Bloco de instruções

FOR EACH: SINTAXE
for(tipo var-iter: conjunto)
Bloco de instruções
• TIPO: especifica o tipo
• VAR-ITER: especifica o nome de uma
variável d eiteração que receberá os
elementos de um conjunto, um de cada vez,
do inicio ao fim
• Neste caso, o conjunto é o ARRAY

FOR EACH
• A cada ITERAÇÃO do laço, o próximo elemento do
conjunto é recuperado e armazenado em VAR-
ITER;
• O LAÇO se repete até todos os elementos do
conjunto terem sido usados;
• FOR-EACH elimina a necessidade de um contador
de laço, de determinar o valor inicial e final e de
indexar manualmente o array;
• Percorre o array inteiro automaticamente, obtendo

FOR EACH: COMPARAÇÃO COM
O FOR
COM O FOR:
int[] nums = {1,2,3,4,5,6,7,8,9,10};
int sum = 0;
for(int i; i<10; i++) sum += nums[i];
COM FOR-EACH:
int[] nums = {1,2,3,4,5,6,7,8,9,10};
int sum = 0;
for(int x : nums) sum += x;
• A cada passagem do laço,
X recebe
automaticamente um
valor igual ao próximo
elemento de NUMS.
• Na primeira iteração, X
contém 1
• Na segunda iteração, X
contém 2
• E assim por diante

FOR EACH: EXEMPLO 1
class ForEach(){
public static void main(Strings[] args){
int[] nums = {1,2,3,4,5,6,7,8,9,10};
int sum = 0;
//exibe e soma os elementos do vetor
for(int x : nums){
system.out.println(“ O valor é: ” + x);
sum += nums;
}
}
System.out.pritnln(“Soma: ” + sum);
}

FOR EACH: EXEMPLO 2
class ForEach(){
int[][] nums = new int[3][r];
int sum = 0;
//fornece alguns valores a nums
for( int i=0; i<3; i++)
for( int j=0; i<5; j++)
nums[i][j] = (i+1)+(j+1);
//exibe e soma os elementos da matriz
for(int[] x : nums){
for(int y : x) {
System.out.println(“Valor é: ” + y);
sum += y;
} } } System.out.println(“ Soma: ” + sum);}

BUSCANDO UM ELEMENTO NO
ARRAY COM FOR EACH
class ForEach(){
int[] nums = {6,8,3,7,5,6,1,4};
int val = 5;
boolean found = false;
//procura um valor – VAL – em nums
for(int[] x : nums){
if(x == val){
found = true;
break;
} }
if(found) System.out.println(“Valor encontrado”); }}

ARRAYLIST

ARRAYLIST
• Biblioteca de coleções
• Substituiu o vector
• Usar a importação da classe para utilizar
esta biblioteca:
import java.util.ArrayList;

DECLARANDO E INICIALIZAÇÃO
ARRAYLIST
ArrayList<String> a = new
ArrayList<String>();
A declaração acima cria um objeto da classe
ArrayList vazio que pode armazenar strings
String é o tipo de dado que será
armazenado no conteiner
Não é necessário mencionar o tamanho

MÉTODO ADD ARRAYLIST
• Elementos podem ser adicionados
posteriormente, bastante indicar a posição em
que se deseja inseri-los:
a.add(1, “TESTE”);
• O elemento na posição especificada já deve
existir. Add aumenta o tamanho da lista. Com
isso, todos os elementos que já estão
armazenados são deslocados em uma posição
à sua direita.

MÉTODO ADD ARRAYLIST
• Depois que o ArrayList é criado, valores podem
ser adicionados usando ADD
ArrayList<String> a = new ArrayList<String>();
a.add(“Olá”);
a.add(“bom dia”);
• Os elementos são adicionados ao final do objeto

MÉTODOS GET E SET
ARRAYLIST
• Os valores armazenados em um ArrayList podem
ser obtidos usando GET
String s = a.get(0);
• A linha acima obtém o valor armazenado na posição
zero do array list e o atribui à variável s
• Um valor de um elemento pode ser alterado usando
SET
a.set(1, “MUNDO”);
• Na linha acima, texto MUNDO está sendo inserido
na posição 1 do ArrayList, isto é, apaga o que

MÉTODOS REMOVE
ARRAYLIST
• Um elemento pode ser removido usando
REMOVE
a.remove(“1”);
• A linha acima remove o elemento que está na
posição 1 e diminui o tamanho do arraylist
• Os elementos que já estão armazenados são
deslocados uma posição para a esquerda

TAMANHO DO ARRAYLIST
• SIZE pode ser usado para saber o tamanho do
arraylist
int tamanho = a.size();
• O método size retorna o tamanho do arraylist
como um número inteiro e esse valor é
armazenado na variável TAMANHO

IMPRIMINDO UM ARRAYLIST
public class Program {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(10);
list.add(20);
list.add(30);
for (int value : list) {
System.out.println(value);
}
}
}

PESQUISANDO UM VALOR
INTEIRO NO ARRAYLIST
public class Estudos{
public static void main(String[] args){
// cria uma ArrayList que conterá inteiros
ArrayList<Integer> valores = new ArrayList<Integer>();
// adiciona itens na lista
valores.add(34);
valores.add(12);
valores.add(8);
valores.add(23);
if(valores.contains(12)){
System.out.println("O valor pesquisado foi encontrado.");
}
else{
System.out.println("O valor pesquisado não foi encontrado.");
}
}
}

ARRAYLIST COM OBJETOS DE
CLASSE
List<Autores> listaAutor = new
ArrayList<Autores>();
Autores a1 = new Autores();
a1.setIdAutores(1234);
a1.setPrimeiroNome(“Elaine”);
a1.setSegundoNome(“Gatto”);
listaAutor.add(a1);
for (Autores a1 : list) {
System.out.println(p);
}

INDEXOF, LASTINDEXOF
list.add(101);
list.add(100);
list.add(99);
list.add(100);
list.add(99);
int index = list.indexOf(100);
int lastIndex = list.lastIndexOf(100);
int notFound = list.indexOf(200);
System.out.println(index); // 1
System.out.println(lastIndex); // 3
System.out.println(notFound); // -1
}
}

VERIFICANDO SE A LISTA ESTÁ
VAZIA
list.add(1);
//imprimirá se a lista está vazia
System.out.println(list.isEmpty());
// limpa o arraylist
list.clear();
//está vazia agora?
if (list.isEmpty()) {
System.out.println("Empty");
}
}
}

ORDENANDO OS VALORES EM
UM ARRAYLIST
import java.util.Collections;
ArrayList<String> list = new ArrayList<>();
list.add("cat");
list.add("bird");
list.add("ant");
list.add("dog");
// organiza os elementos em ordem alfabética
Collections.sort(list);
for (String value : list) {
System.out.println(value);
}
}
}

REFERÊNCIAS

REFERENCIAS
• VICENTE, Angelo. O que significa cada palavra reservada.
Disponível em: http://www.devmedia.com.br/o-que-significa-
cada-palavra-reservada/8320. Acessado em: 06/05/2016.
• FURGERI, Sérgio. Java 7: Ensino Didático. São Paulo: Érica,
2010.
• SCHILDT, Hebert; SKRIEN, Dale. Programação com Java:
Uma Introdução Abrangente. Porto Alegre: AMGH, 2013.
• DEITEL, Harvey M.; DEITEL, PAUL J. Java Como Programar.
Prentice Hall, 2010.
• http://www.dotnetperls.com/arraylist-java

Programação Orientada a Objetos parte 3

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Programação Orientada a Objetos parte 3

Mais de Elaine Cecília Gatto

Último

Programação Orientada a Objetos parte 3