Escolar Documentos
Profissional Documentos
Cultura Documentos
Programação
Prof. Protásio
Laboratório de Microengenharia/DEE/CEAR/UFPB
Programação Orientada a Objeto (POO)
Object-oriented programming (OOP)
▪ POO é um paradigma (modelo, padrão) de
programação que foca no uso de objetos na
construção de programas.
▪ Objetos são entidades que contém estados
(variáveis), comportamento (funções que atuam
nessas variáveis) e interfaces (funções que
comunicam o objeto com o “mundo exterior”).
▪ Objetos tentam retratar objetos do mundo real.
▪ Objetos são prototipados (projetados) por meio de
classes.
▪ Herança: uma das características de POO em que
classes podem herdar estados e comportamentos
de uma outra classe.
Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 2
Programação Orientada a Objeto (POO)
▪ Objeto: entidade de SW que modela “coisas”
do mundo real
▪ Exemplo: sistema de direção θ = Ângulo da
direção desejada
Interface
Objeto: Sistema de Direção
Comportamento
θ Φ=f(θ)
Φ estados
Φ = ângulo resultante
Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 3
Programação Orientada a Objeto (POO)
▪ Objeto: Sistema de Freio
▪ Objeto
▪ Variável
▪ Intensidade da força no pedal de freio (F)
▪ Resultante
▪ Frenagem do carro
Objeto:
F Sistema
▪ Objeto
▪ É uma instância de uma classe.
▪ É a “concretização” de uma classe.
▪ Quando um objeto é criado, memória é
alocada a esse.
▪ nome_da_classe
▪ É um identificador válido para a classe.
▪ Especificador_de_acesso
▪ private:
▪ Membros privados podem ser acessados somente por membros da mesma classe.
▪ public:
▪ Membros públicos podem ser acessados em qualquer escopo em que a classe é visível.
int x, y;
public:
void setar_valores (int, int);
int area (void);
};
Retangulo Ret;
int main () {
Retangulo Ret;
Ret.setar_valores(3, 4);
cout << “Area = " << Ret.area();
return 0;
}
int main () {
Retangulo Ret;
Ret.setar_valores(3, 4);
Ops!!! Algo errado na cout << “Area = " << Ret.area();
compilação? cout << “x = " << x << “ y = " << y;
return 0;
}
Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 11
#include <iostream>
Meu using namespace std;
int main () {
Retangulo Ret;
Ret.setar_valores(3, 4);
Ops!!! Algo errado na cout << “Area = " << Ret.area();
compilação de novo? cout << “x = " << Ret.x << “ y = " << Ret.y;
return 0;
}
int main () {
Retangulo Ret;
Ret.setar_valores(3, -4);
cout << "Area = " << Ret.area();
return 0;
}
int main () {
Retangulo Ret;
Ret.setar_valores(3, 4);
cout << “Area = " << Ret.area();
cout << “x = " << Ret.getX() << “ y = " << Ret.getY();
return 0;
}
#include <iostream>
using namespace std;
class Retangulo {
int x, y;
public:
void setar_valores (int a, int b) { x = a; y = b;}
int area () {return (x*y);}
};
int main () {
Retangulo Ret;// cria um objeto
Retangulo *Ret2;// cria um ponteiro para objeto
Ret2 = &Ret;// Faz com que o ponteiro Ret2 aponte para Ret
Ret2->setar_valores(3, 4);
cout << "Area = " << Ret2->area();
return 0;
}
class Retangulo {
int x, y;
public:
Retangulo(); // Função construtora da classe Retangulo
int area () {return (x*y);}
};
int main () {
Retangulo A;// cria um objeto
cout << "Area = " << A.area() << endl;
return 0;
}
class Retangulo {
int x, y;
public:
Retangulo(); // Função construtora da classe Retangulo
int area () {return (x*y);}
};
int main () {
Retangulo A[10];// cria um objeto
cout << "Area = " << A[0].area() << endl;
return 0;
}
class Retangulo {
int x, y;
public:
Retangulo(); // Função construtora da classe Retangulo
int area () {return (x*y);}
};
int main () {
Retangulo A[10];// cria um objeto
for (int i =0; i < 10; i++)
cout << "Area = " << A[i].area() << endl;
return 0;
}
int main () {
Retangulo A(3,4);// cria um objeto
Retangulo B(10,2);// cria um objeto
cout << "Area = " << A.area() << endl;
cout << "Area = " << B.area() << endl;
return 0;
}
class Retangulo {
int x, y;
public:
Retangulo();
Retangulo (int a, int b); SOBRECARGA DE CONTRUTORA
~Retangulo(); // Função destrutora da classe Retangulo
int area () {return x*y;}
};
int main () {
Retangulo A(2,7);
cout << "Area = " << A.area() << endl;
Retangulo B[10];
for (int i =0; i < 10; i++){
cout << "Area = " << B[i].area() << endl;
}
return 0;
} Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB
Prof. 26
Arrays de objetos criados dinamicamente
#include <iostream>
using namespace std;
class Retangulo {
int x, y;
public:
Retangulo (){x = 5;y = 5;} // Função Construtora
~Retangulo (){cout << "Bye" << endl ;} // Função Destrutora
int area () {return x * y;}
};
int main () {
int i;
cout << "Quantos objetos retangulo deseja criar?" << endl;
cin >> i;
delete[] Ret;
return 0;
}
Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 27
Membros estáticos
▪ Um classe pode ter membros estáticos
▪ Um membro estático contém o mesmo
valor para todos os objetos da classe
▪ Sintaxe:
static int n;
static float A;
class Retangulo {
int x, y;
public:
static int n; // n é uma variável estática
Retangulo (){n++;} // Função Construtora
~Retangulo (){n--;} // Função Destrutora
int area () {return x * y;}
};
int Retangulo::n=0; // Inicialização da variável estática n (DEVE SER DECLARADA COMO GLOBAL)
int main () {
Retangulo *Ret= new Retangulo[5];
cout << "n = " << Retangulo::n << endl;
Retangulo *A= new Retangulo;
cout << "n = " << Retangulo::n << endl;
delete[] Ret;
delete A;
Retangulo C, D;
cout << "n = " << Retangulo::n << endl;
return 0;
}
▪ Denominações
Em C++ Java
Classe Original Classe Base Superclasse
Nova Classe Classe Derivada subclasse
Classe
Derivada cubo Largura, comprimento e altura
#include <iostream>
using namespace std;
int main () {
cubo C;
C.set_altura(3);
C.set_largura(2); // herdada
C.set_comprimento(5); // herdada
cout << C.altura << " " << C.largura << " " << C.comprimento << endl;
return 0;
}
#include <iostream>
using namespace std;
int main () {
cubo_colorido CC;
CC.set_altura(3);
CC.set_largura(2); // herdada
CC.set_comprimento(5); // herdada
CC.set_cor(0)
cout << CC.altura << " " << CC.largura << " " << CC.comprimento << " " << CC.cor << endl;
return 0;
}
int main () {
X cx;
Y cy;
cx.a; //ERRO, pois a não é visível (private)
cx.b; //ERRO, pois b não é visível fora da classe (protegido)
cx.c; //Ok, c é público
class Y : public X
▪ private
▪ Herda os membros public e protected como private
▪ É o acesso padrão, por isso que colocamos public.
▪ public
▪ Não altera a visibilidade dos membros da classe.
▪ protected
▪ Herda os membros public e protected como protected.
▪ Controle de acesso
class Y : public X {
class X { public:
private:
int a; Ñ int geta(){return a; }; //ERRO, pois a não é visível
protected:
int b; S int getb(){return b; }; //Ok, b é protegido (a classe derivada tem acesso)
public:
int c; S int getc(){return c; }; //Ok, c é público
};
};
Só c, que é público, passa!
int main () {
X cx;
Y cy;
cx.a; //ERRO, pois a não é visível (private)
cx.b; //ERRO, pois b não é visível fora da classe (protegido)
cx.c; //Ok, c é público
Rodas
Classe Veículo Número de passageiros
Base
Classes
Caminhão carga Automóvel tipo; //0 = Van, 1=Carro e 2=SUV
Derivadas
▪ Ver-se que as particularidades de caminhão (carga, etc...) é que precisam ser programadas
private:
int passageiros;
int rodas;
public: public não altera a visibilidade dos
void set_rodas(int num) {rodas = num;};
int get_rodas() {return rodas;};
membros da classe (o que é público,
void set_pass(int num) {passageiros = num;}; mantem-se publico)
int get_pass() {return passageiros;};
}; O “:” indica que a classe
caminhao herda da classe
veiculos seus membros
int carga;
public:
void set_carga(int num) { carga = num; };
int get_carga() { return carga; };
void show();
};
private:
int passageiros;
int rodas;
public:
void set_rodas(int num) {rodas = num;};
int get_rodas() {return rodas;};
void set_pass(int num) {passageiros = num;};
int get_pass() {return passageiros;};
};
void automovel::show(){
cout << endl << "Informacao do Automovel" << endl;
cout << "Quantidade de rodas: " << get_rodas() << endl;
cout << "Quantidade maxima de passageiros: " << get_pass() << endl;
cout << "Tipo de automovel: ";
switch(get_type()) {
case 0: cout << " Van\n";
break;
case 1: cout << " Carro\n";
break;
case 2: cout << " SUV\n";
break;
}
}
Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 45
Herança int main()
{
caminhao t1, t2;
▪ Programa Principal automovel c;
t1.set_rodas(18);
t1.set_pass(2);
t1.set_carga(3200);
t2.set_rodas(6);
t2.set_pass(3);
t2.set_carga(1200);
t1.show();
t2.show();
c.set_rodas(4);
c.set_pass(10);
c.set_type(0);
c.show();
return 0;
}
int main(){
caminhao t1, t2;
automovel c;
t1.set_rodas(18);
t1.set_pass(2);
t1.set_carga(3200);
t2.set_rodas(6);
t2.set_pass(3);
t2.set_carga(1200);
t1.show();
t2.show();
c.set_rodas(4);
c.set_pass(10);
c.set_type(0);
c.show();
system("pause");
return 0;
}
int main () {
Retangulo A, B, C;
A.set(1,2);
B.set(3,4);
C = A + B;
C.mostra();
return 0;
} Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 52
#include <iostream>
using namespace std;
Nova sobrecarga do operador
class Retangulo { binário “+”
int x, y;
public:
Retangulo (){x =0 ; y = 0;}
Retangulo operator + (Retangulo); // Função sobrecarregada do operador "+“
Retangulo operator + (int); // Nova função sobrecarregada do operador "+"
void set(int a, int b){x =a; y = b;}
void mostra(){cout << "(x= " << x << ", y= " << y << ")" << endl;};
int area () {return x * y;}
};
int main () {
Retangulo A, B, C;
A.set(1,2);
B.set(3,4);
C = A + B;
C.mostra();
C = A + 6;
C.mostra(); 53
Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB
#include <iostream>
using namespace std; Sobrecarga de operador Unário
class Retangulo {
“++”
int x, y;
public:
Retangulo (){x =0 ; y = 0;}
Retangulo operator + (Retangulo);
void operator ++ () // Função sobrecarregada do operador unário "++"
{ x++; y++; }
void set(int a, int b){x =a; y = b;}
void mostra(){cout << "(x= " << x << ", y= " << y << ")" << endl;};
int area () {return x * y;}
};
int main () {
Retangulo A, B, C;
A.set(1,2);
B.set(3,4);
C = A + B;
C.mostra();
++A; // Operador unário sobrecarregado
A.mostra();
return
Prof.0;
Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 54
Sobrecarga de operador
▪ Observações gerais:
▪ Em geral, é adequado respeitar a definição original do
operador
▪ Exemplo: sobrecarregar o operador + deve ser algo relacionado
com adição
▪ Não é possível mudar o operador de unário para
binário.
▪ Não se pode inventar novos operadores.
▪ Não é possível modificar a precedência de operadores
por meio de sobrecarga.
▪ Operadores que não podem ser sobrecarregados:
▪ . (operador ponto)
▪ :: (operador de resolução de escopo)
▪ ? : (operador ternário)
class Retangulo {
int x, y;
public:
Retangulo (){x =0 ; y = 0;} // Função Construtora
Retangulo operator + (Retangulo); // Função sobrecarregada do operador binário "+"
void operator ++ () // Função sobrecarregada do operador unário "++"
{ x++; y++; }
void set(int a, int b){x =a; y = b;}
void mostra(){cout << "(x= " << x << ", y= " << y << ")" << endl;};
int area () {return x * y;}
};
int main () {
Retangulo A, B, C;
A.set(1,2);
B.set(3,4);
C = A + B;
C.mostra();
++A; // Operador unário sobrecarregado
A.mostra();
return 0;
Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 58
}
Exercícios
1. Crie uma classe para representar uma pessoa, com os atributos privados de nome, idade
e altura. Crie os métodos públicos necessários para sets e gets e também um métodos
para imprimir os dados de uma pessoa.
2. Crie uma classe em C++ chamada Relogio para armazenar um horário, composto por
hora, minuto e segundo. A classe deve representar esses componentes de horário e deve
apresentar os métodos a seguir:
I. um método chamado setHora, que deve receber o horário desejado por parâmetro
(hora, minuto e segundo);
II. um método chamado getHora para retornar o horário atual, através de 3 variáveis
passadas por referência;
III. um método para avançar o horário para o próximo segundo (lembre-se de atualizar o
minuto e a hora, quando for o caso).
3. Definir uma classe que represente um círculo. Essa classe deve possuir métodos Privados
para:
I. calcular a área do círculo;
II. calcular a distância entre os centros de 2 círculos;
III. calcular a circunferência do círculo.
IV. E métodos Públicos para:
a) definir o raio do círculo, dado um número real;
b) aumentar o raio do círculo, dado um percentual de aumento;
c) definir o centro do círculo, dada uma posição (X,Y);
d) imprimir o valor do raio;
e) imprimir o centro do círculo.
f) imprimir a área do círculo. FONTE: CLASSES em C++. Márcio Sarroglia Pinho.
Programação Orientada a Objetos. Marco Antonio M. Carvalho
V. Criar um programa principal para testar a classe.
Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 59
Exercícios
5. Implemente um carro. O tanque de combustível do carro armazena no máximo 50 litros de gasolina. O
carro consome 15 km/litro. Deve ser possível:
I. Abastecer o carro com uma certa quantidade de gasolina;
II. Mover o carro em uma determinada distância (medida em km);
III. Retornar a quantidade de combustível e a distância total percorrida.
IV. No programa principal, crie 2 carros. Abasteça 20 litros no primeiro e 30 litros no segundo. Desloque o
primeiro em 200 km e o segundo em 400 km. Exiba na tela a distância percorrida e o total de
combustível restante para cada um.
6. Implemente uma televisão. A televisão tem um controle de volume do som e um controle de seleção de
canal. O controle de volume permite aumentar ou diminuir a potência do volume de som em uma unidade
de cada vez. O controle de canal também permite aumentar e diminuir o número do canal em uma
unidade, porém, também possibilita trocar para um canal indicado. Também devem existir métodos para
consultar o valor do volume de som e o canal selecionado. No programa principal, crie uma televisão e
troque de canal algumas vezes. Aumente um pouco o volume, e exiba o valor de ambos os atributos.