javaP

Prévia do material em texto

Java 
Prof. Marco Túlio Valente 
Prof. César Francisco de Moura Couto 
Prof. Pedro Felipe 
 
2 
Introdução 
§  Desenvolvida por James Gosling e equipe (Sun, 1995)‏ 
§  Linguagem compilada e posteriormente interpretada 
§  bytecode: linguagem intermediária 
§  Assembly de uma máquina hipotética 
§  Máquina Virtual Java: interpretador de bytecodes 
§  Não é novidade: Pascal-P (Wirth, década de 70)‏ 
§  Mesma estratégia em C#: CLR e CIL (ou MSIL)‏ 
§  Vantagem: portabilidade 
 
 
 COMPILADOR
MÁQUINA VIRTUAL
JAVA - JVM
(INTERPRETADOR)
prog1.class
(bytecodes)
prog1.java
(fonte)
3 
Primeiro Programa 
// arquivo HelloWorld.java 
 
public class HelloWorld { 
 public static void main(String[ ] args){ 
 System.out.println (“Hello, world”); 
 } 
} 
§  Todo arquivo deve ter uma classe pública com o mesmo 
nome do arquivo 
§  Execução começa pelo método main desta classe 
§  Observações: 
§  Programa em Java é um conjunto de classes 
§  Implementação dos métodos sempre dentro da classe 
4 
Classes 
§  Exemplo: 
class Data { 
 private int dia, mes, ano; 
 .... 
 Data(int dia, int mes, int ano) { // metodo construtor 
 this.dia= dia; this.mes= mes; this.ano= ano; 
 } 
 ...... 
 
 } 
§  Método construtor: usado para inicializar objeto 
§  Construtor tem o mesmo nome da classe 
§  this: variável automaticamente declarada em um método 
§  Referencia o objeto alvo da chamada 
 
5 
Classes 
§  Encapsulamento de membros: 
§  public: em qualquer lugar onde a classe for acessível 
§  private: apenas dentro dos métodos da classe 
§  protected: dentro dos métodos da classe, de suas 
subclasses e de classes do mesmo pacote (package)‏ 
§  vazio: por métodos de classes do mesmo pacote 
6 
Objetos 
§  Operador new: usado para instanciar um objeto 
§  Exemplo: 
 Data d1= new Data(1,2,2008); // instanciação 
 Data d2= new Data(25,12,2007); 
 d1.imprime(); // chamada de método 
§  Programas em Java possuem duas áreas de memória: 
§  Heap: onde são alocados objetos criados via new 
§  Stack: onde são alocadas variáveis locais de métodos 
ativados 
§  Dois tipos de valores podem ser armazenados no stack: 
§  Primitivos: byte,short,int,long,float,double,boolean,char 
§  Referências (ou “ponteiros”) para objetos 
§  No exemplo, d1 referencia um objeto do tipo Data 
7 
Coleta de Lixo 
§  Objetivo: Evitar que programador tenha que se preocupar 
com a liberação de memória alocada no heap 
§  Programador aloca, mas não precisa liberar memória 
§  Tarefa normalmente sujeita a diversos erros 
§  Funcionamento: 
§  Existe na JVM um processo, chamado coletor de lixo, 
que fica continuamente procurando por objetos que não 
estão sendo mais referenciados 
§  Quando encontra um objeto inacessível, o coletor de 
lixo libera a área de memória alocada para o mesmo 
§  Não se tem controle sobre o momento em que o coletor 
de lixo roda 
§  Não é uma novidade em LP: LISP, 1960 
8 
Exemplo de Coleta de Lixo 
class BigClasse { 
 private int x; 
 private int bigvetor [ ]; // vetor de inteiros 
 public BigClasse (int x1) { // construtora 
 System.out.println ("Criando " + x1); 
 x= x1; 
 bigvetor= new int [1024*1024]; 
 } 
 protected void finalize () { 
 System.out.println("Eliminando " + x); 
 } 
} // BigClasse 
9 
Exemplo de Coleta de Lixo 
public class Exemplo2 { 
 public static void main(String[] args) { 
 BigClasse p; 
 for (int i= 0; i < 100; i++) ‏ 
 p= new BigClasse (i); 
 } 
} 
§  Método finalize(): chamado automaticamente pelo coletor 
antes de liberar a área de memória de um objeto 
§  Utilidade: liberar outros recursos (que não memória)‏ 
§  Exemplo: fechar arquivos, fechar conexões etc 
§  Chamado no máximo uma vez por objeto, mesmo que sua 
execução “ressucite” o objeto 
§  Não se garante que o método finalize será executado 
10 
Atributos Estáticos 
§  Pertencem à classe e não a cada objeto individualmente 
§  Exemplo: 
 class Conta { ...... 
double saldo; 
 static double saldoMinimo= 500; ..... 
} 
§  Externamente, são acessados via nome da classe 
§  Exemplo: System.out.prinln(Conta.saldoMinimo); 
§  Atributos estáticos e finais: são constantes 
§  Não podem ser alterados, após terem sido inicializados 
§  Exemplo: 
 class Math { ...... 
 public static final double PI = 3.1415; 
} 
11 
Métodos Estáticos 
§  Pertencem à classe e, portanto, não são invocados sobre 
um objeto alvo 
§  Exemplo: 
 class Math { ... 
 public static double sin (double x) { ... } 
 } ..... 
 double x= Math.sin (90); 
