Instituto Federal de Educao, Cincia e Tecnologia IFAL Coordenadoria de Informtica

Programao Orientada a Objetos

Prof. Ricardo R Nunes Ricardo (arroba) ifal.edu.br

Adaptado do seguinte material

Deitel Java Como Programar

Captulo 7: Arrays

OBJETIVOS
O que so arrays. Como utilizar arrays para armazenar dados e recuperlos de listas e tabelas de valores. Como declarar um array, inicializar um array e referenciar elementos individuais de um array. Como utilizar a instruo for aprimorada para iterar por arrays. Como passar arrays para mtodos. Como declarar e manipular arrays multidimensionais. Como escrever mtodos que utilizam listas de argumentos de comprimento varivel. Como ler argumentos da linha de comando em um programa.
PROO 3

Introduo
Arrays:
Estruturas de dados que consistem em itens de dados do mesmo tipo relacionados. Permanecem com o mesmo tamanho depois de criados.
Entradas de largura fixa.

PROO

Arrays
Um Array:
um grupo de variveis (elementos ou componentes) que contm valores que so todos do mesmo tipo. um objeto, da ser considerado tipo por referncia.

PROO

Um array de 12 elementos

PROO

Arrays (Continuao)
ndice:
Tambm chamado subscrito. Nmero de posio entre colchetes. Deve ser inteiro positivo ou expresso de inteiro. Primeiro elemento tem o ndice zero: a = 5; b = 6; c[ a + b ] += 2; Adiciona 2 a c[ 11 ].

PROO

Arrays (Continuao)
Examine o array c:
c o nome do array. c.length acessa o comprimento do array c. c tem 12 elementos (c[0], c[1], c [11])
O valor de c[0] 45.

PROO

7.3 Declarando e criando arrays

Declarando e criando arrays:
Arrays so objetos que ocupam memria. So criados dinamicamente com a palavra-chave new: int c[] = new int[ 12 ]; Equivalente a: int c[]; // declara a varivel array c = new int[ 12 ]; // cria o array Tambm podemos criar arrays de objetos:
String b[] = new String[ 100 ];

PROO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

// Fig. 7.2: InitArray.java // Criando um array. public class InitArray { public static void main( String args[] ) { int array[]; // declara o array identificado

Resumo

Cria 10 ints para um array; cada Declara array int inicializada como 0 por como um array de InitArray.java padro ints Linha 8 Declara array como um array.length array de ints array = new int[ 10 ]; // cria o espao para o array retorna o comprimento Linha 10 "%s%8s\n", "Index", System.out.printf( "%s%8s\n", "Index", "Value" ); // ttulos de coluna Cria 10 ints para um do array
array; cada int inicializado como 0 por padro Linha 15 array.length retorna o comprimento do array

// gera sada do valor de cada elemento do array array.length; for ( int counter = 0; counter < array.length; counter++ ) "%5d%8d\n", System.out.printf( "%5d%8d\n", counter, array[ counter ] ); } // fim de main } // fim da classe InitArray Value 0 0 0 0 0 0 0 0 0 0

Index 0 1 2 3 4 5 6 7 8 9

Cada int inicializado como 0 por padro

Linha 16 array[counter] retorna o int associado com o ndice em um array Sada do programa

array[counter] retorna o int associado com o ndice em um array

10

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// Fig. 7.3: InitArray.java // Inicializando os elementos de um array com um inicializador de array. public class InitArray { public static void main( String args[] ) { valor // lista de inicializadores especifica o valor de cada elemento 32, 27, 64, 18, 95, 14, 90, 70, 60, int array[] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };

Declara array como um array de ints Compilador utiliza a lista inicializadora para alocar um array

Resumo
InitArray.java Linha 9 Declara array como um array de ints Linha 9 Compilador utiliza a lista inicializadora para alocar um array

"%s%8s\n", "Index", System.out.printf( "%s%8s\n", "Index", "Value" ); // ttulos de coluna

// gera sada do valor de cada elemento do array for ( int counter = 0; counter < array.length; counter++ ) "%5d%8d\n", System.out.printf( "%5d%8d\n", counter, array[ counter ] ); 16 } // fim de main 17 } // fim da classe InitArray classe Index 0 1 2 3 4 5 6 7 8 9 Value 32 27 64 18 95 14 90 70 60 37

Sada do programa

11

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// Fig. 7.4: InitArray.java // Calculando valores a serem colocados em elementos de um array. public class InitArray { public static void main( String args[] ) { 10; declara constan ante final int ARRAY_LENGTH = 10; // declara a constante int[ cria array int array[] = new int[ ARRAY_LENGTH ]; // cria o array // calcula o valor para cada elemento do array valor array for ( int counter = 0; counter < array.length; counter; array[ counter ] = 2 + 2 * counter;

Declara a varivel constante ARRAY_LENGTH utilizando o InitArray.java modificador final Declara e cria um Linha 8 Declara a varivel array que contm constante 10 ints counter++ )

Resumo

"%s%8s\n", "Index", System.out.printf( "%s%8s\n", "Index", "Value" ); // ttulos de coluna // gera sada do valor de cada elemento do array for ( int counter = 0; counter < array.length; counter++ ) System.out.printf( "%5d%8d\n", System.out.printf( "%5d%8d\n", counter, array[ counter ] ); } // fim de main classe } // fim da classe InitArray Value 2 4 6 8 10 12 14 16 18 20

Linha 9 Declara e cria um array que contm 10 ints Linha 13 Utiliza o ndice do array para atribuir o array

Index 0 1 2 3 4 5 6 7 8 9

Utiliza o ndice array para atribuir um valor de array

Sada do programa

12

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// Fig. 7.5: SumArray.java // Calculando a soma dos elementos de um array. public class SumArray { public static void main( String { 87, 68, 94, 100, 83, 78, 85, 91, 76, int array[] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 }; int total = 0; // adiciona o valor de cada elemento ao total for ( int counter = 0; counter < array.length; counter++ ) total += array[ counter ]; %d\n", System.out.printf( "Total of array elements: %d\n", } // fim de main

Declara array com uma lista inicializadora args[] )

Resumo
SumArray.java Linha 8 Declara array com uma lista inicializadora Linhas 12-13 Soma todos os valores de array

Soma todos os total ); valores do array

17 } // fim da classe SumArray classe Total of array elements: 849

Sada do programa

13

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// Fig. 7.6: BarChart.java // Programa de impresso de grfico de barras. public class BarChart {

