curso ensino mÉdio integradotÉcnico em ......2 conteúdo introdução à orientação a objetos...
TRANSCRIPT
E.M DR. LEANDRO FRANCESCHINI
CURSO: ENSINO MÉDIO INTEGRADOTÉCNICO EM INFORMÁTICA
COMPONENTE CURRICULAR: TÉCNICAS EM SISTEMAS E
PROCESSAMENTO DE DADOS II
Sumaré – S. P
2
Conteúdo
Introdução à Orientação a Objetos ...............................................................................................................3
Orientação a Objetos ................................................................................................................................3
PHP Orientado a Objetos ..............................................................................................................................5
EXEMPLO OBJETO Explicação: ...................................................................................................................5
EXEMPLO MÉTODOS .................................................................................................................................5
Métodos construtores e destrutores ........................................................................................................9
UML ............................................................................................................................................................ 13
O que é? ................................................................................................................................................. 31
Para que serve? ...................................................................................................................................... 31
Quando usar? ......................................................................................................................................... 31
Diagrama de Casos de Uso ..................................................................................................................... 32
Diagrama de Classes ................................................................................................................................... 35
3
Introdução à Orientação a Objetos
A programação procedural (feita por meio de procedures) foi utilizada em larga escala
durante muito tempo, contudo essa tendência vem se alterando há algum tempo. Esse tipo de
programação é feito por meio de funções que recebem parâmetros de entrada, realiza um
determinado procedimento e devolve um resultado a quem chamou essa função.
Alguns problemas foram detectados na programação procedural:
• Um procedimento não retém estado – a função recebe os parâmetros de
entrada, os processa e devolve uma resposta sem armazenar informações para
futuro uso
• Não implica organização modular – não faz com que o programador agrupe
funcionalidades em comum.
• Não leva a uma organização de nomes – o desenvolvedor que deve elaborar
padrões de nomenclatura para funções.
• Não facilita o reuso – existe repetição de código por conta de não contar com
uma organização modular.
• Mais suscetível a mudanças – quando for necessário fazer qualquer mudança, o
programador terá dificuldade em encontrar as funções que deve alterar.
O PHP é uma linguagem multiparadigma, ou seja, suporta mais de um paradigma de
programação. Em outras palavras, você pode utiliza-lo para programação procedural ou
orientada a objetos.
Orientação a Objetos
A orientação a objetos é uma abordagem para concepção de sistemas, um paradigma de
programação. Essa abordagem envolve desde a modelagem do sistema até sua programação
por meio do uso de objetos e relacionamento entre esses objetos. Alguns aspectos da POO são:
• Permite representar de uma forma mais real o “mundo” a ser modelado;
• Acoplamento entre dados e funcionalidade;
• Utiliza abstrações do mundo real chamadas de OBJETOS;
• Reuso de componentes do programa;
• Facilidade de manutenção, adaptação e ampliação.
4
OBJETO Informalmente, um objeto representa uma entidade de natureza física (uma pessoa) ou conceitual (uma reserva). É um conceito, abstração ou alguma coisa com limites bem definidos e significado bem conhecido dentro do escopo de uma aplicação. Ex: carro, computador, funcionário. Possuem características ou propriedades: ATRIBUTOS. ATRIBUTOS Os atributos identificam o estado de um objeto. Um atributo é uma abstração de uma característica ou um estado que os objetos da classe
possuem.
Exemplo: carro (modelo, cor, marca, ano de fabricação, preço).
MÉTODO Todo objeto possui ações(operações) que modificam seu estado. Essas ações são chamadas de métodos. Exemplo: carro(acelerar, frear, dar ré). CLASSE A classe contém a especificação dos objetos (fôrma) com seus atributos e métodos, ou seja, é na classe que determinamos os atributos de um objeto e seus métodos.
Exercícios
1. Identifique métodos e atributos para as situações a seguir:
a) Conta Corrente
b) Livro
c) Arquivo de computador
d) Funcionário
e) Carro vendido em concessionária.
2. Identifique possíveis nomes de classes para os atributos abaixo: a) Martelo, chave de fenda, alicate, furadeira. b) Carro, caminhão, motocicleta. c) Lava-louças, liquidificador, batedeira, fogão. d) I-Phone, Smartphone, I-Pad.
3. Escolha três objetos do mundo real e faça sua modelagem em termos de orientação a objetos, descrevendo, pelo menos, três atributos e três métodos possíveis de cada um destes objetos, e defina o nome de uma classe para cada um.
5
PHP Orientado a Objetos
EXEMPLO OBJETO Explicação:
No programa a seguir declaramos uma classe, que é a estrutura utilizada para criar objetos. A classe em questão chama-se Produto e terá atributos como $descricao, $estoque e $preco. Para criar objetos a partir de uma classe, utilizamos o operador new seguido do nome da classe que desejamos instanciar. O operador new permite criar um objeto de cada vez. Após criarmos cada objeto, como são públicos, eles podem ser atribuídos de maneira simples. O var_dump() para exibir a estrutura de um objeto em tela e verificar se ele transporta os atributos definidos.
Código
<?php class Produto //declaração de classe { public $descricao; //declaração de atributos public $estoque; //declaração de atributos public $preco; //declaração de atributos } $p1 = new Produto; // operador “new” está instanciando um novo objeto $p1->descricao = 'Chocolate'; //atribuição simples de valor $p1->estoque = 10; $p1->preco = 7; $p2 = new Produto; $p2->descricao = 'Café'; $p2->estoque = 20; $p2->preco = 4; // output objeto inteiro var_dump($p1); var_dump($p2);
Exercícios
1. Utilizando a mesma classe produto do exemplo anterior, crie novos atributos para ele: código
do produto, marca, cor da embalagem, prazo de validade.
2. Com esses novos atributos criados, você deve criar novos objetos com os seguintes dados:
a. Descrição: Bisnaguinhas Estoque: 30 Preço: 4,50 Código: 001 Marca: Seven Boys Cor da
embalagem: Azul Prazo de Validade: 10/10/2018
6
b. Descrição: Nutella Estoque: 45 Preço: 9,50 Código: 002 Marca: Nutella Cor da
embalagem: Marrom Prazo de Validade: 10/11/2018
c. Descrição: Estoque: 30 Preço: 4,50 Código: 001 Marca: Seven Boys Cor da embalagem:
Azul Prazo de Validade: 10/10/2018
EXEMPLO MÉTODOS
No exemplo a seguir vamos criar cada um desses métodos. Para um método referenciar um
atributo interno da classe, basta utilizarmos a variável $this, que por sua vez é uma variável que
representa o objeto atual que está sendo manipulado. Vamos começar utilizando uma classe
pública (public), que não protege seus dados
Código
<?php class Produto //declaração de classe { public $descricao; //declaração de atributos public $estoque; public $preco; public function aumentarEstoque( $unidades ) //declaração de métodos { if (is_numeric($unidades) AND $unidades >= 0) { //verifica se o valor passado é numérico e se é maior ou igual a zero $this->estoque += $unidades;//aumenta a quantidade de estoque usando o valor passado } } public function diminuirEstoque( $unidades ) { if (is_numeric($unidades) AND $unidades >= 0) { //diminui a quantidade de estoque usando o valor passado $this->estoque -= $unidades; } } public function reajustarPreco( $percentual ) { if (is_numeric($percentual) AND $percentual >= 0) { $this->preco *= (1 + ($percentual/100)); } } } $p1 = new Produto;
7
$p1->descricao = 'Chocolate'; $p1->estoque = 10; $p1->preco = 8; print "O estoque de {$p1->descricao} é {$p1->estoque} <br>\n"; print "O preço de {$p1->descricao} é {$p1->preco} <br>\n"; $p1->aumentarEstoque(10); //envia parâmetros para o método Estoque $p1->diminuirEstoque(5); $p1->reajustarPreco(50); print "O estoque de {$p1->descricao} é {$p1->estoque} <br>\n"; print "O preço de {$p1->descricao} é {$p1->preco} <br>\n";
Atividades Métodos
1. Utilizando a mesma classe produto do exemplo anterior e os produtos criados
anteriormente, crie três objetos, utilizando os atributos a seguir:
a. Descrição
b. Estoque
c. Preço
d. Código
e. Marca
f. Cor da embalagem
g. Data de Fabricação
h. Prazo de validade
i. Peso da embalagem
j. Peso do produto
2. Crie três métodos novos:
a. O primeiro deve calcular o número de dias em que o produto pode ser consumido
b. O segundo deve alterar a descrição do produto
c. O terceiro deve calcular o peso total do produto mais a embalagem.
Objeto privado (private)
Nesse caso, a classe vai proteger seus atributos, tornando impossível definir valores arbitrários
a eles.
Código
<?php
class Produto
8
{
private $descricao;
private $estoque;
private $preco;
}
$p1 = new Produto;
$p1->descricao = 'Chocolate';
$p1->estoque = 10;
$p1->preco = 8;
Como não é mais possível definir valores aleatórios aos atributos, é preciso de métodos de
acesso que vão fazer isso por nós. São eles SETTERS e GETTERS, métodos que permitem a
gravação e a leitura dos atributos utilizando alguma regra de validação. No próximo exemplo,
serão criados dois métodos de verificação, setDescricao() e setEstoque(), o primeiro para
verificar se o valor inserido é uma string e o segundo para verificar se o valor é numérico. Isso
só acontece porque os métodos são “public”, ou seja, eles podem ser acessados fora de sua
classe. Contudo, os atributos são “private” o que faz com que sejam acessados somente
dentro da própria classe.
Código
<?php
class Produto
{
private $descricao;
private $estoque;
private $preco;
public function setDescricao($descricao)
{
if (is_string($descricao)) {
$this->descricao = $descricao;
}
9
}
public function getDescricao()
{
return $this->descricao;
}
public function setEstoque($estoque)
{
if (is_numeric($estoque) AND $estoque > 0) {
$this->estoque = $estoque;
}
}
public function getEstoque()
{
return $this->estoque;
}
}
$p1 = new Produto;
$p1->setDescricao('Chocolate');
$p1->setEstoque(10);
print 'Descrição: '. $p1->getDescricao() . '<br>'.PHP_EOL;
print 'Estoque: ' .$p1->getEstoque() . '<br>'.PHP_EOL;
Métodos construtores e destrutores
Construtor
10
Um método construtor é um método executado automaticamente no momento em que
construímos um objeto por meio do operador new. NÃO SE DEVE RETORNAR VALORES
ATRAVÉS DO MÉTODO CONSTRUTOR, POIS O MESMO JÁ RETORNA O PRÓPRIO OBJETO QUE
ESTÁ SENDO INSTANCIADO.
SINTAXE: NOME_CONSTRUCT()
No exemplo a seguir, o método construtor recebe três parâmetros: $descricao, $estoque e
$preco. Caso as variáveis passem nas validações, o objeto $this-> atribui os valores
internamente. Os métodos getters obtêm os valores dos atributos.
Código
<?php
class Produto
{
private $descricao;
private $estoque;
private $preco;
public function __construct($descricao, $estoque, $preco)
{
if (is_string($descricao)) {
$this->descricao = $descricao;
}
if (is_numeric($estoque) AND $estoque > 0) {
$this->estoque = $estoque;
}
if (is_numeric($preco) AND $preco > 0) {
$this->preco = $preco;
}
}
public function getDescricao()
{
return $this->descricao;
11
}
public function getEstoque()
{
return $this->estoque;
}
public function getPreco()
{
return $this->preco;
}
}
$p1 = new Produto('Chocolate', 10, 5);
print 'Descrição: '. $p1->getDescricao() . '<br>'.PHP_EOL;
print 'Estoque: ' . $p1->getEstoque() . '<br>'.PHP_EOL;
print 'Preço: ' . $p1->getPreco() . '<br>'.PHP_EOL;
Destrutores
Um destrutor é um método especial executado automaticamente quando o objeto é
desalocado da memória. Isso ocorre quando:
1. Atribuímos o valor NULL ao objeto;
2. Quando utilizamos a função unset() sobre o objeto;
3. Quando o programa é encerrado.
No exemplo a seguir, o método destrutor também irá exibir uma mensagem de debug. Neste
exemplo, ele será executado quando o método unset() for acionado.
Código
<?php
class Produto
{
private $descricao;
private $estoque;
12
private $preco;
public function __construct($descricao, $estoque, $preco)
{
$this->descricao = $descricao;
$this->estoque = $estoque;
$this->preco = $preco;
print "CONSTRUÍDO: Objeto {$descricao}, estoque {$estoque}, preco {$preco}<br>\n";
}
public function __destruct()
{
print "DESTRUÍDO: Objeto {$this->descricao}, estoque {$this->estoque}, preco {$this-
>preco}<br>\n";
}
}
$p1 = new Produto('Chocolate', 10, 5);
unset($p1);
$p2 = new Produto('Café', 100, 7);
unset($p2);
13
Conversões de Tipos
É possível criar objetos sem ter classes definidas, ou seja, utilizar uma classe genérica vazia. Nesses
casos, deve-se utilizar a classe stdClass (Standard Class), que não possui métodos e nem mesmo
atributos. Ela é muito utilizada para conversões de tipos, como de array para objeto. Nesse exemplo,
será criado um objeto chamado $produto da classe stdClass e por fim será utilizado o comando print
para exibir sua estrutura.
Código
<?php
$produto = new StdClass;
$produto->descricao = 'Chocolate Amargo';
$produto->estoque = 100;
$produto->preco = 7;
print_r($produto);
Para realizar operações de conversão de tipo (casting), como criar um objeto a partir de um vetor e vice-
versa, por meio de utilização de um operador que utiliza o tipo de destino entre parênteses. O objeto
$produto será convertido em um array ($vetor1) por meio do casting. Logo após, será feito o processo
inverso com o $vetor2, que é um vetor, em um objeto ($produto2)
Código
<?php
$produto = new StdClass;
$produto->descricao = 'Chocolate Amargo';
$produto->estoque = 100;
$produto->preco = 7;
$vetor1 = (array) $produto;
print $vetor1['descricao'] . "<br>\n";
$vetor2 = [ 'descricao' => 'Café', 'estoque' => 100, 'preco' => 7 ];
$produto2 = (object) $vetor2;
print $produto2->descricao . "<br>\n";
Outra conversão possível é utilizar variáveis variantes para declarar propriedades de um objeto. Será
criado um vetor simples com alguns índices definidos como descrição, estoque e preço. Após isso, será
14
criado um objeto ($objeto) vazio (stdClass). Depois disso, será percorrido o vetor ($produto) acessando
a chave e o valor de cada posição a cada iteração. No laço de repetição serão preenchidos os atributos
do objeto com a sintaxe ($objeto->$chave). A variável $chave será traduzida pelo seu conteúdo
(descrição, estoque, preco) a cada passada do loop. A única diferença para a atribuição normal é a
presença do cifrão($) na frente da variável de propriedade.
Código
<?php
$produto = array();
$produto['descricao'] = 'Chocolate Amargo';
$produto['estoque'] = 100;
$produto['preco'] = 7;
$objeto = new stdClass;
foreach ($produto as $chave => $valor)
{
$objeto->$chave = $valor;
}
print_r($objeto);
Observação: O foreach é um laço de repetição para iterações em arrays ou matrizes. É um for
simplificado que decompõe um vetor ou uma matriz em cada um de seus elementos por meio de sua
cláusula AS.
Sintaxe:
foreach ($array as $valor) {
Instruções
}
Exemplo:
<?php
$fruta= array(“maçã”, “laranja”, “pera”, “banana”);
foreach ($fruta as $valor) {
print “$valor - ”;
15
}
No formato mais avançado, ao invés de obter apenas o valor, você pode configurar duas
variáveis. A primeira será a chave do índice e a segunda o valor desse mesmo índice. A cada volta do
laço, foreach pega um item do seu array na ordem em que ele estiver, começando pelo primeiro.
Sintaxe:
foreach ( $meu_array as $chave_do_indice => $valor_do_indice ) {
echo $chave_do_indice;
echo $valor_do_indice;
}
Relacionamento entre Objetos
Serão apresentados aqui os principais tipos de relacionamento entre objetos: associação, composição e
agregação.
Associação
Associação é a relação mais comum entre objetos. Na associação um objeto contém uma referência a
outro objeto. Essa referência funciona como um apontamento em que um objeto terá um atributo que
apontará para a posição da memória onde o outro objeto se encontra, podendo executar seus métodos.
A forma mais comum de implementar uma associação é ter um objeto como atributo de outro.
Código
16
<?php
class Fabricante
{
private $nome;
private $endereco;
private $documento;
public function __construct( $nome, $endereco, $documento )
{
$this->nome = $nome;
$this->endereco = $endereco;
$this->documento = $documento;
}
public function getNome()
{
return $this->nome;
}
}
A associação entre as classes Produto e Fabricante se estabelece a partir da classe Produto. A classe
Produto terá como atributos: descrição, estoque, preco e fabricante. Os atributos descrição, estoque e
preco são escalares, ou seja, são definidos pelo seu tipo enquanto o Fabricante é um objeto. Para
estabelecer o vínculo entre eles, serão criados os métodos setFabricante () e getFabricante (), sendo o
primeiro responsável por receber um objeto da classe fabricante e armazená-lo internamente na
propriedade $this->fabricante e o segundo responsável por retornar essa propriedade.
Código
<?php
class Produto
{
private $descricao;
private $estoque;
private $preco;
private $fabricante;
17
private $caracteristicas;
public function __construct($descricao, $estoque, $preco)
{
$this->descricao = $descricao;
$this->estoque = $estoque;
$this->preco = $preco;
}
public function getDescricao()
{
return $this->descricao;
}
public function setFabricante( Fabricante $f )
{
$this->fabricante = $f;
}
public function getFabricante()
{
return $this->fabricante;
}
}
Depois que as classes foram definidas, elas podem ser utilizadas. No próximo código serão importadas
as classes (require_once) para em seguida criar um objeto de cada: Produto e Fabricante. A partir dos
objetos $p1 e $f1 criados, a associação é estabelecida entre os dois objetos no momento da execução
do método setFabricante(), que recebe a instância $f1 e a armazena no atributo $this->fabricante do
objeto Produto.
Código
<?php
require_once 'classes/Fabricante.php';
require_once 'classes/Produto.php';
18
// criação dos objetos
$p1 = new Produto('Chocolate', 10, 7);
$f1 = new Fabricante('Chocolate Factory', 'Willy Wonka Street', '1234985235');
// associação
$p1->setFabricante( $f1 );
print 'A descrição é ' . $p1->getDescricao() . "<br>\n";
print 'O fabricante é ' . $p1->getFabricante()->getNome() . "<br>\n";
Composição
Composição é uma relação de duas classes todo/parte. O relacionamento tem esse nome
porque um objeto contém outros objetos. A composição permite combinar diferentes tipos de objeto
em um objeto mais complexo. O objeto (todo) é responsável pela criação e destruição de suas partes,
exatamente por terem sido criadas pelo objeto “todo”. Tomemos um produto como exemplo, ele é
composto por suas características. Como uma televisão que apresenta várias características como cor,
peso tamanho e potência.
Será criada a classe Caraterística que terá dois atributos: nome e valor. Como exemplos de
nomes “cor”, “peso”, “tamanho” e “potência”. Exemplos de valores: “branco”, “20kg”, “200 watts” e
assim por diante.
Código
<?php
class Caracteristica
{
private $nome;
private $valor;
public function __construct( $nome, $valor )
{
$this->nome = $nome;
$this->valor = $valor;
}
19
public function getNome()
{
return $this->nome;
}
public function getValor()
{
return $this->valor;
Após isso, é preciso alterar a classe Produto para que ela fique com os métodos para compor
características. É preciso declarar um atributo $característica, que será um vetor interno que
armazenará uma ou mais instâncias contendo objetos da classe Característica. O método
addCaracteristica(), que vai receber os parâmetros $nome e $valor e vai criar um objeto da classe
Caracteristica para armazenar os dois dados. O objeto criado será adicionado ao vetor ($this-
>características). O método getCaracteristicas() simplesmente retornará o vetor de características.
Código
<?php
class Produto
{
//..
private $caracteristicas;
public function addCaracteristica( $nome, $valor )
{
$this->caracteristicas[] = new Caracteristica($nome, $valor);
}
public function getCaracteristicas() {
return $this->caracteristicas;
}
}
Finalmente vamos ver como funciona a composição. Vamos importar as classes necessárias
(require_once) para o programa principal. Depois vamos criar o objeto $p1 da classe Produto com
20
alguns atributos iniciais. Cada vez que se inicia o método addCaracteristica() são passados o nome e o
valor da característica, será criado internamente um objeto da classe Caracteristica, contendo o nome e
o valor. Esses objetos criados não existem fora da classe Produto. Assim, se excluirmos o objeto $p1
(Produto) da memória com um comando unset(), os objetos da classe característica também serão
excluídos já que só existem na classe. Esse é o conceito de composição, no qual um objeto (todo)
contém uma ou mais instâncias de outro objeto (parte), sendo responsável pela sua criação e
destruição.
Código
<?php
require_once 'classes/Produto.php';
require_once 'classes/Caracteristica.php';
// criação dos objetos
$p1 = new Produto('Chocolate', 10, 7);
// composição
$p1->addCaracteristica( 'Cor', 'Branco' );
$p1->addCaracteristica( 'Peso', '2.6 Kg' );
$p1->addCaracteristica( 'Potência', '20 Watt RMS' );
print 'Produto: ' . $p1->getDescricao() . "<br>\n";
foreach ($p1->getCaracteristicas() as $c)
{
print ' Característica: ' . $c->getNome() . ' - ' . $c->getValor() . "<br>\n";
Agregação
Agregação também é um tipo de relação entre objetos todo/parte. Na agregação um objeto
agrega outro objeto, ou seja, torna um objeto externo parte de si mesmo pela utilização de um de
seus métodos. Assim o objeto “todo” poderá utilizar funcionalidades do objeto agregado. Nessa
relação um objeto poderá agregar uma ou mais instâncias de um outro objeto. Para agregar
muitas instâncias, a forma mais simples é utilizar arrays. Criamos um array como atributo da
classe , e o papel desse array é armazenar inúmeras instâncias de outro objeto.
21
Na agregação, diferentemente da composição, o objeto “todo” recebe as instâncias de
objetos “parte” já prontas, ou seja, ele não é responsável por sua criação ou destruição. Assim as
instâncias dos objetos “parte” são criadas fora da classe “todo” e agregadas (armazenadas
internamente) por meio de um método de agregação. Quando o objeto “todo” for excluído da
memória, as instâncias das “partes” não serão excluídas, visto que elas pertencem
exclusivamente a um objeto “todos”.
O relacionamento entre uma cesta de compras e seus produtos pode ser visto como uma
agregação. Esse relacionamento é todo/parte, pois enquanto a cesta é o “todo”, os produtos são
suas “partes”. Mas diferentemente da composição as “partes” não são exclusivas do “todo”.
Dessa forma um produto poderá fazer de diferentes cestas. Uma cesta pode ser formada por
inúmeros produtos (instâncias da classe Produto).
A classe Cesta terá um método construtor utilizado para inicializar algumas variáveis como
time (tempo de criação) e itens (vetor de produtos). Para agregar objetos do tipo Produto à Cesta,
criaremos o método de agregação addItem() que receberá uma instância já existente de produto e
irá agrega-la ao vetor ($this->itens) da classe cesta. Veja que o método addProduto() terá uma
indução ao tipo Produto, ou seja, somente poderá receber objetos da classe Produto. A classe
Cesta contará também com o método getItens(), que por sua vez retornará os itens da cesta.
Código
<?php
class Cesta
{
private $time;
private $itens;
public function __construct( )
{
22
$this->time = date('Y-m-d H:i:s');
$this->itens = array();
}
public function addItem( Produto $p )
{
$this->itens[] = $p;
}
public function getItens()
{
return $this->itens;
}
public function getTime()
{
return $this->time;
}
}
Agora iremos demonstrar o relacionamento de agregação na prática. Para tal, inicialmente
vamos importar as classes necessárias (require_once). Em seguida instanciaremos um objeto da
classe Cesta. Depois disso iremos agregar por três vezes os objetos da classe Produto dentro da
classe Cesta ($c1) por meio do método addItem(). Veja que, diferentemente da composição, na
agregação o método que cria “partes” já recebe as instâncias prontas, externas ao escopo da
classe. Assim no escopo principal do programa temos quatro objetos em memória ($c1, $p1,
$p2, $p3) e,ao excluirmos a cesta $c1, as demais instâncias de Produto continuarão existindo,
podendo inclusive fazer parte de outras cestas de compras.
Código
<?php
require_once 'classes/Cesta.php';
require_once 'classes/Produto.php';
23
// criação da cesta
$c1 = new Cesta;
// agregação dos produtos
$c1->addItem( $p1 = new Produto('Chocolate', 10, 5) );
$c1->addItem( $p2 = new Produto('Café', 100, 7) );
$c1->addItem( $p3 = new Produto('Mostarda', 50, 3) );
foreach ($c1->getItens() as $item)
{
print 'Item: ' . $item->getDescricao() . "<br>\n";
}
Herança
A herança faz com que possamos reaproveitar a estrutura já existente sem ter que reescrever o código.
Ela nos fornece uma base abstrata para o desenvolvimento, provendo recursos básicos e comuns. Para
que isso fique mais claro serão utilizados os conceitos de Conta, Conta Corrente e Conta Poupança.
Ambas as contas corrente e poupança possuem elementos comuns como agência, conta e saldo, porém
a conta corrente terá um limite. Ambas as classes terão funcionalidades semelhantes como depositar
valores e retirar valores. Contudo, retirar valores em uma conta corrente possui um limite, algo que não
acontece com a Poupança.
24
A classe Conta terá um método construtor para definir alguns atributos iniciais. Além disso, também
terá o método depositar() para incrementar o saldo, o método getSaldo() para retornar o saldo atual e o
método getInfo() para retornar algumas informações da conta.
Quando declaramos um atributo como private , ele fica protegido do escopo externo da classe. Na
herança é preciso que os atributos fiquem disponíveis para as classes filhas. Para fazer isso, declaramos
os atributos como protected, que permite que ele seja acessado de dentro da classe e por suas filhas
também.
Conta.php
Código
<?php
require_once 'ContaCorrente.php';
require_once 'ContaPoupanca.php';
abstract class Conta
{
protected $agencia;
protected $conta;
protected $saldo;
public function __construct($agencia, $conta, $saldo)
{
$this->agencia = $agencia;
$this->conta = $conta;
if ($saldo >= 0) {
$this->saldo = $saldo;
}
}
public function getInfo()
{
return "Agência: {$this->agencia}, Conta: {$this->conta}<BR>";
}
public function depositar($quantia)
{
if ($quantia > 0) {
25
$this->saldo += $quantia;
}
}
public function getSaldo()
{
return $this->saldo;
}
abstract function retirar($quantia);
}
$contacorrente = new ContaCorrente('000666', '300888',1000,100);
$contapoupanca = new ContaPoupanca('666', '3008',1000);
print $contacorrente->getInfo();
print $contapoupanca->getInfo();
Depois que a classe conta pai foi criada, pode-se aproveita-la para criar as classes derivadas Conta
Corrente e Conta Poupança. Para criar a classe filha, deve-se utilizar o operador extends na declaração
da classe. Esse operador permite indicar que a classe que está sendo criadairá herdar características da
classe pai, como atributos e métodos.
A classe poupança terá uma implementação própria do método retirar(), que por sua vez é de simples
implementação, que é validar se há o valor a ser retirado da conta gerando true (pode retirar) ou false
(não pode retirar).
ContaPoupanca.php
Código
<?<?php
require_once 'conta.php';
final class ContaPoupanca extends Conta
{
function retirar($quantia)
{
if ($this->saldo >= $quantia) {
$this->saldo -= $quantia;
26
}
else {
return false; // retirada não permitida
}
return true; // retirada permitida
}
}
A classe ContaCorrente também contará com um método retirar, contudo ela poderá ter um limite
maior que o valor que há em conta. Para definir o limite foi acrescentado o parâmetro $limite. Para
chamar o construtor já existente utilizamos parente::_construct(), que armazenará os valores recebidos.
O método retirar() também foi sobescrito para verificar se a retira está dentro do saldo real,além de
levar em consideração o limite da conta.
ContaCorrente.php
Código
<?php
require_once 'conta.php';
class ContaCorrente extends Conta
{
protected $limite;
public function __construct($agencia, $conta, $saldo, $limite)
{
parent::__construct($agencia, $conta, $saldo);
$this->limite = $limite;
}
public final function retirar($quantia)
{
if ( ($this->saldo + $this->limite) >= $quantia ) {
$this->saldo -= $quantia; // retirada permitida
}
else {
27
return false; // retirada não permitida
}
return true;
}
}
Conexão com Banco de Dados (PDO)
A conexão com Banco de Dados via PDO (PHP Data Objects) surgiu com a necessidade de unificar
diferentes extensões de banco de dados presentes. O objetivo dele é prover uma API limpa e
consistente, unificando a maioria das características presentes nas extensões de acesso a banco de
dados.
Para conectar a bancos de dados diferentes, a única mudança é na string de conexão:
BANCO STRING DE CONEXÃO
SQLITE New PDO (‘sqlite:teste.db’); FIREBIRD New PDO(“firebird:dbname=C:\\base.GDB”, “SYSDBA”, “masterkey”); MYSQL New PDO(‘mysql:unix_socket=/tmp/mysql.sock;host=localhost;port=3306;
dbname=livro’, ‘user’, ‘senha’); POSTGRESQL New PDO (‘pgsql:dbname=example;user=user;password=senha;host=localhost’)
Para utilizer o PDO, as bibliotecas de acesso para o banco de dados da aplicação devem ser habilitada no
php.ini
No Windows:
Extension=php_mysql.dll
Extension=php_pgsql.dll
Extension=php_sqlite.dll
Extension=php_pdo_mysql.dll
Extension=php_pdo_pgsql.dll
Extension=php_pdo_sqlite.dll
Neste primeiro exemplo o programa irá se conectar ao bando de dados em localhost, chamado livro,
com o usuário MySQL. Em seguida, ele irá inserir dados relativos a pessoas na base de dados. Por fim ele
fechará a conexão ao banco de dados. Caso ocorra algum erro durante a execução das instruções SQL,
será gerada uma exceção, tratada pelo bloco try/catch.
pdo_insere.php
Código
<?php
try
28
{
// instancia objeto PDO, conectando no postgresql
$conn = new PDO('mysql:host=127.0.0.1;port=3306;dbname=livro', 'root', 'mysql');
// executa uma série de instruções SQL
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (1, 'Érico Veríssimo')");
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (2, 'John Lennon')");
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (3, 'Mahatma Gandhi')");
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (4, 'Ayrton Senna')");
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (5, 'Charlie Chaplin')");
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (6, 'Anita Garibaldi')");
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (7, 'Mário Quintana')");
// fecha a conexão
$conn = null;
}
catch (PDOException $e)
{
// caso ocorra uma exceção, exibe na tela
print "Erro!: " . $e->getMessage() . "\n";
}
No próximo exemplo, o programa se conectará ao banco de dados livro. Em seguida ele irá selecionar
código e nome dos famosos existentes nesse banco de dados e exibir na tela. Veja como os resultados
serão percorridos via laço de repetições (foreach) por meio de uma simples iteração. Cada linha
(resultset) do resultado é retornada para dentro do array $row, indexado pelos nomes das colunas do
SELECT (“codigo”, “nome”) e também por índices numéricos que representam as posições das colunas
(0,1). Novamente o controle de erros é realizado por tratamento das exceções. Caso alguma exceção
será gerada, a sua mensagem será exibida na tela pelo bloco catch.
pdo_lista.php
Código
<?php
try {
// instancia objeto PDO, conectando no PostgreSQL
$conn = new PDO('mysql:host=127.0.0.1;port=3306;dbname=livro', 'root', 'mysql');
// executa uma instrução SQL de consulta
29
$result = $conn->query("SELECT codigo, nome FROM famosos");
if ($result) {
// percorre os resultados via iteração
foreach($result as $row) {
// exibe os resultados
echo $row['codigo'] . ' - ' . $row['nome'] . "<br>\n";
}
}
// fecha a conexão
$conn = null;
}
catch (PDOException $e) {
print "Erro!: " . $e->getMessage() . "<br>";
}
Podemos também retorna os dados de uma consulta por meio de função fetch(), que aceita como
parâmetro o “estilo de fetch”. De acordo com o estilo, o retorno poderá ser um dos relacionados a
seguir.
PARÂMETROS DESCRIÇÃO
PDO: :FETCH_ASSOC Retorna um array indexado pelo nome da coluna PDO: :FETCH_NUM Retorna um array indexado pela posição numérica
da coluna PDO: :FETCH_BOTH Retorna um array indexado pelo nome e pela
posição numérica da coluna PDO: :FETCH_OBJ Retorna um objeto anônimo (stdClass), de modo
que cada coluna é acessada como uma propriedade
No exemplo a seguir repetiremos o programa que lista os mesmos dados que o exemplo anterior. A
diferença é que agora utilizaremos a função fetch() para iterar os resultados. O estilo fetch desejado
será o PDO: :FETCH_OBJ, que retorna os dados da consulta em forma de objeto. Veja que agoraa
variável $row é um objeto e cada coluna retornada (código, nome) é acessada como uma propriedade
desse objeto
pdo_lista_obj.php
Código
<?php
try {
30
// instancia objeto PDO, conectando no MySQL
$conn = new PDO('mysql:host=127.0.0.1;port=3306;dbname=livro', 'root', 'mysql');
// executa uma instrução SQL de consulta
$result = $conn->query("SELECT codigo, nome FROM famosos");
if ($result) {
// percorre os resultados via fetch()
while ($row = $result->fetch(PDO::FETCH_OBJ)) {
// exibe os dados na tela, acessando o objeto retornado
echo $row->codigo . ' - '. $row->nome . "<br>\n";
}
}
// fecha a conexão
$conn = null;
}
catch (PDOException $e) {
print "Erro!: " . $e->getMessage() . "<br>";
}
Reescreveremos então o programa de inserção da dados, que anteriormente foi escrito para PostgreSQL
e agora está em MySQL. Veja que única diferença entre um programa e outro é a linha em que
instanciamos o objeto PDO(new PDO), de modo que os parâmetros são diferentes. Todo o restante do
programa é simplesmente igual em razão da interface clara e unificada da biblioteca PDO.
pdo_insere_my.php
Código
<?php
try {
// instancia objeto PDO, conectando no mysql
$conn = new PDO('mysql:host=127.0.0.1;port=3306;dbname=livro', 'root', 'mysql');
// executa uma série de instruções SQL
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (1, 'Érico Veríssimo')");
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (2, 'John Lennon')");
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (3, 'Mahatma Gandhi')");
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (4, 'Ayrton Senna')");
31
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (5, 'Charlie Chaplin')");
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (6, 'Anita Garibaldi')");
$conn->exec("INSERT INTO famosos (codigo, nome) VALUES (7, 'Mário Quintana')");
// fecha a conexão
$conn = null;
}
catch (PDOException $e) {
// caso ocorra uma exceção, exibe na tela
print "Erro!: " . $e->getMessage() . "\n";
}
UML
O que é? A UML (Unified Modeling Language) é uma linguagem visual, onde diagramas representam o
funcionamento (código e funcionalidade) de um sistema.
Para que serve? Usada para literalmente “desenhar” como um sistema será implementado. A UML utiliza diagramas com figuras que representam funcionalidades de um sistema computacional. Contudo, ela também é utilizada para prever como será desenvolvido um ambiente computacional. Em outras palavras, utilizar os requisitos para criar um “esboço” detalhado do futuro sistema.
Quando usar? Antes de codificar: projete como será o seu sistema antes de codificá-lo! Durante a codificação: apresente suas ideias ao grupo de forma que todos possam interagir e discutir um determinado ponto. Depois da codificação: documente seu sistema na forma de diagramas para que novos integrantes e novos colaboradores possam acelerar sua compreensão dos sistemas desenvolvidos pelo grupo.
Os principais
• Diagrama de Casos de Uso
• Diagrama de Classes
• Diagrama de Atividades
• Diagrama de Objetos
32
• Diagrama de Seqüência
Diagrama de Casos de Uso
Para que serve? Representar o que cada tipo de usuário pode fazer no sistema.
Estrutura
Ator – representa os interventores no sistema, podendo ser usuários, sistemas ou sub-
sistemas;
Figura de palito
Casos de uso – um conjunto ou sequência de ações;
Elipse
Assunto – um conjunto de casos de uso, pode ser o sistema em si;
Retângulo
Relacionamentos – representados pela linha, relacionam os casos de uso entre si ou ao
ator.
Linha tracejada (extend)
33
Exemplos Atores: sistema de biblioteca (bibliotecária, usuário). consultório médico (médico, atendente). Casos de Uso: sistema de biblioteca (cadastrar leitor, inserir livro). consultório médico (cadastrar paciente, diagnosticar).
Exemplo de Diagrama
Exercícios
1. Elabore casos de uso e atores para as situações a seguir: a) Cliente realiza transferência de fundos em um caixa eletrônico. b) Clientes compram livros na livraria. c) É produzido um relatório de vendas para o gerente. d) Hóspede se registra em um hotel.
34
Resposta:
Caso de uso Ator
A . Transferir Fundos Cliente
B Comprar Livros Usuário
C Obter Relatório de Vendas
Gerência
D Abrir Estadia Hóspede
2. Em uma empresa, vários projetos são realizados. Os cinquenta empregados da empresa trabalham em pelo menos um projeto. Há um sistema implantado na empresa que permite aos participantes de um determinado projeto marcarem suas horas de trabalho. Esse sistema também permite que o gerente, ao fim do mês, gere os relatórios com os totais de horas trabalhadas de cada participante. Para acessar o sistema é necessário que cada usuário realize o login no mesmo. Como ficaria o diagrama de casos de uso dessa situação?
Casos de Uso - Relacionamentos entre Casos de Uso
Extend e Include
Linha tracejada (extend)
Exercício
1. Imagine que você está fazendo um sistema de Editor de Texto. Nesse sistema o escritor deve poder editar o documento podendo, ao editar, realizar algumas funções específicas como substituir texto, criar índice remissivo e corrigir ortografia. Elabore o diagrama de casos de uso para o sistema.
Resposta:
35
2. Em uma livraria, o sistema permite que o funcionário mantenha o cadastro de livros através do cadastro, pesquisa, alteração e exclusão dos mesmos. Sempre que essas ações são executadas, o sistema deve registrá-la em um histórico. O cliente pode efetuar a compra do livro, sendo necessário emitir uma nota fiscal dessa compra. No momento da compra, o cliente pode optar por realizá-la à vista ou a prazo.
Diagrama de Classes
“Em programação, um diagrama de classes é uma representação da estrutura e relações das
classes que servem de modelo para objetos. Podemos afirmar de maneira mais simples que
seria um conjunto de objetos com as mesmas características, assim saberemos identificar
objetos e agrupá-los, de forma a encontrar suas respectivas classes. Na Unified Modeling
Language (UML) em diagrama de classe, uma classe é representada por um retângulo com três
divisões, são elas: O nome da classe, seus atributos e por fim os métodos.” Extraído de: https://www.devmedia.com.br/orientacoes-basicas-na-elaboracao-de-um-diagrama-de-classes/37224
Exemplo: Sistema de Gerenciamento de uma Biblioteca
36
Atividade
1. Faça um diagrama de Classes para um sistema de compras, onde o cliente realizará a compra de produtos.
2. Desenvolva pelo menos 2 classes possíveis para os sistemas(as classes não precisam estar relacionadas entre si), sendo que cada classe deve ter no mínimo 4 atributos e 4 operações(métodos):
a) Sistema bancário
b) Sistema de uma clínica veterinária
c) Sistema de uma locadora
d) Sistema de estoque de uma empresa
e) Sistema de uma companhia aérea
3. Desenvolva o diagrama de classes para um sistema de uma escola conforme a descrição a seguir:
Os cursos podem ser cadastrados e excluídos do sistema, sendo que todos os cursos são
registrados com um nome específico e uma determinada carga horária. As turmas de cada
curso são formadas com data de início e data de término. Cada turma possui um período que
variam entre manhã, tarde e noite, e podem estar na situação ativa ou cancelada. As turmas
podem ser criadas ou excluídas. O sistema também oferece uma opção de pesquisa e alteração
das turmas já cadastradas. Em cada turma, podemos ter várias matrículas de alunos, sendo que
é necessário armazenar o número dessas matrículas. As matrículas podem ser geradas ou
canceladas, em caso de desistência de algum aluno. Sobre os alunos o sistema armazena dados
como RA, Nome, RG, Endereço e telefone. A secretaria da escola deve poder inserir, excluir,
consultar e alterar os alunos da escola.
4. Imagine que você irá modelar um sistema para uma livraria digital. Faça o diagrama de classes para a livraria, levando em consideração que os dados a serem manipulados pelo
37
sistema serão: cliente, pedido, livro, autor, editora e carrinho de compra. Coloque o máximo de atributos e métodos que você achar pertinente para o sistema.
Diagrama de Classes: Generalização/Especialização
Atividade
Faça o Diagrama de Classes para um sistema Bancário:
Os clientes podem ser Pessoa Física ou Jurídica, sendo possível consultar seus respectivos CPFs
ou CNPJs. Cada conta que é aberta possui um número, saldo, data de abertura, tipo, data de
encerramento, situação (se está ativa ou inativa) e uma senha de acesso. As contas especiais
possuem um limite e a conta poupança um rendimento. É possível abrir uma conta especial e
consultar o Juros do Cheque especial. Todas as contas podem ser abertas, encerradas,
consultadas e realizar depósito ou saque nas mesmas. Todos os clientes são cadastrados com
nome, endereço, telefone e renda pessoal. Para todas as contas é mantido um histórico com
todas as informações da conta e a data e horário. O histórico pode ser gravado e emitido um
extrato.