Download
curso b sico de linguagem java n.
Skip this Video
Loading SlideShow in 5 Seconds..
Curso Básico de Linguagem Java PowerPoint Presentation
Download Presentation
Curso Básico de Linguagem Java

Curso Básico de Linguagem Java

106 Views Download Presentation
Download Presentation

Curso Básico de Linguagem Java

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Curso Básico de Linguagem Java Prof. Marco Aurelio N. Esteves http://geocities.yahoo.com.br/marcoaurelionovaes

  2. JAVA • O Panorama da computação de alto desempenho • O crescimento do volume de dados e da complexidade dos processamentos atuais • Segundo Pfister, existem três alternativas: • Trabalhar mais arduamente • Trabalhar mais sabiamente • Pedir ajuda • A última década, e o avanço e a popularidade dos recursos tecnológicos • Motivação: grande disponibilidade e os altos custos dos supercomputadores • Ainda assim os grandes desafios ainda permanecem • A idéia dos Grids Computacionais

  3. JAVA • PANORAMA DO CURSO • Por que devo aprender Java? • Objetivos x Tempo • Java é difícil? • O QUE É JAVA ? • Linguagem para construção de software de eletroeletrônicos remotos • Linguagem de programação pequena, confiável e portável • Linguagem de programação conveniente para a Internet • Linguagem de programação Orientada a Objetos • Linguagem de programação no formato Cliente-Servidor • FERRAMENTAS DE DESENVOLVIMENTO: • JDK/SDK 1.5 (JAVA 2) • NET BEANS • JBUILDER • ECLIPSE • JCREATOR LE (Freeware)

  4. JAVA • INDEPENDÊNCIA DE PLATAFORMA: • PROGRAMAS TRADICIONAIS • Código Fonte • C, Delphi, VB • PROGRAMA JAVA • Código Fonte • JAVA • PORTABILIDADE X VELOCIDADE: • Usar compiladores de código nativo (Asymetrix, Symantec e IBM) • Usar compiladores “Just in Time” • SEGURANÇA Compilador Windows EXE Windows Binário Compilador Linux EXE Linux Binário Compilador Solaris EXE Solaris Binário Máquina virtual Windows Compilador JAVA Bytecode independente de plataforma Máquina virtual Linux Máquina virtual Solaris H A R D W A R E Byte Code Verifier RunTime Prog1.java Prog1.class

  5. JAVA • SOFTWARES • DOWNLOADS • J2SE (Java 2 Standard Edition) – www.java.sun.com/j2se/downloads/index.html • J2SE v1.5 ( 72 Mb) • Documentação: J2SE V1.5 Documentation (45 Mb) • Jcreator –www.jcreator.com (2Mb) • BlueJ –www.bluj.org(2.3 Mb) • INSTALAÇÃO: • Instalar a documentação na raiz do JDK • Path (Path = ...;C:\J2SDK1.5\BIN) (FILE NOT FOUND !) • JCreator/BlueJ – Informar as pastas do J2SDK e documentação • VARIAÇÕES • APLICATIVOS DESKTOP (caractere e gráfico) • APLICATIVOS WEB: APPLETS, SERVLETS E JSP • EJB • NOÇÕES DE ORIENTAÇÃO A OBJETO • Motivação: Confiabilidade, Produtividade e Manutenibilidade • Estratégias: Encapsulamento, Herança e Polimorfismo • A Classe e o Encapsulamento Classe métodos propriedades

  6. JAVA classe Carro1000 celta gol palio classe Carr_1000_16V Instâncias (Objetos) Nova classe derivada Caso tenha outra definição do método X() teremos uma anulação. Caso tenha mais de uma definição do mesmo método na mesma classe teremos uma sobrecarga. • classe A • método X() • classe B • método Y() • classe C • método Z() classe C1 classe C2 Chamada do método X() obj.X()

  7. JAVA • Organização das classes em java • Hierarquia de Classes • Pacotes • O rt.jar e a documentação da API • Exemplos de Programas • Aplicativo Console • import java.lang.*; //Não precisaria pois este pacote já é importado por default • class Ex1 extends Object // Não precisaria pois estender Object é o default • { • public static void main(String args[]) • { • String frase = "Isto é um exemplo para saida em console"; • System.out.println(frase); • } • }

  8. JAVA // Aplicativo Gráfico import javax.swing.*; import java.awt.*; import java.awt.event.*; public class Ex2 { public static void main(String args[]) { JFrame Ex2 = new JFrame(); Font f = new Font("Arial",Font.BOLD,20); JLabel lab = new JLabel("Este é um programa com interface grafica"); Ex2.setTitle("Interface Grafica"); Ex2.setSize(400,200); Ex2.setFont(f); Ex2.getContentPane().add(lab); Ex2.setVisible(true); Ex2.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {System.exit(0); }}); } }

  9. // Programa Applet import java.awt.*; import javax.swing.*; import java.applet.*; public class Ex3 extends Applet { Font f = new Font("Arial",Font.BOLD,20); JLabel l = new JLabel("Este é um exemplo de Applet"); public void init() { l.setFont(f); add(l); } } ------------------------------------------------------------------------------------------------------------------------------------------- <! Arquivo HTML para rodar o Applet > <HTML> <BODY BGCOLOR="#FFFACD"> <CENTER> <APPLET code = "Ex3.class" width = "300" height = "100" > </APPLET> </CENTER> </BODY> </HTML> JAVA

  10. JAVA • Compilação e Execução: • O arquivo fonte (.java) deverá ter o mesmo nome da classe no programa caso esta classe seja descrita como • public. Por convenção usar a primeira letra do nome da classe em maiúsculo • Para cada classe declarada no programa será criado um arquivo de classe (.class) após a compilação e apenas uma destas classes poderá conter o modificador public • Apenas a classe que será executada terá o método main obrigatoriamente declarado como: • public static void main( String args[ ] ) • O procedimento para compilar e executar um aplicativo Java é: • javac MeuProg.java (Resultará, caso a classe também possua este nome, em MeuProg.class) • java MeuProg • Comentário e Documentação: • // -> Forma de comentar uma única linha • /* e */ -> Forma de comentar várias linhas • /** e */ -> Forma de criar um bloco de comentário para documentação com o utilitário javadoc. Tags de Documentação: @version, @author,@param, @return, @exception e @see • As tags @version e @author são apenas para descrição de classes e serão ignoradas a menos que se use as opções –author e –version como parâmetros para o javadoc

  11. JAVA • /** Esta classe exibe uma string como exemplo • @version 1.0 • @author Marcos Esteves */ • public class TesteDoc { • /** Método para exibir uma string • @param texto é o parâmetro da classe <b>String</b> a ser recebido • @see #main */ • public void exibeString(String texto) { • System.out.println(texto); } • public static void main(String args[]) { • TesteDoc x = new TesteDoc(); • x.exibeString("String de teste !");} } • javadoc –author –version TesteDoc.java • Literais Numéricos – Precedidos por 0 = octal e 0x = Hexa – Ex: 0377 = 3778 , 0x9876 = 987616 • Literais Booleanos – true e false (Não equivalem a 0 e 1) • Literais Caractere – Representado por um caractere isolado entre apóstrofos ou usando uma seqüência de escapes • Ex: ‘a’, ‘\\’, ‘\n’, ‘\u0041’, ‘1’, ‘\”’ • Literal String – São na realidade classes que se comportam como um tipo básico. São representados entre aspas inclusive as seqüências de escapes e caracteres unicode - Ex: “Uma linha\nDuas linhas\tTabulação” • Ex: (“Doom II”, c:\games\doom) - implica em: “\”Doom II\”, c:\\games\\doom”

  12. JAVA • Tipos de Dados – Os tipos de dados em Java são portáveis entre plataformas e portanto, invariáveis • Identificadores - Podem ter qualquer tamanho e caracter, a limitação vem do S.O com os nomes de classes e arquivos. Os tipos primitivos são: char(16), byte(8), short(16), int(32), long(64), float(32), double(64) e boolean(8) • Os tipos primitivos quando usados como variáveis de instância ou classe são inicializados por default, já como variáveis locais, devem ser inicializadas Ex: int x=10; float y = 3.141592F, double z = 1.35e+10, char sexo=‘M’, String texto = “\t\tIsto é\n\t\t um exemplo”, vazia = “”, branco = “ “ • Operadores • Aritméticos = +, -, *, /, % - unários +, -, ++, -- • De Atribuição: +=, -=, *=, /= • Lógicos: &, && (AND), |, || (OR), ^(XOR), !(NOT) • Relacionais: = (atribuição), == (comparação), != (diferenciação), >, >=, <, <= • Ex: int x=20 % 7, y=x / 2, x*=y, y=x++, z=++x, (x=?, y=?) , • (if (i<=10) & (&&) (vet[i].equals(“João”)) • (x=3) != (x==3), (if (i ==3) | (||) (i==5)) • Argumentos passados por linha de programa: • Ex: public static void main(String[ ] args){ ... } • java MeuProg Param1 Param2 (args[0] = param1 e args[1] = param2) • class MeuProg { • public static void main(String[] args){ • System.out.println(“Nome= “+args[0]+”\nSobrenome= “+args[1]); } } • java MeuProg Jose Carlos - Saída : Nome= Jose e Sobrenome= Carlos (em linhas diferentes)

  13. JAVA • Saída para dispositivo padrão: • Ex: System.out.println(String1+String2+...) – A conversão para String é automática devido a concatenação (+) (implicitamente usando o método toString() da superclasse Object) • System.out.println(“Um ”+2+”Tres ”+4); • Coversão de Tipos: As conversões permitidas para tipos primitivos são no sentido do menor para o maior: • byte -> short -> int -> long -> float -> double, e qualquer inversão neste sentido implica no uso de cast. • Ex: double x= 9.997; int y = (int) x; • Principais formas de conversão de tipos: • long x =10 -> int y = (int) x ; float x = 10 -> long y = (long) x ; String x = “10” -> int y = Integer.paseInt(x) • String x = “20.54” -> float y = Float.parseFloat(x) ; String x = “20.54” -> double y = Double.parseDouble(x) ; • int x = 10 -> String y = String.valueOf(x) ; float x = 10.35 -> String y = String.valueOf(x) ; double x = 254.34 -> • String y = String.valueOf(x) • Ex: java Conversao 2 4 3 • class Conversao { • public static void main(String args[]) { • double nota1, nota2, nota3, media; • nota1=Double.parseDouble(args[0]); • nota2=Double.parseDouble(args[1]); • nota3=Double.parseDouble(args[2]); • media=(nota1+nota2+nota3)/3; • System.out.println("A media e: "+media); } } // Saída = A media e: 3.0

  14. JAVA • Constantes: Em Java as constantes somente podem ser declaradas para toda a classe e, por esta razão, é chamada de constante de classe. A declaração final indica a presença de uma constante. • Ex: class UsandoConstantes { • public static final double g = 32; // Definição deve vir antes do método • public static void main(String[] args) {System.out.println(g + “ pes por segundo ao quadrado” } } • Comandos Condicionais: • .if ... else : a) As condições sempre devem estar entre parênteses • b) Caso haja apenas uma instrução as chaves serão desnecessárias • .Ex: if ( valor == 0 || valor == 1 ) • fatorial =1; • else • { fatorial *=valor; • valor--; } • .O operador condicional ou ternário: Retorna sempre um valor pois é na verdade uma expressão • .Ex: int maiorvalor = x > y ? x : y (Equivale a if (x>y) maiorvalor = x; else maiorvalor = y; • .A estrutura switch-case: A variável de teste e os valores somente podem ser dos tipos primitivos simples byte, short, int e char • .Ex: switch (oper) { • case ‘+’ :a += 5; break; • case ‘-’ : a -= 5; break; • case ‘*’: a *= 5; break; • case ‘/’: a /= 5; break; • default: System.out.println(“Operador desconhecido !”); }

  15. JAVA • .Estruturas de repetição: • .O laço for (inicialização; teste; incremento) • a) todos os argumentos são opcionais • b) É possível ter incrementos do tipo float • .Ex: for (double x = 5; x<=10; x+=0.5){ ... } • for (int parte = valor; parte > 1;) • fatorial *= parte--; • O laço while (condição) e do { instruções } while (condição) • a) É necessário parênteses para a condição e se houver apenas uma instrução não necessita de chaves • b) while (condição) 1º Testa e depois executa • do { instruções } while (condição) 1º executa depois testa • Ex: while ( i < 10 ) { do • System.out.println(i + ” “); { System.out.println(i + ” “); • i++; } i++; } • while ( i < 10 ) ; • Prática: Fazer a lista de exercícios nº 1

  16. JAVA • Uso do teclado para entrada de dados usando Streams (JDK 1.4): • import java.io.*; - Informa que será importado o pacote (conjunto de classes) io com todas as suas classes além do pacote default java.lang.* • InputStreamReader obj1 = new InputStreamReader (System.in); - Cria um objeto (obj1) de fluxo de dados para receber da entrada padrão (System.in) um conjunto de bytes e converte-los em caracteres • BufferedReader obj2 = new BufferedReader (obj1); - Cria um buffer a partir do fluxo de entrada de caracteres a fim de armazená-los. Isto evita sucessivas leituras de bytes e conversões para caracteres (atua como um cache). • obj2.readLine(); - Método da classe BufferedReader para ler uma linha de texto e retornar um objeto String com o conteúdo da linha. • try {...} catch (tipo exceção) {...}: Instruções para se controlar os possíveis erros durante a execução do programa • getMessage() – Método da classe Exception que permite capturar a string geradora da exceção • printStackTrace() – Método da classe Exception que mostra o tipo de exceção gerado e onde ocorreu no programa • exit(1) – Método da classe System que interrompe a execução da JVM e o valor 1 é um indicador de anormalidade

  17. JAVA Throwable Exceções Explícitas Exception Error Exceções Implícitas Não Run time Exception RuntimeException • Ex:import java.io.*; • class Dobro { • public static void main ( String args[] ) { • InputStreamReader entrada = new InputStreamReader(System.in); • BufferedReader br = new BufferedReader (entrada ); • String valorstr; int valornum; • System.out.println(“Entre com um valor inteiro: “); • try { • valorstr = br.readLine(); • valornum = Integer.parseInt(valorstr); • System.out.println(“O dobro de “ + valorstr + ” e: “ + (valornum * 2)); } • catch (Exception e) { • System.out.println(“ Erro : “+e.getMessage()); • e.printStackTrace(); • System.exit(1); } } } • Exceções em Java: É a forma em Java de se escrever programas robustos (que possam tratar os possíveis erros sem abortar ). • A hierarquia de exceção:

  18. JAVA • Capturar ou Declarar a possibilidade de ocorrência de uma exceção (levantar a exceção)? • Tratar: Proteger o código do método que contém erro em potencial e tratá-lo usando try- catch {...} • Levantar: Divulgar com a cláusula throws que seu método, ou usa métodos que informam que podem gerar erros, ou levanta ele próprio exceções não tratadas dentro do seu método. • try {...} catch (exceção) {...} – Após a cláusula try, as linhas entre os blocos {...} terão a execução desviada para a cláusula catch predefinida ou genérica (Exception e). Quando um erro ocorre é gerado uma exceção que pode ser tratada. O tipo da exceção gerado depende da classe e método que se esta usando e variam desde erros de entrada e saída até erro de formatação • Ex: try { conjunto de instruções } • catch (nome da exceção) { tratamento deste tipo de erro } • catch (nome da exceção) { tratamento deste tipo de erro }... • finally – Opcional, mas para todo try deverá existir pelo menos um catch, a não ser que se utilize o finally. Consiste em um conjunto de código que será sempre executado independente de haver ou não erro. Normalmente usado para liberar recursos ou tratar erros desconhecidos. • O uso de throw(s): Instrução utilizada para declarar que determinada exceção pode ocorrer em um método e também é usada para provocar uma exceção em um método. • Ex: import java.io.*; • class ExemploException { • public static void main(String args[]) { • int limite; • double nota, media, soma=0; • InputStreamReader entrada = new InputStreamReader(System.in); • BufferedReader br = new BufferedReader(entrada); • try • { • System.out.print("\nEntre com o numero de notas: "); • limite = Integer.parseInt(br.readLine());

  19. JAVA • for ( int i=1; i<=limite; i++) • { • System.out.print("\nEntre com uma nota: "); • nota = Double.parseDouble(br.readLine()); • if (nota < 0 || nota > 10) • throw new Exception("Valor da nota < 0 ou >10 !"); • soma += nota; • } • media = soma / limite; • System.out.print("\nA media e: "+ media); • System.out.println(); • } • catch(NumberFormatException e) • { • System.out.println("Valor digitado invalido !"); • } • catch(IOException e) • { • System.out.println("Erro na entrada de dados! "); • System.exit(0); • } • catch (Exception e) • { • System.out.println(e.getMessage()); • System.exit(0); • } • } • }

  20. JAVA • Uso do teclado para entrada de dados usando a classe Scanner (JDK 1.5) Classe Scanner: Utilizada para ler dados de forma mais facilitada. Esta classe está disponível a partir da versão 1.5 do JDK e pertence ao pacote java.util. Ex: import java.util.Scanner; ... Scanner in = new Scanner(System.in); System.out.println(“Entre com o seu nome: “); String nome = in.nextLine(); // Foi usado o nextLine() pois o nome poderia conter brancos Para ler um dado delimitado por branco: String primeiroNome = in.next(); // a leitura inicia no primeiro caractere diferente de espaço e termina// no primeiro igual a espaço Para ler dados numéricos: int idade = in.nextInt(); double salario = in.nextDouble(); Os métodos nextInt() e nextDouble() disparam Exceptions caso o dado não possa ser convertido para os seu respectivo tipo. Para evitar isso existem os métodos hasNextInt() e hasNextDouble() que retornam true caso a próxima seqüência seja válida. Obs: Sempre que tiver alguma leitura antes do nextLine(), seja com nextInt, nextDouble ou next, usar uma leitura nextLine() . Scanner in = new Scanner(System.in); System.out.println("Entre com a idade: "); idade = in.nextInt(); in.nextLine(); // Se não for colocada esta linha a próxima leitura será pulada System.out.println("Entre com o nome: "); nome = in.nextLine();

  21. JAVA • Funções Matemáticas: Estas funções em Java são provenientes de métodos da classe Math do pacote default java.lang definidos como static. • Sintaxe : Math.<nome do método>(<lista de argumentos>); - Possui duas constantes PI e E. • Método ceil(<valor double>): Calcula o próximo inteiro de um valor double retornando um double. • Ex: Math.ceil(5.2); retornará 6.0 • Método floor(<valor double>): Calcula o inteiro anterior de um valor double retornando um double. • Ex: Math.floor(5.9); retornará 5.0 • Método max(<valor1>,<valor2>): Calcula o maior entre <valor1> e <valor2> retornando o maior tipo encontrado. • Ex Math.max(10,3.5); -> 10.0 • Método min(<valor1>,<valor2>): Calcula o menor entre <valor1> e <valor2> retornando o menor tipo encontrado. • Ex Math.min(10,3.5); -> 3.5 • Método sqrt(<valor1 double>): Calcula a raiz quadrada de <valor1> retornando um double. • Ex Math.sqrt(900); -> 30.0 (Negativo = NaN) • Método pow(<base>,<pot>): Calcula a potência de <base> por <pot> retornando um double. • Ex Math.pow(25,0.5); -> 5.0 • Método round(<valor double>): Calcula o arredondamento do valor retornando um long. • Ex. Math.round(30.5); -> 31 • Método random(): Retorna um valor double aleatório entre [0.0 e 1.0[ • Ex. Para sortear um nº entre 0 e 99 -> (int) (Math.random() * 100)

  22. JAVA • Funções de String:Em Java, String é uma classe que possui métodos para manipulação e que pode ser utilizada como uma variável. • Sintaxe: (Declaração) String s = “Linguagem Java”; (Utilização) s.<método>(argumento/s) • “Os literais String deverão estar entre aspas”. • Método length(): Retorna um inteiro equivalente ao tamanho da string. Ex. int tamanho = s.length(); • (tamanho = 14) • Método charAt(<índice>): Retorna um char correspondendo a posição relativa [0...(n-1)] do caracter na string. Ex. char c = s.charAt(5); (c = ‘a’) • Métodos toUpperCase() e toLowerCase(): Estes métodos convertem os caracteres de uma string para maiúsculo e minúsculo respectivamente retornando um string. Ex. String x = s.toUpperCase() ( x = “LINGUAGEM JAVA” ) – String x = s.toLowerCase() ( x = “linguagem java” ) • Método substring(<índice1>,]<índice2>[): Retorna um String com os caracteres a partir de <índice1> até ]<índice2>[. Se <índice2> não for especificado, será até o final da string. Ex. String x = s.substring(0,9); (x = “Linguagem”) • Método trim(): Remove todos os espaços antes e depois da string retornando uma String. String x = “ Espaços “; x = x.trim(); ( x = “Espaços” ) • Método replace(<char1>,<char2>): Substitui todas as ocorrências de <char1> por <char2> na string retornando um String. Se nenhuma ocorrência de <char1> for encontrada, a string original é retornada. Ex. String x = s.replace(‘a’,’ ‘); (x = “Lingu gem J v “) • Método valueOf(<nomevar>): Converte vários tipos de dados em String. • Ex. String x = String.valueOf(45.74); (x = “45.74”)

  23. JAVA • Formatação da saída: Ao se imprimir um número no console, o default é utilizar o número máximo de dígitos não zero do tipo em questão. Ex: x = 10000 / 3.0; System.out.println(x);  Será exibido 3333.3333333333335 • Formatando com a classe NumberFormat do pacote java.text: (JDK 1.4) • Valores Numéricos: NumberFormat.getNumberInstance(); • Valores Monetários: NumberFormat.getCurrencyInstance(); • Valores Percentuais: NumberFormat.getPercentInstance(); • Cada um destes métodos obtém um formatador que é uma instância da classe NumberFormat, para a localização padrão. Em seguida utiliza-se o método format() desta classe para se obter uma String equivalente ao número formatado. Ex: NumberFormat nf = NumberFormat.getNumberInstance(); System.out.println(“Numero formatado:”+nf.format(x));  Numero Formatado: 3.333,333 • Para ajustar o tamanho utiliza-se os métodos setMaximumIntegerDigits(), setMinimumIntegerDigits(), setMaximumFractionDigits(), setMinimumFractionDigits(). Ex: nf.setMaximumFractionDigits(2); nf.setMaximumIntegerDigits(2); System.out.println("Numero formatado:"+nf.format(x));  33,33 • Trocando a localidade padrão: Locale.xxxxxx, onde xxxxxx é o objeto que contém informações sobre a localidade. Ex: NumberFormat nf = NumberFormat.getNumberInstance(Locale.GERMANY); • Formatando a saída com a classe DecimalFormat(string_formatacao) Ex: Decimalformat df = new Decimalformat(#.###,##); System.out.println("Numero formatado:"+df.format(x));  3.333,33

  24. JAVA • Formatando com printf: A versão 1.5 do JDK trouxe de volta o printf que permite a formatação dos campos. A formatação ocorre de modo que cada um dos especificadores de formato que começam com o caractere % é substituídos pelo argumento correspondente. O caractere de conversão que finaliza o especificador de formato (%) indica o tipo a ser formatado. Ex: System.out.printf (“Olá, %s. no próximo ano o Sr. fará %d anos”, nome, idade); double x = 10000.0 / 3.0; System.out.println(x); // Exibe 3333.33333333333335 System.out.printf ( “%8.2f”,x); // Exibe 3333.33 Principais conversores para printf d -> Número inteiro decimal Ex: 159 f -> Ponto flutuante Ex: 15.9 s -> String Ex: “Hello” c -> Caractere Ex: ‘H’ b -> Lógico Ex: true tx -> Data e Hora (onde x representa o que se deseja da data e/ou hora) Ex: tD -> Data no formato EUA (mës;dia;ano) – 03/20/2006 ty -> Últimos dois dígitos do ano – 06 tm -> Mês com dois dígitos (com zeros iniciais) - 03 td -> Dia com dois dígitos (com zeros iniciais) - 20 Além disso é possível especificar sinalizadores que controlam a aparência do resultado formatado. Alguns exemplos: • + : Exibe o sinal para números positivos e negativos -> +3333.33 • Espaço : Adiciona um espaço antes de números positivos -> 3333.33 • - : Justifica campos à esquerda -> 3333.33 • ( : Insere números negativos entre parênteses -> (3333.33) • , : adiciona separadores de milhares -> 3,333.33 Ex: System.out.printf ( “%,.2f”, 10000.0 / 3.0); // Exibe 3,333.33 System.out.printf ( “%1$s %2$tB %2$te ,2$tY”, “Data Atual: “, new Date() ); Data atual: Febuary 9, 2004 – Usando índice: %índice$ Prática: Fazer a lista de exercícios nº 2

  25. dia = 0 mes= 0 ano= 0 null 0x01abcd JAVA • Como definir Classes: Uma classe em java é sempre definida com a palavra class em minúsculo e o nome da classe com a primeira letra em maiúsculo. Em seguida normalmente se descreve os membros da classe, ou seja, os elementos que definem a classe. • Ex: class Data { • int dia; // Os tipos primitivos alocam espaço em memória, • int mês; // já os tipos classe não pois são referências ! • int ano; } • Data hoje; // Aloca espaço apenas para a referência : hoje • hoje = new Data(); hoje • O operador new cria uma instância, aloca memória e chama o construtor da classe; • O acesso a qualquer membro da classe sem a devida instanciação provoca uma Exception do tipo NullPointerException. • Ex: Data hoje; hoje.dia = 5; // ERRO ! Pois é necessário primeiro a instanciação hoje = new Data(); • Ex: String nome1 = “Joao”; String nome2 = new String(“Joao”); • if (nome1 == nome2) System.out.println(“São iguais”); • else System.out.println(“São diferentes”); • Métodos em Java: São sub-rotinas que podem ser invocadas todas as vezes que se fizer necessário. • qualificador tipo-do-retorno nome-do-método(tipo_parâmetro parâmetro){...} • Qualificador: São os especificadores de acesso informando quem tem direito de acesso ao método, além da presença ou não da cláusula static. Esta cláusula informa se o método é de classe ou de instância. • Tipo-do-retorno:Pode ser void indicando que nada será retornado, ou um tipo de dado ou classe informando o tipo do retorno. Caso tenha algum retorno este deverá ser retornado através da cláusula return.

  26. JAVA • Propriedades ou Variáveis: Existem 3 tipos de variáveis em java: de classe, de instância e local. • Variáveis Locais: São as variáveis definidas dentro de algum método. Estas variáveis devem ser inicializadas antes de serem utilizadas. • Variáveis de Instância: São as variáveis declaradas no corpo da classe e que pertencem a instância, ou seja, pertencem ao objeto e portanto cada objeto terá sua cópia com valores possivelmente diferentes. • Variáveis de Classe: São variáveis também declaradas no corpo da classe mas que pertencem a classe como um todo, qualificando todas as instâncias da classe. Estas variáveis são declaradas com o qualificador static. Existe apenas uma cópia de cada variável de classe para todos os objetos da classe e estas residem em uma dimensão diferente da dos objetos. • Tipos de Métodos: Existem dois tipos de métodos em Java: Métodos de Classe ou Estáticos e de Instância • Métodos de classe: São os métodos definidos com o qualificador static e que operam apenas sobre as variáveis de classe. Estes métodos não precisam de uma instância para serem invocados pois podem ser chamados a partir do próprio nome da classe seguido do método. Ex: Integer.parseInt(), Math.max(), String.valueOf() • Métodos de Instância: São os métodos declarados sem o qualificados static e que operam sobre as instâncias embora possam operar sobre as classes. • Ex: classe Automovel { • static int contaObj; // Variável de classe • String modelo, marca; // Variáveis de instância • public static void main(String args[]) // Método de classe • { int x; ... // Variável local} • String setModelo(String modeloAux) {...} } // Método de Instância

  27. JAVA Variáveis e Métodos de classe e instância: As variáveis e métodos de classe (com o modificador static) ocupam dimensões distintas das variáveis e métodos de instância e são criadas uma única vez na instanciação do primeiro objeto da classe. Ex: class Data { static int tipoCalendario; int dia, mes, ano; static void trocaTipoCalendario(int novo_tipo) { ... } void incrementaDia( int num_dias) { ... } } ... Data hoje = new Data(); Data amanha = new Data() 1º) hoje 2º) amanha Invocando Variáveis e Métodos de classe e instância: As variáveis e os métodos de instância necessitam de uma instância para serem chamados. Já as variáveis e os métodos de classe podem e devem ser chamados pelo nome da classe. Ex: Data hoje = new Data(); hoje.dia = 5; hoje.incrementaDia(3); Data.tipoCalendario = 3; Data.trocaTipoCalendario(3); Integer.parseInt(),String.valueOf(), Math.max(), ... Métodos de Acesso: Seguindo os padrões da Orientação a Objetos de encapsulamento, os membros da classe não devem ter acesso externo a não ser por intermédio de métodos. Para isso as variáveis devem ser declaradas com o modificador private e os métodos que dão acesso as variáveis com o modificador public Os modificadores são: 1) private 2) public 3) protected 4)default (package) Ex: class Data { private int dia, mes, ano; public void setDia( int dia_aux) { dia = dia_aux }; public int getDia() { return dia }; ... // Para todas as demais variáveis } Prática: Faça a Lista de exercícios Usando Classes até o número 5. Instância Dados da classe (Class) dia = 0 mes = 0 ano = 0 incrementaDia() tipoCalendario = 0 trocaTipoCalendario() Instância dia = 0 mes = 0 ano = 0 incrementaDia()

  28. JAVA • Manipulação de Data (classe Date): Esta classe do pacote java.util representa um determinado tempo decorrido a partir de determinada data arbitrária do calendário gregoriano 01 de Jan de 1970 00:00:00. • Esta classe possui vários métodos de instância para data e hora. Ex: Date data = new Date(); • Os métodos mais comuns para manipulação de Datas são: data.getDate() – Retorna o dia do mês; getDay() – Retorna o dia da semana (0 domingo – 6 sábado); getMonth() - Retorna o mês ( 0 até 11); getYear() – Retorna o ano (para anos superiores a 2000 retornará 3 dígitos Ex. para 2000 retornará 100, para 2001 retornará 101, ...); data.setDate(dia) – Define o dia para o objeto data (o mesmo ocorre para setMonth() e setYear()). • Os métodos mais comuns para manipular Hora são: data.getHours() – Retorna a hora de 0 – 23; getMinutes() - Retorna os minutos de 0 – 59; getSeconds() – Retorna os segundos de 0 – 59; setHours(horas), setMinutes(minutos) e setSeconds(segundos) definem a hora, os minutos e os segundos do objeto data; data.toLocaleString() – Retorna uma String contendo a data e hora do objeto data. • A classe GregorianCalendar: Esta classe é mais atual e recomendada para manipular datas e horas. • Ex: GregorianCalendar diaDeHoje = new GregorianCalendar(). diaDeHoje = data do Sistema Oper. • GregorianCalendar diaDeHoje = new GregorianCalendar(1999, 11, 31, 23, 59, 30). Meses de 0 a 11 • Métodos mais utilizados: • int get(int valor) –Onde valor pode ser qualquer uma das constantes definidas em Calendar como: • YEAR, MONTH, DAY_OF_MONTH, DAY_OF_WEEK, DATE, HOUR, MINUTE, SECOND, AM_PM • void set( int ano, int mes, int dia) ou void set(int ano, int mes, int dia, int hora, int minuto, int segundo) • boolean equals(Object quando) – Compara o objeto corrente com quando retornando true se representam o mesmo ponto no tempo. • boolean before(Object quando) – Retorna true se objeto corrente vier antes de quando • boolean after(Object quando) - Retorna true se objeto corrente vier depois de quando

  29. JAVA • Ex:GregorianCalendar diaDeHoje = new GregorianCalendar(). • int dia = diaDeHoje.get(Calendar.DAY_OF_MONTH); • int mes = diaDeHoje.get(Calendar.MONTH); • int ano = diaDeHoje.get(Calendar.YEAR); • Alterando: diaDeHoje.set(Calendar.YEAR, 2007) diaDeHoje.set(Calendar.MONTH, Calendar.DECEMBER) • OBS: A classe abstrata Calendar possui constantes para os meses de 0 a 11 Ex. DECEMBER = 11, APRIL = 3, ... • Construtores: São métodos que possuem o mesmo nome da classe, não possuem tipo de retorno e que tem por finalidade executar as tarefas básicas quando da criação de um objeto. Somente pode ser invocado com o construtor new. Esses métodos quando não são declarados, Java chama um default automaticamente. • Ex: class Empregado • { int mat; String nome; • public Empregado(int mat_aux, String nome_aux) • { mat = mat_aux; • nome = nome_aux } • public static void main (String args[ ] ) • { Empregado emp = new Empregado( 123, “João Carlos”); • System.out.println(“ Mat: “ + emp.mat + “Nome : “ + emp.nome ); } } • OBS: Caso seja declarado algum construtor, o construtor default deixará de ser fornecido automaticamente ! • this e escopo: this dentro de uma definição de método de instância é usado para fazer referência ao objeto a partir do qual o método foi chamado. É uma referência para as variáveis de instância deste objeto, ao invés das variáveis locais, ou passar o objeto corrente como argumento para outro método. • Ex: Uma função tradicional : umaData = amanha( Data d ); • Uma chamada em Java: Data d = new Data(); d.amanha(); // O método amanha irá operar sobre o objeto d

  30. JAVA • Ex: public class Data { • private int dia, mês, ano; • public void amanha() { • this.dia = this.dia + 1; } } // O this é desnecessário pois java já associa as variáveis e métodos ao objeto • Ex: class TestaEscopo { • int teste = 10; • void imprimeTeste() { • int teste = 20; • System.out.println(“Teste = “+ teste); } // this.teste; • public static void main(String args[]) { • TestaEscopo st = new TestaEscopo(); • st.imprimeTeste(); } } • Chamando outro construtor da mesma classe: A utilização de this como primeiro comando em um construtor indica a chamada de outro construtor sobrecarregado da classe. • Ex: class Cliente { • private String nome; int numConta; • public Cliente (String n, int c ) { • nome = n; numConta = c; } • public Cliente ( String n) { • this (n,numConta + 1); } } • Conta.cadastrarConta(this); // o this usado para passar a referência como parâmetro • Exercício: Criar uma classe MeuCirculo com coordenadas de centro x, y e raio r. Defina dois construtores onde no 1º valor de x, y e r seja passado como argumento e, um segundo onde caso não se passe o valor do raio r assume-se o valor 1 como default. • Destrutores: Em Java a remoção dos objetos criados é feita automaticamente quando o objeto perde a referência ou não está mas sendo usado. Esta técnica chama-se Garbage Collection e ocorre quando o sistema esta ocioso nas referências já marcadas. • Prática: Faça a Lista de exercícios Usando Classes do ex. 6 ao 10.

  31. JAVA • Arrays: Em Java os vetores são tratados como objetos, ou seja, são referências e precisam dos passos necessários a criação de qualquer objeto em java (declaração e instanciação). Para diferenciar da declaração de tipos primitivos de dados usa-se [ ] depois do nome do vetor ou do tipo. • Ex: String frase[]; ou String[] frase; • int coordenadas[]; ou int[] coordenadas; • A criação de objetos de array é feita após a sua declaração ou em conjunto com a declaração: • Ex: frase = new String[10]; // String frase[] = new String[10]; • coordenadas = new int[50]; // int[] coordenadas = new int[50]; • Os elementos em um vetor são criados com os seguintes valores default – 0 para arrays numéricos, ‘ ‘ para caracteres, false para arrays boolean e null para objetos. Os arrays também podem ser criados a partir da inicialização: • Ex. String nomes[] = {“João”, “Pedro”, “Mario”}; isto seria o mesmo que : • String nomes[] = new String[3]; • nomes[0] = “João”; • nomes[1] = “Pedro”; • nomes[2] = “Mario”; • Os vetores sempre iniciam em zero e para se saber o tamanho de um vetor utiliza-se a variável de instância length. • Ex: System.out.println(nomes.length); • A cópia de vetores pode ser feita de duas formas: • 1) Movendo-se um objeto array para outro o que faz com que ambas façam referência ao mesmo vetor. • Ex: int[ ] vet1, vet2; vet1 = new int[10]; vet2 = vet1; vet1[5] = 15; • System.out.println(vet2[5]) // também será 15; • 2) Duplicando efetivamente os elementos do vetor com o método • arraycopy(vetOrigem, posOrigem, vetDestino, posDestino, qtd) da classe System.

  32. JAVA vet2 • Ex:vet1={2, 3, 5, 7, 11, 13}; vet2 = {1001, 1002, 1003, 1004, 1005, 1006, 1007}; • System.arraycopy( vet1, 2, vet2, 3, 4); • for (int i = 0; i <vet2.length; i++) • System.out.println(“Elemento “+ i +”: “+vet2[i]); • A utilização de arrays com mais dimensões é semelhante a anterior porém estes necessitam de mais índices. Os arrays multidimensionais em java são montados como arrays de arrays. • int espaco[] [] [] = new int [10] [5] [5]; • MeuObjeto matObj[] [] = new MeuObjeto[5] [5]; •  espaco[1] [2] [2] = 10;  matObj[2] [4] = new matObj(); • Existe uma classe Arrays do pacote java.util que possui alguns métodos de classe bastante úteis como: • static void sort( a ) -> Ordena o array a de um dos tipos int, long, short, char, byte, float ou double usando quicksort; • static int binarySearch( a , v) -> Busca um elemento v no array a ordenado usando pesquisa binária. Retorna o índice onde foi encontrado ou um valor negativo r indicando a posição onde deveria ser inserido. • static void fill ( a, b) -> Preenche todo o array a com o elemento b do mesmo tipo do array a. • static boolean equals( a, b) -> Compara os arrays a e b retornando true se forem do mesmo tipo, tiverem o mesmo comprimento e os elementos nos índices correspondentes coincidirem. • Prática: Faça a Lista de exercícios Usando Vetores. 1001 1002 1003 5 7 11 13

  33. JAVA • Introdução ao Polimorfismo Estático: Implemente uma classe que tenha três métodos capazes de receber valores de tipos diferentes ( int, float e double) e imprimi-los. Instancie um objeto desta classe no método main e chame os métodos com os argumentos correspondentes. • Sobrecarga ou Polimorfismo Estático: É um tipo de polimorfismo onde vários métodos possuem o mesmo nome em uma classe e são diferenciados apenas pela quantidade, tipo ou ordem dos parâmetros. Esta técnica evita que métodos com funcionalidades semelhantes tenham nomes distintos facilitando o reaproveitamento de código. Desta forma métodos com mesmo nome se comportam de maneira diferente, pois possuem códigos diferentes de acordo com os argumentos passados. Ex String.valueOf( .... ) • class Exemplo • { • public static void main(String args[]) • { • System.out.println(“Area do quadrado: “+area(3) ); • System.out.println(“Area do retangulo: “+area(3,2) ); • } • public static int area(int x) { return x * x }; • public static int area(int x, int y) { return x * y }; • } • Exercício: Implemente o exemplo acima em duas classes, uma que irá ler o número de argumentos passados e chamar o método area() e outra que irá conter apenas os métodos sobrecarregados area() para o cálculo da área. • A seguir um exemplo completo de uma classe Empregado e utilização de overloading:

  34. JAVA // CLASSE EMPREGADO import java.util.*; class Empregado { private String nome; private double salario; private GregorianCalendar dataContratacao; public Empregado (String n, double s, GregorianCalendar d) { nome = n; salario = s; dataContratacao = d; } public void aumentaSalario(double percentualDeAumento) { salario = salario + salario * percentualDeAumento / 100; } public void alteraDataContratacao(int ano, int mes, int dia) { dataContratacao.set(Calendar.YEAR, ano); dataContratacao.set(Calendar.MONTH, mes); dataContratacao.set(Calendar.DATE, dia); }

  35. JAVA // CONTINUAÇÃO public int anoContratacao() { return dataContratacao.get(Calendar.YEAR); } public String getNome() { return nome; } public double getSalario() { return salario; } public void print() { System.out.printf(“%s %7.2f %d “,nome, anoContratacao(), salario); } public void print(int i) { System.out.println(i); } public void print(String s) { System.out.println(s); } public void print(double d) { System.out.printf(“7.2f”,d); } }

  36. JAVA // CLASSE QUE IMPLEMENTA O OVERLOADING import java.util.*; // Devido a classe GregorianCalendar public class TestaEmpregados { public static void main(String args[]) { Empregado vetEmpregados[] = new Empregado[3]; vetEmpregados[0] = new Empregado("Luiz Claudio", 3500, new GregorianCalendar(1989, 10, 1)); vetEmpregados[1] = new Empregado("Vinicius Aguiar", 4500, new GregorianCalendar(1989, 12, 6)); vetEmpregados[2] = new Empregado("Luciana Arruda", 2500, new GregorianCalendar(1993, 1, 12)); for (int i = 0; i < 3; i++) { vetEmpregados[i].print(vetEmpregados[i].getNome()); // passa um String vetEmpregados[i].print(vetEmpregados[i].getSalario()); // passa um double vetEmpregados[i].print(vetEmpregados[i].anoContratacao()); // passa um int } } }

  37. JAVA • Pacotes (package): É o modo empregado pela Sun para organizar e agrupar classes. Os pacotes são organizados por níveis de hierarquia de modo a garantir unicidade nas classes. • A cláusula package: A cláusula package deve ser a primeira em um arquivo de classe e informa a que pacote a classe pertencerá, por exemplo: package faturamento. A ausência da cláusula package faz com que a classe pertença a um pacote default, que é o diretório corrente. Os pacotes especificados na cláusula package são mapeados para subdiretórios no sistema de arquivos do SO, sendo criada uma estrutura de subdiretórios similar ao pacote. • Ex: Seja a classe ClasseUtil definida com: package sistemas.comuns e alocada no diretório c:\diretorioSistemas. Ao compilar, com –d, será criado um diretório sistemas abaixo do diretório atual e um subdiretório comuns abaixo do diretório sistemas com ClasseUtil.class: c:\diretorioSistemas\sistemas\comuns\ClasseUtil.class. • Como o compilador localiza os pacotes: Para a localização do pacote é necessário informar ao classpath o diretório a partir do qual se encontra tal pacote, pois os caminhos são relativos a uma ou mais raízes especificadas no classpath. Os pacotes também podem ser oferecidos em arquivos .zip ou .jar, onde internamente existirá a hierarquia dos pacotes e arquivos. • Ex: seja um classpath definido assim: CLASSPATH=.;c:\diretorioSistemas, e uma classe Exemplo que utiliza ClasseUtil definida assim: import sistemas.comuns.ClasseUtil; class Exemplo { ... }. A procura se daria: • por ClasseUtil.classno pacote padrão em JAVA_HOME\jre\lib\rt.jar • por ClasseUtil.classno classpath especificado: c:\diretorioSistemas • por ClasseUtil.classno diretório local da classe Exemplo ( .) • por sistemas\comuns\ClassUtil.classem JAVA_HOME\jre\lib\rt.jar • por sistemas\comuns\ClassUtil.class em c:\diretorioSistemas // Onde deveria estar ! • por sistemas\comuns\ClassUtil.class no diretório local da classe Exemplo • O comando import: Quando em uma classe se utiliza um recurso de outra classe pública, que não pertença ao mesmo pacote, é necessário utilizar o comando import informado o pacote ao qual pertence a classe que oferece o recurso desejado. Ex: import sistemas.comuns.ClasseUtil; ou import sistemas.comuns.*;

  38. JAVA Herança: É a peça chave da OO para o reaproveitamento de código e consiste em derivar uma classe a partir de outra herdando seus atributos e métodos. Em java só é possível estender uma única classe. Uma subclasse, quando criada, tende a incorporar novos atributos e/ou métodos tornando-se mais específica (especialização) que a classe original (generalização). Ex: classe Empregado (slide 33) package testes; import java.util.*; class Gerente extends Empregado { private String nomeDaSecretaria; public Gerente ( String n, double s, GregorianCalendar d ) { super (n, s, d); // super(...) chama o construtor da superclasse de parâmetros equivalentes nomeDaSecretaria = ""; // e deve ser o 1º comando no construtor da subclasse } public void aumentaSalario ( double percentualDeAumento ) // Método aumentaSalario reescrito { GregorianCalendar hoje = new GregorianCalendar( ); double bonus = 0.5 * ( hoje.get(Calendar.YEAR) - anoContratacao( ) ); // Não há acesso direto a super.aumentaSalario( percentualDeAumento + bonus ); // variáveis de Empregado pois são private } // super.metodo() chama o método de mesma assinatura na superclasse para não repetir o código public String getNomeDaSecretaria( ) { return nomeDaSecretaria; } public void setNomeDaSecretaria( String nome ) { nomeDaSecretaria = nome; } }

  39. JAVA package testes; import java.util.*; public class TestaEmpregadoGerente { public static void main( String args[]) { Gerente mandaChuva = new Gerente ("Ricardo", 7500, new GregorianCalendar(1987,11,15)); mandaChuva.setNomeDaSecretaria("Claudia"); Empregado vetEmpregado[] = new Empregado[3]; vetEmpregado[0] = mandaChuva; // Em tempo de compilação vetEmpregado[0] é um Empregado vetEmpregado[1] = new Empregado("Claudia",2000,new GregorianCalendar(1999, 11, 6)); vetEmpregado[2] = new Empregado("Luciana",2500,new GregorianCalendar(1993, 1, 12)); System.out.println("Empregados e salarios antes do aumento"); for (int i = 0; i < 3; i++) { vetEmpregado[i].print(); } System.out.println(); for (int i = 0; i < 3; i++) { vetEmpregado[i].aumentaSalario(5); } // Em tempo de execução vetEmpregado[0] é um Gerente System.out.println("Empregados e salarios apos o aumento"); for (int i = 0; i < 3; i++) { vetEmpregado[i].print(); } // A classe Gerente não tem método print e usa o da classe Empregado System.out.println("\nA secretaria do departamento se chama: "+mandaChuva.getNomeDaSecretaria()); } }

  40. JAVA • Encapsulamento: Com exceção dos modificadores final, static e abstract os demais public, protected, private e package são usados para controlar o acesso as variáveis, métodos e classes e são os primeiros a serem declarados. • Acesso padrão (pakage): Variável ou método declarado desta forma esta disponível para qualquer outra classe do mesmo pacote • Acesso private: Variáveis e métodos private são acessíveis apenas dentro da classe onde foram declaradas, ou através de métodos não private da classe. Nem os métodos nem as variáveis são passados por herança. • Acesso public: Variáveis e métodos públicos são acessíveis para qualquer classe. Aas variáveis de classe normalmente são públicas para poderem ser acessadas de qualquer lugar. • Acesso protected: Variáveis e métodos protected são acessíveis por qualquer classe do mesmo pacote ou por subclasse desta classe (Ex. Applet é subclasse de Panel mas estão em pacotes diferentes java.awt.Panel e java.applet.Applet) • Polimorfismo Dinâmico: Quando um método é invocado, o compilador tenta localizá-lo na classe a qual pertence o objeto e, caso não encontre, procura sucessivamente nas classes ancestrais até encontrar ou gerar erro. Polimorfismo dinâmico ou late binding consiste na utilização de objetos de classes distintas , porém relacionadas por hierarquia e que possuem a mesma assinatura (nome e lista de parâmetros) mas com códigos diferentes. • Ex: Empregado vetEmpregado[ ] = new Empregado[2]; • vetEmpregado[0] = new Gerente(“Ricardo Silva”, 7500, new GregorianCalendar(1987, 12, 15) ); • vetEmpregado[1] = new Empregado(“Luiz Alberto”, 2500, new GregorianCalendar(1988, 10, 11) ); • vetEmpregado[0].aumentaSalario(5); // Aumentos diferenciados para métodos de mesma assinatura • vetEmpregado[1].aumentaSalario(5); // A seleção do método a carregar é realizada na hora da execução

  41. JAVA • Impedindo a Herança: Java permite que se utilize a palavra-chave final juntamente com as classes impedindo assim que essa classe seja estendida (a classe String ). Também é possível aplicar final aos métodos de modo que estes não possam ser sobrepostos em outras classes. Todos os métodos de uma classe final também são final. • Os principais motivos para se utilizar final são eficiência e segurança. • Ex: final class Vendedor { ... } • A cláusula instanceof: Utilizado para se saber a classe real a que pertence um objeto. • Ex: public void atualizaEmpregado( Empregado e ) • { if ( e instanceof Gerente ) // atualiza Gerente • else • if ( e instanceof Vendedor ) // atualiza Vendedor • else • // atualiza Empregado comum; • Conversão entre objetos ( Casting ) : É possível se atribuir a referência de um objeto de uma subclasse para outro de uma superclasse diretamente, sempre no sentido de baixo para cima na árvore de hierarquia. Posteriormente, caso se queira recuperar toda a potencialidade do objeto da subclasse é só se fazer um cast na referência. Em OO há sempre dois tempos, o de compilação e o de execução. • Ex: public void atualizaEmpregado( Empregado e ) • { if ( e instanceof Gerente ) • { e.getNomeDaSecretaria(); // Erro ! Em tempo de compilação e é do tipo Empregado • ( (Gerente) e). e.getNomeDaSecretaria(); // Ok o método é da classe Gerente para o compilador

  42. JAVA • Ex: Empregado e = new Empregado(); • Gerente g = new Gerente(); • e = g; // Ok, Gerente tem tudo de Empregado e mais alguma coisa • g = e; // Erro ! Certamente Empregado não tem tudo que deveria ter um Gerente • g = (Gerente) e; // Ok, para o compilador mas em tempo de execução e tem que ser Gerente ! • Ex: Faça uma classe onde sejam criados Empregados e Gerentes em um array de Empregados e imprima seus nomes e os nomes de suas secretárias quando for o caso a partir do vetor. • import java.util.*; • class ListaEmpregadosGerentes • { public static void main(String args[]) • { Empregado vetEmpregado[] = new Empregado[4]; • Gerente mandaChuva1 = new Gerente ("Ricardo", 7500, new GregorianCalendar(1987,11,15)); • mandaChuva1.setNomeDaSecretaria("Claudia"); • Gerente mandaChuva2 = new Gerente ("Pedro", 5500, new GregorianCalendar(1980,06,28)); • mandaChuva2.setNomeDaSecretaria("Luciana"); • vetEmpregado[0] = mandaChuva1; • vetEmpregado[1] = new Empregado("Claudia",2000,new GregorianCalendar(1999, 11, 6)); • vetEmpregado[2] = new Empregado("Luciana",2500,new GregorianCalendar(1993, 1, 12)); • vetEmpregado[3] = mandaChuva2; • for (int i = 0; i < 4; i++) • { if (vetEmpregado[i] instanceof Gerente) • { System.out.println("Nome Gerente: "+ vetEmpregado[i].getNome()); • System.out.println("Nome Secretária: "+ ((Gerente) vetEmpregado[i]).getNomeDaSecretaria()); } • else • System.out.println("Nome Empregado: "+ vetEmpregado[i].getNome()); • } } • Prática: Faça o exercício usando herança e Polimorfismo

  43. JAVA PassaroCanoro Curió TrincaFerro • Classes Abstratas: É uma classe que define uma hierarquia para outras classes, porém é tão abstrata que seus métodos apenas dizem o que deve ser realizado pelos descendentes sem contudo implementar particularmente os códigos( métodos abstratos). Estas classes, definidas com o modificador abstract, não podem ser instanciadas diretamente apenas através de subclasses. Além disso, podem ter métodos e variáveis concretos e até não possuírem nenhum método abstrato, contudo se houver algum método abstrato a classe deverá ser declarada como abstrata. • Ex: public abstract class PassaroCanoro • { private String origem; // variável concreta • public abstratct void cantar() ; // método abstrato, sem implementação • public String getOrigem() { return origem; } } // método concreto • public class Curio extends PassaroCanoro • { public void cantar() { ... } } • public class TrincaFerro extends PassaroCanoro // Uma classe que estenda outra que seja abstrata deve • { public void cantar() { ... } } // prover implementação a todos os métodos abstratos •  Criando um objeto: // ou também será abstrata • PassaroCanoro pc; // Se pode declarar objeto de classe abstrata • pc = new PassaroCanoro(); // Erro ! Porém não se pode instanciar • PassaroCanoro pc = new Curio(); // Instância da subclasse

  44. JAVA • A superclasse Object: Esta classe é a superclasse a partir da qual todas as classes derivam, ou seja todas as classes são filhas de Object. Normalmente se utiliza um objeto desta classe como armazenador genérico pois pode fazer referência a qualquer objeto. Esta classe também define alguns métodos úteis como: equals() e toString() que devem ser anulados em outras classes para trabalhar de forma customizada. • Método equals(): Na classe Object apenas compara se dois objetos apontam para a mesma área. Para saber se dois objetos distintos possuem o mesmo conteúdo deve-se anulá-lo. • Ex: class Empregado { ... • public booleanequals (Object obj) { // Testa-se um objeto qualquer é igual a um dado Empregado • if ( ! (obj instanceof Empregado) ) • return false; • Empregado e = (Empregado) obj; • return nome.equals(e.nome) && salario == e.salario && dataContratacao.equals(e.DataContratacao); • Método toString: Retorna uma String que representa o valor do objeto. De um geral as classes anulam este método a fim de dar uma representação impressa do estado do objeto. • Ex: class Empregado { ... • public String toString() • { return nome + “\n” + salario + “\n” + dataContratacao; } // Chama toString() das classes • // String eGregorianCalendar • Todos os arrays são classes que derivam da classe Object e todo array de objetos pode ser convertido em um array de Object: • Object vet = new int[10[; // Ok pois qualquer array é um Object; • Object vetObj[] = new Empregado[10]; // Se o array fosse de tipo básico daria erro !

  45. JAVA • Ex.Um método para localizar um objeto de qualquer classe em um array de objetos também de qualquer classe. • public int localizar (Object[] a, Object b) • { for ( int i = 0; i < a.length; i++) • if ( a[i].equals(b) ) return i; // O método equals chamado é o da classe real do objeto a[i] • else return -1; • A classe Vector: É uma classe definida no pacote java.util que armazena elementos do tipo Object, sendo assim, para se recuperar o tipo real do objeto será necessário usar o cast. A classe Vector oferece vários métodos para trabalhar com vetor como se fosse uma lista encadeada, ou seja, aumentando e reduzindo o tamanho dinamicamente. • Criando: Vector vet = new Vector(3); Um Vector vazio com potencial de até 3 elementos. Ao se inserir o quarto elemento o Vector dobrará de tamanho automaticamente. Para se evitar o crescimento exponencial pode-se passar o tamanho do incremento no 2º argumento do construtor. Ex: new Vector(3,5); • Adicionando: Os métodos add() e add(int index, Object obj) adicionam um elemento ao final do Vector ou na posição index deslocando os elementos >= index. Ex: vet.add(new Empregado()) ou vet.add(3,novoFunc); • Removendo: O método remove(int index) remove o elemento na posicão = index no Vector. Ex: vet.remove(3); // Remove o elemento na quarta posição retornando-o como um Object • Obtendo o tamanho do Vector: Com o método size() é possível se obter o tamanho corrente do vetor. Ex int tam = vet.size(); • Acessando o Vector: Com o método get(int index) é possível acessar um elemento que esteja na posição index porém é bom lembrar que ele virá como um Object. Os elementos somente podem ser acessados após se ter inserido elementos com o método add(). Ex Item x = (Item) vet.get(3); • Alterando uma posição: Com set (int index, Object obj) é possível se alterar a posição index do Vector para o conteúdo obj. Também é necessário que a posição index já exista no Vector.

  46. JAVA • Ajustando o tamanho real: É possível ajustar o tamanho do Vector sem adicionar todos os elementos um a um usando setSize(int n). Isto faz com que o Vector passe a ter n elementos null. • Ex Vector v = new Vector(10); // capacidade 10 tamanho 0 • v.set( 0, x ); // Erro ! Posição 0 ainda não existe. • v.add(x); // v.size() passa a ser = 1 • v.setSize(10); // v.size() passa a ser igual a 10 • Performance: As operações com Vector não são tão eficientes como com arrays. Desta forma é comum ao se • saber que o array não mudará mais de tamanho, copiar os elementos do Vector para o array. • Ex String nomes[] = new String[ vet.size() ]; • vet.copyInto[nomes]; • Um exemplo completo: • import java.util.*; • class Departamento { • private String nome; • private Vector empregados = new Vector(10); • public Departamento ( String n ) • { nome = n; } • public void print() • { System.out.println( nome ); } • public void adicionarEmpregado ( Empregado e ) • { empregados.add(e); } • public Empregado removerEmpregado (Empregado e ) • { int n encontrarEmpregado (empregados, e); • if (n == -1 ) return null; • else return (Empregado) empregados.remove(n); }

  47. JAVA public void listarEmpregados() { for ( int i = 0 ; i < empregados.size() ; i++ ) { System.out.println( ( ( Empregado) empregados.get(i) ).getNome() ); } private static int encontrarEmpregado( Vector v, Empregado b ) { for ( int i = 0 ; i < v.size() ; i++ ) { if ( ( ( Empregado) v.get(i) ) . equals(b) ) return i; else return -1; } } import java.util.*; class TestaEmpregado { public static void main(String args[ ]) { Departamento umEmpregado = new Departamento(“Compras”); Empregado vinicius = new Empregado (“Vinicius Aguiar”, 4500, new GregorianCalendar(1992,6,13); umDepartamento.adicionaEmpregado(vinicius); Empregado carlos= new Empregado (“Carlos Ribeiro”, 5500, new GregorianCalendar(1993,7,14); umDepartamento.adicionaEmpregado(carlos); System.out.println(“Lista de Empregados”); umDepartamento.listarEmpregados(); Empregado empRemovido = umDepartamento.removerEmpregado(carlos); if ( ! (empRemovido == null) ) System.out.println(“Empregado removido = “+empRemovido.getNome()); else System.out.println(“EmpregadoInexistente. Nome = ”+carlos.getNome() ); System.out.println(“Lista de Empregados”); umDepartamento.listarEmpregados(); empRemovido = umDepartamento.removerEmpregado(carlos); if ( ! (empRemovido == null) ) System.out.println(“Empregado removido = “+empRemovido.getNome()); else System.out.println(“EmpregadoInexistente. Nome = ”+carlos.getNome() ); } }

  48. JAVA • Objetos Empacotadores (classes Wrappers): Ocasionalmente é preciso converter um tipo básico em objeto e para isso todos os tipos básicos possuem uma classe com esse fim. As classes são Integer, Long, Float, Double, Character e Boolean. Todas essas classes são do tipo final, não podendo portando ser herdada, e também formam objetos imutáveis, ou seja, não se pode alterar o valor contido em objetos destas classes. • Para se criar objetos a partir de tipos básicos utiliza-se os construtores das classes. Por exemplo, new Integer( 5 ) ou new Float( 35.4 ) cria objetos das classes Integer e Float com os valores 5 e 35.4 respectivamente Ex. Criar um Vector com valores do tipo double • Vector v = new Vector(); • v.add( 3.14 ); // Erro ! Método add() de Vector só permite objetos • v.add(new Double(3.14) ); // Cria um objeto do tipo Double que armazena o valor 3.14 • double x = ( (Double) v.get( n ) ). doubleValue(); // Método doubleValue() para recuperar o valor • Outra Forma de converter String em tipo básico podendo conter separadores de milhares. • try { x = new DecimalFormat().parse( s.trim( ) ).doubleValue(); } • catch( ParseException e) { x = 0; } • A classe Class: A classe Class representa a identificação de tipo do objeto criado em tempo de execução. Desta forma a JVM sabe a que classe o objeto pertence e os métodos corretos. No entanto essas informações podem ser obtidas através do método getClass da classe Object que retorna um objeto da classe Class. • Ex. Empregado e; ... Class c1 = e.getClass(); • System.out.println(“Nome da classe = “+ e.getClass().getName() ); // Retorna o nome da classe • for (int i = 0 ; i < 3 ; i++) // Pode retornar um Gerente ou um Empregado como nome de classe • System.out.println( vetEmpregados[ i ].getClass().getName() + “ “+ vetEmpregados[ i ].getNome()); • Existem outras formas de se obter um objeto Class como Class.forName() e .class de um tipo

  49. JAVA • Interfaces: É a forma usada por Java para fazer herança múltipla, ou seja, um filho herdar de mais de um pai como em C++. Como exemplo, suponha que desejamos escrever uma classe genérica para ordenação de qualquer tipo de objeto java. Começamos então com uma classe abstrata Sortable que possua um método abstrato copareTo() capaz de informar se um objeto é maior, menor ou igual a outro. Em seguida criamos uma classe OrdenaObjetos qualquer que possua um método de classe ordnedar( Sortable a[ ] ) que receba um array de objetos Sortable e os ordene a partir de seus métodos compareTo(). Para isso será necessário que as classses dos objetos estendam Sortable anulando o método compareTo(). • Ex. • class Empregados extends Sortable { ... // Estendendo Sortable • public int compareTo( Sortable b ) // codificando o método compareTo() de Sortable • { Empregado emp = (Empregado) b; • if ( salario < emp.salario ) return -1; • if ( salario > emp.salario ) return 1; • return 0; } • public class TestaOrdenacao • { public static void main(String args [ ]) • { Empregado vetEmpregados = new Empregado[ 3 ]; • vetEmpregado[0] = new Empregado (“Vinicius Aguiar”, 4500, new GregorianCalendar(1992,6,13); • vetEmpregado[1] =new Empregado (“Carlos Ribeiro”, 5500, new GregorianCalendar(1993,7,14); • vetEmpregado[2] =new Empregado (“Marco Aurelio”, 3500, new GregorianCalendar(1990,4,30); • OrdenaObjetos.ordenar(vetEmpregados); ... } // passando array de Empregados (Sortable) • for ( int i = 0; i < vetEmpregados.length; i++ ) • System.out.println( vetEmpregados[ i ] ); • } • } • abstract class Sortable • { public abstract int compareTo( Sortable b ); } // método que todo Sortable deve codificar

  50. JAVA • import java.util.*; • class OrdenaObjetos { • public static void ordenar( Sortable a[ ] ) { // recebe um array de Sortable • int n = a.length; • boolean troca = true; • while ( troca ) { • troca = false; • for ( int i = 0; i < n – 1; i++ ) { • Sortable temp = a[ i ]; • if ( temp.compareTo( a[ i + 1 ] ) > 0 ) { // chama o compareTo() do Sortable correspondente • a[ i ] = a[ i + 1 ]; • a[ i + 1 ] = temp; • troca = true; } } } } } • Existe um problema em se usar classe abstrata para expressar propriedade genérica: suponha uma classe que já estenda diretamente uma outra, neste caso não seria possível estender Sortable pois em java uma classe só pode ter um pai. Ex: class ClasseFilho extends ClassePai, Sortable; ERRO ! • A interface soluciona isso e é um compromisso de que sua classe irá implementar certos métodos com a mesma assinatura definida. Inclusive utiliza-se até a palavra implements para indicaresse compromisso. • Ex. public interface Comparable // java.lang.Comparable • { pubic int compareTo(Object b); } • class ClasseFilho extends ClassePai implements Comparable, ... • Interfaces, assim como classes abstratas, também não podem ser instanciadas com new, mas podem fazer referência a objetos de classes que a implementem como se fosse uma superclasse. • Ex. class Empregado implements Comparable { . . . } • Comparable x = new Empregado( . . . ); • if ( y instanceof Comparable ) { . . . }