Este documento apresenta os principais tópicos sobre desenvolvimento de software orientado a objetos em Java. Discute conceitos como classes, objetos, herança, encapsulamento e polimorfismo. Também aborda tópicos como arrays, exceções, tipos genéricos e pacotes no Java. O documento serve como um guia introdutório para o desenvolvimento de aplicações orientadas a objetos usando a linguagem Java.

1. 1
Desenvolvimento
de Software (2011)
Especialização em Projeto e Desenvolvimento de Sistemas
PhD Vagner Figueredo de Santana

2. 2
Objetivo da disciplina
 Desenvolver software básico (em Java)
 Utilizando boas práticas de programação

3. 3
Conteúdo programático
 Implementação de conceitos de
Orientação a Objetos (OO)
 Desenvolvimento de soluções
computacionais stand-alone (em Java)

4. 4
Avaliação
 Um projeto
 Grupo de até 4 pessoas
 Conceitos possíveis: A, B, C e R
 Compõem o conceito
 Apresentação
 Código
 Enviar projeto por email até a data de
apresentação

5. 5
Avaliação - Apresentação
 Tempo (25 min. no máximo)
 Utilização dos termos de OO discutidos
 Clareza e didática da apresentação
 Legibilidade
 Carga de trabalho dos componentes do
grupo

6. 6
Avaliação - Código
 Estrutura/modelagem/arquitetura do trabalho
 Clareza, legibilidade do código e
documentação
 Manipulação de exceções
 Interface de usuário
 Carga de trabalho dos componentes do grupo

7. 7
Introdução
 A linguagem que utilizamos influencia a
maneira como vemos o mundo
 A linguagem de programação usada para
resolver um problema vai influenciar na
solução usada

8. 8
Introdução
 Orientação a Objetos (OO) também é um
paradigma de programação
 ... mas o que é paradigma?

9. 9
Paradigma de programação
 Conceitualizar:
 ... o que significa computar
 ... construção e organização de tarefas
 ... como tarefas são executadas por um
computador

10. 10
Programação Orientada a Objetos
 O que é uma linguagem de programação
orientada a objetos?

11. 11
Programação Orientada a Objetos
 É mais do que incluir coisas em uma
linguagem de programação
 POO é uma forma de pensar em como
decompor problemas e resolvê-los
computacionalmente
 ... mas POO é melhor que as outras?

12. 12
Um pouco de história
 Conjectura/Hipótese de Alonzo Church, 1960s
 Qualquer função computável pode ser processada
por uma Máquina de Turing
 Prova de Böhm, 1966
 Uma Máquina de Turing pode ser emulada por
qualquer linguagem de programação que conte, no
mínimo, com um condicional (e.g., if) e um laço
(e.g., for)

13. 13
Por quê POO?
 POO facilita a resolução de problemas e
gerenciamento de grandes projetos de
software
 Escala bem
 Tem foco na reutilização de componentes
 É baseada em uma metáfora (Qual?)
 ... mas POO não é mágica

14. 14
Objeto
 Conta com:
 Dados (i.e., attributos)
 Operações (i.e., métodos)
 Tudo é objeto!
 Atributos: “Memória” dos objetos e também são
objetos
 Métodos: Algoritmos ou conjunto de operações para
uma dada requisição

15. 15
Classe
 Categoria que representa um grupo de
objetos similares

16. 16
Instância
 Objeto que representa uma classe
 Um exemplar da classe

17. 17
Programas que
seguem OO são:
 Organizados como objetos que interagem
entre si
 Cada um oferecendo um conjunto de
métodos para outros objetos
 Usando solicitações para que objetos
alterem seus próprios dados

18. 18
Tríade
 Herança
 Organização em que atributos e métodos são
automaticamente disponibilizadas para qualquer
descendente
 Em outras palavras: agrupa invariantes
 Encapsulamento
 Proteção dos atributos e métodos
 Polimorfismo
 Existência de um nome (e.g., métodos, classes) e
vários significados (i.e., funcionalidades)

19. 19
Em suma...
 Não pergunte o que pode fazer com
suas estruturas de dados
 Pergunte o que suas estruturas de
dados pode fazer para você

20. 20
Abstração em OO
 Suprimir/esconder propositalmente
detalhes de um processo para destacar
outros detalhes.
 ... mas como encontrar o nível certo de