§  Podem acessar apenas atributos e métodos estáticos 
§  Não podem acessar a referência this 
 
 
12 
Passagem de Parâmetros e Sobrecarga 
§  Passagem de parâmetros: 
§  Sempre por valor 
§  Mesmo que o parâmetro seja uma referência para um 
objeto (e essa referência seja usada no corpo do 
método para alterar o estado do objeto no heap)‏ 
§  Métodos (e construtores) sobrecarregados: 
§  Mesmo nome 
§  Número e tipos de parâmetros diferentes 
§  Para fins de sobrecarga, não se considera o tipo de retorno 
e as exceções levantadas pelo método 
§  Sobrecarga: polimorfismo ad-hoc 
13 
Herança 
§  Java possui Herança Simples 
 class Figura { 
 .... 
 } 
 class Quadrado extends Figura { 
 ... 
 } 
§  Classe Object: raiz da hierarquia de classes de Java 
§  Toda classe (diretamente ou indiretamente) é subclasse de 
Object 
§  Utilidade: variável do tipo Object pode se referir a qualquer 
objeto (de qualquer classe)‏ 
§  Exemplo: void push(Object item) 
14 
Redefinição de Métodos 
§  Quando uma subclasse reimplementa um método herdado 
da superclasse 
§  Reimplementação deve manter assinatura da superclasse 
(regra da invariância)‏ 
§  Exemplo: 
 
public class Superclass { 
 public void printMethod() { 
 System.out.println("Printed in Superclass."); 
 } 
} 
 
 
15 
Redefinição de Métodos 
public class Subclass extends Superclass { 
 public void printMethod() { // redefinição 
 super.printMethod(); // acesso a método da superclasse 
 System.out.println("Printed in Subclass"); 
 } 
 public static void main(String[] args) { 
 Subclass s = new Subclass(); 
 s.printMethod(); 
 } 
} 
 
16 
Classes e Métodos final 
§  Evitando herança: 
final class Senha { ... } 
class MinhaSenha extends Senha { ... } // Erro ! 
 
§  Evitando redefinição de métodos: 
class Senha { ...... 
 public final bool validarSenha () { ..... } 
 .... 
 } 
 class MinhaSenha extends Senha { ...... 
 bool validarSenha () { ...... } // Erro ! 
 ..... 
 } 
 
17 
Chamada Dinâmica de Métodos 
§  Métodos são chamados utilizando o tipo dinâmico de uma 
referência. 
§  Exemplo: 
 Figura p; 
if ( .... )‏ 
 p= new Quadrado (4); // atribuição polimórfica 