public static void main( String { int array[] = { 0, 0, 0, 0, 0, 0, 1, 2, 4, 2, 1 }; System.out.println( System.out.println( "Grade distribution:" );

Declara array com uma lista args[] ) inicializadora

Resumo
BarChart.java (1 de 2) Linha 8 Declara array com uma lista inicializadora Linha 19 Utiliza o flag 0 para exibir nota de um algarismo com um 0 inicial Lines 23-24 Para cada elemento do array, imprime o nmero associado de asteriscos

// para cada elemento de array, gera sada de uma barra do grfico for ( int counter = 0; counter < array.length; counter++ ) { "00"90// output bar label ( "00-09: ", ..., "90-99: ", "100: " ) if ( counter == 10 ) ", System.out.printf( "%5d: ", 100 ); else "%02d", System.out.printf( "%02d-%02d: ", 10, counter * 10, counter * 10 + 9 );

// imprime a barra de asteriscos for ( int stars = 0; stars < array[ counter ]; stars++ ) System.out.print( "*" );

Utiliza o flag 0 para exibir nota de um algarismo com um 0 inicial

System.out.println(); // inicia uma nova linha de sada 27 } // fim do for externo 28 } // fim de main 29 } // fim da classe BarChart classe

Para cada elemento do array, imprime o nmero associado de asteriscos

14

Grade distribution: 0000-09: 1010-19: 2020-29: 3030-39: 4040-49: 5050-59: 6060-69: 7070-79: 8080-89: 9090-99: 100:

Resumo
* ** **** ** *

BarChart.java

(2 de 2) Sada do programa

15

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// Fig. 7.7: RollDie.java // Rola um dado de seis lados 6000 vezes. import java.util.Random; public class RollDie { public static void main( String args[] ) {

Random randomNumbers = new Random(); // gerador de int frequency[] = new int[ 7 ]; // array de contadores de freqncia

Declara frequency comoRollDie.java um array de 7 ints nmero aleatrio Gera 6000 inteiros aleatrios no Linhas 13-14 intervalo 1-6Geram 6000 inteiros 1-6 aleatrios no intervalo
Linha 14 Incrementa valores de frequency no ndice associado com o nmero aleatrio Sada do programa Linha 10 Declara frequency como um array de 7 ints

Resum o

us // lana o dados 6000 vezes; usa o valor do dado como ndice de freqncia 6000; for ( int roll = 1; roll <= 6000; roll++ ) ++frequency[ 1 + randomNumbers.nextInt( 6 ) ];

Incrementa os valores de frequency no ndice // gera sada do valor de cada elemento do array for ( int face = 1; face < frequency.length; face++ um nmero associado com ) "%4d%10d\n", System.out.printf( "%4d%10d\n", face, frequency[ face ] ); aleatrio // fim de main

"%s%10s\n", "Face", System.out.printf( "%s%10s\n", "Face", "Frequency" );

22 } // fim da classe RollDie classe Face Frequency 1 988 2 963 3 1018 4 1041 5 978 1012 6

16

Exemplos que utilizam arrays (Continuao)

Utilizando arrays para analisar resultados de pesquisas:
40 alunos avaliam a qualidade da comida:
Escala de avaliao de 1-10 1 significa horrvel, 10 significa excelente.

Coloque 40 respostas no array de inteiros. Resuma os resultados da enquete.

PROO

17

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// Fig. 7.8: StudentPoll.java // Programa de anlise de enquete. enquete. public class StudentPoll { public static void main( String args[] ) {

Resum o

Declare responses StudentPoll.java as array to store 40 (1 de 2) // array de respostas da pesquisa 2, 10, int responses[] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 1, 6, 3, 8, 6, responses Linhas 9-11 10, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6, 5, 6Declara,frequency como , 7, 5, 6 Declara responses 4, 8, 6, 8, 10 }; um array de 11 ints um array para como e int[ int frequency[] = new int[ 11 ]; // array de contadores de freqncia armazenar ignora o primeiro elemento 40 respostas
resposta, usa // para cada resposta, seleciona elemento de respostas e usa esse valor // como ndice de freqncia para determinar elemento a incrementar for ( int answer = 0; answer < responses.length; answer++ ) ]; ++frequency[ responses[ answer ] ];

} // fim de main

Para cada resposta, "%s%10s", "Rating", System.out.printf( "%s%10s", "Rating", "Frequency" ); incrementa os valores de Linhas frequency no ndice16-17 Para cada resposta, // gera sada do valor de cada elemento do array incrementam os for ( int rating = 1; rating < frequency.length; rating++ ) associados com essa valores de frequency "%d%10d", System.out.printf( "%d%10d", rating, frequency[ rating ] ); resposta no ndice associado // fim de main
com essa resposta

Linha 12 Declara frequency como array de 11 ints e ignora o primeiro elemento

25 } // fim da classe StudentPoll classe

18

Rating Frequency 1 2 2 2 3 2 4 2 5 5 6 11 7 5 8 7 9 1 3 10

Resumo
StudentPoll.java (2 de 2) Sada do programa

19

Exerccios
Defina uma classe Texto que tem uma varivel de instncia do tipo String, que contm um texto, e trs variveis inteiras, que representam, respectivamente, as seguintes informaes sobre o texto:
a) o nmero de algarismos que ocorrem no texto b) o nmero de letras que ocorrem no texto c) o nmero de caracteres que no sao algarismos ou letras O construtor de objetos dessa classe deve ter como parmetro a cadeia de caracteres que constitiu o texto. Defina tambm um mtodo cont_char, que atualiza apropriadamente as demais variveis de instncia de um objeto dessa classe, conforme descrito acima

20

Estudo de caso: Simulao de embaralhamento e distribuio de cartas O programa simula o ato de embaralhar e distribuir cartas:
Utiliza gerao de nmeros aleatrios. Utiliza um array de elementos de tipo por referncia para representar as cartas. Trs classes:
Card:
Representa uma carta do baralho.

DeckOfCards:
Representa um baralho com 52 cartas.

DeckOfCardsTest:
Demonstra o embaralhamento e a distribuio de cartas.
PROO 21

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// Fig. 7.9: Card.java // Classe Card representa uma carta de baralho. baralho. public class Card { private String face; // face da carta ("Ace", "Deuce", ...) private String suit; // naipe da carta ("Hearts", "Diamonds", ...) // construtor de dois argumentos inicializa face e naipe da carta public Card( String cardFace, String cardSuit ) { face = cardFace; // inicializa face da carta suit = cardSuit; // inicializa naipe da carta } // fim do construtor Card de dois argumentos // retorna representao String de Card public String toString() { return face + " of " + suit; mtodo } // fim do mtodo toString

Resumo
Card.java Linhas 17-20

Retorna a representao de string de uma carta

21 } // fim da classe Card classe

22

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

