Java Sintaxe

(1)

Java Básico

Introdução

Fábio Gondim

http://sites.google.com/site/fabioiesp

Java

• Criada a partir de um projeto da Sun Microsystems, iniciado em 1991, voltado para dispositivos portáteis inteligentes, Java foi apresentada em 1995 (disponibilizada para uso em 1996) como uma alternativa para construção de aplicações web e tornou-se um sucesso acadêmico e corporativo devido as suas características.

James Gosling o “pai” de Java

Java

• A plataforma de programação Java é

formada de uma linguagem de mesmo

nome e de uma extensa biblioteca de

classes 100% orientadas a objetos. É

independente de plataforma, segura e

possui ótima performance.

Divisões

• Java ME (Java Micro Edition): destinada a dispositivos computacionais móveis, tais como celulares, PDAs (Personal digital assistants) e set-top-boxes.

• Java SE (Java Standard Edition): integra os elementos padrões do Java e permite criar aplicações de pequeno e médio porte.

• Java EE (Java Enterprise Edition): voltada para o desenvolvimento de aplicações corporativas complexas.

Versões

1. 1.02 (1996) (Primeira versão oficial) 2. 1.1 (1997) 3. Java 2 versão 1.2 (1999) 4. Java 2 versão 1.3 (2000) 5. Java 2 versão 1.4 (2002) 6. Java 5 (2004) 7. Java 6 (2006)

8. Java 7 (prevista para 2010)

Aquisição

da Sun pela Oracle

• Em 2009 foram iniciadas negociações

para a aquisição da Sun pela Oracle. O

negócio foi declarado fechado em 27 de

janeiro de 2010. Java, MySQL e outros

produtos desenvolvidos pela Sun, são

agora, portanto, de propriedade da Oracle

(

www.oracle.com

)

(2)

Características

• Orientada a objetos - Baseada no modelo de Smalltalk e Simula67;

• Portabilidade - Independência de plataforma - "write once, run anywhere“ (Escreva uma vez, execute em qualquer lugar);

• Recursos de Rede - Possui extensa biblioteca de rotinas que facilitam a cooperação com protocolos TCP/IP, como HTTP e FTP;

• Segurança - Pode executar programas via rede com restrições de execução;

• Sintaxe similar a Linguagem C/C++;

• Usuário não precisa se preocupar com ponteiros;

Características

• Facilidades de Internacionalização - Suporta nativamente caracteres Unicode;

• Simplicidade na especificação, tanto da linguagem como do "ambiente" de execução (JVM);

• É distribuída com um vasto conjunto de bibliotecas (ou APIs);

• Possui facilidades para criação de programas distribuídos e multitarefa (múltiplas linhas de execução num mesmo programa);

• Desalocação de memória automática por processo de coletor de lixo (garbage collector).

Compilação e Interpretação

Código Fonte

NomeArquivo.java

Compilador Java

(Específico para uma determinada plataforma) Javac NomeArquivo.java

NomeArquivo.class

Bytecode Independente de Plataforma (Linux , Mac OS,

Windows, etc.)

JVM – Java Virtual Machine

(Interpretador Java - Específico para uma determinada plataforma)

Java NomeArquivo (sem a extensão class)

Execução

Palavras-chave

• Em uma linguagem de programação,

palavra que tem função predeterminada

(como, p. ex., representar instrução ou

definir parâmetro de controle para o

compilador) e que não pode ser utilizada

como rótulo ou identificador de constante,

variável, rotina, etc.; palavra reservada.

[Pl.: palavras-chaves e palavras-chave.]

Keywords (Palavras-chave / Palavras reservadas)

abstract continue for new switch assert*** default goto* package synchronized boolean do if private this break double implements protected throw byte else import public throws case enum**** instanceof return transient catch extends int short try char final interface static void class finally long strictfp** volatile

const* float native super while

* Não usadas

** Adicionada na versão 1.2 *** Adicionada na versão 1.4 **** Adicionada na versão 5.0

(3)

Tipos primitivos de dados

Tipo Dado / Alocação Valores (ao programar utilizar o “.”

como separador decimal)

byte inteiro de 8 bits de-128 a127

short inteiro de16 bits de-32.768 a32.767 int inteiro de 32 bits de-2.147.483.648 a 2.147.483.647 long inteiro de 64 bits de_{9.223.372.036.854.775.807}-9.223.372.036.854.775.808 a

float racional de 32 bits _de_{- 1.40239846E-45}ponto flutuante de simples precisão_a_{+ 3.40282347E + 38}

double racional de 64 bits deponto flutuante de dupla precisão- 4.94065645841246544E-324 a

+ 1.79769313486231570E + 308 boolean lógico (1 bit*) trueoufalse (Não utilizar letras maiúsculas)