else p= new Circulo (3); // atribuição polimórfica 
double a= p.area (); 
18 
Classes Abstratas 
§  Exemplo: 
abstract class Figura { 
 public abstract double area (); 
 public abstract double perimetro (); 
} 
§  Implementação de area() e perimetro() ficará a cargo das 
subclasses de Figura. 
19 
Packages 
§  Recurso para modularização de programas Java 
§  Package: conjunto de arquivos 
§  Cada arquivo pode possuir, no máximo, uma classe 
pública 
§  O nome do arquivo é o mesmo de sua classe pública 
§  Todo pacotepossui um nome 
§  Exemplo: pacote figuras, com classes públicas Figura, 
Circulo, Quadrado 
§  Arquivo c:\temp\figuras\Figura.java: 
package figuras; 
public abstract class Figura { ...... } 
// outras classes (não-públicas)‏ 
20 
Packages 
§  Exemplo (continuação): 
§  Arquivo c:\temp\figuras\Circulo.java 
package figuras; 
public class Circulo { ...... } 
// outras classes (não-públicas)‏ 
§  Arquivo c:\temp\figuras\Quadrado.java 
package figuras; 
public class Quadrado { ...... } 
// outras classes (não-públicas)‏ 
§  Nome do pacote deve ser igual ao nome do diretório que 
contém seus arquivos 
§  Variável de ambiente CLASSPATH: deve conter o nome 
do diretório onde se encontra o diretório do pacote 
§  Exemplo: set CLASSPATH=%CLASSPATH%;c:\temp 
21 
Packages 
§  Classes públicas de um pacote podem ser usados fora do 
pacote da seguinte forma: 
§  Via qualificação com o nome do pacote: 
figuras.Figura fig; 
figuras.Circulo c; 
java.awt.Button btnOk; 
§  Via comando import no início doarquivo: 
import figuras.*; // importa todas classes do pacote figuras 
import java.awt.Button; // importa apenas classe Button 
.......... 
Figura fig; 
Circulo c; 
Button btnOk; 
22 
Interfaces 
§  Uma interface é um tipo (assim como uma classe)‏ 
§  Uma interface define apenas a assinatura de um conjunto 
de métodos (ou seja, são similares a classes abstratas) ‏ 
§  Uma classe pode declarar que implementa (implements) 
uma interface 
§  Neste caso, ela assume o compromisso de implementar 
todos os métodos desta interface 
§  Exemplo: 
interface Comparavel { 
 int compare(Comparavel obj); 
} 
23 
Interfaces 
§  Exemplo: 
class Aluno extends Pessoa implements Comparavel { 
 int compare(Comparavel obj) { 
 Aluno obj2= (Aluno) obj; 
 “compara this.matr com obj2.matr; retorna –1, 0 ou 1” 
 } 
} 
§  Exemplo: suponha um método de ordenação 
§  void ordena(Comparavel [] lista)‏ 
§  Qual a vantagem em relação a uma classe abstrata? 
§  Se Comparavel fosse uma classe abstrata, Aluno não 
poderia herdar de Pessoa 
§  Uma classe pode implementar mais de uma interface 
24 
Classes Genéricas 
§  Motivação: 
List v = new ArrayList(); // List é uma lista de Object 
v.add("test"); 
String a = (String) v.get(0); 
Integer b = (Integer) v.get(0); // erro em tempo de execução 
§  Usando classes genéricas: 
// List agora é uma lista de strings 
List <String> v = new ArrayList <String> (); 
v.add("test"); 
String a = v.get(0); 
Integer b = v.get(0); // errro em tempo de compilação 
 
25 
Classes Genéricas 
§  Declarando uma classe genérica: 
 
class Pair <T, S> { 
 private T first; 
 private S second; 
 public Pair(T f, S s) { 
 first = f; second = s; 
 } 
 public T getFirst() { return first; } 
 public S getSecond() { return second; } 
 public String toString(){ 
 return "("+first.toString()+", "+second.toString()+")"; 
 } 
} 
26 
Classes Genéricas 
§  Usando uma classe genérica: 
Pair<String, String> p1=new Pair<String, String>(“maria", "A"); 
Pair<String, Integer> p2=new Pair<String, Integer>(“maria", 100); 
System.out.println("P1:"+p1.toString()); 
System.out.println("P2:"+p2.toString()); 
27 
Classe Interna 
public class Swinggy extends JFrame { 
 public Swinggy() { 
 ... 
 JButton b1 = new JButton("Sair"); 
 ActionListener listener = new Eco(); 
 b1.addActionListener(listener); 
 } 
 //classe interna 
 class Eco implements ActionListener{ 
 public void actionPerformed(ActionPerformed e) { 
 tf.setText(e.getActionCommand()); 
 } 
 } 
} 
 
28 
Classe Anônima 
public class Swinggy extends JFrame { 
 public Swinggy() { 
 ... 
 JButton b1 = new JButton("Sair"); 
 b1.addActionListener(new ActionListener() { 
 public void actionPerformed(ActionEvent e) { 
 tf.setText(e.getActionCommand()); 
 } 
 }); 
}