// Fig. 7.10: DeckOfCards.java baralho. // Classe DeckOfCards representa um baralho. import java.util.Random; public class DeckOfCards { private Card deck[]; // array de objetos Card prximo private int currentCard; // ndice do prximo Card a ser distribudo 52; private final int NUMBER_OF_CARDS = 52; // nmero constante de Cards private Random randomNumbers; // gerador de nmero aleatrio

Declara deck como um array para armazenar objetos Card DeckOfCards.java A constante2) (1 de Linha 7 NUMBER_OF_CARDS indica o Linha 9 nmero de Cards no baralho
Linhas 15-16 Linha 17 Linhas 24-26

Resumo

// construtor preenche baralho de cartas public DeckOfCards() { "Ace", "Deuce", "Three", "Four", "Five", "Six", String faces[] = { "Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King" }; "Hearts", "Diamonds", "Clubs", String suits[] = { "Hearts", "Diamonds", "Clubs", "Spades" };

deck = new Card[ NUMBER_OF_CARDS currentCard = 0; // configura currentCard ento o primeiro Card distribudo deck[ 0 ] randomNumbers = new Random(); // cria gerador de nmero aleatrio // preenche baralho com objetos Card for ( int count = 0; count < deck.length; count++ deck[ count ] = ], new Card( faces[ count % 13 ], suits[ count / 13 ] ); } // fim do construtor DeckOfCards

Declara e inicializa faces com Strings que representam a face da carta Declara e inicializa suits com Strings que representam o naipe da carta ]; // cria array de objetos Card Preenche o array deck com ) Cards

23

28 29 // embaralha as cartas com um algoritmo de uma passagem 30 public void shuffle() 31 { 32 // depois de embaralhar, a distribuio deve iniciar em deck[ 0 ] novamente 33 reinicializa currentCard = 0; // reinicializa currentCard 34 35 // para cada Card, seleciona outro Card aleatrio e os compara 36 for ( int first = 0; first < deck.length; first++ ) 37 { 38 // seleciona um nmero aleatrio entre 0 e 51 39 randomNumbers.nextInt( int second = randomNumbers.nextInt( NUMBER_OF_CARDS ); 40 41 // compara Card atual com Card aleatoriamente selecionado 42 Card temp = deck[ first ]; 43 deck[ first ] = deck[ second ]; 44 deck[ second ] = temp; 45 } // fim de for 46 } // fim do mtodo shuffle 47 48 // distribui um Card 49 public Card dealCard() 50 { 51 // determina se ainda h Cards a ser distribudos 52 if ( currentCard < deck.length ) 53 return deck[ currentCard++ ]; // retorna Card atual no array 54 else 55 null; return null; // retorna nulo p/ indicar que todos os Cards foram distribudos 56 mtodo } // fim do mtodo dealCard 57 } // fim da classe DeckOfCards class lasse

Resumo
DeckOfCards.java
(2 de 2) Linhas 42-44 Linha 52

Troca a Card atual por uma Card aleatoriamente selecionada

Determine se deck est vazio

24

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// Fig. 7.11: DeckOfCardsTest.java cartas. // Aplicativo de embaralhar e distribuir cartas. public class DeckOfCardsTest { // executa o aplicativo public static void main( String args[] ) { myDeckOfCards DeckOfCards myDeckOfCards = new DeckOfCards(); myDeckOfCards.shuffle(); // coloca Cards em ordem aleatria // imprime todas as 52 cartas na ordem em que elas so distribudas 13; for ( int i = 0; i < 13; i++ ) { // distribui e imprime 4 Cards "%-20s%-20s%-20s%-20s\n", System.out.printf( "%-20s%-20s%-20s%-20s\n", myDeckOfCards.dealCard(), myDeckOfCards.dealCard(), myDeckOfCards.dealCard(), myDeckOfCards.dealCard() ); } // fim de for } // fim de main

Resumo
DeckOfCardsTest.java (1 de 2)

21 } // fim da classe DeckOfCardsTest classe

25

Six of Spades Queen of Hearts Three of Diamonds Four of Spades Three of Clubs King of Clubs Queen of Clubs Three of Spades Ace of Spades Deuce of Spades Jack of Hearts Ace of Diamonds Five of Diamonds

Eight of Spades Seven of Clubs Deuce of Clubs Clubs Ace of Clubs Deuce of Hearts Ten of Hearts Eight of Diamonds King of Diamonds Four of Diamonds Eight of Hearts Seven of Spades Queen of Diamonds Ten of Clubs

Six of Clubs Nine of Spades Ace of Hearts Seven of Diamonds Five of Spades Three of Hearts Deuce of Diamonds Nine of Clubs Seven of Hearts Five of Hearts Four of Clubs Five of Clubs Jack of Spades

Nine of Hearts King of Hearts Ten of Spades Four of Hearts Jack of Diamonds Six of Diamonds Ten of Diamonds Six of Hearts Eight of Clubs Queen of Spades Nine of Diamonds King of Spades Jack of Clubs

Resumo
DeckOfCardsTest.java

(2 de 2)

26

A estrutura for aprimorada

Instruo for aprimorada:
Novo recurso do J2SE 5.0. Permite iterar por elementos de um array ou por uma coleo sem utilizar um contador. Sintaxe:
for ( parmetro : nomeDoArray )

instruo

PROO

27

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// Fig. 7.12: EnhancedForTest.java // Utilizando instruo for aprimorada para somar inteiros em um array. array. public class EnhancedForTest { public static void main( String args[] ) { 87, 68, 94, 00, 83, 78, 85, 91, 76, int array[] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 }; int total = 0; // adiciona o valor de cada elemento ao total for ( int number : array ) total += number;

Resumo
EnhancedForTest.java

Para cada iterao, atribui o prximo elemento do array varivel int number, e ento o adiciona a total

%d\n", System.out.printf( "Total of array elements: %d\n", total ); } // fim de main 17 } // fim da classe EnhancedForTest classe Total of array elements: 849

28

A estrutura de repetio for (Continuao)

As linhas 12-13 so equivalentes a:
for ( int counter = 0; counter < array.length; counter++ ) total += array[ counter ];

Uso:
Pode acessar elementos do array. No pode modificar elementos do array. No pode acessar o contador que indica o ndice.

PROO

29

Passando arrays para mtodos

Para passar um argumento de array para um mtodo:
Especifique o nome de array sem colchetes:
Array hourlyTemperatures declarado como
int hourlyTemperatures = new int[ 24 ];

A chamada de mtodo: modifyArray( hourlyTemperatures ); Passa o array hourlyTemperatures para o mtodo modifyArray.

PROO