abstração?

21. 21
Abstração em OO
 Como gerar novos tipos?
 Composição:
 Combinar tipos primitivo e/ou customizados para
criar outros tipos de dados customizados
 Tipos de dados abstratos

22. 22
Exemplos em código

23. 23
Java – Classe
class People{
private String name;
public People(String n){
setName(n);
}
public String getName(){
return name;
}
public void setName(String n){
name=n;
}

24. 24
Java – Herança
class Employee extends People{
private Double salary;
...
public Double getSalary(){
return salary;
}
public void setSalary(Double s){
salary=s;
}
}

25. 25
Java – Polimorfismo
class FreeLancer extends Employee{
private Double hoursPerMonth;
private Double salaryPerHour;
... // Setters & getters
public void setSalary(Double h, Double s){
salary=h*s;
}
public void setSalary(String s){
try{
String[] temp=s.split("/");
salary=Double.parseDouble(temp[0])*
Double.parseDouble(temp[1]);
}
...

26. 26
Exercício pra entregar
 Proposta de projeto
 Indicar
 Classes
 Atributos
 Métodos
 Herança
 Encapsulamento
 Polimorfismo

27. 27
Exemplo
 Vamos trabalhar na modelagem de um
jogo conhecido usando OO
 Sugestões
 Banco Imobiliário
 Mario Kart
 Truco
 Bilhar
 ...

28. 28
Java – Visão geral da sintaxe
 { } delimitam grupos de comandos
 ; finaliza comando
 // comentário de linha
 /* */ comentário de bloco

29. 29
Java – Visão geral da sintaxe
 Operadores
 ==, !=, <=, >=, <, >
 +, -,*, /, %

30. 30
Java – Tipos
 Alguns tipos primitivos
 int
 long
 boolean
 double
 char

31. 31
Java – Tipos
 Alguns objetos
 Integer
 Boolean
 Double
 String

32. 32
Java – Arrays
 Sequência de valores de tamanho fixo
 Pode ser de tipos primitivos ou objetos
 int[ ] values;
 String[ ] description;
 Para criar arrays
 description = new String[10] ;
 Operações
 description[0] == “Testing 1, 2, 3” ; // atribui
 System.out.println( description[0] ); // recupera

33. 33
Interface
 Não pode ser instanciada
 Define os métodos que as subclasses
devem implementar
 Não contém implementação

34. 34
Classe Abstrata
 Também não pode ser instanciada
 Mas pode conter implementação de
métodos
 Para serem instanciadas as subclasses
devem sobrescrever os métodos
abstrados

35. 35
Herança múltipla
 Em Java a herança múltipla pode ser
implementada combinando interfaces
 Herança de implementação apenas pode
ocorrer de uma classe

36. 36
Java – Tipagem estática
 Dinâmico
 Conhecido ou feito
enquanto o programa roda
 Estático
 Conhecido ou feito
antes do programa rodar
 Dar preferência ao estático ajuda a
identificar bugs mais rapidamente

37. 37
Polimorfismo
Overloading
 Sobrecarga
 Métodos sobrecarregados têm o mesmo
nome
 Mas diferentes argumentos
 Seja pelo tipo ou pelo número de
argumentos

38. 38
Polimorfismo
Overloading
public void setSalary(Double s){
salary = s;
}
public void setSalary(Double h, Double s)
{
salary = h * s ;
}
public void setSalary(String s){
try{ salary = Double.parseDouble( s );}
catch( NumberFormatException nfe ){...}
}

39. 39
Polimorfismo
Overriding
 Sobrescrita
 Um novo corpo é dado para método
herdado
 Para chamar a implementação da
superclasse basta utiliza
 super.nomeDoMétodo( ... );

40. 40
Polimorfismo
Overloading vs. Overriding
 Não confunda Overloading ...
 Métodos na mesma classe com mesmo
nome, mas com argumentos diferentes
 ... com Overriding
 Métodos implementados na superclasse e na
sua subclasse, com mesmos nome e
argumentos
 Uma forma de evitar overriding é usar final

41. 41
Campos e métodos estáticos
 Ao declarar campos/métodos como
estáticos eles são associados à classe e
não ao objeto
 Ele tem um valor apenas para todo o
programa
 Constantes normalmente usam static e
final
 public static final PI = 3.14159;

42. 42
Criando pacotes
 Basta utilizar a palavra package antes da
definição da classe
// No arquivo Card.java
package
br.mackenzie.pds2011.monopoly.model;
abstract class Card{
...

43. 43
Utilizando pacotes
 Organizam classes
 java.net.URL
 No código, basta inserir no início
 import java.net.URL;
 No sistema de arquivos, os pacotes são diretórios
 Seguem estrutura inversa de domínio
 br.com.[domínio].[aplicação].[componente].[Classe]
 br.com.exemplo.monopoly.model.Card

44. 44
Exceções
 São condições anormais de retorno de
um método
 Exceções também são objetos

45. 45
Exceções
 try – Conta com os comandos, então se há um
problema, o fluxo vai para a sequência de
catch
 catch – “Pega” a exceção, então é possível
fazer algo pra solucionar o problema
 finally – Sempre é executado ao final do
bloco; normalmente para liberação de recursos

46. 46
Exceções
 Funcionamento básico
 try executa código que pode disparar um exceção
 Se uma exceção ocorre, então o fluxo do programa
é desviado e um tratador (catch) é procurado
 Note que tudo do bloco try expira
 O primeiro tratador (catch) adequado (em que o
parâmetro combinar com a exceção) é executado
 Então o fluxo de execução é desviado para o finally

47. 47
Exceções
...
public String exemplo(){
...
try{ ... }
catch( [exceção mais específica] e1 ){ ... }
catch( [exceção menos específica] e2 ){ ... }
finally{ ... }
}
...

48. 48
Disparando exceções
 O comando throw dispara uma exceção
 Quando ocorre em um método, em vez de retornar
um valor, uma exceção é disparada
 Se uma exceção não é listada no comando throws, o
compilador indica que deve ser capturada com
try/catch ou declarada (throws)
 Se seu método chamar métodos que disparam
(throws) exceções, elas devem ser capturadas ou
disparadas no seu método
 Requisito catch-or-declare

49. 49
Disparando exceções
...
public String exemplo2()
throws TipoDeExeção1, TipoDeExceção2{
...
// caso específico
throw new TipoDeExceção1();
...
// outro caso específico
throw new TipoDeExceção2();
}
...

50. 50
Type Casting
 Muda o tipo do objeto declarado em
tempo de execução, mas não afeta o tipo
do objeto em si
 É diferente de coerção de tipos primitivos
 Coerção produz um valor diferente em tempo
de execução
 (int)0.5 resulta no valor 0

51. 51
Generics
 Em alguns casos, definir tipos de objetos no
código pode reduzir as possibilidades de reuso
 Generics possibilita parametrizar tipos
 Deixa o código mais estável
 Possibilita verificações de tipos em tempo de
compilação
 Muito usado em Collections como List e Map
 Note que não funciona com tipos primitivos

52. 52
Generics
public class Box {
private Object object;
public void add(Object object) {
this.object = object;
}
public Object get() {
return object;
}
}
Fonte: Oracle – The Java Tutorials – Learning the Java Language

53. 53
Generics
public class BoxDemo1 {
public static void main(String[] args) {
// ONLY place Integer objects
//into this box!
Box integerBox = new Box();
integerBox.add(new Integer(10));
Integer someInteger =
(Integer)integerBox.get();
System.out.println(someInteger);
}
}
Fonte: Oracle – The Java Tutorials – Learning the Java Language

54. 54
Generics
public class BoxDemo1 {
public static void main(String[] args) {
// ONLY place Integer objects
//into this box!
Box integerBox = new Box();
integerBox.add(“10”);
Integer someInteger =
(Integer)integerBox.get();
System.out.println(someInteger);
}
}
Fonte: Oracle – The Java Tutorials – Learning the Java Language

55. 55
Generics
public class Box<T> {
private T t; // T stands for "Type“
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}
Fonte: Oracle – The Java Tutorials – Learning the Java Language

56. 56
Generics
public class BoxDemo3 {
public static void main(String[] args) {
Box<Integer> integerBox =
new Box<Integer>();
integerBox.add(new Integer(10));
// no cast!
Integer someInteger = integerBox.get();
System.out.println(someInteger);
}
}
Fonte: Oracle – The Java Tutorials – Learning the Java Language

57. 57
Generics
 Pode ter mais de um identificador, mas
devem ser diferentes
 Exemplos:
 List<T>
 Box<T>
 HashMap<K,V>
 List<Box<T>>
 List<Box<HashMap<K,V>>>

58. 58
Generics
 Convenções de nomenclatura:
 E - Element (usado em Collections)
 K - Key
 N - Number
 T - Type
 V - Value

59. 59
Generics
 Há casos em que desejamos restringir os tipos
passados como parâmetro
 Nesses casos podemos usar bounded type
parameters
 Exemplo: Box<T extends Number>;
 Note que extends aqui se refere tanto a
classes quanto a interfaces
 Para indicar a implementação de interfaces
basta concatenar usando &
 Exemplo: Box<T extends Number & MyInterface>

60. 60
Generics
 Relembrando o exemplo do Banco
Imobiliário

61. 61
Generics
// Declaração sem Generics
Private HashMap cards;
...
// Caso 1 – Propenso a erros
Card c = cards.get( “Copacabana” ) ;
...
// Caso 2 – Pouco elegante
Card c =
(Card)cards.get( “Copacabana” ) ;
...

62. 62
Generics
// Declaração com Generics!
private HashMap <String,
T extends Card> cards;
...
// Caso 3 – Elegante e evita erros
Card c = cards.get( “Copacabana” ) ;
...

63. 63
Concorrência
 Onde encontramos tarefas concorrentes?
 Java foi projetado para suportar
concorrência
 Em programação concorrente temos duas
unidades básicas de execução:
 Processos
 Threads
 Note que concorrência é possível mesmo
em sistemas com um processador

64. 64
Processos e threads
 Processo
 Ambiente auto contido de execução
 Conta com seu espaço em memória
 Thread
 Existe dentro do processo
 Compartilha recursos do processo
 Eficiente, mas comunicação é complexa
 Toda aplicação tem ao menos uma thread

65. 65
Threads
 Uma das formas de criar uma aplicação
concorrente é controlar
 Criação e gerenciamento de threads
 Instanciação de threads para tarefas
assíncronas
 A aplicação que cria uma thread precisa
fornecer o código que vai rodar na thread

66. 66
Threads
 Duas formas de instanciar threads:
 Runnable object
 A interface Runnable define o método que deve
ter o código a ser executado na thread – run
 O objeto Runnable é passado para o construtor
da Thread

67. 67
Threads
public class HelloRunnable implements Runnable {
public void run() {
System.out.println("Hello from a thread!");
}
public static void main(String args[]) {
(new Thread(new HelloRunnable())).start();
}
}

68. 68
Threads
 Duas formas de instanciar threads:
 Estender a classe Thread
 Thread implementa Runnable
 Ao estender a classe Thread, basta fornecer a
implementação do método run()

69. 69
Threads
public class HelloThread extends Thread {
public void run() {
System.out.println("Hello from a thread!");
}
public static void main(String args[]) {
(new HelloThread()).start();
}
}

70. 70
Threads
 Toda thread tem uma prioridade entre
 Thread.MIN_PRIORITY
 Thread.MAX_PRIORITY
 Cada nova thread herda a prioridade do
objeto que a criou
 O rodízio de execução entre as threads
pode ocorrer com ou sem fracionamento
de tempo (i.e., que usam quantum)

71. 71
Escalonamento de threads

72. 72
Ciclo de vida da thread

73. 73
Como controlar concorrência
em métodos?
 Métodos sincronizados
 Threads chamando o mesmo método ficam
bloqueadas até que a execução seja
terminada
 Para tornar um método sincronizado, basta
adicionar sinchronized
 ...
public synchronized int getX(){
return x ;
}
...

74. 74
Exercício
 Discutam em grupo como resolveriam o
problema de concorrência ao usar o
padrão GoF Singleton
 Identifique no projeto locais em que
threads poderiam ser utilizadaS

75. 75
Referências
 Java: Como programar – Deitel e Deitel
 The Java Tutorials - Learning the Java
Language
http://download.oracle.com/javase/tutorial/java/
TOC.html
 MIT Open Course – Elements of Software
Construction
http://ocw.mit.edu/courses/electrical-
engineering-and-computer-science/6-005-
elements-of-software-construction-fall-2008/
 Oracle Java Tutorials – Concurrency
http://docs.oracle.com/javase/tutorial/essential/
concurrency/index.html