Link para o material da apresentação

Transcrição

Aula 1
Introdução à Programação
Orientada a Objetos e Java
Rafael Santos
Janeiro/Fevereiro 2010
http://www.lac.inpe.br/~rafael.santos
1 / 88
Apresentação
●
Curso
–
–
–
●
Instrutor
–
●
Rafael Santos: [email protected]
Material
–
●
Parte 1: Orientação a Objetos e Java
Parte 2: IO, Sockets e rede, Threads, Texto, Estruturas de
Dados.
Parte 3: Interfaces gráficas, componentes, aplicações desktop
completas.
www.lac.inpe.br/~rafael.santos/ → Ensino
Metodologia
2 / 88
Metodologia
3 / 88
A Linguagem Java
4 / 88
Por quê Java?
●
●
●
●
●
●
●
Simples.
Portátil (entre sistemas operacionais).
Diferentes aplicações (desktop, web, com algumas
restrições).
Padrão ”aberto”.
Flexível (Várias APIs - Application Programming Interfaces).
Conhecida e consolidada.
Decisão de linguagem em projetos ou empresas envolve
muitas variáveis!
5 / 88
Linguagem x Tecnologia
Java technology opens up a wealth of exciting possibilities for consumers. It enables just about any application including games, tools, and information programs and services to run on just about any computer or device. From desktop PCs to mobile handheld devices and cell phones, Java technology today is just about everywhere.
6 / 88
Tecnologia Java
7 / 88
http://java.sun.com/new2java/javamap/intro.html
Tecnologia Java
8 / 88
Tecnologia Java
●
Máquinas Virtuais
–
–
–
–
●
Navegadores: applets.
Desktop: download, Java Web Start, instaladores.
Servidores: JSP/Servlets, frameworks.
Dispositivos móveis.
Mesma base de código.
9 / 88
Showcase
●
Aerith (https://aerith.dev.java.net/): Mashup para criação de slideshows
georeferenciados.
10 / 88
Showcase
●
Projeto Looking Glass
(http://www.sun.com/software/looking_glass/index.jsp): Desktops em 3D.
11 / 88
Showcase
●
A interface do Maple (http://www.maplesoft.com/) é em Java.
12 / 88
Showcase
●
Oculus (http://www.oculusinfo.com): visualização científica (API).
13 / 88
Showcase
●
NIRView (http://www.nirview.com): visualização e exploração em 2D/3D de
campos de força de estações de telecomunicações.
14 / 88
Showcase
●
Radio Explorer (http://www.radioexplorer.com.ru/en): exibe/visualiza
horários de transmissão internacionais de rádio.
15 / 88
Showcase
●
NASA World Wind (http://worldwind.arc.nasa.gov/java e
http://worldwindcentral.com/wiki/Java): SDK para desenvolvimento de
aplicações de visualização da Terra.
16 / 88
Showcase
●
OS MasterMap Viewer
(http://www.snowflakesoftware.co.uk/products/viewer/index.htm):
exibe/visualiza alguns tipos de arquivos de topologia/GML.
17 / 88
Showcase
●
yEd (http://www.yworks.com/en/products_yed_about.htm): visualização de
vários tipos de dados com estrutura de grafos.
18 / 88
Showcase
●
JUNG - The Java Universal Network/Graph Framework
(http://jung.sourceforge.net/): visualização de grafos.
19 / 88
Showcase
●
JGraph (http://www.jgraph.com) / SQL Developer (http://www.solyp.de/):
administração de bancos de dados.
20 / 88
Showcase
●
JGraph (http://www.jgraph.com) / CAOS (Comodity AudiO System,
http://www.ife.ee.ethz.ch/): gerenciamento de clusters para processamento
de áudio.
21 / 88
Showcase
●
JGraph (http://www.jgraph.com) / ImageApp
(http://imageapp.sourceforge.net/v3.0/main.php): programação visual para
processamento de imagens.
22 / 88
Showcase
●
Force Field Explorer (http://dasher.wustl.edu/ffe): visualização e
exploração para química/biologia/nanotecnologia (GUI em Java3D, pacote
Tinker em Fortran)
23 / 88
Showcase
●
PathwayExplorer (http://www.genostar.org): análise funcional genômica.
24 / 88
Showcase
●
Sketsa SVG Editor (http://www.kiyut.com/products/sketsa/index.html):
Edição de arquivos SVG.
25 / 88
Showcase
●
●
Mozilla Rhino (http://www.mozilla.org/rhino): Implementação de JavaScript
em Java.
The Flying Saucer Project (https://xhtmlrenderer.dev.java.net/):
Renderização de XML/HTML/CSS 2.1.
26 / 88
Showcase
●
BD-J (http://www.blueboard.com/bluray/pdf/javaone2006_ts1685_v2.pdf):
Interatividade em discos Blu-Ray usando Java.
27 / 88
Showcase
●
Insider for Oracle (http://www.fourthelephant.com/insider.html):
monitoramento e gerenciamento de bancos de dados Oracle em tempo
real.
28 / 88
Showcase
●
ThinkFree Office (http://product.thinkfree.com/): Office em Java.
29 / 88
Showcase
●
Sferyx JSyndrome HTMLEditor Applet Edition
(http://www.sferyx.com/index.htm): edição de HTML.
30 / 88
Showcase
●
jxProject (http://www.jxproject.com/index.shtml): gerenciamento de
projetos e tarefas.
31 / 88
Showcase
●
Project Sun SPOT (http://www.sunspotworld.com/): hardware programável
em Java.
32 / 88
Showcase
●
Perrone Robotics (http://www.perronerobotics.com/) e Team Jefferson
(http://teamjefferson.com/): robôs autônomos.
33 / 88
Showcase
●
Maestro (http://mars.telascience.org/home): Interface para análise/controle
dos robôs em Marte.
34 / 88
Showcase
●
Ultra Mixer (http://www.ultramixer.com): Software para DJ profissionais.
35 / 88
Showcase
●
JPC (http://www-jpc.physics.ox.ac.uk/home_home.html): Emulador x86 em
Java.
36 / 88
Showcase
●
Wurm Online (http://www.wurmonline.com): Massively Multiplayer Online
Role Playing Game.
37 / 88
Showcase
●
Puzzle Pirates (http://www.puzzlepirates.com): Massively Multiplayer
Online Role Playing Game.
38 / 88
Orientação a Objetos e Java
39 / 88
Orientação a Objetos
●
●
●
Orientação a Classes?
Classes são descritas em Java para representar modelos ou
conceitos.
Objetos ou Instâncias são criados ou instanciados a partir
das classes.
–
–
●
Uma classe pode ser usada para criar muitos objetos.
–
●
Criação pela palavra-chave new.
Referências são usadas para acesso aos objetos.
Os atributos de cada objeto serão independentes.
Exemplos puramente abstratos e discussão.
40 / 88
Orientação a Objetos: Encapsulamento
●
●
●
Classes contém campos ou atributos e métodos.
Atributos são usados para armazenar estado (valores)
relacionados com as instâncias das classes.
Métodos são operações que podem ser realizadas com
estes atributos.
–
●
Construtores são métodos declarados de forma especial,
serão os primeiros* a ser executados quando instâncias
forem criadas.
Em princípio, ocultamos os atributos mas permitimos a
operação via métodos.
41 / 88
●
Atributos e funções relevantes a um domínio ou problema
são encapsulados em uma classe de forma que:
–
–
Somente atributos e funções relevantes sejam representados;
Uma interface seja criada para que usuários/desenvolvedores
tenham acesso somente a funções e atributos que podem
ser acessados diretamente.
42 / 88
●
Exemplo simples: Conta Bancária.
–
–
Queremos armazenar os dados da conta.
Queremos ser capazes de efetuar operações com os dados da
conta (alguns podem ser modificados, outros não, alguns
ainda somente sob certas condições)...
●
Não é científico, mas exemplifica as idéias.
●
Notas:
–
–
–
O dilema do ensino de programação.
Aprendizado incremental – erros e decisões incorretas!
Sintaxe de Java.
43 / 88
class ContaBancaria1
{
String nomeCorrentista;
double saldo;
ContaBancaria1(String n, double s)
{
nomeCorrentista = n;
saldo = s;
}
double getSaldo()
{
return saldo;
}
String getNome()
{
return nomeCorrentista;
}
void deposita(double quantia)
{
saldo = saldo + quantia;
}
void retira(double quantia)
{
if (quantia < saldo) saldo = saldo - quantia;
}
}
44 / 88
class ContaBancaria1
{
String nomeCorrentista;
double saldo;
ContaBancaria1(String n, double s)
{
saldo = s;
}
double getSaldo()
{
return saldo;
}
String getNome()
{
return nomeCorrentista;
}
void deposita(double quantia)
{
}
void retira(double quantia)
{
if (quantia <= saldo) saldo = saldo - quantia;
}
}
45 / 88
●
Uma aplicação que usa a classe:
class UsaContaBancaria1
{
public static void main(String[] args)
{
ContaBancaria1 fred = new ContaBancaria1("Fred",1000);
ContaBancaria1 richard = new ContaBancaria1("Richard",2000);
richard.retira(500);
fred.deposita(500);
}
}
46 / 88
●
Algumas restrições e erros:
class UsaContaBancaria1ComErros
{
{
ContaBancaria1 fred = new ContaBancaria1("Fred"); // Falta parâmetro!
ContaBancaria1 richard =
new ContaBancaria1(2000,"Richard"); // Ordem incorreta!
richard.retira(); // Quanto?
fred.desfalca(500); // O quê??
richard.saldo = 1000000; // oops - isto não é um erro!
}
}
●
E o encapsulamento?
47 / 88
public class ContaBancaria2
{
private String nomeCorrentista;
private double saldo;
public ContaBancaria2(String n, double s)
{
saldo = s;
}
public double getSaldo()
{ return saldo; }
public String getNome()
{ return nomeCorrentista; }
public void deposita(double quantia)
{
}
public void retira(double quantia)
{
}
}
48 / 88
{
{
richard.retira(500);
fred.deposita(500); // ok
richard.saldo = 1000000; // Erro de compilação!
}
}
49 / 88
●
Melhorias incrementais
{
{
saldo = s;
}
{ return saldo; }
{
}
{
}
50 / 88
public void transfereDe(ContaBancaria3 de,double quanto)
{
deposita(quanto);
Má idéia. Por quê?
de.retira(quanto);
}
public String toString()
{
return "Conta de "+nomeCorrentista+" tem saldo "+saldo;
}
}
51 / 88
{
{
System.out.println(fred);
System.out.println(richard);
fred.transfereDe(richard,400);
}
}
Conta
Conta
Conta
Conta
de
de
de
de
Fred tem saldo 1000.0
Richard tem saldo 2000.0
52 / 88
Orientação a Objetos: Sobrecarga de Métodos
{
{
saldo = s;
}
public ContaBancaria4(String n)
{
this(n,0);
}
{ return saldo; }
{
}
53 / 88
{
}
public void transfereDe(ContaBancaria4 de,double quanto)
{
deposita(quanto);
de.retira(quanto);
}
public void transfereDe(ContaBancaria4 de)
{
double quanto = de.getSaldo();
deposita(quanto);
de.retira(quanto);
}
{
return "Conta de "+nomeCorrentista+" tem saldo "+saldo;
}
}
54 / 88
{
{
ContaBancaria4 fred = new ContaBancaria4("Fred");
fred.transfereDe(richard);
}
}
Conta
Conta
Conta
Conta
Conta
Conta
de
de
de
de
de
de
Fred tem saldo 0.0
55 / 88
Comentários
●
●
●
Vantagens e desvantagens do encapsulamento.
Tendência a escrever mais do que o necessário.
Conheça a linguagem!
–
–
–
–
–
meuMétodo(int a)
meuMétodo(int a,int b)
meuMétodo(int a,int b,int c)
meuMétodo(float a)
...
56 / 88
Métodos e Atributos Estáticos
57 / 88
●
Atributos compartilhados entre instâncias.
public class ContaBancariaEstatica
{
private static int contadorGeral = 1;
private int número;
public ContaBancariaEstatica(String n, double s)
{
saldo = s;
número = contadorGeral++;
}
{ return saldo; }
{
return "Conta "+número+" de "+nomeCorrentista+" tem saldo "+saldo;
}
}
58 / 88
class UsaContaBancariaEstatica
{
{
ContaBancariaEstatica fred = new ContaBancariaEstatica("Fred",1000);
ContaBancariaEstatica richard =
new ContaBancariaEstatica("Richard",2000);
}
}
Conta 1 de Fred tem saldo 1000.0
Conta 2 de Richard tem saldo 2000.0
59 / 88
●
Explicação sobre o método main:
{
{
}
}
60 / 88
●
●
Métodos estáticos: uso em coleções de funções genéricas.
Exemplo: classe Math.
public final class Math // editada para simplificar
{
/**
* Don't let anyone instantiate this class.
*/
private Math() {}
public static final double E = 2.7182818284590452354;
public static final double PI = 3.14159265358979323846;
public static double toRadians(double angdeg) {
return angdeg / 180.0 * PI;
}
public static double toDegrees(double angrad) {
return angrad * 180.0 / PI;
}
61 / 88
Herança e Interfaces
62 / 88
Composição
●
Conceito Básico: reuso de classes.
import java.util.Date;
public class Pessoa
{
private String nome;
private int identidade;
private Date nascimento;
public Pessoa(String n,int i,Date d)
{
nome = n; identidade = i; nascimento = d;
}
{
return "Nome: "+nome+"\nIdentidade: "+identidade+" "+
"\nData de Nascimento: "+nascimento;
}
}
63 / 88
Herança
●
Novas classes a partir de existentes:
public class Funcionario extends Pessoa
{
private Date admissão;
private float salário;
public Funcionario(String nome,int id,Date nasc,Date adm,float sal)
{
super(nome,id,nasc);
admissão = adm;
salário = sal;
}
{
String resultado;
resultado = super.toString()+"\n"; // chama o método toString da classe Pessoa
resultado = resultado + "Data de admissão: "+admissão+"\n";
resultado = resultado + "Salário: "+salário;
return resultado;
}
public float qualSalário() { return salário; }
}
64 / 88
Herança
public class UsaPessoa
{
{
Pessoa p =
new Pessoa("Matthew",1212612,new Date(70,9,5)); // 5 de Outubro! de 1970
System.out.println(p);
Funcionario f =
new Funcionario("Matthew",1212612,new Date(70,9,5),
new Date(90,11,3),2000f);
System.out.println(f);
}
}
Nome: Matthew
Identidade: 1212612
Data de Nascimento: Mon Oct 05 00:00:00 BRT 1970
Nome: Matthew
Identidade: 1212612
Data de admissão: Mon Dec 03 00:00:00 BRST 1990
Salário: 2000.0
65 / 88
Herança
public class ChefeDeDepartamento extends Funcionario
{
private String departamento;
private Date promoçãoAChefe;
public ChefeDeDepartamento(String nome,int id,Date nasc,
Date adm,float sal,
String dep,Date prom)
{
super(nome,id,nasc,adm,sal);
departamento = dep;
promoçãoAChefe = prom;
}
{
String resultado;
resultado = super.toString()+"\n";
resultado = resultado + "Departamento:"+departamento+"\n";
resultado = resultado + "Data de promoção ao cargo:"+promoçãoAChefe;
return resultado;
}
}
66 / 88
Herança
public class UsaPessoa2
{
{
Pessoa p =
new Pessoa("Matthew",1212612,new Date(70,9,5)); // 5 de Outubro! de 1970
System.out.println(p);
Funcionario f =
new Funcionario("Matthew",1212612,new Date(70,9,5),new Date(90,11,3),2000f);
System.out.println(f);
ChefeDeDepartamento c =
new ChefeDeDepartamento("Matthew",1212612,new Date(70,9,5),
new Date(90,11,3),2000f,
"Contabilidade",new Date(100,0,1));
System.out.println(c);
Nome: Matthew
}
Identidade: 1212612
}
Nome: Matthew
Identidade: 1212612
Salário: 2000.0
Nome: Matthew
Identidade: 1212612
Salário: 2000.0
Departamento:Contabilidade
Data de promoção ao cargo:Sat Jan 01 00:00:00 BRST 2000
67 / 88
Herança Múltipla
●
●
●
Não podemos escrever X extends A, B.
Existem várias possibilidades de confusão.
Herança múltipla pode ser (parcialmente) simulada com
interfaces.
68 / 88
Interfaces
●
Contratos para classes:
–
Herdeiras devem implementar os métodos ou ser declaradas
abstratas.
69 / 88
Interfaces
public class Ponto2D
{
private double x,y;
public Ponto2D(double _x,double _y)
{
x = _x;
y = _y;
}
public boolean éIgual(Ponto2D outroPonto2D)
{
if ((x == outroPonto2D.x) && (y == outroPonto2D.y)) return true;
else return false;
}
public static Ponto2D origem()
{
return new Ponto2D(0,0);
}
public double getX() { return x; }
public double getY() { return y; }
{
return "("+x+","+y+")";
}
}
70 / 88
Interfaces
public interface ObjetoGeometrico
{
public Ponto2D centro();
public double calculaÁrea();
public double calculaPerímetro();
}
71 / 88
Interfaces
public class Circulo implements ObjetoGeometrico
{
private Ponto2D centro;
private double raio;
public Circulo(Ponto2D centro,double raio)
{
this.centro = centro;
this.raio = raio;
}
public Ponto2D centro() { return centro; }
public double calculaÁrea() { return Math.PI*raio*raio; }
public double calculaPerímetro() { return 2.0*Math.PI*raio; }
{
return "Círculo com centro em "+centro+" e raio "+raio;
}
}
72 / 88
Interfaces
public class Retangulo implements ObjetoGeometrico
{
private Ponto2D primeiroCanto,segundoCanto;
public Retangulo(Ponto2D pc,Ponto2D sc)
{
primeiroCanto = pc;
segundoCanto = sc;
}
public Ponto2D centro()
{
double coordX = (primeiroCanto.getX()+segundoCanto.getX())/2.;
double coordY = (primeiroCanto.getY()+segundoCanto.getY())/2.;
return new Ponto2D(coordX,coordY);
}
public double calculaÁrea()
{
double ladoX = Math.abs(primeiroCanto.getX()-segundoCanto.getX());
double ladoY = Math.abs(primeiroCanto.getY()-segundoCanto.getY());
return ladoX*ladoY;
}
73 / 88
Interfaces
public double calculaPerímetro()
{
double ladoX = Math.abs(primeiroCanto.getX()-segundoCanto.getX());
double ladoY = Math.abs(primeiroCanto.getY()-segundoCanto.getY());
return 2*ladoX+2*ladoY;
}
{
return "Retângulo com cantos "+primeiroCanto+" e "+segundoCanto;
}
}
74 / 88
Interfaces
public class UsaObjetosGeometricos
{
public static void main(String[] argumentos)
{
Circulo c1 = new Circulo(new Ponto2D(0,0),100); // centrado na origem, raio 100
Circulo c2 = new Circulo(new Ponto2D(-1,-1),1); // centrado em (-1,-1), raio 1
Retangulo r1 = new Retangulo(new Ponto2D(-2,-2), // um canto está em (-2,-2)
new Ponto2D(2,2)); // e o outro em (2,2)
Retangulo r2 = new Retangulo(new Ponto2D(-100,-1), // um canto está em (-100,1)
new Ponto2D(100,1)); // e o outro em (100,1)
System.out.println(c1);
System.out.println(c2);
System.out.println(r1);
System.out.println(r2);
}
}
Círculo com centro em (0.0,0.0) e raio 100.0
Círculo com centro em (-1.0,-1.0) e raio 1.0
Retângulo com cantos (-2.0,-2.0) e (2.0,2.0)
Retângulo com cantos (-100.0,-1.0) e (100.0,1.0)
75 / 88
Interfaces
public interface ObjetoEscalavel
{
public void amplia(double escala);
public void espelha();
}
public class CirculoEscalavel implements ObjetoGeometrico,ObjetoEscalavel
{
private Ponto2D centro;
private double raio;
public CirculoEscalavel(Ponto2D centro,double raio)
{
this.raio = raio;
}
{
return centro;
}
76 / 88
Interfaces
{ return Math.PI*raio*raio; }
public double calculaPerímetro()
{ return 2.0*Math.PI*raio;
}
public void amplia(double escala)
{
raio *= escala;
}
public void espelha()
{
centro = new Ponto2D(-centro.getX(),centro.getY());
}
{
}
}
77 / 88
Comentários
●
●
●
Vantagens e desvantagens do uso de heranças.
Novamente tendência a escrever mais do que o necessário e
a fragmentar funcionalidade em múltiplas classes com
herança.
Mais uso de classes prontas do que desenvolvimento de
ancestrais.
78 / 88
Polimorfismo
79 / 88
Polimorfismo
●
Polimorfismo (“muitas formas”): classes que herdam de uma
ancestral são-um-tipo-de ancestral.
class UsaCirculoEscalavel
{
public static void main(String[] argumentos)
{
CirculoEscalavel ce = new CirculoEscalavel(new Ponto2D(10,10),30);
System.out.println(ce);
ce.amplia(3);
ce.espelha();
// É uma instância da classe CirculoEscalavel ?
System.out.println(ce instanceof CirculoEscalavel); // true
// É uma instância da interface ObjetoGeometrico ?
System.out.println(ce instanceof ObjetoGeometrico); // true
// É uma instância da interface Escalavel ?
System.out.println(ce instanceof ObjetoEscalavel); // true
}
}
80 / 88
Comentários
●
●
●
Implicações de Polimorfismo.
Todas as classes herdam de Object.
Vantagens e desvantagens.
81 / 88
Pacotes e Visibilidade
82 / 88
●
Pacotes são formas de organizar classes em grupos
similares.
–
●
●
Mapeamento para diretórios.
Até agora tudo simples: todas as classes estão em um
mesmo pacote anônimo.
Todas as classes em um mesmo pacote são acessíveis pelas
outras.
83 / 88
●
Pacote geometria.
package geometria;
public class Circulo implements ObjetoGeometrico
{
protected Ponto2D centro;
protected double raio;
public Circulo(Ponto2D centro,double raio)
{
this.raio = raio;
}
{ return centro;
}
{ return Math.PI*raio*raio; }
public double calculaPerímetro() { return 2.0*Math.PI*raio; }
{
}
}
84 / 88
package minhaApp;
import geometria.Circulo;
import geometria.Ponto2D;
public class MeuCirculo extends Circulo
{
private int id;
public MeuCirculo(Ponto2D centro, double raio,int id)
{
super(centro, raio);
Deve chamar o construtor!
this.id = id;
}
{
return "Círculo com ID "+id+", centro em "+centro+" e raio "+raio;
}
}
85 / 88
●
Algumas regras são mais complicadas, ex. envolvendo
superposição (herdeiras não podem ser mais restritas).
package minhaApp;
import geometria.Circulo;
import geometria.Ponto2D;
public class CirculoAproximado extends Circulo
{
// O construtor paramétrico deve existir.
public CirculoAproximado(Ponto2D centro, double raio)
{
super(centro, raio);
}
{
return 3.14*raio*raio;
}
protected double calculaPerímetro() // Erro de compilação!
{
return 3.14*Math.PI*raio;
}
}
86 / 88
●
Modificadores de acesso para uso:
private
protected
default
public
Métodos na mesma classe
Sim
Sim
Sim
Sim
Métodos em classes herdeiras
Não
Sim
Sim
Sim
Métodos em outras classes do mesmo pacote
Não
Não
Sim
Sim
Métodos em outras classes em outro pacote
Não
Não
Não
Sim
Deve ser evitado
●
Regra mais simples: usar somente public e private.
87 / 88
●
●
●
Dicas e truques para organização em pacotes.
Considerar necessidade de protected – métodos get e
set podem ser usados.
Vantagens e desvantagens.
88 / 88

Link para o material da apresentação

Transcrição

Documentos relacionados

Casa de Campo São Rafael

Casa de Campo São Rafael

Ingresso em 2012. Candidatos aprovados para matrícul

FÁBRICA DE LEITE EM PÓ

Christiane Anneliese G. von Wangenheim.xlsx

Programa de Pós-Graduação em Estudos Contemporâneos das

Transferência e Portador de Diploma para o Curso de - PUC-SP

139 Lac caninum como tratamento homeopático de

Laboratórios Virtuais

Seagate Crystal Reports