30

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// Fig. 7.13: PassArray.java // Passando arrays e elementos do arrays individuais aos mtodos. mtodos. public class PassArray {

Declara array de 5 ints com // main cria array e chama modifyArray e modifyElement public static void main( String args[] ) uma lista { int array[] = { 1, 2, 3, 4, 5 }; inicializadora Passa o array System.out.println( array:\ "Effects of passing reference to entire array:\n" + inteiro para o "The values of the original array are:" ); mtodo elementos // gera sada de elementos do array original modifyArray for ( int value : array )
System.out.printf( " %d", %d", value ); passa modifyArray( array ); // passa referncia de array ); System.out.println( "\n\nThe values of the modified array are:" ); // gera sada de elementos do array modificado for ( int value : array ) System.out.printf( " %d", %d", value );

Resumo
PassArray.java
(1 de 2) Linha 9 Linha 19

System.out.printf( value:\ "\n\nEffects of passing array element value:\n" + %d\n", "array[3] before modifyElement: %d\n", array[ 3 ] );

31

29 30 modifyElement( array[ 3 ] ); // tenta modificar o array[ 3 ] 31 System.out.printf( 32 %d\n", "array[3] after modifyElement: %d\n", array[ 3 ] ); 33 } // fim de main 34 35 // multiplica cada elemento de um array por 2 36 public static void modifyArray( int array2[] ) 37 { 38 for ( int counter = 0; counter < array2.length; counter++ ) 39 array2[ array2[ counter ] *= 2; 40 mtodo } // fim do mtodo modifyArray 41 42 multiplica argumento // multiplica o argumento por 2 43 public static void modifyElement( int element ) 44 { 45 element *= 2; 46 System.out.printf( 47 modifyElement: %d\n", "Value of element in modifyElement: %d\n", element ); 48 todo } // fim do mtodo modifyElement 49 } // fim da classe PassArray classe Effects of passing reference to entire array: The values of the original array are: 3 4 5 1 2 The values of the modified array are: modified 6 8 2 4 10 Effects of passing array element value: array[3] before modifyElement: 8 Value of element in modifyElement: 16 array[3] after modifyElement: 8

Passa o elemento de array Resumo array[3] para o mtodo PassArray.java O modifyElement mtodo modifyArray (2 de 2) Linha 30 manipula o array Linhas O mtodo36-40 Linhas diretamente43-48 modifyElement manipula aSada do programa cpia de um primitivo

32

Passando arrays para mtodos (Continuao)

Duas maneiras de passar argumentos para mtodos:
Passagem por valor:
Cpia do valor do argumento passada para o mtodo chamado. No Java, todo primitivo passado por valor.

Passagem por referncia:

O chamador fornece ao mtodo chamado acesso direto aos dados do chamador. Mtodo chamado pode manipular esses dados. Desempenho aprimorado em relao passagem por valor. No Java, todo objeto passado por referncia.
No Java, arrays so objetos. Portanto, arrays so passados para os mtodos por referncia.
PROO 33

Estudo de caso: Classe GradeBook utilizando um array para armazenar notas Desenvolve ainda mais a classe GradeBook. Classe GradeBook:
Representa um boletim de notas que armazena e analisa notas. No mantm valores de notas individuais. A repetio dos clculos exige a reinsero das mesmas notas. Isso pode ser resolvido armazenando notas em um array.

PROO

34

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

// Fig. 7.14: GradeBook.java teste. // Grade book utilizando um array para armazenar notas de teste. public class GradeBook { private String courseName; // nome do curso que essa GradeBook representa array private int grades[]; // array de notas de aluno // construtor de dois argumentos inicializa courseName e array de notas public GradeBook( String name, int gradesArray[] ) {

Resumo
GradeBook.java
(1 de 5) Linha 7 Linha 13

Declara o array grades para inicializa courseName = name; // inicializa courseName gradesArray; grades = gradesArray; // armazena notas armazenar notas } // construtor de dois argumentos inicializa courseName e array de notas individuais Atribui a referncia do mtodo // mtodo para configura o nome do curso public void setCourseName( String name ) array varivel de { instncia grades courseName = name; // armazena o nome do curso
} // fim do mtodo setCourseName mtodo // mtodo para recuperar o nome do curso public String getCourseName() { return courseName; } // fim do mtodo getCourseName

35

28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

boas// exibe uma mensagem de boas-vindas para o usurio GradeBook public void displayMessage() { // getCourseName obtm o nome do curso for\n%s!\ n", System.out.printf( "Welcome to the grade book for\n%s!\n\n", getCourseName() ); getCourseName() } // fim do mtodo displayMessage // realiza vrias operaes nos dados public void processGrades() { // gera sada de array de notas outputGrades(); mtodo // chama mtodo getAverage para calcular a mdia %.2f\n", System.out.printf( "\nClass average is %.2f\n", getAverage() ); // chama mtodos getMinimum e getMaximum %d\ %d\ n", System.out.printf( "Lowest grade is %d\nHighest grade is %d\n\n", getMinimum(), getMaximum() ); // chama outputBarChart para imprimir grfico de distribuio de nota outputBarChart(); } // fim do mtodo processGrades // encontra nota mnima getMinimum() public int getMinimum() { int lowGrade = grades[ 0 ]; // assume que grades[ 0 ] a menor nota

Resumo
GradeBook.java (2 de 5)

36

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// faz um loop pelo array de notas for ( int grade : grades ) { atribui// se nota for mais baixa que lowGrade, atribui-a a lowGrade if ( grade < lowGrade ) lowGrade = grade; // nova nota mais baixa } // for final retorna return lowGrade; // retorna a menor nota } // fim do mtodo getMinimum

Resumo

// localiza nota mxima public int getMaximum() { int highGrade = grades[ 0 ]; // assume que grades[ 0 ] a maior nota

Faz um loop pelas grades a fim de GradeBook. java encontrar a nota (3 de 5) Linhas 59-64 mais baixa Linhas 75-80

// faz um loop pelo array de notas for ( int grade : grades ) { maior // se a nota for maior que highGrade, atribui essa nota a highGrade if ( grade > highGrade ) highGrade = grade; // nova nota mais alta } // for final retorna return highGrade; // retorna a nota mais alta } // fim do mtodo getMaximum mtodo

Faz um loop pelas grades para encontrar a nota mais alta

37

85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

// determina mdia para o teste public double getAverage() { inicializa int total = 0; // inicializa o total // soma notas de um aluno for ( int grade : grades ) total += grade; retorna // retorna a mdia de notas (double double) return (double) total / grades.length; } // fim do mtodo getAverage

Resumo
GradeBook.java
(4 de 5) Linhas 91-92 Linhas 107-108

