Notas de Aula - Java Escrito por 980863 Agradecimentos a Ruth pelas aulas que faltei :P Aula 1 - Caracteristicas de Java: - Linguagem orientada a objetos - Polimorfismo - Heranca Programas se dividem em dois tipos: Aplicativos e Applets Ex: Alicacao: Hello.java ========== public class hello { public void static main(){ system.out.printer("hello world") } } Compilacao e execucao: % javac Hello.java % java Hello hello world % Ex: Applet: Welcome.java import java.applet.Applet; import java.awt.Graphics; public class Welcome extends Applet { public void paint (Graphics g){ g.drawString("Welcome",25,25(; } } Compilacao: %javac Welcome.japa Adicionando num html qualquer: Sintaxe: -> basicamente igual ao C. diferencas: / - serve como div() se aplicada a inteiros if (condicao) nao pode retornar um int, como em C talvez nao tenha switch(confirmar) impressao na tela: Aplicacao: system.out.println("XXX"); Applet: g.drawString ("XXX",x,y); Tipos primitivos: Tipo Tamanho (bits) boolean 1 char 16(unicode) byte 8 short 16 int 32 long 64 float 32 double 64 Atribuicao de valores: a=b - Se a e b forem tipos primitivos, e feita uma copia - se a e b sao instancias de uma classe ou um array, ha o compartinhamento (ou seja, a e b sao apontadores para um mesmo valor) ou seja, todo objeto ja e um ponteiro de nascenca, java nao tem o conceito de "ponteiro" A passagem de parametro segue as mesmas regras. Parametros passados por primitivos sao por valor, passados por outra coisa, sao por referencia. Aula 2 ============ Classes e Objetos: Exemplo: Public class Arvore{ int height // dados da classe Nó raiz; ... ... void imprimir() {... codigo da funcao ...} //tarefas da classe } Exemplo 2: Complex! atributos: Parte Real - double Parte Imaginaria- double Metodos: - Construtor - void addto(Complex) - Complex add(Complex) ... ... (igual para todas as operacoes). - double norm() - destrutor Definicao - Complex.java public class Complex { private: double real-part; double imag-part; public: Complex(double r_p, double i_p){ real_part = r_p; imag_part = i_p; } Complex(){ Complex(0,0); } // construtor nao tem retorno void addto(Complex c){ real_part = c.real_part(); imag_part = c.imag_part(); } double real_part() {return(real_part);} double imaf_part() {return(imag_part);} Complex add(Complex c){ return new complex (real_part + c.real_part(), imag_part + c.imag_part()); } Complex norm(){ return real_part*real_part + imag_part*imag_part; } } //Public class Complex HERANCA ======= A classe complexo, por exemplo, nao possui um procedimento println. Para resolver isso, desenvolvemos a subclasse Meucomplexo, que e igual a complexo mas alem disso tem o println(). public class Meucomplexo extends complex{ pubblic: void println(){ System.out.print(real_part()); // System e uma classe, como podemos identificar pela inicial maiuscula. System.out.print(" + i"); // em java, nao podemos colocar parametros variaveis com virgula. System.out.print(imag_part()); } Meucomplexo(){super;} // para acessar metodos da superclasse que foi redefinido: super.real_part(); - java converte implicitamente subclasse para superclasse quando necessario (atribuicao, passagem de parametro) - se a e Meucomplexo, e b e Complex, pode fazer b=a;, mas nao a=b; ARRAYS ====== nao sao primitivas nem objetos a.length -> diferenca para um objeto, um array sabe seu proprio tamanho. Evita a passagem de parametros inteiros como em Pascal, so para se passar a dimensao. declaracao - int a[ ]; inicializacao: a=new int[20]; <- pode ser uma variavel ao inves de 20... (int a[]=new int [20];) Uso: a[1]=1; System.out.println(a.length); Mais dimensoes: int a[][]; a = new int [5][3]; //retangular indices de formatos estranhos: a= new int[7][] a[0]= new int[4]; a[1]= new int[2]; ... ... a[6]= new int[1]; (ps: indices sempre vao de 0 a n-1) TABELA COMPARATIVA: =================== tipo primitivo I Array I objeto copia (n compart) SIM I NAO I NAO precisa de new NAO I SIM I SIM subclasses NAO I NAO I SIM constantes (+, []) SIM I SIM I so strings STRINGS E CHARACTERS ==================== Duas classes: String e Stringbuffer (a segunda pode alterar o tamanho). char -> tipo primitivo, unicode, 16 bits Character -> Classe. Classe String: constantes: "Hello" operacao: + (concatenacao). Metodos: contrutores: String (); inicializa vazio String a,b,c; a=new String("Hello") //inicializa c/esse valor b=new String(a + "World); a=b; String(s); // faz uma copia da string s String(a); //(sendo a do tipo char[] String(a,3,5); // a = char[], 3 = tamanho? 5 = inicio? String(b); // sendo b do tipo Stringbuffer. length(); // devolve o comprimento charAt(3); // devolve o terceiro caractere. getChars(3,5,a,0); comparacao equals(s); esqualIgnoreCase(s); compareTo(s); //-1, 0, +1, ordem alfabetica. indexOf(a); procura char lastIndexOf(a); substring( ); concat(s); replace(?); toUpperChar(); Classe StringBuffer: alem dos metodos anteriores metodos: length(); capacity(); setLength(); ensureCapacity(); setcharAt reverse append etc... Classe Character: Versao classe do primitivo Char. Cada primitivo tem uma versao classe sua. boolean - Boolean int - Integer float - Float LISTA LIGADA EM JAVA =================== 3 arquivos - 4 classes list.java - ListNode que define no, e List, que define lista. EmptyListException.java - EmptyListException -> excecao ListTest.java - ListTest - uso da lista package com.deitel.jhtp2.ch17; //diretorio onde java vai colocar as coisas compiladas public class EmptyListException extends RuntimeException{ public EmptyListException(string name){ super("The "+ name" is empty"); } } class ListNode{ // nao e publica Object data; LetNode Next; //metodos: ListNode(Object o){...codigo...} ListNode(Object o, ListNode nextNode){ data=o; next=nextNode;} Object getObject(){...} ListNode getNext(){...} } public class List{ private ListNode firstNode; private ListNode lastNode; private String name; //metodos: public List(string s) public List() // usa nome default public insertAtFront public insertAtBack public removeFromFront public removeFromBack public isEmpty public print } Em detalhe: public Object removeFromBack() throws EmptyListException{ Object removeItem=null; if (isEmpty()) { throw new EmptyListException(name); } removeItem = lastNode.data; // guarda o que sera retornado no final if (firstNode.equals(lastNode)) //compara se ambos ocupam o mesmo endereco na memoria, todos os objetos ja nascem com este metodo. firstNode=lastNode=null; else { ListNode current = firstNode While (current.next != lastNode) current = current.next lastNode = current; lastNode.netx = null; } return removeItem; } como imprimeir, se o objeto data e generico: print(){ ... ... while( ) system.out.printer(current.data.toString()) //mais um metodo que todo objeto tem. Uso da Classe (de tudo o que foi feito acima): Boolean b = new Boolean(true); Character c = new Character('a'); Integer i = new Integer(5123); List objList = new List(); Saida: The list is: 5123 true a ====== try{... Object item = objList.removeFromBack(); ... } catch (EmptyListException e){ system.err.println(e.toString()); } ====== padrao de nomes para se dar a metodos: se o retorno e: Void - verbo - substantivo (que explique o que o metodo retornara). Classes abstratas e interfaces: =============================== Classes abstratas: Nao tem instancias agrupam conceitos. Interfaces: So tem constantes e metodos abstratos servem para - heranca multipla constantes compartilhadas por varios modulos passar funcoes como parametro. Classes Abstratas: Metodos abstratos - nao tem corpo - palavra reservada "abstract" ex: abstract double area(); Classe abstrata: - palavra reservada "abstract" - pode ter metodos abstratos. - nao tem instancias (new proibido) - mas objetos podem ser declarados dessas classes. ex: abstract class Shape { ... } Shape { Area() } <- abstrato Circle { Area() } Triangle { Area() } Rectangle { Area() } <- concreta, filhas de shape. Interfaces: - Todos os metodos sao abstratos - todos os atributos sao constantes. Heranca multipla: so e permitido quando temos uma superclasse normal, e uma ou mais interfaces implementadas... ex: Class X extends Y implements Z,W {... } Outros usos: - compartilhar constantes - passagem de funcoes como parametros. - Ordenacao de objetos genericos: object a[]; // tipo generico usado no exemplo da lista. Definicao: Interface CMP{ int cmp(Object x, Object y); } static void qsort (Object v[], Cmp cmp){ ... if (cmp.cmp(V[i], v[j])== -1) // quick sort totalmente generico. ... } USO: (exemplificando para comparador de inteiros) class Icmp implements Cmp{ intcmp (Object x, Object y){ int i1 = ((integer).x).intValue(); int i2 = ((integer).y),intValue(); if(i1