Introdução à programação em Android e iOS - OOP Java

Programação Orientada a Objectos
(OOP) - Parte 1: Java
Cursos de Verão na Católica 2011

Jorge C. S. Cardoso, Luís Gustavo Martins
jorgecardoso@ieee.org, lmartins@porto.ucp.pt

Conteúdo

● Objectos
● Classes
● Construtores
● Destrutores
● Encapsulamento
● Herança
● Method overriding
● Strings

Objectos no mundo real
Objectos no mundo real podem ser
descritos através de duas características
essenciais: atributos (estado) e
comportamento.
Por exemplo, o cão do João tem:

● atributos:
○ Cor: castanho
○ Tamanho pêlo: curto
○ Raça: Rafeiro
○ Idade: 3 anos
○ Nome: Bobi

● comportamento
○ corre
○ ladra
○ senta-se
○ come
○ dorme

Objectos no mundo real
Outro exemplo: o automóvel do
Jorge

● Atributos:
○ Cor: azul escuro
○ Marca: Opel
○ Modelo: Corsa
○ Velocidade: parado
○ Combustível: 30%

● Comportamento:
○ arrancar
○ acelerar
○ travar

(O comportamento não se refere necessariamente a comportamento
autónomo, mas simplesmente a acções que o objecto pode realizar.)

Classes no mundo real
O exemplo anterior, automóvel, referia-se
a um objecto concreto (o automóvel do
Jorge).

No entanto, existem milhares de
automóveis diferentes, com o mesmo
comportamento e com os mesmos
atributos (cor, marca, modelo, etc -
embora não com os mesmos valores)

A este conjunto genérico de
comportamentos e atributos dá-se o
nome de classe.

Classes em OOP

● Uma classe é, basicamente, um molde para a criação de
objectos.

● Em OOP, ao processo de criar um objecto a partir de uma
classe dá-se o nome de instanciação.
○ Usando o exemplo anterior, o objecto "Automóvel do Jorge" seria uma
instância da classe "Automóvel".

● Os atributos são representados através de variáveis e o
comportamento através de métodos.

http://www.stanford.edu/class/cs193p/cgi-bin/drupal/downloads-2010-winter

Um exemplo concreto: Classe Veículo
Atributos: Comportamento:
- Cor - Arrancar
- Marca - Travar
- Modelo - Acelerar
- Peso - Buzinar
- Vel. Máx. - Encher Depósito
- Vel. Actual - *Parado?
- Num. Rodas - *Mostrar Estado
- Num. lugares
- Kilómetros
- Litros de Combustvel

* Em OOP não temos de nos cingir à realidade :)

Um exemplo concreto: Classe Veículo
Atributos:
Design Phase - Cor
- Marca
- Modelo
- Peso
- Vel. Máx.
● Criar uma classe - Vel. Actual
- Num. Rodas
○ Veículo - Num. lugares
- Kilómetros
- Litros de Combustível
● Determinar a "superclass" (classe pai)
○ ObjC => NSObject
Comportamento:
○ Java => Object (implicitamente) - Arrancar
- Travar
- Acelerar
● Que propriedades deve ter a classe? - Buzinar
- Encher Depósito
- *Parado?
● Que acções deve ela implementar? - *Mostrar Estado