// gera a sada do grfico de barras exibindo outputBarChart() public void outputBarChart() { System.out.println( "Grade distribution:" );

Faz um loop pelas grades para somar as notas de um aluno distribuio de notas

// armazena freqncia de notas em cada intervalo de 10 notas int frequency[] = new int[ 11 ]; nota, incrementa freq reqncia // para cada nota, incrementa a freqncia apropriada for ( int grade : grades ) ++frequency[ grade / 10 ];

Faz um loop pelas grades para calcular a freqncia

38

110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136

// para cada freqncia de nota, imprime barra no grfico for ( int count = 0; count < frequency.length; count++ ) { // gera sada do rtulo de barra ( "00-09: ", ..., "90-99: ", "100: " ) "00"90if ( count == 10 ) ", System.out.printf( "%5d: ", 100 ); else "%02d", System.out.printf( "%02d-%02d: ", 10, count * 10, count * 10 + 9 );

Resumo
GradeBook.java
(5 de 5) Linhas 134-136

asteriscos // imprime a barra de asteriscos for ( int stars = 0; stars < frequency[ count ]; stars++ ) System.out.print( "*" ); System.out.println(); // inicia uma nova linha de sada } // fim do for externo } // fim do mtodo outputBarChart // gera a sada do contedo do array de notas public void outputGrades() { are:\ System.out.println( "The grades are:\n" );

Faz um loop pelas grades para exibir cada nota

// gera a sada da nota de cada aluno for ( int student = 0; student < grades.length; student++ ) %3d\n", System.out.printf( "Student %2d: %3d\n",

student + 1, grades[ student ] ); 137 do } // fim do mtodo outputGrades 138 } // fim da classe GradeBook

39

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// Fig. 7.15: GradeBookTest.java // Cria objeto GradeBook utilizando um array de notas. notas. public class GradeBookTest { // mtodo main inicia a execuo de programa public static void main( String args[] ) { // array de notas de aluno 87, 68, 94, 100, 83, 78, 85, 91, 76, int gradesArray[] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 }; GradeBook myGradeBook = new GradeBook( "CS101 Introduction to Java Programming", gradesArray ); Programming", ng" myGradeBook.displayMessage(); myGradeBook.processGrades(); main } // fim de main

Resumo
Declara e inicializa GradeBookTest.java gradesArray com 10 elementos (1 de 2)
Linha 10 Linha 13

17 } // fim da classe GradeBookTest

Passa gradesArray para construtor de GradeBook

40

Welcome to the grade book for CS101 Introduction to Java Programming! The grades are: Student 1: 87 Student 2: 68 Student 3: 94 Student 4: 100 Student 5: 83 Student 6: 78 Student 7: 85 Student 8: 91 Student 9: 76 Student 10: 87 Class average is 84.90 Lowest grade is 68 Highest grade is 100 Grade distribution: 0000-09: 1010-19: 2020-29: 3030-39: 4040-49: 5050-59: 6060-69: * 7070-79: ** 8080-89: **** 9090-99: ** 100: *

Resumo
GradeBookTest.java
(2 de 2) Sada do programa

41

Objetos Iguais
Como comparar se dois objetos so iguais?

42

Arrays multidimensionais
Arrays multidimensionais:
Tabelas com linhas e colunas:
Array bidimensional. Array m por n.

PROO

43

Array bidimensional com trs linhas e quatro colunas

PROO

44

Arrays multidimensionais (Continuao)

Arrays de arrays unidimensionais:
Declarando um array bidimensional b[2][2]
int b[][] = { { 1, 2 }, { 3, 4 } };
1 e 2 inicializam b[0][0] e b[0][1]. 3 e 4 inicializam b[1][0] e b[1][1].

int b[][] = { { 1, 2 }, { 3, 4, 5 } };
A linha 0 contm elementos 1 e 2. A linha 1 contm elementos 3, 4 e 5.

PROO

45

Arrays multidimensionais (Continuao)

Arrays bidimensionais com linhas de diferentes comprimentos:
Os comprimentos das linhas no array no precisam ser idnticos.
Por exemplo, int b[][] = { { 1, 2 }, { 3, 4, 5 } };

PROO

46

Arrays multidimensionais (Cont.)

Criando arrays bidimensionais com expresses de criao de arrays:
Pode ser criado dinamicamente. Array 3 por 4: int b[][]; b = new int[ 3 ][ 4 ]; Cada linha pode ter um nmero diferente de colunas:
int b[][]; b = new int[ 2 ][ ]; // cria 2 linhas b[ 0 ] = new int[ 5 ]; // cria 5 colunas para a linha 0 b[ 1 ] = new int[ 3 ]; // cria 3 colunas para a linha 1

PROO

47

