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