Classe Veículo em Java
public class Veiculo { // ficheiro Veiculo.java

int velMax = 120; // em Km/h
int velActual = 0;
int numRodas = 4;
int numLugares = 5;
public void arrancar() {
// implementação do método arrancar
}

public void travar() {//... }
public void acelerar() {//... }
public void buzinar() {//... }
public boolean estaParado() {//... }
public void mostrarEstado() {//... }
}

Encapsulamento
● Uma das vantagens da programação orientada a objectos é a de
permitir o encapsulamento dos dados/comportamento:

○ Por um lado, permite agrupar numa unidade lógica dados
associados a um determinado conceito e operações sobre
esses dados.

○ Por outro lado, permite "esconder" informação do exterior,
prevenindo erros e estados inconsistentes.
■ (Dentro do possível as classes devem ser implementadas de
forma a não ser possível que código externo à classe altere
dados, colocando o objecto num estado de erro)

Encapsulamento
● Estas duas propriedades facilitam o trabalho do
programador que utiliza os objectos: tal como no caso das
funções, não é necessário compreender o funcionamento
interno do objecto para tirar partido dele.

● A estruturação de um programa em classes/objectos
permite também ao programador definir e restringir as
interdependências entre código, tornando-o mais robusto e
compreensível.

● (Sem objectos teríamos programas em que o estado e
comportamento de diferentes componentes estariam todos
misturados).

Encapsulamento em Java
● A linguagem Java não força o encapsulamento na
perspectiva do "esconder" a informação do exterior
● O programador escolhe:
○ Os atributos podem ser declarados como vísiveis do
exterior (access modifier)
■ keyword public
○ Ou podem ser declarados como visíveis apenas pela
classe
■ keyword private

Java: Variáveis e Métodos de Classe e de
Instância
● Apesar de isto não acontecer com objectos no mundo real,
em OOP é possível modelar atributos (variáveis) e
comportamento (métodos) como pertencentes à classe ou à
instância da classe (objecto)
○ Variáveis e métodos de classe: podem ser usados
mesmo sem criarmos um objectos dessa classe
○ Variáveis e métodos de instância: apenas podemos usá-
los depois de instanciarmos o objecto (caso mais
comum)
● Por omissão as variáveis e métodos são de instância, para
os tornarmos de classe usamos o "access modifier"
○ static

Instância
public classe XPTO {
public int var1 = 1;
public static int var2 = 2;

public void metodo1() {
System.out.println("Instancia");
}
public static void metodo2() {
System.out.println("Static");
}
}

Instância
● Para usarmos variáveis/métodos de classe usamos a
notação "." directamente no nome da classe

XPTO.var2 = 3;
XPTO.metodo2();
//XPTO.metodo1(); // Erro!

Construtores

● Para instanciar um objecto é necessário inicializar os seus
atributos (variáveis) e, possivelmente, iniciar outras acções
como estabelecer comunicações de rede, inicializar
sensores, etc. Este tipo de inicialização só pode ser feita
pelo próprio objecto que está a ser instanciado -
encapsulamento.

● Por isso, quando um objecto é criado, é invocado um
método especial chamado construtor.

Construtores em Java

● Em Java, o construtor é um método com o mesmo nome da
classe, mas sem tipo de retorno.

● Uma classe pode definir vários construtores com parâmetros
diferentes (número e/ou tipo).
○ Chamado constructor overloading

● É o nome do construtor (e parâmetros) que colocamos a seguir à
keyword 'new' quando criamos um objecto.

Construtores em Java
Projecto Java-Construtor
public static void main(String args[]) {
public class Veiculo { Veiculo v = new Veiculo();
// Atributos aqui Veiculo v1 = new Veiculo(130, 0, 3, 2);
public Veiculo() { v.mostrarEstado();
velMax = 120; v1.mostrarEstado();
velActual = 0; }
numRodas = 4;
numLugares = 5;
}
public Veiculo(int velMax, int velActual,
int numRodas, int numLugares)
{

this.velMax = velMax;
this.velActual = velActual;
this.numRodas = numRodas;
this.numLugares = numLugares;
}
}

Destrutores

● Um destrutor é o oposto de um construtor: é um método
especial invocado quando o objecto é destruído.

● O destrutor é usado para dar oportunidade ao objecto de
libertar recursos (por exemplo memória).

● Em Java não existem destrutores porque a gestão de
memória é feita automaticamente pelo garbage collector.
○ Em Obj-C existem destrutores

Herança
● Em muitos casos existe uma relação entre
classes diferentes num programa.
● Voltando aos veículos, o nosso programa
poderia necessitar de trabalhar com
bicicletas e automóveis.

● Apesar de ambos serem veículos, uma
parte do estado e alguns comportamentos
são completamente diferentes.

Herança
● Nestes casos, faz mais sentido
modelar três classes:
Automóvel e Bicicleta como
classes derivadas da classe
Veículo.

● Desta forma, evita-se repetir o
estado e comportamento
partilhados.

● Nesta situação, as classes Automóvel e Bicicleta, herdam o estado
e comportamento de Veículo, podendo estendê-los.

● A classe Veículo é a superclasse e as classes Automóvel e
Bicicleta as subclasses.

Herança
● As subclasses herdam todos os atributos e métodos da
superclasse, excepto os construtores.

● O construtor da subclasse deve invocar o construtor da
superclasse

● (se a superclasse tiver um construtor vazio - sem
parâmetros, este é invocado automaticamente).

● Para invocarmos o construtor da classe mãe usa-se a
instrução
○ super()
○ super(param1, param2, etc);

Herança em Java
Projecto Java-Heranca
public class Automovel extends Veiculo {
int numPortas;
public Automovel() {
// Não é necessário, o construtor vazio é invocado automaticamente, se não
// o invocarmos nós
//super();
System.out.println("Automovel()");
}
public Automovel(int velMax, int velActual, int numRodas, int numLugares) {
super(velMax, velActual, numRodas, numLugares);
numPortas = 4;

System.out.println("Automovel(velMax, velActual, numRodas, numLugares)");
}
public void abrirPorta() { }
public void ligarMotor() { }
public void trocarOleo() { }
}

Method Overriding
● Method overriding ("sobreposição de método") é uma
funcionalidade das linguagens OOP que permite a uma
subclasse definir uma implementação mais específica
de um método da superclasse.

○ Por exemplo, a classe Veículo define um método buzinar() com uma
implementação genérica para todos os tipos de veículo ("horn"). No
entanto, faz mais sentido a uma Bicicleta proporcionar uma
implementação mais específica deste método ("ring ring").

Method overriding
Method overriding permite à
classe Bicicleta re-implementar
um método da classe Veículo.

A classe Automóvel, como não
re-implementa o método
buzinar(), usa a implementação
de Veículo ("horn").

Method overriding em Java
Projecto Java-Overriding
Automovel a = new Automovel(130, 20, 4, 4);
a.buzinar();
public class Veiculo {
Bicicleta b = new Bicicleta();
// Atributos aqui
b.buzinar();
// Construtores

// outros métodos

public void buzinar() {
System.out.println("Buzinar veículo: horn!");
}

}

public class Bicicleta extends Veiculo{
// Construtores
// Outros métodos

@Override
public void buzinar() {
System.out.println("Buzinar bicicleta: ring ring!");
}
}

Exercício
● Reimplementar o problema das operações sobre fracções com
objectos
● Classe Fraction
○ Atributos: ?
○ Construtores: ?
○ Métodos: 4 métodos para efectuar as 4 operações aritméticas
■ Parametro: outra Fraction
■ Retorno: uma Fraction que resulta da operação da própria
com o parâmetro
● Classe Calculator
○ Atributos: duas Fraction, um operador (char)
○ Construtores: ?
○ Métodos: 1 método para efectuar a operação correspondente
sobre as duas Fraction

Exercício
public class Fraction {

int numerator;
int denominator;
public void setTo(int n, int d) {
this.numerator = n;
this.denominator = d;
}
public Fraction add(Fraction f) {
Fraction result = new Fraction();
int resultNum, resultDenom;

resultNum = this.numerator*f.denominator + this.denominator*f.numerator;
resultDenom = this.denominator * f.denominator;
result.setTo(resultNum, resultDenom);
result.reduce();
return result;
}

Exercício
public class Calculator {

Fraction operand1, operand2;
public Calculator(Fraction frac1, Fraction frac2) {
operand1 = frac1;
operand2 = frac2;
}
public Fraction performOperation(char op) {
Fraction result = new Fraction();
switch(op) {
case '+':
result = operand1.add(operand2);
break;
case '-':
result = operand1.subtract(operand2);
break;
case '*':
result = operand1.multiply(operand2);
break;
case '/':
result = operand1.divide(operand2);
break;
}
return result;
}
}

Exercício
Fraction f1 = new Fraction();
Fraction f2 = new Fraction();
Fraction result;
f1.setTo(1, 4);
f2.setTo(1, 4);
Calculator calc = new Calculator(f1, f2);
result = calc.performOperation('+');
result.print();

Strings
● strings (texto)
● Para guardarmos texto num programa usamos o tipo
○ String

String nome = "Jorge";

System.out.println(nome);

// aplicado a Strings o operador +
// significa concatenação
nome = nome + " Cardoso";

System.out.println(nome);

Strings
● As strings em Java são implementadas como objectos
String nome = "jorge";

● é o mesmo que
char data[] = {'j', 'o', 'r', 'g', 'e'};
String str = new String(data);

● Como as strings são tipos de dados muito comuns, para
facilitar a sua utilização, apesar de internamente serem
representadas como objectos, podemos nalguns aspectos
usá-las como tipos primitivos.

Referências

http://download.oracle.com/javase/tutorial/java/concepts/

http://en.wikipedia.org/wiki/Object-oriented_programming

http://en.wikipedia.org/wiki/Inheritance_(object-
oriented_programming)

http://en.wikipedia.org/wiki/Method_overriding

Fim

Cursos de Verão na Católica 2011
http://porto.ucp.pt/cvc/

Jorge C. S. Cardoso, Luís Gustavo Martins
jorgecardoso@ieee.org, lmartins@porto.ucp.pt

http://slideshare.net/jorgecardoso (tag: cvc2011)

Introdução à programação em Android e iOS - OOP Java

Mais conteúdo relacionado

Mais procurados

Semelhante a Introdução à programação em Android e iOS - OOP Java

Mais de Luís Gustavo Martins

Introdução à programação em Android e iOS - OOP Java