public class InitArray { // cria e gera sada de arrays bidimensionais 7 public static void main( String args[] ) 8 { 9 int array1[][] = { { 1, 2, 3 }, { 4, 5, 6 } }; 10 int array2[][] = { { 1, 2 }, { 3 }, { 4, 5, 6 } }; 11 12 System.out.println( "Values in array1 by row are" ); 13 14 15 16 17 18

1 2 3 4 5 6

// Fig. 7.17: InitArray.java bidimensionais. // Inicializando arrays bidimensionais.

Resumo
InitArray.java
(1 de 2) Linha 9 Linha 10

Utiliza inicializadores de array aninhados Utiliza para inicializar de inicializadores array1 outputArray( array1 ); // exibe array1 por linha array aninhados de comprimentos diferentes para inicializar array2

System.out.println( System.out.println( "\nValues in array2 by row are" ); array2 outputArray( array2 ); // exibe array2 por linha } // fim de main

48

19 20 21 22 23 24 25 26 27 28 29 30 31 32

// gera sada de linhas e colunas de um array bidimensional public static void outputArray( int array[][] ) {

Resumo array[row].length // faz um loop pelas linhas do array array.length; for ( int row = 0; row < array.length; row++ ) retorna o nmero de colunas { InitArray.java // faz um loop pelas colunas da linha atual associado com o subscrito 2) (2 de ].length; for ( int column = 0; column < array[ row ].length; column++ ) Linha 26 ", System.out.printf( "%d ", array[ row ][ column ] ); row Linha 27
Utiliza a notao de colchete duplo para Sada do programa acessar valores do array bidimensional

System.out.println(); // inicia nova linha de sada } // fim do for externo } // fim do mtodo outputArray } // fim da classe InitArray

Values in array1 by row are 1 2 3 4 5 6 Values in array2 by row are 1 2 3 4 5 6

49

Arrays multidimensionais (Continuao)

Manipulaes de arrays multidimensionais comuns realizadas com as instrues for:
Muitas manipulaes de array comuns utilizam as instrues for. Por exemplo:
for ( int column = 0; column < a[ 2 ].length; column++ ) a[ 2 ][ column ] = 0;

PROO

50

Estudo de caso: Classe GradeBook utilizando um array bidimensional Classe GradeBook:

Array unidimensional:
Armazena as notas de um aluno em um exame individual.

Array bidimensional:
Armazena as notas de um aluno individual e da turma como um todo.

PROO

51

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

// Fig. 7.18: GradeBook.java notas. // Livro de nota utilizando um array bidimensional para armazenar notas. public class GradeBook {

Declara o array private String courseName; // nome de curso que este livro de nota representa bidimensional grades
grades[][]; private int grades[][]; // array bidimensional de notas de aluno // construtor de dois argumentos inicializa courseName e array de notas public GradeBook( String name, int gradesArray[][] ) { inicializa courseName courseName = name; // inicializa courseName grades = gradesArray; // armazena notas } // fim do construtor GradeBook de dois argumentos // mtodo para configurar o nome do curso public void setCourseName( String name ) { courseName = name; // armazena o nome do curso } // fim do mtodo setCourseName // mtodo para recuperar o nome do curso public String getCourseName() { return courseName; } // fim do mtodo getCourseName

Resumo
GradeBook.java
(1 de 7) Linha 7 Linha 10

Construtor GradeBook aceita uma String e um array bidimensional

52

28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

boas// exibe uma mensagem de boas-vindas para o usurio GradeBook public void displayMessage() { // getCourseName obtm o nome do curso for\n%s!\ n", System.out.printf( "Welcome to the grade book for\n%s!\n\n", getCourseName() getCourseName() ); } // fim do mtodo displayMessage // realiza vrias operaes nos dados public void processGrades() { // gera sada de array de notas outputGrades(); mtodos // chama mtodos getMinimum e getMaximum %d\ %d\ n", System.out.printf( "\n%s %d\n%s %d\n\n", is", "Lowest grade in the grade book is", getMinimum(), is", "Highest grade in the grade book is", getMaximum() ); // gera sada de grfico de distribuio de notas de todas as notas em todos os testes outputBarChart(); } // fim do mtodo processGrades // localiza nota mnima public int getMinimum() { elemento // assume que o primeiro elemento de array de notas o menor int lowGrade = grades[ 0 ][ 0 ];

Resumo
GradeBook.java
(2 de 7)

53

57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

// faz um loop pelas linhas do array de notas for ( int studentGrades[] : grades ) { // faz um loop pelas colunas da linha atual for ( int grade : studentGrades ) { lowGrade // se a nota for menor que lowGrade, atribui a nota a lowGrade if ( grade < lowGrade ) lowGrade = grade; } // fim de for interno externo } // fim de for externo return lowGrade; // retorna nota mais baixa } // fim do mtodo getMinimum // localiza nota mxima public int getMaximum() { primeiro // assume que o primeiro elemento de array de notas o maior int highGrade = grades[ 0 ][ 0 ];

Resumo
GradeBook.java
(3 de 7) Linhas 58-67

Faz um loop pelas linhas de grades para encontrar a nota mais baixa de qualquer aluno

54

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105

// faz um loop pelas linhas do array de notas for ( int studentGrades[] : grades ) { // faz um loop pelas colunas da linha atual for ( int grade : studentGrades ) { // se a nota for maior que highGrade, atribui essa nota a highGrade if ( grade > highGrade )

Resumo
GradeBook.java
(4 de 7) Linhas 79-88 Linhas 94-104

Faz um loop pelas linhas de grades highGrade = grade; para encontrar a nota } // fim do for interno } // fim do for externo mais alta de qualquer reto return highGrade; // retorna nota mais alta aluno
mtodo } // fim do mtodo getMaximum // determina a mdia do conjunto de particular de notas public double getAverage( int setOfGrades[] ) { inicializa int total = 0; // inicializa total // soma notas de um aluno for ( int grade : setOfGrades ) grade; total += grade;

// retorna mdia de notas reto (double double) return (double) total / setOfGrades.length; mtodo } // fim do mtodo getAverage

Calcula a mdia semestral de um aluno em particular

55

106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133

// gera a sada do grfico de barras para exibir distribuio total de notas public void outputBarChart() { System.out.println( "Overall grade distribution:" ); cada // armazena freqncia de notas em cada intervalo de 10 notas int[ int frequency[] = new int[ 11 ]; // para cada nota em GradeBook, incrementa a freqncia apropriada for ( int studentGrades[] : grades ) { for ( int grade : studentGrades ) ++frequency[ grade / 10 ]; externo } // fim do for externo

Resumo
GradeBook.java
(5 de 7) Linhas 115-119

Calcula a distribuio de // para cada freqncia de nota, imprime barra no grfico for ( int count = 0; count < frequency.length; count++ ) todas as notas dos { "00"90// gera sada do rtulo de barra ( "00-09: ", ..., "90-99: ", "100: " ) alunos if ( count == 10 )
", System.out.printf( "%5d: ", 100 ); else "%02d", System.out.printf( "%02d-%02d: ", 10, ); count * 10, count * 10 + 9 ); // imprime a barra de asteriscos for ( int stars = 0; stars < frequency[ count ]; stars++ ) System.out.print( "*" );

56

134 135 136 137 138 139 140 141 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158

System.out.println(); // inicia uma nova linha de sada } // fim do for externo } // fim do mtodo outputBarChart // gera sada do contedo do array de notas public void outputGrades() { are:\ System.out.println( "The grades are:\n" ); alinha coluna System.out.print( " " ); // alinha ttulos de coluna // cria um ttulo de coluna para cada um dos testes for ( int test = 0; test < grades[ 0 ].length; test++ ) ", System.out.printf( "Test %d ", test + 1 ); System.out.println( "Average" ); // ttulo da coluna de mdia do aluno // cria linhas/colunas de texto que representam notas de array for ( int student = 0; student < grades.length; student++ ) { %2d", System.out.printf( "Student %2d", student + 1 ); for ( int test : grades[ student ] ) // gera sada de notas do aluno "%8d", System.out.printf( "%8d", test );

Resumo
GradeBook.java
(6 de 7)

57

159 160 161 162 163 164 165

// chama mtodo getAverage para calcular a mdia do aluno; // passa linha de notas como o argumento para getAverage double average = getAverage( grades[ student ] ); System.out.printf( "%9.2f\n", average ); "%9.2f\n", average } // fim do for externo } // fim do mtodo outputGrades lasse } // fim da classe GradeBook

Resumo
GradeBook.java
(7 de 7)