char caractere (16 bits) caracteres Unicode ( do código 0 até 65.535)

* De acordo com a especificação da linguagem, representa 1 bit de informação, mas seu tamanho não é precisamente definido.

Obs.: Ao programar escrever o tipo em letras minúsculas.

Principais Operadores

• Atribuição Simples: = (Ex.: x =10)

• Operadores Aritméticos

Adição(utilizado, também para concatenação de Strings: +(Ex.: 4 +5, Ex.: “Java” + “ SE”)

Subtração: –(Ex.: 10 –2)

Multiplicação: *(Ex.: 5 *4)

Divisão: /(Ex.: 10 /2)

Resto da Divisão Inteira: %(Ex.: 5 %2) (Resultado: 1)

Principais Operadores

• Atribuição Composta += (x +=5 equivale a x = x + 5) – = (x – =5 equivale a x = x - 5) *= (x *=5 equivale a x = x * 5) /= (x /=5 equivale a x = x / 5) %= (x %=5 equivale a x = x % 5)

Principais Operadores

• Operadores Unários

Positivo: +(Ex.: +5 / 2) (pode ser omitido pois

por padrão os números são considerados positivos)

Negativo: –(Ex.: –2 + 8)

Incremento (Pré ou Pós): ++(Ex.: ++x * y++)

(utilizar apenas em variáveis)

Decremento (Pré ou Pós): --(Ex.: --x * y--)

(utilizar apenas em variáveis)

Complemento Lógico / Negação (inverte o valor lógico): !(Ex.: ! false) (resultado: true)

Principais Operadores

• Operadores Relacionais

Igual a: ==(Ex.: x== 5)

Diferente de: !=(Ex.: x !=y)

Maior que: >(Ex.: x >y)

Maior ou igual a: >=(Ex.: nota >=7) Menor que: <(Ex.: faltas< 21) Menor ou igual a: <=(Ex.: 10 <=100)

Principais Operadores

• Operadores Lógicos

Negação: !(Ex.: ! (10 > 100)) (res.: true)

Conjunção (E): &&

(Ex.: (media >=7 &&faltas <= 20)

Disjunção (OU): ||

(4)

Principais Operadores

• Operador Condicional Ternário:

?:

Semelhante a estrutura condicional if-then-else

Ex.:

boolean aprovado = (media >= 7) ?true :false;

Equivale a: boolean aprovado;_{if (media >= 7) {} aprovado = true; } else { aprovado = false; }

Estruturas Condicionais

(Simples e Composta)

if (media >= 7) status = "Aprovado";

if (media >= 7) {

status = "Aprovado"; }

If (media >=7) status = “Aprovado”; else status = “Reprovado”;

Melhor* if (media >= 7) { status = "Aprovado"; } else { status = "Reprovado“; } Melhor*

* Apesar de a definição de blocos (utilização de chaves) só ser obrigatória quando houver mais de uma linha de comando, é recomendável utilizá-los sempre, para melhorar a legibilidade e facilidade nas possíveis modificações.

Seleção Múltipla - Switch

int mes = 8; switch (mes) {

case 1: System.out.println("Janeiro"); break; case 2: System.out.println("Fevereiro"); break; case 3: System.out.println("Março"); break; case 4: System.out.println("Abril"); break; case 5: System.out.println("Maio"); break; case 6: System.out.println("Junho"); break; case 7: System.out.println("Julho"); break; case 8: System.out.println("Agosto"); break; case 9: System.out.println("Setembro"); break; case 10: System.out.println("Outubro"); break; case 11: System.out.println("Novembro"); break; case 12: System.out.println("Dezembro"); break; default: System.out.println("Mês Inválido"); break;

} int mes = 2; int ano = 2000; int numeroDeDias = 0; switch (mes) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: numeroDeDias = 31; break; case 4: case 6: case 9: case 11: numeroDeDias = 30; break; case 2: // Continua... switch Exemplo 2

case 2: // Linha repetida – não redigitar if ( ((ano % 4 == 0) && !(ano % 100 == 0))

|| (ano % 400 == 0) ) { numeroDeDias = 29; } else { numeroDeDias = 28; } break; default: System.out.println("Mês inválido!"); break; } // Fim do Switch

System.out.println("Número de dias = " + numeroDeDias);

Observação: A estrutura switch só funciona para os tipos primitivos: byte, short, char e int; ou com enumerações e classes wrapper (empacotadoras) que serão vistas adiante.

Repetição com teste no início

int i = 0;

while (i < 100) {

System.out.println(“Não conversarei durante a aula”);

i++; }

(5)

Repetição com teste no final

int i = 0;

do {

i++;

} while (i < 100);

Repetição com variável de controle

for (int i = 0; i < 100; i++) {

} Obs.:

Existe um outro tipo de for, conhecido como for aprimorado, que será explicado juntamente com vetores.

break

• O comando break força a finalização do laço de repetição desviando o fluxo para após o seu final.

int i = 0;

while(true) {

System.out.println("testando 1....");

if(++i == 5) {

System.out.println("Finalizado pelo break.");

break;

}

System.out.println("testando 2...."); }

// O break desviará o fluxo para aqui

System.out.println("testando 3....");

break rotulado

• Para abandonar laços “aninhados” utiliza-se o break rotulado.

inti = 0;

zebra: while(true) { while(i < 10) { System.out.println("testando 1...."); if(++i == 1) { break zebra; } System.out.println("testando 2...."); } System.out.println("testando 3...."); } System.out.println("testando 4...."); // testando 1.... e testando 4....

continue

• Desvia o fluxo para o o início do laço e retesta.

int j = 0;

while (j < 3) {

System.out.println("testando 1a....");

if (++j == 1) {

continue; }

System.out.println("testando 2a...."); }

continue rotulado

• Desvia o fluxo para o rótulo e retesta.

int x = 0, z = 2;

saida: while(x <= z--) {

while (x < 2) {

System.out.println("testando 1b....");

if (++x == 1) {

continue saida; }

System.out.println("testando 2b...."); }

System.out.println("testando 3b...."); }

(6)

Saída de dados

• Exibição na saída padrão semquebra de linha: System.out.print(“O valor de x é: ” + x); • Exibição na saída padrão comquebra de linha

após a impressão:

System.out.println(“O valor de x é: ” + x);

Saída formatada de dados

Int i = 2, j = 5;

System.out.printf(“i vale %de j vale %d”, i, j); // Com quebra de linha (\n)

System.out.printf(“i vale %d e j vale %d\n”, i, j); double num = 8.5;

System.out.printf(“O valor de num é %f”, num); System.out.printf(“O valor de num é %.2f”, num); System.out.printf(“O valor de num é %5.2f”, num);

Saída formatada de dados

char letra = ‘a’;

System.out.printf(“%cé a primeira vogal”, letra); String curso = “medicina”;

System.out.printf(“Mariana cursa%s”, curso); double inflacao = 5.2;

System.out.printf(“O governo afirma que a inflação anual foi igual a %.2f %%”, inflacao);

Entrada de dados

utilizando a classe Scanner

/* acrescentar import java.util.Scanner na

primeira linha do arquivo */

Scanner s = new Scanner(System.in);

int x = 0;

double d = 0;

// acrescentar instruções para o usuário.

x = s.nextInt(); // Lê um inteiro

d = s.nextDouble(); // Lê um double

Entrada de dados

utilizando a classe Scanner

Scanner entrada = new Scanner(System.in); String palavra = "";

String frase = "";

System.out.print("Digite uma palavra: "); palavra = entrada.next(); // Lê uma palavra

System.out.println("Palavra: " + palavra); System.out.print("Digite uma frase: "); entrada.nextLine(); //Evita ler sobras frase = entrada.nextLine(); // Lê uma linha

System.out.println("Frase: " + frase);

Entrada de dados

utilizando a classe Scanner

/* Não existe um nextChar() na classe Scanner. Utiliza-se next() em conjunto com charAt(0) da classe String. */

char c= ‘’;

System.out.print("Digite uma caractere: "); c = entrada.next().charAt(0);

(7)

Executando o primeiro programa

• Em Java, programas são construídos a

partir de classes (será melhor detalhado

posteriormente). Antes do nome da classe

deve vir escrito, em letras minúsculas, a

palavra reservada “class”.

Ex.:

class Aluno {

}

Executando o primeiro programa

• Por convenção, amplamente adotada, o nome

de uma Classe deve iniciar com letra maiúscula. O restante deve ser em minúsculas a não ser que represente o início de uma segunda palavra (Evite o underline: escreva AlunoEspecial e não Aluno_especial).

Ex.:

class AlunoEspecial{ }

Executando o primeiro programa

• A classe que funcionará como ponto de partida do sistema deve conter um método especial denominado “main” (principal). Após compilar a classe (“javac AlunoEspecial.java”), para executar a classe abaixo a partir da tela de comando do sistema, digitar-se-ia java AlunoEspecial . O sistema iniciaria, então, a sua execução pela primeira linha contida no interior do método “main” da classe AlunoEspecial.

class AlunoEspecial{

public static voidmain(String[] args) { System.out.print(“Alô Mundo."); {

{

• Detalharemos melhor alguns tópicos no decorrer do curso, mas podemos adiantar superficialmente o significado dos elementos que compõe a assinatura do método “main”.

• public static voidmain(String[] args)

– public: o método poderá ser acessado a partir de qualquer classe em qualquer pacote.

– static : o método pertence a classe e não aos objetos. – void: o método não retorna nenhum valor.

– main: nome do método.

– String[] args: declara um array de Strings denominado args que terá a função de receber parâmetros passados na chamada do programa (ex.: java Folha janeiro 2010).

Executando o primeiro programa

Exemplo: args

public class TesteArgs {

public static void main(String[] args) { System.out.print("Olá");

for (int i=0; i< args.length; i++) { System.out.print (args[i] + " " ); }

} }

/* Após compilar, experimente executar a classe digitando java TesteArgs Hans Albert Einstein */

Exemplo: args utilizando o for aprimorado

public class TesteArgs {

public static void main(String[] args) { System.out.print("Olá");

for (String argumento : args) {

System.out.print(argumento + " " ); }

} }

/* Após compilar, experimente executar a classe digitando java TesteArgs Hans Albert Einstein */

(8)

Atributos e métodos estáticos

• Embora as classes sejam como projetos para a

criação de objetos elas podem, também, conter atributos e métodos independentes destes. Estes atributos e métodos conhecidos como membros estáticos podem ser acessados diretamente a partir das classes a que pertencem sem a necessidade de criação de objetos.

• Um exemplo de uma classe da API Java que contém vários métodos estáticos é a classe Math.

Atributos e métodos estáticos

• A classe Math fornece vários métodos estáticos que

podem ser acessados a partir de seu nome:

– Ex.:

• double x = Math.pow(2, 3); – Math: nome da classe;

– pow: nome do método; //pow de power (potência) – 2 e 3: parâmetros passados para o método; – A variável x, do tipo double, receberá o resultado de

2 elevado a 3 (2 * 2 * 2 = 8)

Atributos e métodos estáticos

– Ex.:

• double x = Math.sqrt(25); – Math: nome da classe;

– sqrt: nome do método; //sqrt de square root (raiz quadrada);

– 25: parâmetro passado para o método;

– A variável x, do tipo double, receberá o resultado da raiz quadrada de 25 (5).

Atributos e métodos estáticos

– Ex.:

• System.out.println(Math.abs(-2.5)); // 2.5

• System.out.println(Math.ceil(5.4)); // 6.0 (ceil = teto) • System.out.println(Math.ceil(5.5)); // 6.0

• System.out.println(Math.floor(5.9)); // 5.0 (floor = chão) • System.out.println(Math.floor(5.4)); // 5.0

• System.out.println(Math.round(5.4)); // 5 (round = redondo) • System.out.println(Math.round(5.5)); // 6

Atributos e métodos estáticos

– Ex.:

• System.out.println(Math.max(5, 2)); //retorna o maior (5) • System.out.println(Math.min(5, 2)); // retorna o menor (2) • System.out.println(Math.PI); // 3.141592653589793

– Note que PI não tem parênteses pois não é método; – PI está em maiúsculas porque é uma constante.

Exemplo de uma classe

com métodos estáticos

public class Retangulo {

public static double area(double lado1, double lado2) { return lado1 * lado2;

}

public static double perimetro(double lado1, double lado2) { return 2*(lado1 + lado2);

}

public static double diagonal(double lado1, double lado2) { return Math.sqrt(Math.pow(lado1, 2) + Math.pow(lado2, 2)); }

(9)

Exemplo de uma classe

com métodos estáticos

public class UsaRetangulo {

public static void main(String[] args) { System.out.println(Retangulo.area(8,5)); System.out.println(Retangulo.perimetro(8,5)); System.out.println(Retangulo.diagonal(8, 5)); System.out.printf("%.2f", Retangulo.diagonal(8, 5)); } }

• Classerepresenta um conjunto de objetos com características afins. Uma classe define o comportamento dos objetos através de seus métodos, e quais estados ele é capaz de manter através de seus atributos. Exemplo de classe: Os seres humanos.

• Subclasseé uma nova classe originada de sua classe base (superclasse).

Programação Orientada a Objetos

Conceitos Essenciais

Fonte: Wikipédia

• Objeto

é uma

instância

de uma

classe

. Um

objeto é capaz de armazenar estados através

de seus atributos e reagir a mensagens

enviadas a ele, assim como se relacionar e

enviar mensagens a outros objetos. Exemplo

de objetos da classe Humano: João, José,

Maria.

Conceitos Essenciais

Fonte: Wikipédia

• Atributossão características de um objeto. Basicamente a estrutura de dados que vai

representar a classe. Exemplos: Funcionário: nome, endereço,telefone, CPF,....; Carro: nome, marca, ano, cor, …; Livro: autor, editora, ano. Por sua vez, os atributos possuem valores. Por exemplo, o atributo cor pode conter o valor azul. O conjunto de valores dos atributos de um determinado objeto é chamado de estado.

Conceitos Essenciais

Fonte: Wikipédia

• Métodosdefinem as habilidades dos objetos. Bidu é uma instância da classe Cachorro, portanto tem habilidade para latir, implementada através do método latir(). Um método em uma classe é apenas uma definição. A ação só ocorre quando o método é invocado através do objeto, no caso Bidu. Dentro do programa, a utilização de um método deve afetar apenas um objeto em particular; Todos os cachorros podem latir, mas você quer que apenas Bidu dê o latido. Normalmente, uma classe possui diversos métodos, que no caso da classe Cachorro poderiam ser: sentar(), comer() e morder().

Conceitos Essenciais

Fonte: Wikipédia

• Mensagemé uma chamada a um objeto para invocar um de seus métodos, ativando um comportamento descrito por sua classe. Também pode ser direcionada diretamente a uma classe (através de uma invocação a um método estático).

Conceitos Essenciais

Fonte: Wikipédia

(10)

• Herança(ou generalização/especialização) é o mecanismo pelo qual uma classe (subclasse) pode estender outra classe (superclasse), aproveitando seus comportamentos (métodos) e variáveis possíveis (atributos). Um exemplo de herança: Mamífero é superclasse de Humano. Ou seja, um Humano é um mamífero. Há Herança múltiplaquando uma subclasse possui mais de uma superclasse. Essa relação é normalmente chamada de relação "é um". Java não suporta herança múltipla.

Conceitos Essenciais

Fonte: Wikipédia

• Associaçãoé o mecanismo pelo qual um objeto utiliza os recursos de outro. Pode tratar-se de uma associação simples "usa um" ou de um

acoplamento "parte de". Por exemplo: Um humano usa um telefone. A tecla "1" é parte de um telefone.

Conceitos Essenciais

Fonte: Wikipédia

• Encapsulamentoconsiste na separação de aspectos internos e externos de um objeto. Este mecanismo é utilizado amplamente para impedir o acesso direto ao estado de um objeto (seus atributos), disponibilizando externamente apenas os métodos que alteram estes estados. Exemplo: você não precisa conhecer os detalhes dos circuitos de um telefone para utilizá-lo. A carcaça do telefone encapsula esses detalhes, provendo a você uma interface mais amigável (as teclas, o microfone, os sinais de tom, etc.).

Conceitos Essenciais

Fonte: Wikipédia

Encapsulamento

• Abstração

é a habilidade de se concentrar

nos aspectos essenciais de um contexto

qualquer, ignorando características menos

importantes ou acidentais. Em modelagem

orientada a objetos, uma classe é uma

abstração de entidades existentes no

domínio do sistema de software.

Conceitos Essenciais

Fonte: Wikipédia

Programação Orientada a Objetos

(11)

Programação Orientada a Objetos

• Abstração:

– “(...) 2. Processo mental que consiste em escolher ou isolar um aspecto determinado de um estado de coisas relativamente complexo, a fim de simplificar a sua avaliação, classificação ou para permitir a comunicação do mesmo (...)”

Fonte: Dicionário Houaiss

Criando Objetos

• Antes de criar objetos é necessário projetá-los.

• Devemos identificar quais atributossão comuns a todos os objetos do tipo que estamos modelando e que serão úteis no domínio da aplicação do sistema. Ex.: para uma conta corrente teríamos número, titular, saldo, data de abertura, etc.

• Devemos identificar quais operaçõessão comuns a todos os objetos do tipo que estamos modelando e que serão úteis no domínio da aplicação do sistema. Ex.: para uma conta corrente teríamos creditar, debitar, transferir, conferir saldo, etc.

Criando Objetos

• Opcionalmente, devemos identificar quais parâmetros devem ser informados na criação de cada objeto para que estes possam ser criados com valores diferenciados ou seja: embora todos os objetos de um determinado tipo tenham os mesmos atributos os seus valores podem variar.

• Uma vez criada a classe contendo os atributos e operações comuns aos objetos que ela modela podemos utilizá-la para declarar variáveis do tipo referência. Ex.: ContaCorrente conta;

Criando Objetos

• A variável “conta” do item anterior ainda não está associada a nenhum objeto. Ela funcionará como um ponteiro para um objeto a ser criado. No momento ela ainda não aponta para nenhum objeto. Para que a variável aponte para algum objeto, este deve ser instanciado e atribuído à ela.

– Ex.:

ContaCorrente conta;

conta = new ContaCorrente(“001”, 200); // número da conta e saldo inicial.

Criando Objetos

• Fazendo uma analogia para visualizar melhor o que ocorre: – Declarar uma variável do tipo referência seria como especificar um

controle remoto para uma televisão que ainda não foi construída mas que já temos o projeto.

– Ex.: Teste t;

Temos o controle remoto, mas não temos o televisor

Criando Objetos

• Criando o controle remoto e a televisão: – Ex.:

Teste t; new Teste();

Temos o controle remoto e o televisor, mas eles não foram associados

(12)

Criando Objetos

• Associando o controle remoto à televisão: – Ex.:

Teste t; t =new Teste(); Ao escrever t = new Teste();

associamos o controle remoto ao televisor

Criando Objetos

• Utilizando o controle remoto: – Ex.:

Teste t =new Teste(); t .ligar();

Podemos então utilizar o controle remoto para ativar

operações no objeto.

Construtores

Carro carro1, carro2, carro3;

carro1 = new Carro(); carro2 = new Carro(); carro3 = new Carro();

As classes possuem pelo menos um construtor. Utilizando apenas o construtor padrão os objetos são criados com o mesmo estado.

Construtores

carro1 = new Carro(“Branco”); carro2 = new Carro(“Verde”); carro3 = new Carro(“Azul”);

As classes podem ter construtores com parâmetros. Isto possibilita criar objetos com atributos iguais porém com valores diferentes.

Sobrecarga de Construtores

carro1 = new Carro(“Branco” 3); carro2 = new Carro(“Verde”, 2); carro3 = new Carro(“Azul”, 1);

Tamanho

Uma mesma classe pode ter vários construtores desde que os parâmetros sejam diferentes na quantidade, ordem ou tipo. São construtores sobrecarregados.

Sobrecarga de Construtores

private int lado1, lado2; public Retangulo(intlado) {

this.lado1 = this.lado2 = lado; }

public Retangulo(intlado1, intlado2) { this.lado1 = lado1;

this.lado2 = lado2; }

//... }

A palavra this(este) representa o objeto corrente (aquele que está sendo criado ou utilizado)

(13)

Sobrecarga de Construtores

this.lado1 = this.lado2 = lado; }

//... }

Ei! Esta classe possui dois construtores!

Podia até ter mais desde que com

assinaturas

diferentes.

Sobrecarga de Construtores

e o uso do this(...)

this(lado, lado); }

//... }

Você viu esta utilização do this?

Sobrecarga de Construtores

e o uso do this(...)

public class Retangulo { private int lado1, lado2; public Retangulo(intlado) {

this(lado, lado); }

//... }

Utilizado desta forma o this chama outro construtor dentro da mesma classe. Aquele que possua a mesma

assinatura. Esta operação tem que ser a primeira em

um construtor.

Copiando a referência

carro1 = new Carro(“Branco”); carro2 = carro1;

carro3 = carro2;

Neste exemplo, as três variáveis referenciam o mesmo objeto. Funcionam como apelidos para o mesmo objeto, ou seja: neste exemplo existe apenas uma instância da classe Carro.

carro1 carro2 carro3

Métodos

• Os métodos representam o comportamento dos objetos. Eles definem as operações que podem ser realizadas pelos objetos e pelas classes (quando estáticos ).

• Um método pode, opcionalmente, receber parâmetros. • Os métodos podem retornar um valor de qualquer tipo (tanto

primitivo como objeto).

• Métodos que não retornam valores devem possuir a palavra reservada “void” no local do tipo de retorno.

• Para retornar mais de um valor é necessário que o objeto retornado seja um vetor ou outro tipo de agregação.

• Os métodos podem ser sobrecarregados (localizados na mesma classe, com o mesmo nome mas com assinaturas diferentes).

Métodos

public class Circulo {

private double raio;

// Construtor

publicCirculo(double raio) {

this.raio = raio;

}

public doublearea() {

return 2 * Math.PI * Math.pow(this.raio, 2);

}

public doubleperimetro() {

return 2 * Math.PI * this.raio;

}

// Mais métodos ...

(14)

Métodos sobrecarregados

public class Aviao {

public void voar() {

System.out.println("Voando na altitude padrão ...");

}

public void voar(double altitude) {

System.out.println("Voando a " + altitude + " pés de altitude ...");

} }

Encapsulamento e métodos de acesso

• Imagine uma classe Aluno que contenha um

atributo nota. Você não vai querer que alguém

faça algo como nota = -5 ou nota = 11 não é?

O mesmo ocorreria com relação a um atributo

sexo. Você não gostaria que valores inválidos

fossem especificados.

– Para que coisas deste tipo não ocorram encapsule as suas variáveis tornando-as privadas e crie métodos de acesso controlados: getters e setters.

Encapsulamento e métodos de acesso

//....

public double getNota() { return nota; }

public void setNota(double nota) { if (nota >= 0 && nota <=10) {

this.nota = nota; } else { if (nota < 0) { this.nota = 0; } else { this.nota = 10; } } } //...

Encapsulamento e métodos de acesso

//....

public double getNota() { return nota; }

public void setNota(double nota) { if (nota >= 0 && nota <=10) {

this.nota = nota; } else { if (nota < 0) { this.nota = 0; } else { this.nota = 10; } } } //...

Não seria melhor lançar uma exceção?

Com certeza, mas este assunto só será visto adiante.

Passagem por valor e por referência

• Em Java, tipos primitivos são sempre

passados por valor na chamada de métodos:

• int num = 5; umCalculoQualquer(num);

// funciona como umCalculoQualquer(5);

// Ou seja o método recebe o valor 5 e não

// o endereço de num.

// A variável local que recebe 5 pode alterar

// este valor, mas num não sofrerá alterações

// em decorrência disto.

Passagem por valor e por referência

• Em Java, objetos são sempre passados por

referência na chamada de métodos: • Pessoa p = new Pessoa(“Luciana”);

umMetodoQualquer(p);

// É passada a referência para o objeto p. // Localmente ele pode até ter outro // identificador mas os dois fazem referência // ao mesmo objeto. Em decorrência disto // qualquer alteração de estado realizada // dentro do método estará sendo feita no objeto // que foi passado.

(15)

Vetor

Array unidimensional organizado como uma

linha ou coluna de dados. Em Java, um array é

um objeto com uma forma especial de

instanciação.

int[] idades = new int[10];

Tipo de dados que o array vai armazenar.

Indica que se trata de um array de inteiros e não de apenas um inteiro.

Identificador escolhido

pelo programador. _{Tamanho do Array} (comprimento).

Vetor (Array unidimensional)

int[] idades = new int[5];

Cria um vetor com capacidade para receber 5

inteiros. Cada posição do array é acessada

individualmente por intermédio de um índice. O

primeiro elemento é o de índice zero, o segundo

é o de índice 1 e assim por diante até o último

que é o de índice 4 (neste exemplo).

idades

0 0 0 0 0

0 1 2 3 4

Vetor (Array unidimensional)

boolean[] status = new boolean[5] status

false false false false false

0 1 2 3 4

double[] notas = new double[5] notas

0.0 0.0 0.0 0.0 0.0

0 1 2 3 4

Vetor (Array unidimensional)

Um array não está limitado a receber tipos

primitivos. Ele pode armazenar objetos.

String[] nomes = new String[5];

Indica que se trata de um array de Strings e não de apenas uma String.

pelo programador. _{Tamanho do Array} (comprimento).

Vetor (Array unidimensional)

Um array não está limitado a receber tipos

primitivos. Ele pode armazenar objetos.

Aluno[] alunos = new Aluno[5];

Indica que se trata de um array de Alunos e não de apenas uma Aluno.

pelo programador. Tamanho do Array (comprimento).

Vetor (Array unidimensional)

Aluno[] alunos = new Aluno[5] alunos

null null null null null

0 1 2 3 4

String[] nomes = new String[5] nomes

null null null null null

(16)

Vetor (Array unidimensional)

Formas alternativas de declaração:

String[] nomes = new String[100];

ou

String nomes[] = new String[100];

double[] notas = new double[50];

ou

double notas[] = new double[50]

Vetor (Array unidimensional)

Formas alternativas de declaração:

String[] nomes = {“Ana”, “Beatriz”, “Carla”};

double[] notas = { 9.4, 7.5, 6.5 }

Vetor (Array unidimensional)

• Um array é um objeto e contém, portanto,

propriedades e operações:

– length (comprimento, extensão, quantidade) – Ex.:

String[] nomes = {“Ana”, “Beatriz”, “Carla”}; System.out.println(nomes.length); //Saída: 3

Note que em um array, length não é um método e sim um atributo (campo).

Vetor (Array unidimensional)

• Percorrendo um vetor:

int[] idades = {18, 19, 25, 17, 22, 35}; for (int i=0; i<idades.length; i++) {

System.out.println(idades[i]); }

// Um vetor de tamanho 6 vai do índice 0 ao 6. // Portanto utilize i < idades.length

// e não i <= idades.length

Vetor (Array unidimensional)

• Percorrendo um vetor utilizando o for

aprimorado:

int[] idades = {18, 19, 25, 17, 22, 35}; for (int i : idades) {

System.out.println(i); }

Matriz (Array multidimensional)

• Java não dá suporte a arrays com várias dimensões

mas permite que um vetor contenha referência para um outro vetor que por sua vez também pode fazê-lo. Na prática isto significa que podemos simular matrizes multimensionais.

(17)

Matriz (Array multidimensional)

• Por exemplo, para criar um vetor que na prática

corresponderia a uma matriz de Strings com três linhas e cinco colunas teríamos:

String[][] nomeDoArray = new String[3][5];

Matriz (Array multidimensional)

• Por exemplo, para criar um vetor que na prática

corresponderia a uma matriz de caracteres com três linhas e três colunas teríamos:

char[][] nomeDoArray = new char[3][3];

Matriz (Array multidimensional)

• Atribuindo valores:

char[][] letras = new char[3][3];

letras[0][0] = ‘a’; letras[0][1] = ‘b’;

Letras[0][2] = ‘c’; letras

‘a’ ‘b’ ‘c’

Matriz (Array multidimensional)

char[][] letras = new char[3][3];

char c = 'a';

for (int lin=0; lin < letras.length; lin++) { for (int col = 0; col < letras[lin].length; col++) {

letras[lin][col] = c++; } } ‘a’ ‘b’ ‘c’ ‘d’ ‘e’ ‘f’ ‘g’ ‘h’ ‘i’

Matriz (Array multidimensional)

char[][] letras = {{'a', 'b', 'c'}, {'d', 'e', 'f'}, {'g', 'h', 'i'}};

‘a’ ‘b’ ‘c’ ‘d’ ‘e’ ‘f’ ‘g’ ‘h’ ‘i’

Propriedade length em array de arrays

char[][] letras = { {'a', 'b'}, {'c', 'd', 'e'}, {'f', 'g', 'h', 'i', } };

‘a’ ‘b’ ‘c’ ‘d’ ‘e’ ‘f’ ‘g’ ‘h’ ‘i’

System.out.println(letras.length); // 3

System.out.println(letras[0].length); // 2

System.out.println(letras[1].length); // 3

(18)

Percorrendo um vetor de vetores

char[][] letras = { {'a', 'b'}, {'c', 'd', 'e'}, {'f', 'g', 'h', 'i', } };

for(int i=0; i < letras.length; i++) {

for(int j=0; j < letras[i].length; j++) {

System.out.println(letras[i][j]);

} }

Percorrendo um vetor de vetores

utilizando o for aprimorado

char[][] letras = { {'a', 'b'}, {'c', 'd', 'e'}, {'f', 'g', 'h', 'i', } };

for(char[] letras2 : letras) {

for(char c : letras2) {

System.out.println(c);

} }

ArrayList

(Este tópico será aprofundado nas próximas disciplinas)

• Os vetores possuem uma forte limitação: o seu tamanho é definido na sua criação e não pode mudar.

• Uma boa opção é utilizar um objeto do tipo ArrayList nos casos em que não é possível antecipar a quantidade de elementos que serão inseridos pois este tipo de coleção tem seu tamanho modificado dinamicamente de acordo com a necessidade de espaço.

• Antes da versão 5 de Java, um ArrayList só podia manipular elementos do tipo Object.

• Com o surgimento dos “Generics” é possível especificar qualquer tipo não primitivo (existente ou criado pelo usuário).

ArrayList

• Um ArrayList com elementos do tipo Object:

– ArrayList objetos = new ArrayList(); // Não é muito usado • Um ArrayList de inteiros:

– ArrayList<Integer> inteiros = new ArrayList<Integer>(); // Como não aceita tipos primitivos é necessário utilizar // classes wrapper (Integer, Double, Float, Boolean, etc.). • Um ArrayList com elementos de um tipo criado pelo

programador:

– ArrayList<Aluno> alunos = new ArrayList<Aluno>();

ArrayList

• Principais métodos:

– public boolean add(Ee);

• Adiciona o elemento ‘e’ no final da lista. – public void add(int index, Eelement);

• Adiciona o elemento ‘e’ na posição ‘index ‘ (não sobrepõe). – public void clear();

• Remove todos os elementos. – public boolean contains(Objecto);

• Retorna “true” se o elemento ‘o’ existir e “false” caso contrário.

– public Eget(int index);

• Retorna o elemento existente na posição ‘index’.

ArrayList

• Principais métodos:

– public int indexOf(Objecto)

• Retorna o índice da primeira ocorrência do objeto ‘o’. – public int lastIndexOf(Objecto);

• Retorna o índice da última ocorrência do objeto ‘o’. – public Eremove(int index);

• Retorna e remove o elemento existente na posição ‘index’.

– public boolean remove(Objecto);

• Remove a primeira ocorrência do objeto ‘o’; – public int size();