58

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// Fig. 7.19: GradeBookTest.java notas. // Cria objeto GradeBook utilizando um array bidimensional de notas. public class GradeBookTest { // mtodo main inicia a execuo de programa public static void main( String args[] ) { // array bidimensional de notas de aluno int gradesArray[][] = { { 87, 96, 70 }, 87, 96, 68, 87, { 68, 87, 90 }, 94, 100, { 94, 100, 90 }, 100 81, { 100, 81, 82 }, 83, 65, { 83, 65, 85 }, 78, 87, { 78, 87, 65 }, 85, 75, { 85, 75, 83 }, 91, 94, { 91, 94, 100 }, 76, 72, { 76, 72, 84 }, 87, 93, { 87, 93, 73 } };

Resum o Declara gradesArray

como um array GradeBookTest.java 3 por 10
(1 de 2) Linhas 10-19

GradeBook myGradeBook = new GradeBook( Programming", "CS101 Introduction to Java Programming", gradesArray ); myGradeBook.displayMessage(); myGradeBook.displayMessage(); myGradeBook.processGrades(); } // fim de main lasse } // fim da classe GradeBookTest

Cada linha representa um aluno; cada coluna representa uma nota de exame

59

Welcome to the grade book for CS101 Introduction to Java Programming! The grades are: Student 1 Student 2 Student 3 Student 4 Student 5 Student 6 Student 7 Student 8 Student 9 Student 10 Test 1 87 68 94 100 83 78 85 91 76 87 Test 2 96 87 100 81 65 87 75 94 72 93 Test 3 70 90 90 82 85 65 83 100 84 73 Average 84.33 81.67 94.67 87.67 77.67 76.67 81.00 95.00 77.33 84.33

Resumo
GradeBookTest.java
(2 de 2) Sada do programa

Lowest grade in the grade book is 65 Highest grade in the grade book is 100 Overall grade distribution: 0000-09: 1010-19: 2020-29:

3030-39: 40-49: 405050-59: 6060-69: 7070-79: 80-89: 809090-99: 100:

*** ****** *********** ******* ***

60

Listas de argumentos de comprimento varivel

Listas de argumentos de comprimento varivel:
Novo recurso no J2SE 5.0. Nmero no-especificado de argumentos. Utilize reticncias () na lista de parmetros do mtodo. Pode ocorrer somente uma vez na lista de parmetros. Deve ser colocado no final da lista de parmetros O array cujos elementos so todos do mesmo tipo.

PROO

61

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// Fig. 7.20: VarargsTest.java // Utilizando listas de argumentos de comprimento varivel. varivel. public class VarargsTest { // calcula mdia double... public static double average( double... numbers ) { 0.0 inicializa double total = 0.0; // inicializa total usando // calcula total usando a instruo for ( double d : numbers ) total += d; numbers.length; return total / numbers.length; } // fim do mtodo average

Resumo
VarargsTest.java

(1 de 2) Linha 7 for aprimorada O mtodo average recebeLinhas 12-13 uma seqncia varivel de Linha 15

comprimento Calcula o total dos de doubles doubles no array public static void main( String args[] ) { Acessa 10.0; double d1 = 10.0; 20.0; double d2 = 20.0; numbers.length para 30.0; double d3 = 30.0; 40.0; double d4 = 40.0; obter o tamanho do array numbers

62

25 26 27 28 29 30 31 32 33 34

%.1f\ %.1f\ %.1f\ %.1f\ n", System.out.printf( "d1 = %.1f\nd2 = %.1f\nd3 = %.1f\nd4 = %.1f\n\n", d1, d2, d3, d4 ); System.out.printf( average( d1, d2 System.out.printf( "Average of d1 and d2 is %.1f\n", %.1f\ n", ); ) ); %.1f\n", "Average of d1, d2 and d3 is %.1f\n", ); average( d1, d2, d3 ) ); %.1f\n", System.out.printf( "Average of d1, d2, d3 and d4 is %.1f\n",

Resumo

); average( d1, d2, d3, d4 ) ); } // fim de main classe 35 } // fim da classe VarargsTest d1 d2 d3 d4 = = = = 10.0 10.0 20.0 30.0 40.0

Invoca o mtodo VarargsTest.java average com (2 de 2) dois argumentos Invoca o mtodo Linha 29 average com Linha 31 trs argumentos Linha 33

Sada do programa

Average of d1 and d2 is 15.0 Average of d1, d2 and d3 is 20.0 Average of d1, d2, d3 and d4 is 25.0

Invoca mtodo average com quatro argumentos

63

Utilizando argumentos de linha de comando

Argumentos da linha de comando:
possvel passar argumentos a partir da linha de comando (argumentos de linha de comando): String args[] Aparece depois do nome da classe no comando java: java MyClass a b Nmero de argumentos passados a partir da linha de comando obtido acessando: args.length Primeiro argumento de linha de comando args[ 0 ]

PROO

64

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// Fig. 7.21: InitArray.java // Utilizando argumentos de linha de comando para inicializar um array. array. public class InitArray { public static void main( String args[] ) { // verifica nmero de argumentos de linha de comando if ( args.length != 3 )

Resumo
InitArray.java (1 de 2) Linha 6 Linha 9 Linha 16 Linhas 20-21 Linhas 24-25

Array args armazena argumentos de linha de Verifica o nmero de comando else { argumentos passados a // obtm o tamanho do array do primeiro argumento de linha de comando partir da linha de args[ 0 ] int arrayLength = Integer.parseInt(comando);
System.out.println( reincluding\ "Error: Please re-enter the entire command, including\n" + "an array size, initial value and increment." ); int[ cria int array[] = new int[ arrayLength ]; // cria array // obtm o valor inicial e o incremento do argumento de linha de comando int initialValue = Integer.parseInt( args[ 1 ] ); int increment = Integer.parseInt( args[ 2

Obtm o primeiro argumento ] ); na linha de comando

// calcula o valor de cada elemento do array for ( int counter = 0; counter < array.length; counter++ ) array[ counter ] = initialValue + increment * counter; "%s%8s\n", "Index", System.out.printf( "%s%8s\n", "Index",

Obtm o segundos e o terceiro argumentos na "Value" ); linha de comando Calcula o valor de cada elemento do array com base nos argumentos de linha de comando
65

29 // exibe o valor e o ndice de array 30 for ( int counter = 0; counter < array.length; counter++ ) 31 System.out.printf( "%5d%8d\n", counter, array[ counter ] ); "%5d%8d\n", else 32 } // fim de else main 33 } // fim de main classe 34 } // fim da classe InitArray java InitArray reError: Please re-enter the entire command, including an array size, initial value and increment. java InitArray 5 0 4 Index Value 0 0 1 4 2 8 3 12 4 16

Resumo
InitArray.java

Argumentos da linha de comando ausentes Trs argumentos de linha de comando so 5, 0 e 4

(2 de 2) Sada do programa

java InitArray 10 1 2 Index Value 0 1 1 3 2 5 3 7 4 9 5 11 6 13 7 15 8 17 9 19

Trs argumentos de linha de comando so 10, 1 e 2

66

Exerccios
7.19 7.22 7.30 at 7.33

67

(Opcional) Estudo de caso de GUIs e imagens grficas: Desenhando arcos Desenhe um arco-ris:
Utilize arrays. Utilize a instruo de repetio. Utilize o mtodo fillArc de Graphics.

PROO

68

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

// Fig. 7.22: DrawRainbow.java array. // Demonstra a utilizao de cores em um array. import java.awt.Color; import java.awt.Graphics; import javax.swing.JPanel; public class DrawRainbow extends JPanel { ndigo // Define as cores ndigo e violeta 128, final Color VIOLET = new Color( 128, 0, 128 ); 75, final Color INDIGO = new Color( 75, 0, 130 ); arco// a utilizar no arco-ris, iniciando da parte mais interna arco // As duas entradas em branco resultam em um arco vazio no centro private Color colors[] = Color.WHITE, Color.WHITE, VIOLET, INDIGO, Color.BLUE, { Color.WHITE, Color.WHITE, VIOLET, INDIGO, Color.BLUE, Color.GREEN, Color.YELLOW, Color.ORANGE, Color.GREEN, Color.YELLOW, Color.ORANGE, Color.RED }; // construtor public DrawRainbow() { setBackground( Color.WHITE ); // configura o fundo como branco } // fim do construtor DrawRainbow de arco// desenha um arco-ris usando crculos concntricos public void paintComponent( Graphics g ) {

Resumo
DrawRainbow .java

(1 de 2) Linha 22

Configura o segundo plano do componente super.paintComponent( super.paintComponent( g ); como branco 20; int radius = 20; // raio de um arco
69

31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 // preenche o arco de 0 a 180 graus g.fillArc( centerX - counter * radius, centerY - counter * radius, counter * radius * 2, counter * radius * 2, 0, 180 ); } // fim de for } // fim do mtodo paintComponent // desenha arcos preenchidos com o mais externo counter-for ( int counter = colors.length; counter > 0; counter-- ) { // configura a cor para o arco atual g.setColor( colors[ counter - 1 ] ); arco// desenha o arco-ris perto da parte central inferior int centerX = getWidth() / 2; 10; int centerY = getHeight() - 10;

Resumo
DrawRainbow .java

(2 de 2) Linhas 43-45

class lasse 48 } // fim da classe DrawRainbow

Desenha um semicrculo preenchido

70

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// Fig. 7.23: DrawRainbowTest.java arco-ris. // Aplicativo de teste para exibir um arco-ris. import javax.swing.JFrame; public class DrawRainbowTest { public static void main( String args[] ) { DrawRainbow panel = new DrawRainbow(); JFrame application = new JFrame(); application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); application.add( panel ); application.setSize( 400, 250 ); 400, application.setVisible( application.setVisible( true ); } // fim de main

Resumo
DrawRainbowTest. java

classe 17 } // fim da classe DrawRainbowTest

71

Desenhando uma espiral com drawLine (esquerda) e drawArc (direita)

PROO

72

(Opcional) Estudo de caso de engenharia de software: Colaborao entre objetos

Colaboraes (interaes):
Quando objetos se comunicam para realizar uma tarefa, diz-se que eles so colaboradores.
Objetos se comunicam invocando operaes (mtodos) uns dos outros.

Consistem em um objeto de uma classe enviar uma mensagem para um objeto de outra classe.

PROO

73

(Opcional) Estudo de caso de engenharia de software (Continuao)

Identificando as colaboraes em um sistema:
Leia o documento de requisitos para localizar:
o que ATM deve fazer para autenticar um uso; e o que ATM deve fazer para realizar transaes.

Para cada ao, decida:

Quais objetos devem interagir:
Objeto emissor. Objeto receptor.

PROO

74

Colaboraes no sistema ATM.

Um objeto da classe
ATM

envia a mensagem
displayMessage getInput authenticateUser execute execute Execute

para um objeto da classe

Screen Keypad BankDatabase BalanceInquiry Withdrawal Deposit BankDatabase BankDatabase Screen Screen Keypad BankDatabase CashDispenser BankDatabase CashDispenser Screen Keypad DepositSlot BankDatabase Account Account Account Account Account
75

BalanceInquiry getAvailableBalance getTotalBalance displayMessage Withdrawal displayMessage getInput getAvailableBalance isSufficientCashAvailable debit dispenseCash displayMessage getInput isEnvelopeReceived Credit validatePIN getAvailableBalance getTotalBalance debit Credit
PROO

Deposit

BankDatabase

(Opcional) Estudo de caso de engenharia de software (Continuao)

Diagramas de interao:
Interaes modelo utilizam UML. Diagramas de comunicao.
Tambm chamados de diagramas de colaborao. Enfatizam quais objetos participam das colaboraes.

Diagramas de seqncia:
Enfatizam quando mensagens so enviadas entre objetos.

PROO

76

(Opcional) Estudo de caso de engenharia de software (Continuao)

Diagramas de comunicao:
Objetos:
Modelados como retngulos. Contm nomes na forma nomeDoObjeto : nomeDaClasse

Objetos so conectados por linhas slidas. Mensagens so passadas ao longo dessas linhas na direo mostrada pelas setas. O nome da mensagem aparece ao lado da seta.

PROO

77

Diagrama de comunicao do ATM executando uma consulta de saldo

PROO

78

(Opcional) Estudo de caso de engenharia de software (Continuao)

Seqncia de mensagens em um diagrama de comunicao:
Aparece esquerda do nome de uma mensagem. Indica a ordem em que a mensagem passada. Processa na ordem numrica descendente.

PROO

79

Diagrama de comunicao para executar uma consulta de saldo

PROO

80

(Opcional) Estudo de caso de engenharia de software (Continuao)

Diagramas de seqncia:
Ajudam a modelar a sincronizao das colaboraes. Linha da vida:
Linha pontilhada que se estende para baixo a partir do retngulo de um objeto:
Representa a progresso do tempo.

Ativao:
Pequeno retngulo vertical:
Indica que um objeto est em execuo.

PROO

81

Diagrama de seqncia que modela um Withdrawal em execuo

PROO

82

Diagrama de seqncia que modela um Deposit em execuo

PROO

83