Apostila Versao 4.0 DWIII - ALUNO

UNIVERSO
UNIVERSIDADE SALGADO DE OLIVEIRA
Curso:
Sistemas de Informação
DISCIPLINA:
Desenvolvimento
WEB III - 7142
Versão 4.0
6º período
Prof. Marcos Vinícius Celeste Dalamura

dalamura@gmail.com http://dalamura.zip.net
Juiz de Fora-MG
2º Semestre / 2018
SUMÁRIO
APRESENTAÇÃO ................................................................................. 4
1-INTRODUÇÃO .................................................................................. 5
O que é PHP ? ............................................................................. 5
O que pode ser feito com PHP ?.................................................... 5
Como surgiu a linguagem PHP ? ................................................... 5
Instalação do PHP ....................................................................... 6
2-SINTAXE BÁSICA ............................................................................. 7
Delimitando o código PHP............................................................. 7
Separador de instruções ............................................................... 7
Nomes de variáveis ...................................................................... 7
Comentários ................................................................................ 8
3-PRIMEIROS SCRIPTS........................................................................ 9
Primeiro exemplo ......................................................................... 9
Utilizando formulários HTML ....................................................... 10
Interagindo com o browser......................................................... 11
4-TIPOS DE DADOS .......................................................................... 13
Tipos suportados ....................................................................... 13
Inteiros ..................................................................................... 13
Números em ponto flutuante ...................................................... 13
Strings ...................................................................................... 14
Arrays ....................................................................................... 15
Listas ........................................................................................ 16
Objetos ..................................................................................... 17
Booleanos ................................................................................. 17
Transformação de tipos .............................................................. 18
DESENVOLVIMENTO WEB III - 7142
5-CONSTANTES ................................................................................ 20
Constantes pré-definidas ............................................................ 20
Definindo constantes.................................................................. 20
6-OPERADORES ................................................................................ 21
Aritméticos ................................................................................ 21
De Strings ................................................................................. 22
De Atribuição ............................................................................ 22
Bit a Bit..................................................................................... 23
Lógicos ..................................................................................... 23
Comparação .............................................................................. 24
De Incremento e Decremento ..................................................... 25
Ordem de precedência dos operadores ....................................... 25
7-ESTRUTURAS DE CONTROLE .......................................................... 27
Blocos ....................................................................................... 27
Comandos de seleção ................................................................ 27
Comandos de repetição .............................................................. 31
Quebra de fluxo ......................................................................... 36
8-FUNÇÕES ...................................................................................... 38
Definindo funções ...................................................................... 38
Valor de retorno ........................................................................ 38
Argumentos .............................................................................. 38
Passagem de parâmetros por referência ...................................... 40
Argumentos com valores pré-definidos ........................................ 41
Contexto ................................................................................... 42
Escopo ...................................................................................... 42
Funções do PHP ........................................................................ 44
9-VARIÁVEIS .................................................................................... 47
O modificador static ................................................................... 47
Variáveis variáveis ..................................................................... 48
-2-
Variáveis enviadas pelo navegador .............................................. 48

Variáveis de ambiente ................................................................ 48
Verificando o tipo de uma variável .............................................. 49
Destruindo uma variável ............................................................. 50
Verificando se uma variável possui valor ...................................... 51
10 - ACESSO A BANCOS DE DADOS.................................................... 52
Exemplo Prático ......................................................................... 52
Funções do Exemplo Prático ....................................................... 84
Como mudar senha do usuário do BD MySQL ............................... 86
11 - INTRODUÇÃO À ORIENTAÇÃO A OBJETOS EM PHP ...................... 87
Exemplo Prático de uso do BD MySQL usando POO em PHP ........ 139
CONSIDERAÇÕES FINAIS ................................................................ 158
REFERÊNCIAS BIBLIOGRÁFICAS ...................................................... 159
SITES SOBRE PHP E MYSQL ............................................................ 160
-3-
APRESENTAÇÃO
Esta disciplina é voltada a todos os estudantes e profissionais de informática

que trabalham ou querem conhecer um pouco mais sobre Desenvolvimento Web. De
forma sucinta, apresentaremos os principais conceitos e mecanismos da linguagem
PHP e sua interação com o HTML na construção de páginas dinâmicas.
O PHP, por ser gratuito (Linguagem de Programação Opensource), de fácil
instalação e configuração e possuir uma curva de aprendizado relativamente curta,
está sendo cada vez mais difundido e consolidado entre desenvolvedores de sites e
webmasters.
O objetivo desta disciplina é fazer com que os alunos conheçam o
funcionamento básico da linguagem e que possam depois ter condições de explorar
todos os seus recursos.
-4-
1 - INTRODUÇÃO
O que é PHP?
PHP é uma linguagem que permite criar sites WEB dinâmicos, possibilitando
uma interação com o usuário através de formulários, parâmetros da URL e links. O
código PHP é executado no servidor, sendo enviado para o cliente apenas HTML
puro. Desta maneira é possível interagir com bancos de dados e aplicações
existentes no servidor, com a vantagem de não expor o código fonte para o cliente.
Útil quando o programa está lidando com senhas ou informação confidencial.
O que pode ser feito com PHP?
Basicamente, coletar dados de um formulário, gerar páginas dinamicamente

ou enviar e receber cookies. PHP também tem como uma das características mais
importantes o suporte a um grande número de bancos de dados, como dBase,
Interbase, mSQL, mySQL, Oracle, Sybase, PostgreSQL e vários outros.
Além disso, PHP tem suporte a outros serviços através de protocolos como
IMAP, SNMP, POP3 e, logicamente, HTTP.
Como surgiu a linguagem PHP?
A linguagem PHP foi concebida durante o outono de 1994 por Rasmus Lerdorf.
A primeira versão ficou conhecida como “Personal Home Page Tools” (ferramentas
para página pessoal). Era composta por um sistema bastante simples que
interpretava algumas macros e alguns utilitários que rodavam “por trás” das home-
pages: um livro de visitas, um contador e algumas outras coisas.
Em meados de 1995 o interpretador foi reescrito, e ganhou o nome de
PHP/FI, quando ele adicionou suporte a mSQL. Estima-se que em 1996 PHP/FI
estava sendo usado por cerca de 15.000 sites pelo mundo, e em meados de 1997
esse número subiu para mais de 50.000. Nessa época houve uma mudança no
desenvolvimento do PHP. Ele passou a ter uma equipe de desenvolvimento mais
organizada. O interpretador foi reescrito por Zeev Suraski e Andi Gutmans, e
esse novo interpretador foi a base para a versão 3.
Atualmente o uso do PHP vem crescendo numa velocidade incrível.
Em junho de 2004 foi lançada a versão 5 do PHP. Atualmente ele se encontra
na versão 7.2.8 (19/07/2018).
-5-
Instalação do PHP
Inevitavelmente, todos os iniciantes em PHP passam por alguma dificuldade

na hora de instalar o PHP. O que poucos sabem é que existem alguns programas que
já fazem isso, usando somente os famosos cliques next, next, next. Abordarei aqui o
WAMP5.
O WAMP5 (que significa Windows, Apache, MySQL, PHP5) é um pacote de
programas que instala automaticamente o Apache 2.2.22, PHP5.3.13, MySQL
Database 5.5.24, PHPmyadmin e SQLitemanager (WAMP5 Versão 2.2e - 32 bits).
Com esse pacote você poderá fazer sua página na Internet ser dinâmica. Também é
possível criar um servidor que possa hospedar e armazenar dados ou páginas da
Internet em um banco de dados.
• Apache: É um dos maiores servidores de web livre e foi criado em
cima de códigos já prontos. O servidor é compatível com o protocolo
HTTP. Para saber mais sobre as funcionalidades visite o site oficial do
Apache (em inglês): http://httpd.apache.org/
• MySQL database: MySQL é um sistema gerenciador de banco de
dados (SGDB) que funciona de forma estruturada. Possui um excelente
desempenho e é um software livre. Compatível com muitos drivers e
também módulos de interfaces para muitas linguagens de
programação. Suporta vários tipos de tabelas. Para mais informações
sobre o MySQL database, visite o site oficial do MySQL (em inglês):
http://www.mysql.com/
• PHPmyadmin: Programa desenvolvido para a parte administrativa do
PHP. É possível criar e deletar bases de dados ou tabelas. É possível
que você faça alterações nas suas tabelas, campos, enfim, tudo o que
você precisar alterar na sua base de dados. Para mais informações
sobre o PHPmyadmin visite http://www.phpmyadmin.net/
• SQLitemanager: É o sistema gerenciador do SQL. Você pode aplicar o
SQLitemanager na hora que estiver montando o seu banco de dados
com o MySQL database.
Os arquivos em PHP criados deverão ser salvos na pasta www que o WAMP5
criará em sua pasta raiz (C:/wamp/www/dw3), e para acessar esses arquivos via
browser você deverá ir pelo seguinte endereço local: http://127.0.0.1/ ou
http://localhost/. Seja organizado separando seus sites em pastas. Assim ficará mais
fácil encontrar o que precisa. Portanto crie subpastas no diretório www (Ex:
C:/wamp/www/dw3/aula).
Para edição dos arquivos .php, utilizaremos o programa PHP Editor Versão
2.22. PHP Editor é um editor freeware e totalmente em português destinado a
edição de páginas PHP e HTML. Para baixa-lo, acesse: http://www.dalamura.zip.net
Se você já utiliza outro editor de código fonte, fique a vontade para continuar
utilizando o mesmo.
-6-
2 – SINTAXE BÁSICA
Delimitando o Código PHP
O código PHP fica embutido no próprio HTML. O interpretador identifica

quando um código é PHP pelas seguintes tags:
<?php
comandos
?>
<script language=”php”>
comandos
</script>
<?
comandos
?>
<%
comandos
%>
Os tipos de tags mais utilizados são o primeiro e o terceiro. Para utilizar a

terceira forma é necessário habilitar a opção short_open_tag na configuração do PHP
(php.ini). O último tipo serve para facilitar o uso por programadores acostumados à
sintaxe de ASP. Para utilizá-lo também é necessário habilitá-lo no PHP (opção
asp_tags), através do arquivo de configuração php.ini.
Separador de Instruções
Entre cada instrução em PHP é preciso utilizar o ponto-e-vírgula, assim como

em C, Perl e outras linguagens mais conhecidas. Exemplo:
echo “Hello, World”;
Nomes de Variáveis
Toda variável em PHP tem seu nome composto pelo caracter $ e uma string,
que deve iniciar por uma letra ou o caracter “_”. PHP é case sensitive, ou seja, as
variáveis $var e $VAR são diferentes. É costume usar minúsculas.
-7-
Comentários
Há dois tipos de comentários em código PHP:
Comentários de uma linha:

Marca como comentário até o final da linha ou até o final do bloco de código
PHP – o que vier antes. Pode ser delimitado pelo caracter “#” ou por duas barras
(//).
Exemplo:
<? echo “teste”; #isto é um teste ?>

<? echo “teste”; //este teste é similar ao anterior ?>
Comentários de mais de uma linha:

Tem como delimitadores os caracteres “/*” para o início do bloco e “*/” para o
final do comentário. Se o delimitador de final de código PHP ( ?> ) estiver dentro de
um comentário, não será reconhecido pelo interpretador.
Exemplo:
<?
echo “teste”; /* Isto é um comentário com mais
de uma linha
*/
?>
-8-
3 – PRIMEIROS SCRIPTS
Primeiro Exemplo
Neste exemplo, criaremos um script com uma saída simples, que servirá, entre
outras coisas, para testar se a instalação foi feita corretamente:
Salve o arquivo como “exemplo1.php” no diretório de documentos do Web

Server. Abra uma janela do navegador e digite o endereço
“http://nome_do_servidor/exemplo1.php”. Verificando o código fonte da página
exibida, temos o seguinte:
<html>
<head><title>Aprendendo PHP</title></head>
<body>
Meu Primeiro Script usando PHP
</body>
</html>
Isso mostra como o PHP funciona. O script é executado no servidor, ficando
disponível para o usuário apenas o resultado. Agora vamos escrever um script que
produza exatamente o mesmo resultado utilizando uma variável. Salve o arquivo
como “exemplo2.php” no diretório de documentos do Web Server.
-9-
Utilizando Formulários HTML
Ao clicar num botão “Submit” em um formulário HTML as informações dos

campos serão enviadas ao servidor especificado para que possa ser produzida uma
resposta. O PHP trata esses valores como variáveis, cujo nome é o nome do campo
definido no formulário. O exemplo a seguir mostra isso, e mostra também como o
código PHP pode ser inserido em qualquer parte do código HTML:
Ao salvar o arquivo acima (exemplo3.php) e carregá-lo no browser, o usuário

verá apenas um formulário que contém um espaço para digitar o texto. Ao digitar
um texto qualquer e submeter o formulário, a resposta, que é o mesmo arquivo PHP
(indicado pela constante $_SERVER['PHP_SELF'], que retorna o nome do arquivo)
mostrará o que foi digitado.
Isso ocorre porque o código PHP testa o conteúdo da variável $texto.

Inicialmente ele é uma string vazia, e por isso nada é impresso na primeira parte.
Quando algum texto é digitado no formulário e submetido, o PHP passa a tratá-lo
como uma variável. Como no formulário o campo possui o nome “texto”, a variável
com seu conteúdo será $texto. Assim, no próximo teste o valor da variável será
diferente de uma string vazia, e o PHP imprime um texto antes do formulário.
No exemplo a seguir (exemplo4.php), estaremos enviando a variável $texto

via POST e as variáveis $acao e $variavel via GET. Observe que a variável enviada
via POST é um campo do formulário e as variáveis enviadas via GET, estão na URL
(Uniform Resource Indicator).
- 10 -
Interagindo com o Browser
PHP também permite interagir com informações do browser automaticamente.

Por exemplo, o script a seguir (exemplo5.php) mostra informações sobre o browser
do usuário.
- 11 -
Observe que o resultado mostra características de cada browser, como a

versão. Com isso, se você criar uma página com recursos disponíveis somente no
Internet Explorer, por exemplo, pode esconder o código dos outros browsers, com
um código semelhante ao seguinte (exemplo6.php):
Neste exemplo, será apenas exibido um texto informando se está sendo

utilizado o Microsoft Internet Explorer ou não, mas para outras funções poderia ser
utilizado algo semelhante.
É bom notar o surgimento de mais uma função no código anterior:
strpos(string1,string2). Essa função retorna a posição da primeira aparição de string2
em string1, contando a partir de zero, e não retorna valor algum se não ocorrer.
Assim, para testar se a string $_SERVER['HTTP_USER_AGENT'] contém a string
“MSIE”, basta testar se strpos devolve algum valor.
- 12 -
4 – TIPOS DE DADOS
Tipos Suportados
PHP suporta os seguintes tipos de dados:
• Inteiro
• Ponto flutuante
• String
• Array
• Objeto
• Booleano
PHP utiliza checagem de tipos dinâmica, ou seja, uma variável pode conter
valores de diferentes tipos em diferentes momentos da execução do script. Por este
motivo não é necessário declarar o tipo de uma variável para usá-la. O interpretador
PHP decidirá qual o tipo daquela variável, verificando o conteúdo em tempo de
execução.
Ainda assim, é permitido converter os valores de um tipo para outro desejado,
utilizando a função settype.
Inteiros (integer ou long)

Uma variável pode conter um valor inteiro com atribuições que sigam as
seguintes sintaxes:
$var = 1234; # inteiro positivo na base decimal

$var = -234; # inteiro negativo na base decimal
$var = 0234; # inteiro na base octal-simbolizado pelo 0
# equivale a 156 decimal
$var = 0x34; # inteiro na base hexadecimal(simbolizado
# pelo 0x) – equivale a 52 decimal.
A diferença entre inteiros simples e long está no número de bytes utilizados

para armazenar a variável. Como a escolha é feita pelo interpretador PHP de maneira
transparente para o usuário, podemos afirmar que os tipos são iguais.
Números em Ponto Flutuante (double ou float)
Uma variável pode ter um valor em ponto flutuante com atribuições que sigam
as seguintes sintaxes:
$var = 1.234; = (1,234)

$var = 23e4; # equivale a 230.000 = (23 X 104)
(23 e4 = 23x10 elevado a 4)
- 13 -
Strings
Strings podem ser atribuídas de duas maneiras:
a) utilizando aspas simples ( ' ) – Desta maneira, o valor da variável será

exatamente o texto contido entre as aspas (com exceção de \\ e \' –
ver tabela abaixo)
b) utilizando aspas duplas ( " ) – Desta maneira, qualquer variável ou
caracter de escape será expandido antes de ser atribuído.
Exemplo7.php
A saída desse script será "---$teste--\n".
Exemplo8.php
A saída desse script será "---Brasil--" (com uma quebra de linha no final).
- 14 -
A tabela seguinte lista os caracteres de escape:
Sintaxe Significado
\n Nova linha
\r Retorno de carro (semelhante a \n)
\t Tabulação horizontal
\\ A própria barra ( \ )
\$ O símbolo $
\’ Aspa simples
\” Aspa dupla
Arrays
Arrays em PHP podem ser observados como mapeamentos ou como vetores
indexados. Mais precisamente, um valor do tipo array é um dicionário onde os
índices são as chaves de acesso. Vale ressaltar que os índices podem ser valores de
qualquer tipo e não somente inteiros. Inclusive, se os índices forem todos inteiros,
estes não precisam formar um intervalo contínuo.
Como a checagem de tipos em PHP é dinâmica, valores de tipos diferentes
podem ser usados como índices de array, assim como os valores mapeados também
podem ser de diversos tipos.
Exemplo9.php
Equivalentemente, pode-se escrever:
Exemplo10.php
- 15 -
Listas
As listas são utilizadas em PHP para realizar atribuições múltiplas. Através de
listas é possível atribuir valores que estão num array para variáveis. Vejamos o
exemplo:
Exemplo:
list($a, $b, $c) = array(“a”, “b”, “c”);
O comando acima atribui valores às três variáveis simultaneamente. É bom

notar que só são atribuídos às variáveis da lista os elementos do array que possuem
índices inteiros e não negativos. No exemplo acima as três atribuições foram bem
sucedidas porque ao inicializar um array sem especificar os índices eles passam a ser
inteiros, a partir do zero. Um fator importante é que cada variável da lista possui um
índice inteiro e ordinal, iniciando com zero, que serve para determinar qual valor será
atribuído. No exemplo anterior temos $a com índice 0, $b com índice 1 e $c com
índice 2.
Vejamos um outro exemplo (exemplo11.php):
- 16 -
Objetos
Um objeto pode ser inicializado utilizando o comando new para instanciar uma
classe para uma variável.
exemplo12.php
No Capítulo 11 (Introdução à Orientação a Objetos em PHP) estudaremos

como se cria uma Classe, Atributos, Métodos e Objetos em PHP. Criaremos também
um exemplo prático de uso do Banco de Dados MySQL, usando POO em PHP.
Outras informações sobre a programação com objetos em PHP podem ser

consultadas no Manual da linguagem em http://www.php.net/manual/pt_BR/.
Booleanos
Este é o tipo mais fácil. Um booleano expressa um valor de verdade. Ele pode ser
TRUE ou FALSE. Nota: O tipo booleano foi introduzido no PHP 4.
Sintaxe:
Para especificar um literal booleano, use as palavras chave TRUE ou FALSE. Ambas
são insensitivas ao caso.
<?php
$teste = True; // assimila o valor TRUE para a variável $teste
?>
Usualmente você pode utilizar algum tipo de operador que retorne um valor
booleano, e passá-lo para uma estrutura de controle.
<?php
// == é um operador que testa igualdade e retorna um booleano
- 17 -
if ($acao == "mostrar_versao") {
echo "A versão é 1.25";
}
?>
Aviso: Sempre é usado o valor 0 (zero) para representar o estado FALSE, e qualquer
valor diferente de zero (geralmente 1) para representar o estado TRUE.
-1 é considerado TRUE, como qualquer valor não zero (negativos ou positivos)!
Transformação de Tipos
A transformação de tipos em PHP pode ser feita das seguintes maneiras:
Coerções
Quando ocorrem determinadas operações (“+”, por exemplo) entre dois
valores de tipos diferentes, o PHP converte o valor de um deles automaticamente
(coerção). É interessante notar que se o operando for uma variável, seu valor não
será alterado.
O tipo para o qual os valores dos operandos serão convertidos é determinado
da seguinte forma: Se um dos operandos for float, o outro será convertido para float,
senão, se um deles for integer, o outro será convertido para integer.
Exemplo:
$var = “1”; // $var é a string “1”

$var = $var + 1; // $var é o integer 2
$var = $var + 3.7; // $var é o double 5.7
$var = 1 + 1.5; // $var é o double 2.5
Como podemos notar, o PHP converte string para integer ou double mantendo
o valor. O sistema utilizado pelo PHP para converter de strings para números é
o seguinte:
- É analisado o início da string. Se contiver um número, ele será
avaliado. Senão, o valor será 0 (zero);
- O número pode conter um sinal no início (“+” ou “-“);
- Se a string contiver um ponto em sua parte numérica a ser
analisada, ele será considerado, e o valor obtido será double;
- Se a string contiver um “e” ou “E” em sua parte numérica a ser
analisada, o valor seguinte será considerado como expoente da base
10, e o valor obtido será double;
Exemplos:
$var = 1 + “10.5”; // $var == 11.5

$var = 1 + “-1.3e3”; // $var == -1299
$var = 1 + “teste10.5”; // $var == 1
$var = 1 + “10testes”; // $var == 11
$var = 1 + " 10testes"; // $var == 11
$var = 1 + "+ 10testes"; // $var == 1
- 18 -
Transformação explícita de tipos
A sintaxe do typecast de PHP é semelhante ao C: basta escrever o tipo entre

parênteses antes do valor.
Exemplos:
$var = 15; // $var é integer (15)

$var = (double) $var; // $var é double (15.0)
$var = 3.9; // $var é double (3.9)
$var = (int) $var; // $var é integer (3)
Os tipos de cast permitidos são:

(int), (integer)  muda para integer;
(real), (double), (float)  muda para float;
(string)  muda para string;
(array)  muda para array;
(object)  muda para objeto.
Com a função settype
A função settype converte uma variável para o tipo especificado, que pode ser
“integer”, “double”, “string”, “array” ou “object”. Exemplo:
$var = 15; // $var é integer

settype($var,double); // $var é double
- 19 -
5 – CONSTANTES
Constantes Pré-Definidas
O PHP possui algumas constantes pré-definidas, indicando a versão do PHP, o
Sistema Operacional do servidor, o arquivo em execução, e diversas outras
informações. Para ter acesso a todas as constantes pré-definidas, pode-se utilizar a
função phpinfo(), que exibe uma tabela contendo todas as constantes pré-definidas,
assim como configurações da máquina, sistema operacional, servidor http e versão
do PHP instalada (exemplo13.php):
Definindo Constantes
Para definir constantes utiliza-se a função define. Uma vez definido, o valor
de uma constante não poderá mais ser alterado. Uma constante só pode
conter valores escalares, ou seja, não pode conter nem um array nem um objeto. A
assinatura da função define é a seguinte:
bool define ( string $name , mixed $value [, bool $case_insensitive ] );
A função retorna TRUE se for bem-sucedida. Veja um exemplo de sua
utilização a seguir (exemplo14.php):
- 20 -
6 – OPERADORES
Aritméticos
Só podem ser utilizados quando os operandos são números (integer ou float).
Se forem de outro tipo, terão seus valores convertidos antes da realização da
operação.
+ adição
- subtração
* multiplicação
/ divisão
% Módulo (Resto da Divisão)
Exemplo15.php:
- 21 -
De Strings
Só há um operador exclusivo para strings:
. concatenação
Exemplo16.php:
Observe no exemplo acima que será exibido apenas 01 (um) espaço entre a
variável $a e a variável $b.
De Atribuição
Existe um operador básico de atribuição e diversos derivados. Sempre
retornam o valor atribuído. No caso dos operadores derivados de atribuição, a
operação é feita entre os dois operandos, sendo atribuído o resultado para o
primeiro.
= atribuição simples
+= atribuição com adição
-= atribuição com subtração
*= atribuição com multiplicação
/= atribuição com divisão
%= atribuição com módulo
.= atribuição com concatenação
Exemplo17.php:
- 22 -
Bit a Bit
Comparam dois números bit a bit.
Exemplo Nome Resultado
Os bits que estão ativos tanto em $a
$a & $b E
quanto em $b são ativados.
Os bits que estão ativos em $a ou
$a | $b OU
em $b são ativados.
Os bits que estão ativos em $a ou
$a ^ $b XOR em $b, mas não em ambos, são
ativados.
Os bits que estão ativos em $a não
~ $a NÃO
são ativados, e vice-versa.
Desloca os bits de $a $b passos para
Deslocamento à
$a << $b a esquerda (cada passo significa
esquerda
"multiplica por dois")
Desloca os bits de $a $b passos para
Deslocamento à
$a >> $b a direita (cada passo significa "divide
direita
por dois")
Exemplo18.php:
Lógicos

Verdadeiro (TRUE) se
$a and $b E tanto $a quanto $b
são verdadeiros.
Verdadeiro se $a ou
$a or $b OU
$b são verdadeiros.
Verdadeiro se $a ou
$a xor $b XOR $b são verdadeiros,
mas não ambos.
Verdadeiro se $a não
! $a NÃO
é verdadeiro.
- 23 -
Verdadeiro se tanto
$a && $b E $a quanto $b são
verdadeiros.
Verdadeiro se $a ou
$a || $b OU
$b são verdadeiros.
Existem dois operadores para “e” e para “ou” porque eles têm diferentes
posições na ordem de precedência.
Exemplo19.php:
Comparação
As comparações são feitas entre os valores contidos nas variáveis, e não as
referências. Sempre retornam um valor booleano.
Verdadeiro (TRUE) se $a é igual a
$a == $b Igual
$b.
Verdadeiro (TRUE) se $a é igual a
$a === $b Idêntico $b, e eles são do mesmo tipo
(introduzido no PHP4).
$a != $b Diferente Verdadeiro se $a não é igual a $b.
$a <> $b Diferente Verdadeiro se $a não é igual a $b.
Verdadeiro de $a não é igual a $b,
$a !== $b Não idêntico ou eles não são do mesmo tipo
(introduzido no PHP4).
Verdadeiro se $a é estritamente
$a < $b Menor que
menor que $b.
Verdadeiro se $a é estritamente
$a > $b Maior que
maior que $b.
Verdadeiro se $a é menor ou igual
$a <= $b Menor ou igual
a $b.
Verdadeiro se $a é maior ou igual a
$a >= $b Maior ou igual
$b.
Obs: $a == $b (é Comparação) $a = $b (é Atribuição)
- 24 -
De Incremento e Decremento
++ incremento
-- decremento
Podem ser utilizados de duas formas: antes ou depois da variável. Quando

utilizado depois, retorna o valor da variável antes de incrementá-la ou decrementá-
la. Quando utilizado antes, retorna o valor da variável já incrementado ou
decrementado. Veja o exemplo20.php:
Ordem de Precedência dos Operadores

A precedência de um operador especifica quem tem mais prioridade quando
há duas delas juntas. Por exemplo, na expressão, 1 + 5 * 3, a resposta é 16 e não
18 porque o operador de multiplicação ("*") tem prioridade de precedência que o
operador de adição ("+"). Parênteses podem ser utilizados para forçar a precedência,
se necessário. Assim, (1 + 5) * 3 é avaliado como 18. Se a precedência do operador
é igual, a associatividade da esquerda para direita é usada.
A tabela seguinte mostra a precedência dos operadores, da maior precedência

no começo. Operadores com a mesma precedência estão na mesma linha, no caso a
associatividade deles decide qual ordem eles são avaliados.
Associação Operador Informação adicional
não associativo clone new clone e new
esquerda [ array()
não associativo ++ -- incremento/decremento
~ - (int) (float) (string)
não associativo tipos
(array) (object) (bool) @
não associativo instanceof tipos
direita ! lógico
esquerda */% aritmético
esquerda +-. aritmético e string
esquerda << >> Bit-a-bit
não associativo < <= > >= <> comparação
não associativo == != === !== comparação
- 25 -
esquerda & Bit-a-bit e referências

esquerda ^ Bit-a-bit
esquerda | Bit-a-bit
esquerda && lógico
esquerda || lógico
esquerda ?: ternário
= += -= *= /= .= %= &=
direita atribuição
|= ^= <<= >>=
esquerda and lógico
esquerda xor lógico
esquerda or lógico
esquerda , muitos usos
Associatividade a esquerda significa que a expressão é avaliada da esquerda
para direita, associatividade a direita o oposto.
- 26 -
7 – ESTRUTURAS DE CONTROLE
As estruturas que veremos a seguir são comuns para as linguagens de
programação imperativas, bastando, portanto, descrever a sintaxe de cada uma
delas, resumindo o funcionamento.
Blocos
Um bloco consiste de vários comandos agrupados com o objetivo de

relacioná-los com determinado comando ou função. Em comandos como if, for,
while, switch e em declarações de funções blocos podem ser utilizados para
permitir que um comando faça parte do contexto desejado. Blocos em PHP são
delimitados pelos caracteres “{” e “}”. A utilização dos delimitadores de bloco
em uma parte qualquer do código não relacionada com os comandos citados ou
funções não produzirá efeito algum, e será tratada normalmente pelo interpretador.
Exemplo:
if ($x == $y)
comando1;
comando2;
Para que comando2 esteja relacionado ao if é preciso utilizar um bloco:
if ($x == $y){ //se ñ colocar as chaves, será entendido só 1º comando

comando1;
comando2;
}
Comandos de Seleção
Também chamados de condicionais, os comandos de seleção permitem
executar comandos ou blocos de comandos com base em testes feitos durante a
execução.
if
O mais trivial dos comandos condicionais é o if. Ele testa a condição e executa
o comando indicado se o resultado for true. Ele possui duas sintaxes:
if (expressão):
if (expressão) comando;
comando; ...
comando;
endif;
- 27 -
Para incluir mais de um comando no if da primeira sintaxe, é preciso utilizar

um bloco, demarcado por chaves.
O else é um complemento opcional para o if. Se utilizado, o comando será
executado se a expressão retornar o valor false . Sua sintaxe é:
if (expressão)
comando;
else
comando;
A seguir, temos um exemplo do comando if utilizado com else:
if ($a > $b)

$maior = $a;
else
$maior = $b;
O exemplo acima coloca em $maior o maior valor entre $a e $b
Em determinadas situações é necessário fazer mais de um teste, e executar

condicionalmente diversos comandos ou blocos de comandos. Para facilitar o
entendimento de uma estrutura do tipo:
if (expressao1)
comando1;
else
if (expressao2)
comando2;
else
if (expressao3)
comando3;
else
comando4;
Foi criado o comando, também opcional elseif. Ele tem a mesma função de
um else e um if usados seqüencialmente, como no exemplo acima. Num mesmo if
podem ser utilizados diversos elseif’s, ficando essa utilização a critério do
programador, que deve zelar pela legibilidade de seu script.
Veja o exemplo21.php:
- 28 -
switch
O comando switch atua de maneira semelhante a uma série de comandos if
na mesma expressão. Freqüentemente o programador pode querer comparar uma
variável com diversos valores, e executar um código diferente a depender de qual
valor é igual ao da variável. Quando isso for necessário, deve-se usar o comando
switch. O exemplo seguinte mostra dois trechos de código que fazem a mesma coisa,
sendo que o primeiro utiliza uma série de if’s e o segundo utiliza switch:
if ($i == 0)
print “i é igual a zero”;
elseif ($i == 1)
print “i é igual a um”;
elseif ($i == 2)
print “i é igual a dois”;
switch ($i) {
case 0:
break; //se não colocar o break, quando achar uma condição que satisfaça,
// sai executando todos os blocos de comandos
case 1:
break;
case 2:
break;
}
- 29 -
É importante compreender o funcionamento do switch para não cometer

enganos. O comando switch testa linha a linha os cases encontrados, e a partir do
momento que encontra um valor igual ao da variável testada, passa a executar todos
os comandos seguintes, mesmo os que fazem parte de outro teste, até o fim do
bloco. Por isso usa-se o comando break, quebrando o fluxo e fazendo com que o
código seja executado da maneira desejada. Veremos mais sobre o break mais
adiante. Veja o exemplo:
switch ($i) {
case 0:
case 1:
case 2:
}
No exemplo acima, se $i for igual a zero, os três comandos “print” serão

executados. Se $i for igual a 1, os dois últimos “print” serão executados. O comando
só funcionará da maneira desejada se $i for igual a 2.
Em outras linguagens que implementam o comando switch, ou
similar, os valores a serem testados só podem ser do tipo inteiro. Em PHP é
permitido usar valores do tipo string como elementos de teste do comando
switch. O exemplo abaixo funciona perfeitamente:
switch ($s) {
case “casa”:
print “A casa é amarela”;
case “arvore”:
print “a árvore é bonita”;
case “lampada”:
print “joao apagou a lampada”;
}
- 30 -
Comandos de Repetição
while
O while é o comando de repetição (laço) mais simples. Ele testa uma condição
e executa um comando, ou um bloco de comandos, até que a condição testada seja
falsa. Assim como o if, o while também possui duas sintaxes alternativas:
while (<expressao>) while (<expressao>):

<comando>; <comando>;
...
<comando>;
endwhile;
A expressão só é testada a cada vez que o bloco de instruções termina, além

do teste inicial. Se o valor da expressão passar a ser false no meio do bloco de
instruções, a execução segue até o final do bloco. Se no teste inicial a condição for
avaliada como false, o bloco de comandos não será executado.
O exemplo a seguir mostra o uso do while para imprimir os números de 1 a 10:
$i = 1;
while ($i <=10)
print $i++;
- 31 -
do... while
O laço do..while funciona de maneira bastante semelhante ao while, com a
simples diferença que a expressão é testada ao final do bloco de comandos. O laço
do..while possui apenas uma sintaxe, que é a seguinte:
do {
<comando>
...
<comando>
} while (<expressao>);
O exemplo utilizado para ilustrar o uso do while pode ser feito da seguinte
maneira utilizando o do.. while:
$i = 0;
do {
print ++$i;
} while ($i < 10);
- 32 -
for
O tipo de laço mais complexo é o for. Para os que programam em C, C++ ou
Java, a assimilação do funcionamento do for é natural. Mas para aqueles que estão
acostumados a linguagens como Pascal, há uma grande mudança para o uso do for.
As duas sintaxes permitidas são:
for (<inicializacao>;<condicao>;<incremento>)
<comando>;
for (<inicializacao>;<condicao>;<incremento>) :
<comando>;
...
<comando>;
endfor;
As três expressões que ficam entre parênteses têm as seguintes finalidades:
- Inicialização: comando ou seqüência de comandos a serem

realizados antes do inicio do laço. Serve para inicializar variáveis.
- Condição: Expressão booleana que define se os comandos que
estão dentro do laço serão executados ou não. Enquanto a
expressão for verdadeira os comandos serão executados.
- Incremento: Comando executado ao final de cada execução do
laço.
Um comando for funciona de maneira semelhante a um while escrito da

seguinte forma:
<inicializacao>
while (<condicao>) {
comandos
...
<incremento>
}
- 33 -
foreach
Desde a versão 4, o PHP trás o construtor foreach que é uma função que
permite uma navegação muito fácil e simplificada para se “navegar” por um array. As
duas sintaxes permitidas são:
foreach ($nome_array as $elemento)

{
comandos
}
ou
foreach ($nome_array as $chave => $valor)

{
comandos
}
A primeira forma vai do primeiro ao último índice do array definido na variável

$nome_do_array, e a cada interação o valor do elemento corrente do array é
atribuído à variável $elemento, e o ponteiro interno do array é avançado. Dessa
forma, podemos trabalhar com todos os valores do array utilizando apenas a variável
$elemento.
A segunda forma faz a mesma coisa, mas com uma diferença: além do valor
do elemento corrente do array ser atribuído à variável $elemento, a chave (ou
índice) do elemento atual é atribuído à variável $chave. Veja o exemplo26.php
abaixo:
O exemplo acima mostrará na tela todos os valores do array $vetor.
Veja outro exemplo abaixo (exemplo27.php):
- 34 -
Este exemplo mostrará todas as chaves (ou índices) e valores do array $a, e
terá o seguinte resultado:
$a [um] => 1.
$a [dois] => 2.
$a [tres] => 3.
Vamos ver um exemplo com um array com índices diferentes

(exemplo28.php):
A saída deste exemplo será:
alice
aline
alba
amélia
anna
- 35 -
OU
0) alice
1) aline
2) alba
nome4) amélia
3) anna
Quebra de Fluxo
Break
O comando break pode ser utilizado em laços de do, for e while, além do uso
já visto no comando switch. Ao encontrar um break dentro de um desses laços, o
interpretador PHP pára imediatamente a execução do laço, seguindo normalmente o
fluxo do script.
while ($x > 0) {
...
if ($x == 20) {
echo “erro! x = 20”;
break;
...
}
No trecho de código acima, o laço while tem uma condição para seu término
normal ($x > 0), mas foi utilizado o break para o caso de um término não previsto
no início do laço. Assim o interpretador seguirá para o comando seguinte ao laço.
Veja o exemplo29.php abaixo:
- 36 -
Continue
O comando continue também deve ser utilizado no interior de laços, e
funciona de maneira semelhante ao break, com a diferença que o fluxo ao invés de
sair do laço volta para o início dele. Vejamos o exemplo30.php:
O exemplo acima é uma maneira eficiente de imprimir os números pares entre

0 e 100. O que o laço faz é testar se o resto da divisão entre o número e 2 é 0. Se
for diferente de zero (valor lógico true) o interpretador encontrará um continue, que
faz com que os comandos seguintes do interior do laço sejam ignorados, seguindo
para a próxima iteração.
- 37 -
8 – Funções
Definindo Funções
A sintaxe básica para definir uma função é:
function nome_da_função([arg1, arg2, arg3]) {

Comandos;
... ;
[return <valor de retorno>];
}
Qualquer código PHP válido pode estar contido no interior de uma função.
Como a checagem de tipos em PHP é dinâmica, o tipo de retorno não deve ser
declarado, sendo necessário que o programador esteja atento para que a função
retorne o tipo desejado.
Valor de Retorno
Toda função pode opcionalmente retornar um valor, ou simplesmente
executar os comandos e não retornar valor algum.
Não é possível que uma função retorne mais de um valor, mas é permitido
fazer com que uma função retorne um valor composto, como listas ou arrays.
Argumentos
É possível passar argumentos para uma função. Eles devem ser declarados
logo após o nome da função, entre parênteses, e tornam-se variáveis pertencentes
ao escopo local da função. A declaração do tipo de cada argumento também é
utilizada apenas para efeito de documentação.
exemplo31.php:
- 38 -
Podemos também criar funções matemáticas em PHP. No exemplo32.php

mostraremos como criar uma função para calcular a média aritmética entre dois
números:
Vamos escrever agora uma função que retorna a soma de dois valores. Veja o
exemplo33.php:
- 39 -
Passagem de Parâmetros por Referência

Normalmente, a passagem de parâmetros em PHP é feita por valor, ou seja,
se o conteúdo da variável for alterado, essa alteração não afeta a variável original.
Exemplo34.php:
No exemplo anterior, como a passagem de parâmetros é por valor, a função

mais5 é inútil, já que após a execução sair da função o valor anterior da variável é
recuperado. Se a passagem de valor fosse feita por referência, a variável $a teria 8
como valor. O que ocorre normalmente é que ao ser chamada uma função, o
interpretador salva todo o escopo atual, ou seja, os conteúdos das variáveis. Se uma
dessas variáveis for passada como parâmetro, seu conteúdo fica preservado, pois a
função irá trabalhar na verdade com uma cópia da variável. Porém, se a passagem
de parâmetros for feita por referência, toda alteração que a função realizar no valor
passado como parâmetro afetará a variável que o contém.
Existe uma maneira de fazer com que uma função tenha parâmetros passados
por referência, indicando isso na declaração da função, o que faz com que a
passagem de parâmetros sempre seja assim (por referência). Para isso, utiliza-se o
modificador “&”. Vejamos abaixo o exemplo35.php:
- 40 -
Argumentos com Valores Pré-Definidos (default)

Em PHP é possível ter valores default para argumentos de funções, ou seja,
valores que serão assumidos em caso de nada ser passado no lugar do argumento.
Quando algum parâmetro é declarado desta maneira, a passagem do mesmo na
chamada da função torna-se opcional. Veja o exemplo36.php
É bom lembrar que quando a função tem mais de um parâmetro, o que tem
valor default deve ser declarado por último (exemplo37.php):
- 41 -
Contexto
O contexto é o conjunto de variáveis e seus respectivos valores num
determinado ponto do programa. Na chamada de uma função, ao iniciar a execução
do bloco que contém a implementação da mesma é criado um novo contexto,
contendo as variáveis declaradas dentro do bloco, ou seja, todas as variáveis
utilizadas dentro daquele bloco serão eliminadas ao término da execução da função.
Escopo
O escopo de uma variável em PHP define a porção do programa onde ela
pode ser utilizada. Na maioria dos casos todas as variáveis têm escopo global.
Entretanto, em funções definidas pelo usuário um escopo local é criado. Uma
variável de escopo global não pode ser utilizada no interior de uma função sem que
haja uma declaração. Exemplo38.php:
O trecho anterior não produzirá saída alguma, pois a variável $var é de escopo
global, e não pode ser referida num escopo local, mesmo que não haja outra com
nome igual que cubra a sua visibilidade. Para que o script funcione da forma
desejada, a variável global a ser utilizada deve ser declarada. Exemplo39.php:
- 42 -
Uma declaração “global” pode conter várias variáveis, separadas por vírgulas.
Uma outra maneira de acessar variáveis de escopo global dentro de uma função é
utilizando um array pré-definido pelo PHP cujo nome é $GLOBALS. O índice para a
variável referida é o proprio nome da variável, sem o caracter $. O exemplo acima e
o abaixo (exemplo40.php) produzem o mesmo resultado:
- 43 -
Funções do PHP
DATA/HORA
Sintaxe: array getdate ([ int $timestamp ] )
Elementos chave de retorno do array associativo

Exemplo dos
Chave Descrição valores
retornados
Representação numérica
"seconds" 0 a 59
dos segundos
"minutes" 0 a 59
dos minutos
"hours" 0 a 23
das horas
"mday" 1 a 31
do dia do mês
Representação numérica 0 (para Sunday) a 6
"wday"
do dia da semana (para Saturday)
"mon" 1 a 12
de um mês
Representação numérica Exemples: 1999 ou
"year"
completa do ano, 4 digitos 2003
Numeric representation of
"yday" 0 a 365
the day of the year
Representação textual
"weekday" Sunday a Saturday
completa do dia da semana
Representação textual
"month" completa de um mês, tal January a December
como January ou March
Exemplo41.php
- 44 -
Exercício: Monte uma função em PHP para imprimir a data atual dinamicamente
conforme texto a seguir: Juiz de Fora – MG, Sexta-Feira, 16 de Setembro de 2016.
MATEMÁTICAS
Sintaxe: number pow ( number $base , number $exp )

Retorna a base elevada ao expoente exp .
Exemplo42.php
Sintaxe: float log10 ( float $arg )

Retorna o logaritmo na base 10 de arg.
Sintaxe: float log ( float $arg [, float $base ] )

Retorna o logarimo de arg na base , se fornecido, ou o logaritmo natural (base e).
Exemplo43.php
Veja mais funções matemáticas em: http://br.php.net/manual/pt_BR/ref.math.php
- 45 -
STRING
Vamos ver duas funções utilizadas em strings: strlen e strpos.

Exemplo44.php
Veja mais funções para strings em: http://br.php.net/manual/pt_BR/ref.strings.php
- 46 -
9 – Variáveis
O Modificador static
Uma variável estática é visível num escopo local, mas ela é inicializada apenas
uma vez e seu valor não é perdido quando a execução do script deixa esse escopo.
O último comando da função é inútil, pois assim que for encerrada a execução
da função a variável $a perde seu valor. Já no exemplo46.php seguinte, a cada
chamada da função a variável $a terá seu valor impresso e será incrementada:
O modificador static é muito utilizado em funções recursivas1, já que o valor

de algumas variáveis precisa ser mantido. Ele funciona da seguinte forma: O valor
das variáveis declaradas como estáticas é mantido ao terminar a execução da
função. Na próxima execução da função, ao encontrar novamente a declaração com
static, o valor da variável é recuperado.
1
É uma função que invoca a si própria, ou invoca outra função, e na seqüência das diversas sub-
funções, uma das sub-funções invoca a primeira função.
- 47 -
Em outras palavras, uma variável declarada como static tem o mesmo “tempo
de vida” que uma variável global, porém sua visibilidade é restrita ao escopo local
em que foi declarada e só é recuperada após a declaração.
Variáveis Variáveis
(Variáveis geradas dinamicamente)
O PHP tem um recurso conhecido como variáveis variáveis, que consiste em
variáveis cujos nomes também são variáveis. Sua utilização é feita através do duplo
cifrão ($$). Vejamos o exemplo47.php:
Variáveis Enviadas pelo Navegador

Para interagir com a navegação feita pelo usuário, é necessário que o PHP
possa enviar e receber informações para o software de navegação. A maneira de
enviar informações, como já foi visto anteriormente, geralmente é através de um
comando de impressão, como o echo. Para receber informações vindas do
navegador através de um link ou um formulário HTML o PHP utiliza as informações
enviadas através da URL. Por exemplo: se você chama seu script PHP com a url
“http://localhost/teste.php?var=teste”, automaticamente o PHP criará uma variável
com o nome $var contendo a string “teste”.
Variáveis de Ambiente
O PHP possui diversas variáveis de ambiente, como a
$_SERVER['PHP_SELF'], por exemplo, que contém o nome e o path do próprio
arquivo. Algumas outras contém informações sobre o navegador do usuário, o
servidor http, a versão do PHP e diversas informações. Para ter uma listagem de
todas as variáveis e constantes de ambiente e seus respectivos conteúdos, deve-se
utilizar a função phpinfo().
- 48 -
Verificando o Tipo de uma Variável
Por causa da tipagem dinâmica utilizada pelo PHP, nem sempre é possível
saber qual o tipo de uma variável em determinado instante se não contar com a
ajuda de algumas funções que ajudam a verificar isso. A verificação pode ser feita de
duas maneiras:
Função que retorna o tipo da variável

Esta função é a gettype. Sua assinatura é a seguinte:
string gettype ( mixed $var )
A palavra “mixed” indica que a variável $var pode ser de diversos tipos.
Valor Retornado: Os possíveis valores retornados pela função são:
• "boolean"
• "integer"
• "double" (por razões históricas "double" é retornado no caso de float, e
não simplesmente "float")
• "string"
• "array"
• "object"
• "resource"
• "NULL"
• "unknown type"
Exemplo48.php
- 49 -
Funções que testam o tipo da variável

São as funções is_int, is_integer, is_bool, is_real, is_long, is_float, is_string,
is_array e is_object. Todas têm o mesmo formato, seguindo modelo da assinatura a
seguir:
bool is_integer(mixed var);
Todas essas funções retornam true se a variável for daquele tipo, e false em
caso contrário.
Exemplo49.php
Destruindo uma Variável

É possível desalocar uma variável se ela não for usada posteriormente através
da função unset, que tem a seguinte assinatura:
void unset(mixed var);
Veja o exemplo50.php
- 50 -
A função destrói a variável, ou seja, libera a memória ocupada por ela,

fazendo com que ela deixe de existir. Se mais na frente for feita uma chamada á
variável, será criada uma nova variável de mesmo nome e de conteúdo vazio, a não
ser que a chamada seja pela função isset. Se a operação for bem sucedida, retorna
true.
Verificando se uma Variável Possui um Valor

Existem dois tipos de teste que podem ser feitos para verificar se uma variável
está setada: com a função isset e com a função empty.
A função isset
Possui o seguinte protótipo:
bool isset ( mixed $var [, mixed $var [, $... ]] )
Retorna true se a variável estiver setada (ainda que com uma string vazia ou
o valor zero), e false em caso contrário.
A função empty
Possui a seguinte assinatura:
bool empty ( mixed $var )
E retorna true se a variável não contiver um valor (não estiver setada) ou

possuir valor 0 (zero) ou uma string vazia. Caso contrário, retorna false.
Veja o exemplo51.php
- 51 -
10 - ACESSO A BANCOS DE DADOS

EXEMPLO PRÁTICO
Este tutorial foi preparado especialmente para os usuários que estão começando seu
aprendizado na linguagem PHP e com o Banco de Dados MySQL.
Vamos fazer um cadastro de clientes onde teremos a opção de incluir novos clientes,
alterar os dados dos clientes existentes, excluir e buscar determinado cliente, bem como gerar
relatório de clientes cadastrados na nossa base de dados.
Cadastro de clientes
Área do nosso sistema para a inclusão de novos clientes. Abaixo, segue a estrutura da nossa
tabela.
tb_clientes
- id_cli - Número auto–incremento, vai ser a nossa chave primária (PK)
- inclusao_cli - Data e horário do cadastro do cliente
- nome_cli - Nome completo
- end_cli - Endereço
- bairro_cli - Bairro
- email_cli - Email
- tel_cli - Telefone
- cidade_cli - Cidade
- estado_cli - Código do Estado (FK)
tb_estados - Essa tabela contém os estados do Brasil.

- id_estado - Número auto–incremento, vai ser a nossa chave primária (PK)
- estado - Nome do Estado
- uf - Sigla do Estado
tb_user – Essa tabela contém os usuários que tem permissão para mexer na área
administrativa
- id_user - Número auto–incremento, vai ser a nossa chave primária (PK)
- apelido - apelido do usuário que vai ter acesso ao sistema.
- senha - senha do usuário que vai ter acesso ao sistema.
Criando as tabelas
Se você usa o Windows, aconselho você a baixar um software de gerenciamento de banco de
dados, nesse caso o PHPMyAdmin (http://www.phpmyadmin.net/) que é uma ótima ferramenta para
manipular base de dados MySQL. No WAMPSERVER já existe pré-instalado o PHPMyAdmin.
- 52 -
Antes de criarmos as tabelas, devemos criar o nosso Database, para isso digite o seguinte
comando:
CREATE DATABASE projeto;
Como vocês podem observar eu criei um database chamado projeto, abaixo segue as tabelas
que farão parte da nossa base de dados.
tb_clientes - Tabela com os clientes cadastrados no sistema
tb_estados - Tabela com os estados do Brasil
tb_user - Usuários que tem permissão para entrar na área administrativa do sistema.
Crie as tabelas no MySQL, executando os comandos abaixo dentro do database projeto:

CREATE TABLE tb_clientes(
id_cli int auto_increment primary key,
inclusao_cli datetime,
nome_cli varchar(80),
end_cli varchar(80),
bairro_cli varchar(40),
email_cli varchar(90),
tel_cli varchar(25),
cidade_cli varchar(80),
estado_cli int
);
CREATE TABLE tb_estados(
id_estado int auto_increment primary key,
estado varchar(60),
uf char(2));
CREATE TABLE tb_user(
id_user int auto_increment primary key,
apelido varchar(60),
senha varchar(20));
Depois de termos criado as tabelas, vamos “popular” a tabela de estados, ou seja, vamos
cadastrar os estados e um usuário administrador do sistema. Para isso vamos fazer uso do comando
SQL: INSERT INTO.
INSERT INTO `tb_estados` (uf,estado) VALUES('AC', 'Acre');
INSERT INTO `tb_estados` (uf,estado) VALUES('AL', 'Alagoas');
INSERT INTO `tb_estados` (uf,estado) VALUES('AP', 'Amapá');
INSERT INTO `tb_estados` (uf,estado) VALUES('AM', 'Amazonas');
INSERT INTO `tb_estados` (uf,estado) VALUES('BA', 'Bahia');
INSERT INTO `tb_estados` (uf,estado) VALUES('CE', 'Ceará');
- 53 -
INSERT INTO `tb_estados` (uf,estado) VALUES('DF', 'Distrito Federal');

INSERT INTO `tb_estados` (uf,estado) VALUES('ES', 'Espírito Santo');
INSERT INTO `tb_estados` (uf,estado) VALUES('GO', 'Goiás');
INSERT INTO `tb_estados` (uf,estado) VALUES('MA', 'Maranhão');
INSERT INTO `tb_estados` (uf,estado) VALUES('MT', 'Mato Grosso');
INSERT INTO `tb_estados` (uf,estado) VALUES('MS', 'Mato Grosso do Sul');
INSERT INTO `tb_estados` (uf,estado) VALUES('MG', 'Minas Gerais');
INSERT INTO `tb_estados` (uf,estado) VALUES('PA', 'Pará');
INSERT INTO `tb_estados` (uf,estado) VALUES('PB', 'Paraíba');
INSERT INTO `tb_estados` (uf,estado) VALUES('PR', 'Paraná');
INSERT INTO `tb_estados` (uf,estado) VALUES('PE', 'Pernambuco');
INSERT INTO `tb_estados` (uf,estado) VALUES('PI', 'Piauí');
INSERT INTO `tb_estados` (uf,estado) VALUES('RN', 'Rio Grande do Norte');
INSERT INTO `tb_estados` (uf,estado) VALUES('RS', 'Rio Grande do Sul');
INSERT INTO `tb_estados` (uf,estado) VALUES('RJ', 'Rio de Janeiro');
INSERT INTO `tb_estados` (uf,estado) VALUES('RO', 'Rondônia');
INSERT INTO `tb_estados` (uf,estado) VALUES('RR', 'Roraima');
INSERT INTO `tb_estados` (uf,estado) VALUES('SC', 'Santa Catarina');
INSERT INTO `tb_estados` (uf,estado) VALUES('SP', 'São Paulo');
INSERT INTO `tb_estados` (uf,estado) VALUES('SE', 'Sergipe');
INSERT INTO `tb_estados` (uf,estado) VALUES('TO', 'Tocantins');
INSERT INTO `tb_user` (ìd_user`, àpelido`, `senha`) VALUES

(1, 'universo', 'php');
Antes de começarmos a criar nossos arquivos, vamos criar um diretório chamado

projeto2016 dentro de c:/wamp/www/dw3. Salve todos os seus arquivos dentro deste diretório
(c:/wamp/www/dw3/projeto2016). Agora, antes de construirmos o formulário de cadastro de
clientes, vamos criar o arquivo que vai estabelecer a conexão com a nossa base de dados.
Arquivo: conecta.php
<?php
$dbname="projeto";
$usuario="root";
$password="";
//1º passo - Conecta ao servidor MySQL

if(!($id = mysql_connect("localhost",$usuario,$password))) {
echo "<p align=\"center\"><big><strong>Não foi possível estabelecer uma
conexão com o gerenciador MySQL. Favor contatar o Administrador.
</strong></big></p>";
- 54 -
exit;
}
//2º passo - Seleciona o Banco de Dados
if(!($con=mysql_select_db($dbname,$id))) {
echo " <p align=\"center\"><big><strong>Não foi possível estabelecer uma
conexão com o Banco de Dados informado. Favor contatar o Administrador.
</strong></big></p>";
exit;
}
?>
A conexão com o MySQL acima mostrada, é para quem está trabalhando localmente na
máquina (localhost).
mysql_connect - Abre uma conexão com o banco de dados MySQL

No nosso código acima, caso ele não consiga estabelecer uma conexão com o servidor MySQL
ele exibe a mensagem: “Não foi possível estabelecer uma conexão com o gerenciador MySQL. Favor
contatar o Administrador”.
mysql_select_db - Seleciona um Banco de Dados MySQL.

Funciona da mesma maneira, caso ocorra algum erro na hora de selecionar a base de dados
(projeto), ele emitirá uma mensagem de erro: “Não foi possível estabelecer uma conexão com o
Banco de Dados informado. Favor contatar o Administrador.”.
Área Administrativa
É a área responsável por fazer o controle dos clientes cadastrados, ou seja, nela vamos poder
incluir, alterar, excluir e buscar qualquer cliente que esteja cadastro em nossa base de dados.
Vamos fazer uso das sessões em PHP nessa área (método para gerenciamento de usuários
que está disponível a partir da versão 4 do PHP), pois precisamos restringir o acesso a essa área
apenas para pessoas que tenham permissão.
Página inicial (index.php)

Essa é a página inicial do nosso sistema. É aonde vamos ter que digitar o apelido e a senha
para o acesso à área administrativa.
Código fonte:
<?php
include "conecta.php"; //Arquivo que conecta com o MySQL
//INICIALIZA A SESSÃO
session_start();
- 55 -
//DESTRÓI AS VARIÁVEIS
unset($_SESSION[id_projeto]);
unset($_SESSION[apelido_projeto]);
unset($_SESSION[senha_projeto]);
//DESTRÓI TODOS OS DADOS INICIALIZADOS NA SESSÃO

session_destroy();
//RECEBE OS DADOS DO FORMULÁRIO

$apelido_login = $_POST[apelido_login];
$senha_login = $_POST[senha_login];
if(($apelido_login) AND ($senha_login)) { //Ele entra nessa condição se as

duas variáveis não estiverem vazias
$sql = mysql_query("SELECT * FROM tb_user WHERE apelido='$apelido_login'
AND senha='$senha_login'") or die("ERRO no comando SQL :".mysql_error());
if(mysql_num_rows($sql) > 0) {
$id_projeto = mysql_result($sql,0,"id_user");
$apelido_projeto = mysql_result($sql,0,"apelido");
$senha_projeto = mysql_result($sql,0,"senha");
session_start();
//GRAVA AS VARIÁVEIS NA SESSÃO

$_SESSION[id_projeto] = $id_projeto;
$_SESSION[apelido_projeto] = $apelido_projeto;
$_SESSION[senha_projeto] = $senha_projeto;
header("Location:opcoes.php"); //Redireciona para a página de opções

}
else{
echo "<font color=\"#FF0000\"><b>Apelido ou Senha incorretos. Tente
novamente!</b>";
}
}
?>
<html>
<head>
<title>Tutorial UNIVERSO</title>
- 56 -
</head>
<body bgcolor="#FFFFFF" text="#000000">
<center>
<form name="frm_login" method="post" action="<?php echo
basename($_SERVER['PHP_SELF']); ?>">
<table width="200" border="0" cellspacing="0" cellpadding="0">
<tr>
<td colspan="2" align="center"><b><font face="Arial"
size="3">IDENTIFICAÇÃO</font></b></td>
</tr>
<tr>
<td width="33%" height="25"><font face="Arial"
size="2">Apelido:</font></td>
<td width="67%" height="25"><font face="Arial" size="2"><input
type="text" name="apelido_login"></font></td>
</tr>
<tr>
<td width="33%" height="25"><font face="Arial"
size="2">Senha:</font></td>
<td width="67%" height="25"><font face="Arial" size="2"><input
type="password" name="senha_login"></font></td>
</tr>
<tr>
<td colspan="2"><input type="submit" name="entrar" value="Entrar
>>"></td>
</tr>
</table>
</form>
</center>
<script>document.frm_login.apelido_login.focus()</script>
</body>
</html>
Essa página vai mostrar um formulário com dois campos: um de apelido e outro de senha.
No action do form temos <?php echo basename($_SERVER['PHP_SELF']); ?>, isso quer dizer que os
dados serão enviados para a mesma página.
Note que no começo do código temos um if(($apelido_login) AND ($senha_login)). Depois
que digitamos o apelido e a senha e clicamos no botão Entrar >>, vamos cair nessa condição que
vai verificar se o usuário e a senha foram digitados. Em seguida é verificado se estes dados existem
em nosso banco de dados. Caso exista é criada uma sessão e nela são registradas 3 variáveis, sendo
- 57 -
o id, o apelido e a senha do usuário. Em seguida através do comando header(“Location:opcoes.php”)

somos redirecionados para a página de opções.
Atenção: Vale lembrar, que depois da página index.php, todas as outras são de uso restrito.
Portanto, precisamos criar um arquivo que vai verificar se o usuário está ativo na sessão ou não.
Vamos ver seu código fonte:
Código fonte: ver_sessao.php
<?php
session_start();
//SE NÃO TIVER VARIÁVEIS REGISTRADAS

//RETORNA PARA A TELA DE LOGIN
if( (!isset($_SESSION[id_projeto])) AND (!isset($_SESSION[apelido_pojeto]))
AND (!isset($_SESSION[senha_pojeto])) )
Header("Location: index.php");
?>
Inicializamos a sessão através do session_start(), e verificamos se as variáveis estão

registradas na sessão através do comando if acima (verifica se as variáveis estão “setadas”). Caso
elas não estejam, é automaticamente redirecionado para a página index.php
Atenção: Precisamos colocar uma require com esse arquivo em todas as páginas que são de uso
restrito (require("ver_sessao.php");).
Página com as opções (opcoes.php)

Se o apelido e a senha forem digitados corretamente iremos ser redirecionados para a página
opcoes.php que é apenas uma página HTML simples, onde iremos escolher uma das opções
fornecidas.
As opções são:
- Cadastrar clientes
- Gerenciar clientes
- Pesquisar clientes
Na primeira opção, temos a oportunidade de cadastrar um novo cliente no sistema. Na
segunda opção, temos uma listagem dos clientes cadastrados, com as opções para se fazer uma
busca, alterar os dados ou excluir determinado cliente. Na terceira opção, poderemos montar um
relatório com os clientes de acordo com as opções de pesquisa.
<?php
require("ver_sessao.php"); //Verifica se a sessão está ativa
?>
- 58 -
<html>
<head>
</head>
<body>
<table width="60%" border="0" cellspacing="0" cellpadding="0"
align="center">
<tr>
<td height="60"><div align="center"><font face="Arial" size="4"><b>Menu
Principal</b></font></div></td>
</tr>
</table>
<br />
<p align="center">
<font face=Arial size=2>
- <a href="cadclientes.php?acao=entrar">Cadastrar Clientes</a><br /><br />
- <a href="gerclientes.php">Gerenciar Clientes</a><br /><br />
- <a href="pesqclientes_a.php">Pesquisar Clientes</a><br />
</font>
</p>
</body>
</html>
Cadastro de Clientes (cadclientes.php)
A principal função desse arquivo é cadastrar um novo cliente ao sistema.

Código fonte:
<?php
require("conecta.php"); //Conecta com a nosso banco de dados MySQL
?>
<html>
<head>
</head>
<br />
<table width="60%" border="0" cellspacing="0"
cellpadding="0" align="center">
- 59 -
<tr>
<td height="60">
<div align="center"><font face="Arial"
size="4"><b>Cadastro de Clientes</b></font></div></td>
</tr>
</table>
<br />
<?php
//RECEBE OS DADOS DA URL
$acao = $_GET[acao];
if($acao == 'cadastrar') { /*Cadastra o cliente depois que o formulário for

enviado */

$nome_cli = $_POST[nome_cli];
$end_cli = $_POST[end_cli];
$bairro_cli = $_POST[bairro_cli];
$email_cli = $_POST[email_cli];
$tel_cli = $_POST[tel_cli];
$cidade_cli = $_POST[cidade_cli];
$estado_cli = $_POST[estado_cli];
//Verifica os dados enviados

if($nome_cli == '') {
$erros++;
$html_erros = $html_erros."<br />Nome";
}
if($end_cli == '') {
$erros++;
$html_erros = $html_erros."<br />Endereço";
}
if($bairro_cli == '') {
$erros++;
$html_erros = $html_erros."<br />Bairro";
}
if($email_cli == '') {
$erros++;
$html_erros = $html_erros."<br />Email";
}
if($tel_cli == '') {
- 60 -
$erros++;
$html_erros = $html_erros."<br />Telefone";
}
if($cidade_cli == '') {
$erros++;
$html_erros = $html_erros."<br />Cidade";
}
if($estado_cli == 0) {
$erros++;
$html_erros = $html_erros."<br />Estado";
}
if($erros == 0) { //Se não tiver nenhum erro, faz a inclusão
$sql = mysql_query("INSERT INTO
tb_clientes(inclusao_cli,nome_cli,end_cli,bairro_cli,email_cli,
tel_cli,cidade_cli,estado_cli)
VALUES(now(),'$nome_cli','$end_cli','$bairro_cli',
'$email_cli','$tel_cli','$cidade_cli','$estado_cli')")
or die("Erro no comando SQL:".mysql_error());
echo "<div align=center><font face=Arial size=2>Cliente cadastrado com
Sucesso!!</font></div><br /><br />";
} //fecha $erros == 0
else {
echo "<div align=center><font face=Arial
size=2><b> ATENÇÃO </b><br /><br />Foram encontrados
<b>$erros</b>
erro(s) no cadastro do
cliente:<br /><b>$html_erros</b>
<br /><br /><a href='javascript:history.go(-1)'><<
Voltar</a></font></div><br /><br />";
}//fecha else
} /*fecha acao= cadastrar*/ ?>
<?php
if($acao == 'entrar') { /*Mostra o formulário de cadastro de clientes */
$sql_estados = mysql_query("SELECT * FROM tb_estados ORDER BY estado")
or die("ERRO no comando SQL:".mysql_error());
?>
<form name="frm_clientes" method="post" action="<?php echo
basename($_SERVER['PHP_SELF']); ?>?acao=cadastrar">
<table width="500" border="0" cellspacing="0" cellpadding="0"
align="center">
<tr>
- 61 -
<td width="24%" height="25"><font face="Arial" size="2">Nome:</font></td>

<td height="25" width="76%"><font face="Arial" size="2">
<input type="text" name="nome_cli" size="35"></font></td>
</tr>
<tr>
<td height="25" width="24%"><font face="Arial"
size="2">Endereço:</font></td>
<input type="text" name="end_cli" size="30"></font></td>
</tr>
<tr>
<td height="25" width="24%"><font face="Arial" size="2">Bairro:</font></td>
<input type="text" name="bairro_cli" size="30"></font></td>
</tr>
<tr>
<td height="25" width="24%"><font face="Arial" size="2">Email:</font></td>
<input type="text" name="email_cli" size="35"></font></td>
</tr>
<tr>
size="2">Telefone:</font></td>
<input type="text" name="tel_cli" size="20"></font></td>
</tr>
<tr>
<td height="25" width="24%"><font face="Arial" size="2">Cidade:</font></td>
<input type="text" name="cidade_cli" size="35"></font></td>
</tr>
<tr>
<td height="25" width="24%"><font face="Arial" size="2">Estado:</font></td>
<select name="estado_cli">
<option value="0"><< Selecione o estado >></option>
<?php while($array = mysql_fetch_array($sql_estados))
{?>
<option value="<?echo
$array['id_estado'];?>"><?echo $array['estado'];?></option>
<?php }?>
- 62 -
</select></font></td>
</tr>
<tr>
<td height="25" colspan="2">
<div align="center">
<input type="submit" name="cadastrar" value="Cadastrar cliente
>>"></div></td>
</tr>
</table>
</form>
<script>document.frm_clientes.nome_cli.focus()</script>
<?} /*fecha acao=entrar */?>
<div align=center><font face=Arial size=2>
[ <a href='opcoes.php'>Voltar para o menu principal</a> ]</font>
</div>
</body>
</html>
Quando clicamos na opção para cadastrar cliente na página opcoes.php, caímos na página
cadclientes.php?acao=entrar, que nada mais é, que a página que contém o formulário de cadastro e a
rotina para a inclusão dos dados em nossa base de dados.
Como vocês podem observar acima temos uma condição depois do nome do arquivo:
cadclientes.php?acao=entrar. Vá até o código acima e procure uma linha if($acao==’entrar’).
Encontrou? É aí que começa a nossa página. Depois de ter preenchido todos os dados e clicarmos no
botão Cadastrar cliente >> seremos redirecionados para a mesma página, isso ocorre porque no
action do form temos o comando <?php echo basename($_SERVER['PHP_SELF']); ?>mais ele não
vem sozinho, ele está acompanhado do ?acao=cadastrar, encontramos aqui, mais uma condição.
Vá ao código acima e procure a linha if($acao==’cadastrar’). Como vocês podem observar,
recebemos os dados da url (GET) e do formulário (POST), fazemos uma verificação dos dados que
foram enviados, para ver se nenhum foi enviado em branco, caso algum dado seja enviado em branco
é mostrado uma mensagem de erro e pedimos para a pessoa retornar ao formulário e complementar
os dados que estão faltando.
Observe essa linha:
$sql = mysql_query("INSERT INTO
tb_clientes(inclusao_cli,nome_cli,end_cli,bairro_cli,email_cli,
tel_cli,cidade_cli,estado_cli)
VALUES(now(),'$nome_cli','$end_cli','$bairro_cli',
'$email_cli','$tel_cli','$cidade_cli','$estado_cli')")
- 63 -
mysql_query => Envia uma consulta SQL ao banco de dados MySQL.

E o comando SQL para a inserção de dados em uma determinada tabela é o INSERT INTO.
Gerenciamento de clientes (gerclientes.php)

Através desse arquivo vamos ter uma listagem de todos os clientes cadastrados no sistema.
Além disso, será possível também fazer uma busca, alteração ou exclusão de determinado cliente.
Código fonte:
<?php
?>
<html>
<head>
</head>
<?php
$pesquisar = $_POST[pesquisar];
$criterio = $_POST[criterio];
$sql_cliente = "SELECT id_cli,date_format(inclusao_cli,'%d/%m/%Y - %H:%i')

as inclusao_cli, nome_cli,cidade_cli,uf FROM
tb_clientes,tb_estados WHERE tb_estados.id_estado =
tb_clientes.estado_cli";
if($pesquisar == 'sim')
$sql_cliente = $sql_cliente." AND nome_cli LIKE \"%$criterio%\"";
$sql_cliente = $sql_cliente." ORDER BY inclusao_cli";
$sql_cliente = mysql_query($sql_cliente) or die("Erro no SQL:
".mysql_error());
?>
<br />

align="center">
<tr>
<td height="60">
<div align="center"><font face="Arial" size="4"><b>Gerenciamento de
Clientes</b></font></div></td>
- 64 -
</tr>
</table>
<br />
<form name="frm_pesq" method="post" action="<?echo $PHP_SELF?>">
align="center">
<tr bgcolor="#6699CC">
<td colspan="2">
<div align="center"><font face="Arial"
size="2"><b>Pesquisa</b></font></div></td>
</tr>
<tr bgcolor="ebebeb">
<td width="32%" align="center"><font face="Arial" size="2">Nome a ser
procurado:</font></td>
<td width="68%"> <font face="Arial" size="2"><input type="text"
name="criterio" size="25">
<input type="submit" name="pesq" value="Pesquisar >>">
<input type="hidden" name="pesquisar" value="sim"></font></td>
</tr>
</table>
</form>
<script>document.frm_pesq.criterio.focus()</script>
<br />
<?if(mysql_num_rows($sql_cliente) > 0) {?>
align="center">
<tr bgcolor="#6699CC">
<td colspan="5">
<div align="center"><font face="Arial" size="2"><b><font
color="#FFFFFF">Clientes cadastrados</font></b></font></div>
</td>
</tr>
<tr bgcolor="cccccc">
<td width="19%">
<div align="center"><b><font face="Arial" size="2">Data de
inclusão</font></b></div>
</td>
<td width="33%">
<div align="center"><b><font face="Arial" size="2">Cliente</font></b></div>
</td>
<td width="23%">
- 65 -
<div align="center"><b><font face="Arial"

size="2">Cidade/UF</font></b></div>
</td>
<td width="13%">
<div align="center"><b><font face="Arial" size="2">Alterar
</font></b></div>
</td>
<td width="12%">
<div align="center"><b><font face="Arial" size="2">Excluir</font></b></div>
</td>
</tr>
<?php while($array_cliente = mysql_fetch_array($sql_cliente))
{?>
<tr bgcolor="ebebeb">
<td width="19%" height="25"><font face="Arial" size="2">
<?php echo $array_cliente['inclusao_cli'];?> hs
</font></td>
<?php echo $array_cliente['nome_cli'];?>
</font></td>
<?php echo $array_cliente['cidade_cli'];?> / <?echo $array_cliente['uf'];?>
</font></td>
<td width="13%" height="25">
<div align="center"><font face="Arial" size="2">[ <a
href='altclientes.php?id_cliente=<?echo
$array_cliente['id_cli'];?>&acao=entrar'>Alterar</a> ]</font></div>
</td>
<td width="12%" height="25">
href='excluirclientes.php?id_cliente=<?php echo
$array_cliente['id_cli'];?>'>Excluir</a> ]</font></div>
</td>
</tr>
<?}?>
</table>
<?}/* fecha mysql_num_rows > 0 */
else{
echo "<br /><br /><div align=center><font face=Arial size=2>
Nenhum registro encontrado!<br /><br /></font></div>";
}?>
- 66 -
<br />
</div>
</body>
</html>
Caso o usuário faça uma pesquisa passamos um campo oculto:

<input type="hidden" name="pesquisar" value="sim">
Note, que no SQL não efetuamos direto o mysql_query(), fomos concatenando a variável que
continha o SQL.
<?php
$sql_cliente = "SELECT id_cli,date_format(inclusao_cli,'%d/%m/%Y - %H:%i')
as inclusao_cli, nome_cli,cidade_cli,uf FROM
tb_clientes,tb_estados WHERE tb_estados.id_estado =
tb_clientes.estado_cli";
if($pesquisar == 'sim')
$sql_cliente = $sql_cliente." AND nome_cli LIKE \"%$criterio%\"";
$sql_cliente = $sql_cliente." ORDER BY inclusao_cli";
$sql_cliente = mysql_query($sql_cliente) or die("Erro no SQL:
".mysql_error());
?>
Para fazer a pesquisa usamos no SQL a opção LIKE. Note, que formatamos a saída da data usando
date_format().
Alteração dos dados do cliente (altclientes.php)

Esse arquivo é bem parecido com o de cadastro de clientes, a única coisa que muda é que um
faz a inserção de um novo cliente e o outro faz a alteração dos dados.
Observação: O cadastro de clientes e o de alteração poderia ter sido fundido em um arquivo
só, em vez de criarmos dois.
Código fonte:
<?php
?>
<html>
<head>
</head>
- 67 -

<br />
align="center">
<tr>
<td height="60">
<div align="center"><font face="Arial" size="4"><b>Alterar dados do
Cliente</b></font></div>
</td>
</tr>
</table>
<br />
<?php
$acao = $_GET[acao];
$id_cliente = $_GET[id_cliente];
if($acao == 'alterar') { /*Cadastra o cliente depois que o

formulário for enviado */

$nome_cli = $_POST[nome_cli];
$end_cli = $_POST[end_cli];
$bairro_cli = $_POST[bairro_cli];
$email_cli = $_POST[email_cli];
$tel_cli = $_POST[tel_cli];
$cidade_cli = $_POST[cidade_cli];
$estado_cli = $_POST[estado_cli];
$id_cliente = $_POST[id_cliente];
//Verifica os dados enviados

if($nome_cli == '') {
$erros++;
$html_erros = $html_erros."<br />Nome";
}
if($end_cli == '') {
$erros++;
$html_erros = $html_erros."<br />Endereço";
}
if($bairro_cli == '') {
$erros++;
- 68 -
$html_erros = $html_erros."<br />Bairro";

}
if($email_cli == '') {
$erros++;
$html_erros = $html_erros."<br />Email";
}
if($tel_cli == '') {
$erros++;
$html_erros = $html_erros."<br />Telefone";
}
if($cidade_cli == '') {
$erros++;
$html_erros = $html_erros."<br />Cidade";
}
if($estado_cli == 0) {
$erros++;
$html_erros = $html_erros."<br />Estado";
}
if($erros == 0) { //Se não tiver nenhum erro, grava os dados na tabela
$sql = mysql_query("UPDATE tb_clientes SET
nome_cli='$nome_cli',end_cli='$end_cli',
bairro_cli='$bairro_cli',email_cli='$email_cli',tel_cli='$tel_cli',cidade_c
li='$cidade_cli',estado_cli='$estado_cli' WHERE id_cli='$id_cliente'")
echo "<div align=center><font face=Arial size=2>Dados do cliente
<b>$nome_cli</b> alterados com Sucesso!!<br /><br /><a
href='gerclientes.php'><<
} //fecha $erros == 0
else {
echo "<div align=center><font face=Arial
size=2><b> ATENÇÃO </b><br /><br />Foram encontrados
<b>$erros</b>
erro(s) no cadastro do
cliente:<br /><b>$html_erros</b>
<br /><br /><a href='javascript:history.go(-1)'><<
}//fecha else
} /*fecha acao= alterar*/
?>
<?php
- 69 -
if($acao == 'entrar') { /*Mostra o formulário de alteração

dos dados do cliente */
$sql_cliente = mysql_query("SELECT * FROM tb_clientes WHERE
id_cli='$id_cliente'")
$array_cliente = mysql_fetch_array($sql_cliente);
$sql_estados = mysql_query("SELECT * FROM tb_estados ORDER BY estado")
?>
<form name="frm_clientes" method="post" action="<?php echo
$_SERVER[PHP_SELF];?>?acao=alterar">
align="center">
<tr>
<td width="24%" height="25"><font face="Arial" size="2">Nome:</font></td>
<input type="text" name="nome_cli" size="35" value="<?php echo
$array_cliente['nome_cli'];?>"></font></td>
</tr>
<tr>
size="2">Endereço:</font></td>
<input type="text" name="end_cli" size="30" value="<?php echo
$array_cliente['end_cli'];?>"></font></td>
</tr>
<tr>
<td height="25" width="24%"><font face="Arial" size="2">Bairro:</font></td>
<input type="text" name="bairro_cli" size="30" value="<?php echo
$array_cliente['bairro_cli'];?>"></font></td>
</tr>
<tr>
<td height="25" width="24%"><font face="Arial" size="2">Email:</font></td>
<input type="text" name="email_cli" size="35" value="<?php echo
$array_cliente['email_cli'];?>"></font></td>
</tr>
<tr>
size="2">Telefone:</font></td>
- 70 -

<input type="text" name="tel_cli" size="20" value="<?php echo
$array_cliente['tel_cli'];?>"></font></td>
</tr>
<tr>
<td height="25" width="24%"><font face="Arial" size="2">Cidade:</font></td>
<input type="text" name="cidade_cli" size="35" value="<?php echo
$array_cliente['cidade_cli'];?>"></font></td>
</tr>
<tr>
<td height="25" width="24%"><font face="Arial" size="2">Estado:</font></td>
<select name="estado_cli">
<option value="0"><< Selecione o estado >></option>
<?php
while($array = mysql_fetch_array($sql_estados)) {
$estado_cliente = $array_cliente['estado_cli'];
$cod_estado = $array['id_estado'];
$estado = $array['estado'];
if($estado_cliente == $cod_estado)
echo "<option value='$estado_cliente' selected>$estado</option>";
else
echo "<option value='$cod_estado'>$estado</option>";
}?>
</select></font></td>
</tr>
<tr>
<td height="25" colspan="2">
<div align="center">
<input type="submit" name="alterar" value="Alterar dados >>">
<input type="hidden" name="id_cliente" value="<?echo
$array_cliente['id_cli'];?>">
</div></td>
</tr>
</table>
</form>
<?php
} /*fecha acao=entrar */
?>
- 71 -

</div>
</body>
</html>
Na página gerclientes.php (página de gerenciamento), passamos como parâmetro o id do
cliente que vai ser alterado.
Na página altclientes.php (página que altera os dados) fizemos um SELECT na tabela de
clientes acrescentando na cláusula WHERE o id_cliente sendo igual ao código que foi passado como
parâmetro. Com isso, não teremos os dados de todos os clientes mais sim todos os dados de um
determinado cliente.
Depois de ter executado o mysql_query(), usamos o comando mysql_fetch_array() que vai
retornar o resultado da consulta como um array, aí fica mais fácil para manipularmos os dados do
cliente.
Como disse anteriormente, esse arquivo é bem parecido com o de cadastro, e na hora de
alterar os dados fazemos uso do comando SQL: UPDATE tabela SET campo=’$campo’. No nosso caso,
precisamos acrescentar um WHERE porque senão ele vai alterar os dados de todos os clientes que
temos no banco de dados e não é isso que queremos. É para ele alterar apenas o do usuário
escolhido. Então o nosso código vai ficar desse jeito.
<?php
$sql = mysql_query("UPDATE tb_clientes SET nome_cli =
'$nome_cli',end_cli='$end_cli',bairro_cli='$bairro_cli',email_cli='$email_c
li',tel_cli='$tel_cli',cidade_cli='$cidade_cli', estado_cli='$estado_cli'
WHERE id_cli='$id_cliente'")
?>
Sendo que na cláusula WHERE, aquele id_cliente é o código do cliente que está sendo
modificado.
Exclusão do cliente (excluirclientes.php)

Essa página contém apenas o comando SQL para excluir o usuário da tabela conforme o
parâmetro passado. Esse parâmetro será passado pela página ger_clientes.php que nada mais é
que o código do cliente que vai ser excluído.
Código fonte:
<?php
- 72 -
$id_cliente = $_GET[id_cliente];
$sql_del = mysql_query("DELETE FROM tb_clientes WHERE

id_cli='$id_cliente'")
or die("Erro no SQL: ".mysql_error());
echo "<br /><br /><div align=center><font face=Arial size=2>Cliente

EXCLUÍDO com Sucesso!
<br /><br /><a href='opcoes.php'>[ Voltar para o menu principal ]</a>
</font></div><br />";
?>
Se ficar simplesmente assim, poderemos excluir algum cliente sem querer. Portanto, vamos
alterar o arquivo gerclientes.php para que, ao clicarmos em [ Excluir ], uma janela seja aberta
perguntando se temos certeza que queremos excluir o cliente.
Para isso, vamos utilizar o javascript:
<script language="javascript">
function confirmaExclusao(aURL) {
if(confirm('Tem certeza que deseja excluir?')) {
location.href = aURL;
}
}
</script>
Vamos colocar o código fonte acima entre a linha <body bgcolor="#FFFFFF"
text="#000000"> e a linha <?php do arquivo gerclientes.php.
Devemos agora substituir o trecho de código abaixo (próximo a linha 95) do mesmo arquivo
(gerclientes.php):

href='excluirclientes.php?id_cliente=<?php echo
$array_cliente['id_cli'];?>'>Excluir</a> ]</font></div>
por este código:

href="javascript:confirmaExclusao('excluirclientes.php?id_cliente=<?php
echo $array_cliente['id_cli'];?>')">Excluir</a> ]</font></div>
Vamos rodar o programa e testar se está funcionando corretamente.
- 73 -
Pesquisar Clientes (pesqclientes_a.php)

A principal função desse arquivo é apresentar um formulário com algumas opções de pesquisa
de clientes, que gerará um relatório com os mesmos.
Código fonte:
<?php
?>
<html>
<head>
</head>
<script language=javascript>
function verifyForm()
{
if(document.pesquisa.dtinicial.value == "") {
alert("A Data Inicial deverá ser digitada !!!");
document.pesquisa.dtinicial.focus();
return(false);
};
if(document.pesquisa.dtfinal.value == "") {
alert("A Data Final deverá ser digitada !!!");
document.pesquisa.dtfinal.focus();
return(false);
};
if(document.pesquisa.dtinicial.value.length<10) {
alert("A Data Inicial deve possuir 10 dígitos. Ex:
01/01/2015");
document.pesquisa.dtinicial.focus();
return(false);
};
if(document.pesquisa.dtfinal.value.length<10) {
alert("A Data Final deve possuir 10 dígitos. Ex:
30/06/2015");
document.pesquisa.dtfinal.focus();
return(false);
};
- 74 -
return(true);
};

function formatar(src, mask)

{
var i = src.value.length;
var saida = mask.substring(0,1);
var texto = mask.substring(i)
if (texto.substring(0,1) != saida)
{
src.value += texto.substring(0,1);
}
}
function mascara(o,f)
{
//alert("Cheguei na função!!!");
v_obj=o
v_fun=f
setTimeout("execmascara()",1)
}
function execmascara()
{
v_obj.value=v_fun(v_obj.value)
}
function mesano(v)
{
v=v.replace(/\D/g,"") //Remove tudo o que não é
dígito
v=v.replace(/(\d{2})(\d{1,4})$/,"$1/$2") //Coloca uma barra entre o
segundo e o terceiro dígito
return v
}
function masc_data(v)
{
- 75 -

dígito
v=v.replace(/(\d{2})(\d)/,"$1/$2") //Coloca uma barra entre o
segundo e o terceiro dígitos
v=v.replace(/(\d{2})(\d)/,"$1/$2") //Coloca uma barra entre o
quarot e o quinto dígitos
return v
}
function processo(v)
{
dígito
v=v.replace(/(\d{6})(\d{1,4})$/,"$1/$2") //Coloca uma barra entre o
quinto e o sexto dígito
return v
}
function soNumeros(v)
{
return v.replace(/\D/g,"")
}
</SCRIPT>
<br />
align="center">
<tr>
<td height="60">
<div align="center"><font face="Arial" size="4"><b>Pesquisar
Clientes</b></font></div>
</td>
</tr>
</table>
<br />
<font face="Arial">
<center>
- 76 -
Digite o <b>DADO</b> desejado, escolha o critério, digite a <b>Data Inicial

de Cadastro</b>,<br /> a <b>Data Final de Cadastro</b> e clique em
<b>Pesquisar</b>.<br />
<br />
<TABLE border="0" cellPadding="1" cellSpacing="1" width="750" valign="top"
bgcolor="#000000">
<tr>
<td bgcolor="#eeeeee" width="20%" valign="top">
<br /><CENTER>
<form name="pesquisa" method="post"
action="pesqclientes.php" target="_blank">
Digite o <B>DADO</B> desejado:
<input type="text" name="criterio"
value=""><br /><br />
<input type="radio" name="campo"
value="nome_cli" checked>Nome do Cliente
value="end_cli">Endereço
value="bairro_cli">Bairro
value="email_cli">E-mail
value="tel_cli">Telefone
value="cidade_cli">Cidade
value="uf">Estado (Ex: MG)<br /><br />
<b>Digite o período abaixo, considerando
como base a Data de Cadastro:</b><br />
<b>Data Inicial:</b> <input
type="text" name="dtinicial" value="" size="10"
onkeyup="mascara(this,masc_data)"
maxlength="10">
<b>Data Final:</b> <input type="text"
name="dtfinal" value="" size="10" onkeyup="mascara(this,masc_data)"
maxlength="10"><br />
<br />
<b>Ordenar por:</b><br />
<input
name="ordenar_por" type="radio" value="nome_cli" checked>Nome do Cliente
- 77 -
<input name="ordenar_por" type="radio"

value="inclusao_cli">Data / Hora de Cadastro
<input name="ordenar_por" type="radio"
value="bairro_cli,end_cli">Bairro / Endereço<br />
<br />
<input
onclick=javascript:return(verifyForm()); type="submit" value=" Pesquisar
"><br /><br />
</form>
<script>document.pesquisa.criterio.focus()</script>
</CENTER>
</td>
</tr>
</table>
</center>
</font>
<br />
</div>
</body>
</html>
Agora que já temos o formulário de Pesquisa de Clientes criado, vamos montar o arquivo que
exibirá o resultado da pesquisa (pesqclientes.php):
Código fonte:
<?php
require("conecta.php") //Conecta com a nosso banco de dados MySQL
?>
<html>
<head>
<title>Tutorial UNIVERSO - Relatório de Clientes</title>
</head>
<body>

- 78 -
<script language="javascript">
function mudar_cor_over(celula){
celula.style.backgroundColor="#cccccc"
}
function mudar_cor_out(celula){
celula.style.backgroundColor="#ffffff"
}
</script>
<center>
<font size="+2" face="Arial Narrow"><b>Relatório de
Clientes</b></font>
</center>
<br />
<?php
$criterio = $_POST[criterio];
$campo = $_POST[campo];
$dtinicial = $_POST[dtinicial];
$dtfinal = $_POST[dtfinal];
$ordenar_por = $_POST[ordenar_por];
// Colocando a Data Inicial no formato aaaa-mm-dd

$dti_dia = substr($dtinicial, 0, 2);
$dti_mes = substr($dtinicial, 3, 2);
$dti_ano = substr($dtinicial, 6, 4);
$dti = "$dti_ano-" . "$dti_mes-" . "$dti_dia " . "00:00:00";
// Colocando a Data Final no formato aaaa-mm-dd

$dtf_dia = substr($dtfinal, 0, 2);
$dtf_mes = substr($dtfinal, 3, 2);
$dtf_ano = substr($dtfinal, 6, 4);
$dtf = "$dtf_ano-" . "$dtf_mes-" . "$dtf_dia " . "23:59:59";
?>
<?php
$sql = "SELECT id_cli,inclusao_cli,date_format(inclusao_cli,'%d/%m/%Y -
%H:%i') as inclusao_cli_formatado, nome_cli, end_cli, bairro_cli,
email_cli, tel_cli, cidade_cli, estado_cli, uf
FROM tb_clientes,tb_estados
- 79 -
WHERE tb_estados.id_estado = tb_clientes.estado_cli AND $campo Like

\"%" . $criterio. "%\" and inclusao_cli >= '$dti' and inclusao_cli <=
'$dtf' order by $ordenar_por";
$sql_result=mysql_query($sql);
$numreg = mysql_numrows($sql_result);
$i = 0;
?>
<center>
<b>
<FONT SIZE=+1 FACE="Arial">
<?php
if ($campo == "nome_cli") {
$campo = "pelo Nome do Cliente";}
if ($campo == "end_cli") {
$campo = "pelo Endereço do Cliente";}
if ($campo == "bairro_cli") {
$campo = "pelo Bairro do Cliente";}
if ($campo == "email_cli") {
$campo = "pelo E-mail do Cliente";}
if ($campo == "tel_cli") {
$campo = "pelo Telefone do Cliente";}
if ($campo == "cidade_cli") {
$campo = "pela Cidade do Cliente";}
if ($campo == "uf") {
$campo = "pelo Estado do Cliente (Ex: MG)";}
if ($ordenar_por == "nome_cli") {
$ordenado_por_ext = "Ordenado pelo Nome do Cliente";}
if ($ordenar_por == "inclusao_cli") {
$ordenado_por_ext = "Ordenado pela Data de Inclusão do
Cliente";}
if ($ordenar_por == "bairro_cli,end_cli") {
$ordenado_por_ext = "Ordenado pelo Bairro / Endereço do
Cliente";}
// Colocando a data no formato certo: dd/mm/aaa

print "Pesquisa efetuada $campo igual a '$criterio' \n<br /> ";
print "no período de '$dtinicial' até '$dtfinal' \n<br /> ";
- 80 -
print "<font size='2'>$ordenado_por_ext</font>" . "<br /><br />";

print "Número de Clientes encontrados: " .$numreg. " <br />";
?>
<br />
</FONT>
</b>
</center>
<center>
<table border="1" cellspacing="3" cellpadding="3" width="800">
<tr>
<td>
<Center><B><FONT SIZE="-1" FACE="Arial">Nome do
Cliente</FONT></B></Center>
</td>
<td>
<Center><B><FONT SIZE="-1" FACE="Arial">E-
mail</FONT></B></Center>
</td>
<td>
<Center><B><FONT SIZE="-1"
FACE="Arial">Telefone</FONT></B></Center>
</td>
<td>
FACE="Arial">Endereço</FONT></B></Center>
</td>
<td>
FACE="Arial">Bairro</FONT></B></Center>
</td>
<td>
<Center><B><FONT SIZE="-1" FACE="Arial">Cidade /
Estado</FONT></B></Center>
</td>
<td>
<Center><B><FONT SIZE="-1" FACE="Arial">Data e Hora
de Cadastro</FONT></B></Center>
</td>
</tr>
<?php
- 81 -
while ($row = mysql_fetch_array($sql_result))

{
?>
<tr onmouseover="mudar_cor_over(this)"
onmouseout="mudar_cor_out(this)">
<td>
<Center><FONT SIZE="-2" FACE="Arial"><?php
echo($row['nome_cli']) ?></FONT></Center>
</td>
<td>
echo($row['email_cli']) ?></FONT></Center>
</td>
<td>
echo($row['tel_cli']) ?></FONT></Center>
</td>
<td>
echo($row['end_cli']) ?></FONT></Center>
</td>
<td>
echo($row['bairro_cli']) ?></FONT></Center>
</td>
<td>
echo($row['cidade_cli']) ?> / <?php echo($row['uf']) ?></FONT></Center>
</td>
<td>
echo($row['inclusao_cli_formatado']) ?> hs</FONT></Center>
</td>
</tr>
<?php
}
if ( mysql_num_rows($sql_result) == 0)
{
?>
<tr>
- 82 -
<td COLSPAN="7">
<FONT SIZE=+1 FACE="Arial">
<center>Nenhum registro encontrado!</center>
</FONT>
</td>
</tr>
<?php
}
?>
</table>
</center>

<br />
<center><a
HREF="javascript:self.print()">Imprimir</a>
<a HREF="javascript:self.close()">Fechar</A></center>
</body>
</html>
Vamos rodar o programa e verificar se tudo está funcionando perfeitamente.
Exercício: Crie agora o cadastro, gerenciamento, alteração e exclusão de usuários.

Altere a tabela tb_user, adicionando um campo chamado status, do tipo char,
tamanho igual a 1. Este campo receberá A para Administradores do sistema e U
para Usuários Comuns. Na tela do menu de opções, além dos links de Cadastro,
Gerenciamento e pesquisa de Clientes, aparecerá Cadastro e Gerenciamento de
Usuários somente para usuários cujo status for igual a A (Administradores). Para
Usuários Comuns, só aparecerão os links de Cadastro, Gerenciamento e pesquisa de
Clientes.
Bom trabalho!!!
- 83 -
FUNÇÕES DO EXEMPLO PRÁTICO:
ARQUIVO: index.php
Vamos fazer com que os nomes dos arquivos acessados não apareçam na barra de endereços.
Antes de salvar o arquivo abaixo como index.php, renomeie o arquivo index.php do seu projeto para
index_a.php



<html>
<head>
<title>Tutorial Universo</title>
</head>
<FrameSet framespacing="0" border="false" frameborder="0" Rows="0%,100%">
<FRAME name="topo" SRC = "menu.htm" target="main" scrolling="no"
noresize>
<FRAME name="main" SRC = "index_a.php" target="main" scrolling="yes"
noresize>
</FRAMESET>
<noframes>
<body>
<p>Esta página usa o recurso frame e seu browser não suporta este
recurso.
Verifique atualizações do seu browser com o fabricante
correspondente.</p>
</body>
</noframes>
</html>
ARQUIVO: logout.php
<?
session_start();
//DESTRÓI AS VARIÁVEIS
unset($_SESSION[id_projeto]);
unset($_SESSION[apelido_projeto]);
unset($_SESSION[senha_projeto]);
unset($_SESSION[status_projeto]);
//DESTRÓI TODOS OS DADOS INICIALIZADOS NA SESSÃO

session_destroy();
//REDIRECIONA PARA A TELA DE LOGIN

Header("Location: index.php");
?>
Colocar o código abaixo no final do arquivo opcoes.php / cadclientes.php / altclientes.php /

pesqclientes_a.php / gerclientes.php..., antes do </body> </html>
[ <a href='logout.php'>Finalizar Sessão</a>
]</font>
</div>
- 84 -
ARQUIVO: functions.php
<?php
#******************************************************************#
#* Converte as palavras digitadas em minúscula para maiúscula #
#******************************************************************#
function stringUpDown($text, $return){
# Converte valores de minúsculo para maiúsculo e vice-versa

$arrayLower=array('ç','â','ã','á','à','ä','é','è','ê','ë','í','ì','î'
,'ï','ó','ò','ô','õ','ö','ú','ù','û','ü','ñ');
$arrayUpper=array('Ç','Â','Ã','Á','À','Ä','É','È','Ê','Ë','Í','Ì','Î'
,'Ï','Ó','Ò','Ô','Õ','Ö','Ú','Ù','Û','Ü','Ñ');
if($return=='lower') {
$text=strtolower($text);
for($i=0;$i<count($arrayLower);$i++) {
$text=str_replace($arrayUpper[$i], $arrayLower[$i], $text);
}
}
elseif($return=='upper') {
$text=strtoupper($text);
for($i=0;$i<count($arrayLower);$i++) {
$text=str_replace($arrayLower[$i], $arrayUpper[$i], $text);
}
}
return($text);
}
#********************************************************#
#* Encripta e Descripta Senhas #
#********************************************************#
##Encripta a senha
function encode($var) {
$var = base64_encode($var);
$var = base64_encode($var);
return($var);
}
##Retorna a senha na forma normal
function decode($var) {
$var = base64_decode($var);
$var = base64_decode($var);
return($var);
}
?>
Como chamamos as funções acima?
//Colocando o texto em letra maiúscula / minúscula

$nome_cli = stringUpDown(trim($nome_cli), 'upper'); //Coloca em letra MAIÚSCULA
$email_cli = stringUpDown(trim($email_cli), 'lower'); //Coloca em letra minúscula
#### Encripta senha ####

$senha_login = encode($senha_login);
- 85 -
Como mudar senha do usuário do SGBD MySQL:
Sabemos que o usuário padrão do MySQL é root e a senha default é vazia (em
branco). Segue abaixo alguns passos para alterar esta senha padrão:
• Abra o PHPMyAdmin;
• Clique na aba Users;
• Clique em Privilégios;
• Ao lado direito do usuário root, clique no ícone “Editar Privilégios”;
• Role a página até encontrar a opção “Alterar Senha”;
• Marque a opção Senha e digite “universo” (minúsculo) duas vezes: na linha
de cima e na debaixo;
• Clique em Executar;
• Abra o arquivo config.inc.php que se encontra no diretório
c:/wamp/apps/phpmyadmin3.5.1/config.inc.php;
• Digite na linha 16 a Senha ‘universo’ (minúsculo) no lugar de ‘123456’ ou ‘ ’;
- 86 -
11 - Introdução à Orientação a
Objetos em PHP
Inicialmente veremos os 4 principais pilares da Programação Orientada a

Objetos (POO), bem como as diferenças para programação estruturada e as
principais vantagens da POO.
O desenvolvimento de software é extremamente amplo. Nesse mercado,
existem diversas linguagens de programação, que seguem diferentes paradigmas.
Um desses paradigmas é a Orientação a Objetos, que atualmente é o mais
difundido entre todos. Isso acontece porque se trata de um padrão que tem evoluido
muito, principalmente em questões voltadas para segurança e reaproveitamento de
código, o que é muito importante no desenvolvimento de qualquer aplicação
moderna.
A Programação Orientada a Objetos diz respeito a um padrão de
desenvolvimento que é seguido por muitas linguagens, como C#, Java e PHP. A
seguir, iremos entender as diferenças entre a POO e a Programação Estruturada, que
era muito utilizada há alguns anos. Esse padrão se baseia em quatro pilares que
veremos a seguir. Além disso, a POO tem diversas vantagens em sua utilização, que
também serão vistas e explicadas.
Programação Estruturada vs Programação Orientada a Objetos
- 87 -
Na figura acima vemos uma comparação muito clara entre a Programação

Estruturada e a Programação Orientada a Objetos no que diz respeito aos dados.
Repare que, no paradigma estruturado, temos procedimentos (ou funções) que são
aplicados globalmente em nossa aplicação. No caso da orientação a objetos, temos
métodos (nome dado às funções na POO) que são aplicados aos dados de cada
objeto. Essencialmente, os procedimentos e métodos são iguais, sendo diferenciados
apenas pelo seu escopo.
Os 4 pilares da Programação Orientada a Objetos:

Para entendermos exatamente do que se trata a orientação a objetos, vamos
entender quais são os requerimentos de uma linguagem para ser considerada nesse
paradigma. Para isso, a linguagem precisa atender a quatro tópicos bastante
importantes:
Abstração
A abstração consiste em um dos pontos mais importantes dentro de qualquer
linguagem Orientada a Objetos. Como estamos lidando com uma representação de
um objeto real (o que dá nome ao paradigma), temos que imaginar o que esse
objeto irá realizar dentro de nosso sistema. São três pontos que devem ser levados
em consideração nessa abstração:
O primeiro ponto é darmos uma identidade ao objeto que iremos criar. Essa
identidade deve ser única dentro do sistema para que não haja conflito.
O segundo ponto diz respeito às características do objeto. Como sabemos,
no mundo real qualquer objeto possui elementos que o definem. Dentro da
Programação Orientada a Objetos, essas características são nomeadas
- 88 -
propriedades (também chamadas de atributos). Por exemplo, as propriedades de

um objeto "Carro" poderiam ser "Ano", "Modelo", "Cor" e "Fabricante".
Por fim, o terceiro ponto é definirmos as ações que o objeto irá executar.
Essas ações, ou eventos, são chamados métodos. Esses métodos podem ser
extremamente variáveis, desde "Ligar()" em um objeto Carro até "Latir()" em um
objeto cachorro.
Encapsulamento
O encapsulamento é uma das principais técnicas que define a programação
Orientada a Objetos. Trata-se de um dos elementos que adicionam segurança à
aplicação em uma Programação Orientada a Objetos pelo fato de esconder as
propriedades, criando uma espécie de caixa preta.
A maior parte das linguagens Orientadas a Objetos implementam o
encapsulamento baseado em propriedades privadas. Essa atitude evita o acesso
direto a propriedade do objeto, adicionando uma outra camada de segurança à
aplicação.
Para fazermos um paralelo com o que vemos no mundo real, temos o
encapsulamento em outros elementos. Por exemplo, quando clicamos no botão ligar
da televisão, não sabemos o que está acontecendo internamente. Podemos então
dizer que os métodos que ligam a televisão estão encapsulados.
Herança
O reuso de código é uma das grandes vantagens da programação Orientada a
Objetos. Muito disso se dá por uma questão que é conhecida como herança. Essa
característica otimiza a produção da aplicação em tempo e linhas de código.
Para entendermos essa característica, vamos imaginar uma família: a criança,
por exemplo, está herdando características de seus pais. Os pais, por sua vez,
herdam algo dos avós, o que faz com que a criança também o faça, e assim
sucessivamente. Na Orientação a Objetos, a questão é exatamente assim. O objeto
abaixo na hierarquia irá herdar características de todos os objetos acima dele, seus
"ancestrais". A herança a partir das características do objeto mais acima é
considerada herança direta, enquanto as demais são consideradas heranças
- 89 -
indiretas. Por exemplo, na família, a criança herda diretamente do pai e

indiretamente do avô e do bisavô.
Polimorfismo
Outro ponto essencial na programação Orientada a Objetos é o chamado
polimorfismo. Na natureza, vemos animais que são capazes de alterar sua forma
conforme a necessidade, e é dessa ideia que vem o polimorfismo na Orientação a
Objetos. Como sabemos, os objetos filhos herdam as características e ações de seus
"ancestrais". Entretanto, em alguns casos, é necessário que as ações para um
mesmo método seja diferente. Em outras palavras, o polimorfismo consiste na
alteração do funcionamento interno de um método herdado de um objeto pai.
Como um exemplo, temos um objeto genérico "Eletrodoméstico". Esse objeto
possui um método, ou ação, "Ligar()". Temos dois objetos, "Televisão" e "Geladeira",
que não irão ser ligados da mesma forma. Assim, precisamos, para cada uma das
classes filhas, reescrever o método "Ligar()".
Esses quatro pilares são essenciais no entendimento de qualquer linguagem

Orientada a Objetos e da Orientação a Objetos como um todo. Cada linguagem irá
implementar esses pilares de uma forma, mas essencialmente é a mesma coisa.
Principais vantagens da POO

A programação Orientada a Objetos traz uma ideia muito interessante: a
representação de cada elemento em termos de um objeto. Esse tipo de
representação procura aproximar o sistema que está sendo criado ao que é
observado no mundo real, e um objeto contém características e ações, assim
como vemos na realidade. Esse tipo de representação traz algumas vantagens muito
interessantes para os desenvolvedores e também para o usuário da aplicação.
Veremos algumas delas a seguir:
A reutilização de código é um dos principais requisitos no desenvolvimento
de software atual. Com a complexidade dos sistemas cada vez maior, o tempo de
desenvolvimento iria aumentar exponencialmente caso não fosse possível a
reutilização. A Orientação a Objetos permite que haja uma reutilização do código
- 90 -
criado, diminuindo o tempo de desenvolvimento, bem como o número de linhas de

código. Isso é possível devido ao fato de que as linguagens de Programação
Orientada a Objetos trazem representações muito claras de cada um dos elementos,
e esses elementos normalmente não são interdependentes. Essa independência
entre as partes do software é o que permite que esse código seja reutilizado em
outros sistemas no futuro.
Outra grande vantagem que o desenvolvimento Orientado a Objetos traz, diz
respeito à leitura e manutenção de código. Como a representação do sistema se
aproxima muito do que vemos na vida real, o entendimento do sistema como um
todo e de cada parte individualmente fica muito mais simples. Isso permite que a
equipe de desenvolvimento não fique dependente de uma pessoa apenas, como
acontecia com frequência em linguagens estruturadas.
A criação de bibliotecas é outro ponto que é muito mais simples com a
Orientação a Objetos. No caso das linguagens estruturadas, temos que as bibliotecas
são coleções de procedimentos (ou funções) que podem ser reutilizadas. No caso da
POO, entretanto, as bibliotecas trazem representações de classes, que são muito
mais claras para permitirem a reutilização.
Entretanto, nem tudo é perfeição na programação Orientada a Objetos. A
execução de uma aplicação Orientada a Objetos é mais lenta do que o que vemos
na programação estruturada, por exemplo. Isso acontece devido à complexidade do
modelo, que traz representações na forma de classes. Essas representações irão
fazer com que a execução do programa tenha muitos desvios, diferente da execução
sequencial da programação estruturada. No momento atual em que estamos,
tecnologicamente essa execução mais lenta não é sentida. Isso significa que, em
termos de desenvolvimento de sistemas modernos, a Programação Orientada a
Objetos é a mais recomendada devido às vantagens que foram apresentadas. Essas
vantagens são derivadas do modelo de programação, que busca uma representação
baseada no que vemos no mundo real.
- 91 -
Programação Orientada a Objetos na linguagem PHP

Vamos ver agora uma introdução à Programação Orientada a Objetos, com
apresentação dos conceitos básicos desse paradigma e de exemplos práticos na
linguagem PHP.
Para iniciar esta introdução, vejamos um pouco de história: Como o PHP não é
uma linguagem que foi criada para ser Orientada a Objetos (só começou a suportar
Orientação a Objetos na versão 3, sendo aprimorada na versão 4. Na versão 5.3 ou
superiores, o suporte a Orientação a Objetos está excelente), os programadores PHP
utilizavam ou a programação estruturada ou orientada a funções (nomenclatura
usada por estudantes para definir um método de desenvolvimento). Este método
basicamente organiza as funções mais utilizadas em arquivos específicos, como por
exemplo, um arquivo chamado funções de banco e neste arquivo são colocadas as
funções de insert, update e delete, depois bastava incluir o arquivo no local onde
deseja utilizar as funções. Para isso utilizam-se os métodos include, include_once,
require ou require_once do PHP e chamar as funções.
O include tenta incluir o arquivo, caso não ache, retorna um Warning
(warning é apenas um alerta do PHP, a aplicação não é interrompida quando
acontece). O require por sua vez retorna um Fatal Error (o fatal error interrompe a
aplicação e não executa o resto dos comandos), o include_once e require_once
tentam incluir o arquivo, porém se o arquivo já foi incluso ele retorna false e não o
inclui novamente.
Saindo um pouco da parte histórica e indo para a parte mais acadêmica,
vamos estudar um pouco dos conceitos básicos de Orientação a Objetos para em
seguida fazer alguns trechos de código para fixar melhor os conceitos. O primeiro e
mais importante conceito de orientação a objetos é a classe, uma abstração do
software de objetos similares, ou seja, um template do qual os objetos serão criados.
A partir de agora veremos alguns conceitos novos e iremos colocá-los em
prática, montando um projeto Orientado a Objetos. Salve os arquivos criados dentro
do diretório c:/wamp/www/dw3/POO.
Antes de codificar, lembre-se sempre:
• Comente o seu código, pois isso irá ajudar você e a sua equipe de
trabalho na hora de realizar alguma manutenção no mesmo;
- 92 -
• Sempre que criar um arquivo ou diretório de classe, usar sempre a

escrita CamelCase (CamelCase é a denominação em inglês para a
prática de escrever palavras compostas ou frases, onde cada palavra é
iniciada com Maiúsculas e unidas sem espaços. É um padrão
largamente utilizado em diversas linguagens de programação, como
Java, C#, Ruby, PHP e Python, principalmente nas definições de
Classes e Objetos. Pela sua associação com tecnologia, o marketing
se apropriou dessa maneira de escrever, injetando certo ar de
"tecnologia" nos produtos assim nomeados: iPod, GameCube,
OpenOffice.org, StarCraft, dentre outros. A provável origem do termo é
a semelhança do contorno de expressões CamelCase, onde as letras em
maiúsculo "saltam" no meio das minúsculas como corcovas de um
camelo).
Vamos à prática: veja a imagem abaixo e me ajude a retirar informações

dela para criar uma classe chamada Carro usando Orientação a Objetos:
Quais as características desse carro?

Quais são os atributos que posso
extrair desse carro?
O que esse carro faz? Quais são as

funções desse carro? Quais são os
métodos desse carro?
- 93 -
Após análise, encontramos:

Atributos:
Ano: 2016
Modelo: Camaro
Cor: Amarelo
Fabricante: Chevrolet
Métodos:
- Ligar
- Desligar
- Acelerar
- Frear
Vamos agora criar o primeiro exemplo de PHP Orientado a Objetos. Crie um

subdiretório chamado 01 dentro do diretório POO já criado anteriormente
(c:/wamp/www/dw3/POO/01). Agora, crie um diretório chamado Classes
dentro do diretório 01, que será o repositório das classes do exemplo 01
(c:/wamp/www/dw3/POO/01/Classes). Monte a classe Carro dentro do
diretório c:/wamp/www/dw3/POO/01/Classes. Nome do arquivo:
Carro.class.php
Obs: Não é obrigatório colocar o .class no nome dos arquivos que definem as
classes do projeto. Coloquei simplesmente para identificar que se trata de um
arquivo de classe, diferenciando-os dos demais arquivos do projeto.
<?php
class Carro {
/*
* Primeiro Passo: Declarar os Atributos
*/
public $ano;
public $modelo;
public $cor;
public $fabricante;
- 94 -
/*
* Segundo Passo: Criar os Métodos
* Para tornar mais didático, vamos criar um método
chamado MostraDados
*/
function MostraDados() {
echo "Ano: ".$this->ano; /* Toda vez que você
quiser referenciar um atributo dentro da própria classe,
utilize a instrução $this-> */
echo '<br>';
echo "Modelo: ".$this->modelo;
echo '<br>';
echo "Cor: ".$this->cor;
echo '<br>';
echo "Fabricante: ".$this->fabricante;
}
}
?>
Neste momento, nossa classe Carro (Carro.class.php) está pronta. Agora,
dentro do diretório c:/wamp/www/dw3/POO/01 vamos criar nosso objeto em
um arquivo chamado Objeto1.php com o código abaixo:
<?php
/* Primeiro passo: Antes de criar um Objeto.

* Devo informar onde está a classe que este objeto irá
utilizar
*/
include('./Classes/Carro.class.php');
/* Segundo Passo: Instanciar um Objeto */
$carro = new Carro();

- 95 -
$carro->ano="2016";
$carro->cor="Amarelo";
$carro->fabricante="Chevrolet";
$carro->modelo="Camaro";
/* Terceiro passo: Vou acionar o método que desejo. Neste

caso, vou acionar o método MostraDados declarado na classe
Carro */
$carro->MostraDados();
?>
Via localhost do WampServer, acesse o arquivo Objeto1.php e veja se o

mesmo está executando o método MostraDados() corretamente.
Vamos criar agora mais dois métodos na classe Carro (Carro.class.php).
Adicione as linhas abaixo, dentro da classe Carro no arquivo Carro.class.php
function Ligar() {
echo '<br><br>';
echo "Carro ligado!!! :)";
}
function Desligar() {
echo '<br><br>';
echo "Carro desligado!!! :(";
}
Agora, no objeto carro (Objeto1.php), acione os dois métodos criados na
classe Carro: o método Ligar e o método Desligar.
Via localhost do WampServer, acesse novamente o arquivo Objeto1.php e
veja se o mesmo está executando corretamente todos os métodos referenciados.
Exercícios: Crie os métodos Acelerar e Frear na classe Carro

(Carro.class.php) e acione os mesmos no objeto carro (Objeto1.php). Crie um
- 96 -
segundo objeto (Objeto2.php) que utiliza a classe Carro (Carro.class.php) com as

seguintes características: Ano: 2014, Cor: Preta, Fabricante: Honda, Modelo: Civic.
Acione neste objeto (Objeto2.php) os métodos MostraDados() e Ligar().
Responda: Em que momento eu uso o “$this->”?
Método Construtor:
O método __construct() dá a possibilidade ao usuário de sua classe passar
argumentos para o objeto durante o processo de criação do mesmo. Sua sintaxe é
function __construct
Obs: Antes da palavra construct temos 02 (dois) __ “underlines”.
Vamos agora criar o segundo exemplo de PHP Orientado a Objetos. Crie um

Carro.class.php
<?php
class Carro {
/*
* Vamos utilizar a partir deste exemplo o padrão
CamelCase
*/
public $Ano;
public $Modelo;
public $Cor;
public $Fabricante;
- 97 -
/*
* Vamos criar o Método Construtor
*/
function __construct($ArgumentoAno, $ArgumentoModelo,

$ArgumentoCor, $ArgumentoFabricante){
$this->Ano = $ArgumentoAno;
$this->Modelo = $ArgumentoModelo;
$this->Cor = $ArgumentoCor;
$this->Fabricante = $ArgumentoFabricante;
}
echo "Ano: ".$this->Ano; /* Toda vez que você
echo '<br>';
echo "Modelo: ".$this->Modelo;
echo '<br>';
echo "Cor: ".$this->Cor;
echo '<br>';
echo "Fabricante: ".$this->Fabricante;
echo '<br>';
}
}
?>
<?php

- 98 -

utilizar
*/
/* Segundo Passo: Instanciar o Objeto */
$carro = new Carro('2017','Toro','Vermelho','Fiat');

Carro */
?>
Veja como reduzimos consideravelmente o número de linhas de código.

- 99 -
Método Destrutor:
O método __destruct() é responsável por limpar da memória os atributos
utilizados na execução da classe. Funciona como um finalizador e é executado ao
finalizarmos um objeto, ou seja, quando o objeto é desalocado da memória. Sua
sintaxe é function __destruct
Obs: Antes da palavra destruct temos 02 (dois) __ “underlines”.
No arquivo Carro.class.php, dentro da classe Carro, vamos criar o método
destrutor de acordo com o código abaixo:
function __destruct(){
echo '<br>';
echo "O Objeto carro foi destruido com
sucesso!!!";
}
Via localhost do WampServer, acesse novamente o arquivo Objeto1.php e

veja se o mesmo está executando o método destrutor.
Exercícios: Crie um segundo objeto (Objeto2.php) que utiliza a classe Carro

(Carro.class.php) com as seguintes características: Ano: 2017, Cor: Branca,
Fabricante: Ford, Modelo: Fusion. Acione neste objeto (Objeto2.php) o método
MostraDados().
Responda: Qual é a função do método construtor? E do método destrutor?
Método Herança:
É um mecanismo que permite construir uma nova classe com base em
uma classe previamente existente, em que a nova classe herda
automaticamente todos os atributos, comportamentos e implementações da classe
pai.
Com a herança podemos reutilizar partes de códigos já definidas. Além da
agilidade, ela elimina a necessidade de duplicar ou reescrever o código.
- 100 -
Vamos agora criar o terceiro exemplo de PHP Orientado a Objetos. Crie um

Carro.class.php
<?php
class Carro {
/*
* Vamos utilizar a partir deste exemplo o padrão
CamelCase
*/
public $Ano;
public $Modelo;
public $Cor;
public $Fabricante;
/*
*/

$ArgumentoCor, $ArgumentoFabricante){
}
- 101 -
echo "Ano: ".$this->Ano; /* Toda vez que você
echo '<br>';
echo "Modelo: ".$this->Modelo;
echo '<br>';
echo "Cor: ".$this->Cor;
echo '<br>';
echo "Fabricante: ".$this->Fabricante;
echo '<br>';
}
}
?>

<?php

utilizar
*/
$carro = new Carro('2014','Fusion','Preto','Ford');
- 102 -

Carro */
?>
Vamos supor que eu queira lançar no meu sistema o valor do IPVA e do IPI
dos carros. Aí vai entrar a parte de Herança. Para isso, vou criar uma nova classe
chamada CarroImpostos.class.php dentro do diretório
c:/wamp/www/dw3/POO/03/Classes. Esta classe será somente dos impostos
dos veículos. Quando eu for criar uma classe com herança, a primeira coisa que devo
fazer é chamar o arquivo da Classe Pai:
require_once './Carro.class.php';
Após feito isso, devo informar que a nova classe (CarroImpostos) será uma
extensão da classe Carro.
class CarroImpostos extends Carro{
Veja abaixo o código da classe CarroImpostos (CarroImpostos.class.php):

<?php
require_once 'Carro.class.php';
class CarroImpostos extends Carro{ // extends indica que

vou herdar todos os atributos e métodos da Classe Pai Carro
/*
*/
public $IPVA;
- 103 -
public $IPI;
/*
* Segundo Passo: Declarar os Métodos
*/

$ArgumentoCor, $ArgumentoFabricante, $ArgumentoIPVA,
$ArgumentoIPI){
parent::__construct($ArgumentoAno,
$ArgumentoModelo, $ArgumentoCor, $ArgumentoFabricante); // Faz
referência aos atributos da Classe Pai
$this->IPVA = $ArgumentoIPVA;
$this->IPI = $ArgumentoIPI;
}
parent::MostraDados(); // Imprime na tela os
atributos da Classe Pai
echo '<br>';
echo "Valor do IPVA: ".$this->IPVA;
echo '<br>';
echo "Valor do IPI: ".$this->IPI;
echo '<br>';
}
}
?>
Neste momento, nossa classe filha CarroImpostos

(CarroImpostos.class.php) está pronta. Agora, dentro do diretório
c:/wamp/www/dw3/POO/03 vamos alterar o código do nosso objeto
(Objeto1.php) de acordo com o código abaixo:
<?php
- 104 -

utilizar
*/
include('./Classes/CarroImpostos.class.php');
$carro = new
CarroImpostos('2014','Fusion','Preto','Ford',2000,300);

CarroImpostos */
?>

Exercícios: Utilizando o conceito estudado de Herança, crie uma nova Classe

chamada CarroAcessorios (CarroAcessorios.class.php), fazendo com quem esta
classe seja uma classe filha da Classe Carro (Carro.class.php). Esta nova classe terá,
além de todos os atributos e métodos da classe pai, os seguintes atributos:
Insulfilm (que conterá o valor para instalação de Insulfim no carro), Engate (que
conterá o valor para instalação do engate de carretinha no carro) e Camera (que
conterá o valor para instalação da câmera de ré no carro). Esta classe conterá
também o método MostraDados que imprimirá todos os atributos da Classe Pai, bem
como os valores para instalação do Insulfilm, Engate e Câmera de Ré. Monte um
novo objeto (Objeto2.php) que faz referência a esta nova classe criada
- 105 -
(CarroAcessorios.class.php). Não se esqueça de imprimir os valores para instalação

do Insulfim, Engate de Carretinha e Câmera de Ré.
Responda: O que significa a palavra reservada extends na declaração de
uma Classe?
Método Polimorfismo:
O polimorfismo significa muitas formas ou algo que pode mudar sua forma.
Em termos de Programação Orientada a Objetos, polimorfismo pode ser entendido
como um único nome de classe ou métodos que represente um código diferente. Ou
seja, mesmo nome, porém código diferente (uma ação diferente).
Vamos agora criar o quarto exemplo de PHP Orientado a Objetos. Crie um

(c:/wamp/www/dw3/POO/04/Classes).
Vamos criar uma classe chamada CarroFinanciamento dentro do diretório
c:/wamp/www/dw3/POO/04/Classes.
Nome do arquivo: CarroFinanciamento.class.php
<?php
class CarroFinanciamento {
/*
*/
public $ValorFinanciamento;
/*
*/
- 106 -
function __construct($ArgumentoValor){
$this->ValorFinanciamento = $ArgumentoValor;
}
function CalcularJuros() {
echo "Valor Financiamento (Carro): ".$this-
>ValorFinanciamento;
echo '<br>';
echo "Total Juros (Carro): ".$this-
>ValorFinanciamento * 0.1; // Taxa de 10% de Juros
echo '<br><br>';
}
}
?>
Agora, para entendermos o conceito de Polimorfismo, crie uma nova classe

chamada MotoFinanciamento (MotoFinanciamento.class.php), e acordo com o
código abaixo:
<?php
class MotoFinanciamento extends CarroFinanciamento {
function CalcularJuros() {
echo "Valor Financiamento (Moto): ".$this-
>ValorFinanciamento;
echo '<br>';
echo "Total Juros (Moto): ".$this-
>ValorFinanciamento * 0.5; // Taxa de 50% de Juros
echo '<br><br>';
}
}
?>
- 107 -
Neste momento, nossas classes CarroFinanciamento

(CarroFinanciamento.class.php) e MotoFinanciamento (MotoFinanciamento.class.php)
estão prontas. Agora, dentro do diretório c:/wamp/www/dw3/POO/04 vamos
criar nosso objeto em um arquivo chamado Objeto1.php com o código abaixo:
<?php

* Devo informar onde estão as classe que este objeto irá
utilizar
*/
include('./Classes/CarroFinanciamento.class.php');
include('./Classes/MotoFinanciamento.class.php');
/* Segundo Passo: Instanciar os Objetos */
$carro = new CarroFinanciamento(25000);

$carro->CalcularJuros();
$moto = new MotoFinanciamento(9000);

$moto->CalcularJuros();
?>
Observe que em um mesmo objeto, chamamos métodos de mesmo

nome – CalcularJuros() – mas a forma de funcionamento deles é diferente. Com
isso não foi preciso criar código redundante. Daí tiramos o conceito de
Polimorfismo.
mesmo está executando o método CalcularJuros() corretamente, porém, de forma
diferente (10% de juros para carros e 50% de juros para motos).
Exercício: Crie uma nova classe com o nome CaminhaoFinanciamento

(CaminhaoFinanciamento.class.php), filha de CarroFinanciamento (herança), onde o
- 108 -
método CalcularJuros desta nova classe terá uma taxa de 25% de juros sobre o
Valor Financiado. No arquivo Objeto1.php referencie o método CalcularJuros desta
nova classe.
Classes e Métodos Abstratos:

Mas o que é abstração? Podemos considerar abstração uma forma de separar
mentalmente, simplificar ou mesmo analisar isoladamente.
Um sistema Orientado a Objetos não deve ser visto como uma única peça.
Devemos separar em blocos, concentrando nas peças mais importantes e ignorando
os detalhes para que possamos construir peças bem definidas que possam ser
reutilizadas mais tarde, formando uma estrutura hierárquica.
Sempre que estiver desenvolvendo um sistema Orientado a Objetos, você
deve aplicar o seguinte conceito:
"Abstraia ao máximo e busque separar o sistema em módulos".
Classe Abstrata: Nada mais é do que um modelo comum, que deve ser
seguido pelas classes filhas. Nunca é instanciada em um objeto, ou seja, não
existe isoladamente.
Definimos uma classe como abstrata utilizando a palavra reservada abstract

antes da palavra class. Em caso do método se utiliza abstract antes da criação do
método.
- 109 -
Métodos abstratos: Não podem ser implementados nas classes abstratas,

deve ser definido somente a assinatura do método e deve obrigatoriamente, ser
implementado na íntegra pela classe filha que o estender. Em suma, um método
abstrato é definido em uma classe abstrata, mas deve conter somente sua
assinatura, o "corpo" do método fica por conta das classes filhas.
Vamos agora criar o quinto exemplo de PHP Orientado a Objetos. Crie um

(c:/wamp/www/dw3/POO/05/Classes).
Vamos criar uma classe abstrata chamada Pessoas dentro do diretório
c:/wamp/www/dw3/POO/05/Classes.
Nome do arquivo: Pessoas.class.php
<?php
abstract class Pessoas {
/*
*/
public $Nome;
public $CPF;
public $RG;
public $Endereco;
public $Bairro;
public $Cidade;
public $UF;
public $CEP;
public $Telefone;
public $Celular;
public $Email;
- 110 -
/*
*/
function __construct($ArgNome, $ArgCPF, $ArgRG,

$ArgEndereco, $ArgBairro, $ArgCidade, $ArgUF, $ArgCEP,
$ArgTelefone, $ArgCelular, $ArgEmail) {
$this->Nome = $ArgNome;
$this->CPF = $ArgCPF;
$this->RG = $ArgRG;
$this->Endereco = $ArgEndereco;
$this->Bairro = $ArgBairro;
$this->Cidade =$ArgCidade;
$this->UF = $ArgUF;
$this->CEP = $ArgCEP;
$this->Telefone = $ArgTelefone;
$this->Celular = $ArgCelular;
$this->Email = $ArgEmail;
public function MostrarPessoas() {

echo "Dados Pessoais";
echo '<br>';
echo "Nome: " . $this->Nome;
echo '<br>';
echo "CPF: " . $this->CPF;
echo '<br>';
echo "RG: " . $this->RG;
echo '<br>';
echo "Endereco: " . $this->Endereco;
echo '<br>';
- 111 -
echo "Bairro: " . $this->Bairro;

echo '<br>';
echo "Cidade: " . $this->Cidade;
echo '<br>';
echo "UF: " . $this->UF;
echo '<br>';
echo "CEP: " . $this->CEP;
echo '<br>';
echo "Telefone: " . $this->Telefone;
echo '<br>';
echo "Celular: " . $this->Celular;
echo '<br>';
echo "Email: " . $this->Email;
echo '<br>';
}
/*
* Assinar Método Abstrato ContaCorrente
*/
abstract public function ContaCorrente(); // Quando

coloco meu método como abstrato, não posso implementar o mesmo
na classe pai, somente nas classes filhas
}
?>
Vamos criar agora uma nova classe (esta classe não será abstrata!!!) chamada
ProdutoContaCorrente que será classe filha da classe Pessoas dentro do
diretório c:/wamp/www/dw3/POO/05/Classes.
Nome do arquivo: ProdutoContaCorrente.class.php
<?php
require_once 'Pessoas.class.php';
- 112 -
class ProdutoContaCorrente extends Pessoas {
/*
* Primeiro Passo: Declarar os atributos
*/
public $Banco;
public $Agencia;
public $Conta;
/*
*/
function __construct($ArgNome, $ArgCPF, $ArgRG,

$ArgTelefone, $ArgCelular, $ArgEmail, $ArgBanco, $ArgAgencia,
$ArgConta) {
parent::__construct($ArgNome, $ArgCPF, $ArgRG,
$ArgTelefone, $ArgCelular, $ArgEmail); //Referencia a Classe
Pai
$this->Banco = $ArgBanco;
$this->Agencia = $ArgAgencia;
$this->Conta = $ArgConta;
function MostrarPessoas() {
parent::MostrarPessoas();
}
- 113 -
function ContaCorrente(){
echo '<br>';
echo "Dados da Conta Corrente";
echo '<br>';
echo "Banco: ". $this->Banco;
echo '<br>';
echo "Agencia: ". $this->Agencia;
echo '<br>';
echo "Conta Corrente: ". $this->Conta;
}
}
?>
Neste momento, nossas classes Pessoas (Pesoas.class.php) e

ProdutoContaCorrente (ProdutoContaCorrente.class.php) estão prontas. Agora,
<?php

utilizar
*/
include('./Classes/ProdutoContaCorrente.class.php');
/* Segundo Passo: Instanciar os Objetos */
$ContaCorrente = new ProdutoContaCorrente('Francisco

Carlos Lopes', '111.222.333-44', '1234567-89', 'Avenida
Brasil, 830', 'Centro', 'Juiz de Fora', 'MG', '36124-125',
- 114 -
'(32)3025-1234', '(32)99999-8888', 'francisco@gmail.com',

'Itau', '1234', '1234567-8');
/* Terceiro passo: Vou acionar os métodos que desejo. */

$ContaCorrente->MostrarPessoas();
$ContaCorrente->ContaCorrente();
?>

mesmo está executando os métodos declarados corretamente.
Classes Finais e Métodos Finais:

Classes Finais: Podemos definir classes finais como classes que não podem
ser estendidas, ou seja, não pode ser uma superclasse (você nunca vai poder
criar uma herança dessa classe).
Uma classe é definida como final quando colocamos a palavra reservada
final antes da palavra class.
Vamos agora criar o sexto exemplo de PHP Orientado a Objetos. Crie um

Carro.class.php
<?php
final class Carro {

/*
*/
- 115 -
public $ano;
public $Modelo;
public $Cor;
public $Fabricante;
/*
*/

$ArgumentoCor, $ArgumentoFabricante) {
}
echo "Ano: ". $this->Ano;
echo '<br>';
echo "Modelo: ". $this->Modelo;
echo '<br>';
echo "Cor: ". $this->Cor;
echo '<br>';
echo "Fabricante: ". $this->Fabricante;
echo '<br>';
}
}
?>

<?php
- 116 -
include './Classes/Carro.class.php';
$Carro = new Carro('2010', 'Fusion', 'Branco', 'Ford');

$Carro->MostraDados();
?>

mesmo está executando o método MostraDados() corretamente. Até aqui,
nenhuma novidade.
Agora vamos criar uma nova classe chamada CarroImpostos.class.php

dentro do diretório c:/wamp/www/dw3/POO/06/Classes. Esta classe será
somente dos impostos dos veículos e será uma classe filha da classe Carros
(Herança).
Veja abaixo o código da classe CarroImpostos (CarroImpostos.class.php):
<?php
require_once 'Carro.class.php';
class CarroImpostos extends Carro{ // extends indica que

vou herdar todos os atributos e métodos da Classe Pai Carro
/*
*/
public $IPVA;
public $IPI;
/*
- 117 -
*/

$ArgumentoCor, $ArgumentoFabricante, $ArgumentoIPVA,
$ArgumentoIPI){
parent::__construct($ArgumentoAno,
$ArgumentoModelo, $ArgumentoCor, $ArgumentoFabricante); // Faz
referência aos atributos da Classe Pai
$this->IPVA = $ArgumentoIPVA;
$this->IPI = $ArgumentoIPI;
}
parent::MostraDados(); // Imprime na tela os
atributos da Classe Pai
echo '<br>';
echo "Valor do IPVA: ".$this->IPVA;
echo '<br>';
echo "Valor do IPI: ".$this->IPI;
echo '<br>';
}
}
?>
Neste momento, nossa classe filha CarroImpostos

(CarroImpostos.class.php) está pronta. Agora, dentro do diretório
c:/wamp/www/dw3/POO/06 vamos criar o arquivo Objeto2.php de acordo
com o código abaixo:
<?php

utilizar
*/
- 118 -
include('./Classes/CarroImpostos.class.php');
$carro = new
CarroImpostos('2014','Fusion','Preto','Ford',2000,300);

CarroImpostos */
?>

mesmo está executando o método MostraDados() corretamente. Não? Não
apareceu nada? Por quê?
Vá na classe Carro (Carro.class.php) e retire a palavra reservada final antes
de class (final class Carro {). Salve sua classe e via localhost do WampServer, acesse
novamente o arquivo Objeto2.php e veja se o mesmo está executando o método
MostraDados() corretamente.
Métodos Finais: Um método final não pode ser estendido e obviamente não
pode ser abstrato, pois métodos abstratos foram feitos para serem estendidos e
declarados na classe filha.
Para declarar um método como final basta usar a palavra reservada final
antes da palavra function.
Para exemplificar, edite a classe Carros (Carros.class.php) e coloque a

palavra reservada final antes do método MostrarDados.
- 119 -

mesmo está executando o método MostraDados() corretamente. Não? Não
apareceu nada? Por quê?
Atribuindo Visibilidade a Propriedades e Métodos:

O public, protected e private são utilizados para declarar a visibilidade de
uma propriedade (argumento) ou método.
• private: Este modificador não permite ser acessado por classes
descendentes (classes filhas), só pode ser acessado dentro da própria
classe;
• public: Este modificador é o default (padrão), ou seja, quando um
método não tiver um modificador de visibilidade definido, ele sempre
será public. Public significa que o método ou propriedade em questão
pode ser acessado por todas as outras classes e métodos sem
quaisquer restrições;
• protected: Pode ser acessado apenas por métodos da própria classe e
classes filhas.
Veja o exemplo abaixo:
<?php
class Carro {
private $Ano; // Este atributo só pode ser acessado
dentro da própria classe
protected $Modelo; // Este atributo só pode ser
acessado apenas por métodos da própria classe e das classes
filhas
public $Cor; // Este atributo pode ser acessado por
todas as outras classes e métodos sem quaisquer restrições
?>
Constantes
Uma constante é algo que mantém seu valor fixo, ou seja, sem alterações. A
declaração de constantes é feita através da palavra chave const. Para acessar
- 120 -
constantes de classe fora do escopo dela, a seguinte notação é utilizada

Nome_da_Classe::Nome_da_Constante. Já dentro da classe, utilizamos a
notação self::Nome_da_Constante.
O uso de contantes é muito útil quando utilizamos cálculos no nosso sistema.
Exemplo: Valor de PI.
Vamos agora criar o sétimo exemplo de PHP Orientado a Objetos, aplicando o

conceito de constantes. Crie um subdiretório chamado 07 dentro do diretório POO
já criado anteriormente (c:/wamp/www/dw3/POO/07). Agora, crie um diretório
chamado Classes dentro do diretório 07, que será o repositório das classes do
exemplo 07 (c:/wamp/www/dw3/POO/07/Classes). Monte a classe Versoes
dentro do diretório c:/wamp/www/dw3/POO/07/Classes. Nome do arquivo:
Versoes.class.php
<?php
class Versoes {
/*
* Informações de Versões de Aplicativos
*/
const Versao = '1.0';

const Autor = 'Francisco Carlos Lopes';
const Data = '17/11/2016';
const SO = 'IOS';
?>
Agora vamos criar outra classe, filha da classe Versoes, com o nome de
Aplicativos (Aplicativos.class.php), com o código abaixo:
<?php
include 'Versoes.class.php';
- 121 -
class Aplicativos extends Versoes {
/*
* Primeiro Passo: Declarar os Atributos e as
Constantes
*/
public $NomeAplicativo;
const TipoLicenca = 'Trial';
/*
*/
function __construct($ArgumentoNomeAplicativo) {
$this->NomeAplicativo = $ArgumentoNomeAplicativo;
function MostraDados(){
echo "Nome Aplicativo: ". $this->NomeAplicativo;
// Usei o $this-> porque estou referenciando um atributo
dentro da própria classe
echo '<br>';
echo "Tipo de Licenca: ". self::TipoLicenca; //
Usei o self:: porque estou referenciando uma constante dentro
da própria classe
echo '<br>';
echo "Versao: ". Versoes::Versao;
echo '<br>';
- 122 -
echo "Autor: ". Versoes::Autor; // Usei Versoes::

porque estou referenciando a constante Autor da classe Versoes
echo '<br>';
echo "Data: ". Versoes::Data;
echo '<br>';
echo "Sistema Operacional: ". Versoes::SO;
}
}
?>
Neste momento, as classes Versoes e Aplicativos estão criadas. Agora,

dentro do diretório c:/wamp/www/dw3/POO/07 vamos criar o arquivo
Objeto1.php de acordo com o código abaixo:
<?php
include './Classes/Aplicativos.class.php';
$Versionamento = new Aplicativos('Calculadora');

$Versionamento->MostraDados();
?>
Exercícios: Na classe Versoes crie um atributo chamado Raio, uma

constante com o nome PI com o valor igual a 3.14159265359, um método
__construct que receberá o Raio de uma circunferência e um método
CalculaComprimento, que imprimirá o valor do comprimento da circunferência.
Crie um arquivo Objeto2.php que instancie o método CalculaComprimento e
passe o atributo raio com o valor do mesmo.
Responda: Quando eu uso o self:: para referenciar uma constante?
- 123 -
Propriedades (ou Atributos) e Métodos Estáticos

Podemos considerar que propriedades e métodos estáticos podem ser
acessados sem a necessidade de instanciar um objeto. Utilizamos este recurso
quando, por exemplo, temos um método que é acessado diversas vezes na mesma
aplicação, e queremos economizar algumas linhas de código a fim de não ter que
criar um objeto a todo o momento.
É importante destacar que membros estáticos podem ser acessados
internamente utilizando o operador self.
Vamos agora criar o oitavo exemplo de PHP Orientado a Objetos, aplicando o

conceito de Propriedades e Métodos Estáticos. Crie um subdiretório chamado 08
dentro do diretório POO já criado anteriormente (c:/wamp/www/dw3/POO/08).
Agora, crie um diretório chamado Classes dentro do diretório 08, que será o
repositório das classes do exemplo 08 (c:/wamp/www/dw3/POO/08/Classes).
Monte a classe Versoes dentro do diretório c:/wamp/www/dw3/POO/
08/Classes. Nome do arquivo: Versoes.class.php
<?php
class Versoes {
/*
* Propriedade Estática
*/
public static $Rodape = 'ERP | v.1.0 | Desenvolvido por

Francisco Carlos Lopes';
/*
* Método Estático
*/
static function MostrarDados() {

echo self::$Rodape;
}
- 124 -
}
?>
Neste momento, a classe Versoes está criada. Agora, dentro do diretório

<?php
include './Classes/Versoes.class.php';
/*
* Acionar meu método estático
*/
//Versoes::MostrarDados(); // Aqui eu instanciei o método

MostraDados da minha classe VErsoes
/*
* Acessar a propriedade estática
*/
echo Versoes::$Rodape; // Aqui eu acesso diretamente a

propriedade estática da classe Versoes, sem ter que instanciar
o método MostrarDados
?>

mesmo está executando corretamente. Retire o comentário da linha 8 e comente a
linha 14 e entenda o seu funcionamento.
- 125 -
Relacionamento entre objetos

Associação: A forma mais comum de associação é quando temos um objeto
como atributo de outro.
Vamos agora criar o nono exemplo de PHP Orientado a Objetos. Crie um

(c:/wamp/www/dw3/POO/09/Classes). Criaremos uma classe Carro e outra
classe Fabricante. Onde Fabricante é um dos atributos de Carro. Crie estas classes
dentro do diretório c:/wamp/www/dw3/POO/09/Classes. Nome do arquivo:
Carro.class.php
<?php
class Carro {
/*
*/
public $Id;
public $NomeCarro;
public $Valor;
public $Fabricante;
/*
*/
function __construct($ArgumentoId,
$ArgumentoNomeCarro, $ArgumentoValor, $ArgumentoFabricante) {
$this->Id = $ArgumentoId;
$this->NomeCarro = $ArgumentoNomeCarro;
$this->Valor = $ArgumentoValor;
- 126 -
}
}
?>
Nome do arquivo: Fabricante.class.php

<?php
class Fabricante {
/*
*/
public $Id;
public $NomeFantasia;
public $Telefone;
public $Email;
/*
*/
function __construct($ArgumentoId,
$ArgumentoNomeFantasia, $ArgumentoTelefone, $ArgumentoEmail) {
$this->Id = $ArgumentoId;
$this->NomeFantasia = $ArgumentoNomeFantasia;
$this->Telefone = $ArgumentoTelefone;
$this->Email = $ArgumentoEmail;
}
}
?>
- 127 -
Neste momento, as classes estão criadas. Agora, dentro do diretório

<?php
include './Classes/Carro.class.php';
include './Classes/Fabricante.class.php';
/*
* Associação
*/
$fabricante = new Fabricante(9033, 'Ford do Brasil', '(11)
99999-8888', 'contato@ford.com.br');
$carro = new Carro('1232', 'Fusion', 80000, $fabricante);
echo "Codigo do Carro: ". $carro->Id;

echo '<br>';
echo "Nome do Carro: ". $carro->NomeCarro;
echo '<br>';
echo "Fabricante: ". $carro->Fabricante->NomeFantasia;
echo '<br>';
echo "E-mail: ". $carro->Fabricante->Email;
?>

mesmo está executando corretamente.
Exercício: Faça imprimir também no arquivo Objeto1.php o Valor do carro,

o Código do fabricante e o Telefone do fabricante.
- 128 -
Métodos Mágicos
Os métodos mágicos são reservados, todos prefixados com dois caracteres
“_” (underline) no início.
Os métodos __set(), __get() e __call são alguns desses métodos. Trata-se de
métodos opcionais e geralmente utilizados para executarem ações consideradas
especiais e específicas.
__SET: O método __set() é invocado toda vez que um atributo não declarado
da classe recebe a atribuição de um valor. Este método espera dois parâmetros, o
primeiro contendo o nome do atributo e o segundo seu valor.
__GET: É análogo ao método __set(). O __get() é chamado quando um

atributo da classe precisa ser retornado para o objeto. Ele espera um parâmetro, que
será preenchido com o nome do atributo chamado.
Vamos agora criar o décimo exemplo de PHP Orientado a Objetos. Crie um

(c:/wamp/www/dw3/POO/10/Classes). Criaremos uma classe com o nome
Pessoas dentro do diretório c:/wamp/www/dw3/POO/10/Classes. Nome do
arquivo: Pessoas.class.php
<?php
class Pessoas {
/*
*/
private $Nome;
private $Sobrenome;
- 129 -
/*
* Obs: Se não existissem os métodos __set e __get eu
jamais conseguiria
* acessar estes atributos, pois os mesmos são private
=> estes
* atributos só podem ser acessados dentro da própria
classe
*/
public function __set($name, $value) {

$this->$name = $value;
}
public function __get($name) {

return $this->$name;
}
}
?>
Neste momento, a classe está criada. Agora, dentro do diretório

<?php
include './Classes/Pessoas.class.php';
$Pessoas = new Pessoas();
// Usando o método __set

$Pessoas->Nome = 'Jorge';
$Pessoas->Sobrenome = 'Silva';
- 130 -
// Usando o método __get

echo $Pessoas->Nome. " ". $Pessoas->Sobrenome;
?>

mesmo está executando corretamente. Observe que estamos utilizando os métodos
__set() e __get() no Objeto1.php
__CALL: O método __call() entra em ação quando é feita uma chamada a um

método que não existe. Sempre que um método não existir em um objeto,
automaticamente a execução será direcionada para ele que também recebe dois
parâmetros: o nome e os parâmetros informados. Assim ele pode decidir o que pode
fazer nesta situação.
O método __call() entra em ação para centralizar determinadas
chamadas a métodos que não foram implementados por uma classe, que ao
invés de retornar o erro “este método não existe” irá chamar o método __call(). O
Método __call() é implementado com 2 parametros:
● (string) Name – aonde será armazenado o nome da função (método);
● (string) Parameters – aonde serão armazenados os dados dos
parâmetros.
Vamos agora criar o décimo primeiro exemplo de PHP Orientado a Objetos.

Crie um subdiretório chamado 11 dentro do diretório POO já criado anteriormente
(c:/wamp/www/dw3/POO/11/Classes). Criaremos uma classe com o nome
Teste dentro do diretório c:/wamp/www/dw3/POO/11/Classes. Nome do
arquivo: Teste.class.php
<?php
class Teste {
- 131 -
// Criei um método chamado __call

public function __call($name, $arguments) {
echo "Voce chamou o metodo: " . $name . " e passou
os parametros " . print_r($arguments, 1);
}
// o comando print_r imprime na tela a estrutura de
um array
}
?>
Neste momento, a classe está criada. Agora, dentro do diretório

<?php
include './Classes/Teste.class.php';
$TesteMetodo = new Teste();
// Vou chamar agora um método que não existe na classe

Teste
// Neste caso, o método Fazer
$TesteMetodo->Fazer("Piada", "Banana", 5.8);
?>

mesmo está executando corretamente. Observe que no Objeto1.php chamamos o
método Fazer que não existe dentro da classe Teste (Teste.class.php). Como a
classe Teste possui o método __call, o mesmo entra em ação neste momento e é
executado, mostrando os comandos definidos dentro do mesmo.
- 132 -
Função __autoload
A partir da versão 5 do PHP, foi inserido uma nova forma de carregar classes.
Essa abordagem para carregamento “sob demanda” é feita através da função
__autoload. Está função permite que o desenvolvedor não tenha que declarar uma
longa lista de includes ou require_once no início de cada script.
Vamos agora criar o décimo segundo exemplo de PHP Orientado a Objetos.

Crie um subdiretório chamado 12 dentro do diretório POO já criado anteriormente
(c:/wamp/www/dw3/POO/12/Classes). Criaremos duas classes
(PrimeiraClasse.class.php e SegundaClasse.class.php) dentro do diretório
c:/wamp/www/dw3/POO/12/Classes de acordo com os códigos abaixo.
Nome do arquivo: PrimeiraClasse.class.php

<?php
class PrimeiraClasse {
/*
* Primeiro Passo: Declarar atributos
*/
public $nome;
public function __construct($ArgNome) {

$this->nome = $ArgNome;
}
public function MostraNome() {

echo "Esse e meu nome: ". $this->nome;
}
}
?>
- 133 -
Nome do arquivo: SegundaClasse.class.php

<?php
class SegundaClasse {
/*
*/
public $idade;
public function __construct($ArgIdade) {

$this->idade = $ArgIdade;
}
public function MostraIdade() {

echo "<br>";
echo "Essa e minha idade: ". $this->idade;
}
}
?>
Neste momento, as classes estão criadas. Agora, dentro do diretório

<?php
function __autoload($classe) {
include_once "./Classes/{$classe}.class.php";
// Se eu fosse fazer no método tradicional,

// teria que dar um include em cada classe
- 134 -
// Se este objeto fosse utilizar 15 classes

// diferentes, teria que fazer 15 includes diferentes
// A função __autoload substitui estes 15 includes,
// ou seja, o carregamento das classes é feito sob demanda
// Criei um objeto instanciando a PrimeiraClasse

$PrimeiraClasse = new PrimeiraClasse("Francisco");
// Chamei o método MostraNome definido na PrimeiraClasse

$PrimeiraClasse->MostraNome();
// Criei um objeto instanciando a SegundaClasse

$SegundaClasse = new SegundaClasse(32);
// Chamei o método MostraIdade definido na SegundaClasse

$SegundaClasse->MostraIdade();
?>

mesmo está executando corretamente.
- 135 -
Banco de Dados
Cada driver PDO (PHP DATA OBJECT) especifica uma forma de como é
montado o chamado “DNS”, que é uma string de conexão para o SGBD
correspondente. Além do DNS, também é informado, por parâmetro, o usuário, a
senha de acesso e algumas opções adicionais. Vejamos abaixo o uso do PDO para
sqlite, firebird e Postgre SQL.
new PDO('sqlite:teste.db');
new PDO("firebird:dbname=c:\banco.GDB", "SYSDBA", "masterkey");
new PDO("pgsql:dbname=exemplo;user=user;password=senha;host=localhost");
Para conexão com um SGBD, vamos utilizar uma classe chamada

PDOConnectionFactory.class.php. Com esta classe podemos conectar em
qualquer SGBD desejado (Oracle, SQLite, Postgre, Firebirb, MySQL, ...), bastando
alterar apenas alguns parâmetros no mesmo.
Veja o código fonte do arquivo PDOConnectionFactory.class.php
<?php
/*
* Conexão de Banco de Dados (Fábrica de Conexões)
*/
class PDOConnectionFactory {
/*
* Recebe a conexão do banco de dados
*/
protected $con = null;
/*
* Recebe qual o tipo de banco de dados
*/
protected $dbType = "mysql"; //mysql, oracle, pgsql,
firebird ...
- 136 -
/*
* Parâmetros de Conexão
*/
protected $host = "localhost";
protected $user = "root";
protected $senha = "";
protected $db = "agenda_PDO";
/*
* Configura a persistência da conexão
* Ela pode ser verdadeira, se você for utilizar uma
conexão persistente
* ou falsa, caso contrário
*/
protected $persistent = false;
/*
* new PDOConnectionFactory( true ) <--- conexão
persistente
* new PDOConnectionFactory() <--- conexao não
persistente
*/
public function PDOConnectionFactory($persistent =

false) {
/*
* Verificar a persistência da conexao
*/
if ($persistent != false) {
$this->persistent = true;
}
}
- 137 -
public function getConnection() {

try {
/*
* Realiza a conexão com o banco de dados
*/
$this->con = new PDO($this->dbType . ":host="
. $this->host . ";dbname=" . $this->db, $this->user, $this-
>senha, array(PDO::ATTR_PERSISTENT => $this->persistent));
/*
* Se realizado com sucesso, retorna conectado
*/
return $this->con;
/*
* Caso ocorra um erro, retorna o erro;
*/
} catch (PDOException $ex) {
echo "Erro: " . $ex->getMessage();
}
}
/*
* Desconectar o banco de dados
*/
public function Close() {

if ($this->con != null) {
$this->con = null;
}
}
}
?>
- 138 -
Exemplo Prático de uso do Banco de Dados MySQL usando POO em PHP:

Agenda de Contatos
Vamos colocar em prática tudo o que foi aprendido até o momento. Vamos
criar uma aplicação chamada Agenda, onde vamos utilizar todos os conceitos
aprendidos com PHP Orientado a Objetos.
Primeiro passo: Utilizando o PHPMyAdmin, vamos criar o nosso Banco de
Dados MySQL com o nome projetopoo. Agora, dentro deste banco de dados criado,
vamos criar uma tabela com o nome agenda de acordo com o código abaixo:
CREATE TABLE àgenda` (
ìd` int(11) NOT NULL AUTO_INCREMENT,
`nome` varchar(45) COLLATE latin1_general_ci NOT NULL,
èmail` varchar(45) COLLATE latin1_general_ci NOT NULL,
`telefone` varchar(30) COLLATE latin1_general_ci NOT NULL,
PRIMARY KEY (ìd`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1
COLLATE=latin1_general_ci;
Nossa Agenda de Contatos terá as seguintes funcionalidades:

1. Cadastrar;
2. Listar;
3. Alterar;
4. Excluir.
Vamos agora criar o projeto final de PHP Orientado a Objetos. Crie um
subdiretório chamado ProjetoAgenda dentro do diretório POO já criado
anteriormente (c:/wamp/www/dw3/POO/ProjetoAgenda). Agora, crie um
diretório chamado Classes dentro do diretório ProjetoAgenda, que será o
repositório das classes do nosso projeto (c:/wamp/www/dw3/POO/
ProjetoAgenda/Classes). Dentre deste diretório Classes criado, vamos criar dois
subdiretórios: Um com o nome de PDO, que conterá a classe de conexão com o
Banco de Dados e outro com o nome DAO (Data Access Object), que conterá as
classes de inserção, seleção, alteração e exclusão, bem como uma classe com os
- 139 -
métodos mágicos __get() e __set(). Na pasta PDO vamos colocar a classe

PDOConnectionFactory.class.php com o código abaixo:
<?php
/*
* Conexão de Banco de Dados (Fábrica de Conexões)
*/
class PDOConnectionFactory {
/*
* Recebe a conexão do banco de dados
*/
protected $con = null;
/*
* Recebe qual o tipo de banco de dados
*/
protected $dbType = "mysql"; //mysql, oracle, pgsql,
firebird ...
/*
* Parâmetros de Conexão
*/
protected $host = "localhost";
protected $user = "root";
protected $senha = "";
protected $db = "projetopoo";
/*
* Configura a persistência da conexão
* Ela pode ser verdadeira, se você for utilizar uma
conexão persistente
* ou falsa, caso contrário
*/
- 140 -
protected $persistent = false;
/*
* new PDOConnectionFactory( true ) <--- conexão
persistente
* new PDOConnectionFactory() <--- conexao não
persistente
*/
public function PDOConnectionFactory($persistent =

false) {
/*
* Verificar a persistência da conexao
*/
if ($persistent != false) {
$this->persistent = true;
}
}
public function getConnection() {

try {
/*
* Realiza a conexão com o banco de dados
*/
$this->con = new PDO($this->dbType . ":host="
. $this->host . ";dbname=" . $this->db, $this->user, $this-
>senha, array(PDO::ATTR_PERSISTENT => $this->persistent));
/*
* Se realizado com sucesso, retorna conectado
*/
return $this->con;
- 141 -
/*
* Caso ocorra um erro, retorna o erro;
*/
} catch (PDOException $ex) {
echo "Erro: " . $ex->getMessage();
}
}
/*
* Desconectar o banco de dados
*/
public function Close() {
if ($this->con != null) {
$this->con = null;
}
}
}
?>
- 142 -
Agora, dentro do subdiretório DAO, vamos criar uma classe com o nome
MagicAgenda.class.php. Nesta classe vamos colocar os métodos mágicos __get()
e __set(). Veja o código abaixo:
<?php
class MagicAgenda {
/*
*/
private $id;
private $nome;
private $email;
private $telefone;
/*
* Segundo Passo: Declarar os métodos
*/
public function __set($name, $value) {

$this->$name = $value;
}
public function __get($name) {

return $this->$name;
}
}
?>
Agora, ainda dentro do subdiretório DAO, vamos criar uma nova classe com o
nome AgendaDAO.class.php. Nesta classe vamos colocar os métodos Inserir
(insere novos contatos), Deletar (apaga um contato), Alterar (altera um contato
selecionado) e Listar (lista os contatos). Veja abaixo o código da
AgendaDAO.class.php:
- 143 -
<?php
/* Classe DAO (Data Access Object) para tabela Agenda
* Será reponsável pelas operações (INSERT, UPDATE,
DELETE, SELECT)
*/
// Como vamos trabalhar com Banco de Dados agora, o

primeiro passo que devemos fazer é uma conexão
// O arquivo responsável por fazer esta conexão é o
PDOConnectionFactory.class.php
require_once
'../Classes/PDO/PDOConnectionFactory.class.php';
// Como vamos utilizar alguns métodos de

PDOConnectionFactory.class.php, vamos fazer uma Herança
class AgendaDAO extends PDOConnectionFactory {
/*
* Atributo de Conexão
*/
public $conex = null;
/*
* Método Construtor
* Aqui chamamos o método getConnection da Classe
PDOConnectionFactory
*/
public function __construct() {
$this->conex =
PDOConnectionFactory::getConnection();
}
- 144 -
/*
* Cadastrar Registro
*/
public function Inserir($agenda){
try {
/*
* Preparar a query de inserção - Prepare
Statement
* Note que estou protegendo do SQL Injection
(A Injeção de SQL, mais
* conhecida através do termo americano SQL
Injection, é um tipo de ameaça
* de segurança que se aproveita de falhas em
sistemas que interagem com bases
* de dados via SQL. A injeção de SQL ocorre
quando o atacante consegue inserir
* uma série de instruções SQL dentro de uma
consulta (query) através da
* manipulação das entradas de dados de uma
aplicação.).
*/
$stmt = $this->conex->prepare("INSERT INTO

agenda(id, nome, email, telefone) VALUES(?, ?, ?, ?)");
/*
* Valores encapsulados nas variavies da
classe Agenda
*/
$stmt->bindValue(1,$agenda->id);
$stmt->bindValue(2,$agenda->nome);
$stmt->bindValue(3,$agenda->email);
$stmt->bindValue(4,$agenda->telefone);
- 145 -
/*
* Executar a Query
*/
$stmt->execute();
echo "<center>";
echo "Registro inserido com sucesso!!!<br
/><br />";
echo "<div><font face=Arial size=2>[ <a
href='../index.php'>Voltar para o Menu Principal</a>
]</font></div>";
echo "</center>";
/*
* Fecha a Conexão
*/
$this->conex = null;
} catch (Exception $ex) {

echo "Erro: ". $ex->getMessage();
}
}
/*
* Remover Registro
*/
public function Deletar($id) {
try {
//executar minha query

$num = $this->conex->exec("DELETE FROM agenda
WHERE id=$id");
echo "<center>";
- 146 -
echo "Registro excluido com sucesso!!!<br

/><br />";
]</font></div>";
echo "</center>";
//Caso seja executado retorna o numero de

linhas afetadas
if ($num >= 1) {
return $num;
} else {
return 0;
}

}
}
/*
* Alterar Registro
*/
public function Alterar($agenda,$condicao){
try {
/*
* Preparar a query de alteração
* Note que estou protegendo do SQL Injection.
*/
- 147 -
$stmt = $this->conex->prepare("UPDATE agenda

SET nome=?, email=?, telefone=? WHERE id=?");
/*
* Valores encapsulados nas variavies da
classe Agenda
*/
$stmt->bindValue(1,$agenda->nome);
$stmt->bindValue(2,$agenda->email);
$stmt->bindValue(3,$agenda->telefone);
$stmt->bindValue(4,$condicao);
/*
* Executar minha Query
*/
$stmt->execute();
echo "<center>";
echo "Registro alterado com sucesso!!!<br
/><br />";
]</font></div>";
echo "</center>";
/*
* Fechar Conexão
*/

}
}
- 148 -
/*
* Listar Registros
*/
public function Listar($query=null) {
try {
// Se eu não passar query nenhuma como
parâmetro, será selecionado todos os registros
if ($query == null) {
$stmt = $this->conex->query("SELECT * FROM
agenda");
// Se eu passar uma query como parâmetro,

será executada esta query
} else {
$stmt = $this->conex->query($query);
}
echo"<center>";
echo"<b>Lista de Contatos
Selecionados</b><br /><br />";
while ($row = $stmt-
>fetch(PDO::FETCH_ASSOC)){
echo "ID: {$row['id']} | Nome:

{$row['nome']} | Email: {$row['email']} | Telefone:
{$row['telefone']} | <a
href='FrmAgendaAlterar.php?tf_id={$row['id']}&tf_nome={$row['n
ome']}&tf_email={$row['email']}&tf_telefone={$row['telefone']}
'>ALTERAR</a> | <a
href='AgendaDelete.php?tf_id={$row['id']}'>EXCLUIR</a> <br/>
";
}
- 149 -
echo"<br /><div><font face=Arial size=2>[

<a href='../index.php'>Voltar para o Menu Principal</a>
]</font></div>";
echo"</center>";
/*
* Fechar Conexão
*/
return $stmt;

}
}
}
?>
Agora, dentro do diretório ProjetoAgenda, vamos criar um arquivo php com

o nome index.php. Neste arquivo vamos colocar os links para cadastrar novos
contatos, bem como para listar os contatos já cadastrados. Veja abaixo o código do
arquivo index.php:
<html>
<head>
<title>Tutorial UNIVERSO PHP OO</title>
</head>
<body>
<br />
<table width="60%" border="0" cellspacing="0"
cellpadding="0" align="center">
<tr>
- 150 -
<td height="60"><div align="center"><font face="Arial"

size="4"><b>Menu Principal<br />Agenda
POO</b></font></div></td>
</tr>
</table>
<p align="center">
<font face=Arial size=2>
- <a href="Application/FrmAgendaInserir.php">Cadastrar
Contato</a><br /><br />
- <a href="Application/FrmAgendaListar.php">Gerenciar
Contatos</a><br /><br />
</font>
</p>
</body>
</html>
Vamos criar agora um subdiretório chamado Application dentro do diretório

ProjetoAgenda já criado anteriormente (c:/wamp/www/dw3/POO/
ProjetoAgenda/Application). Neste diretório terei a parte visual da minha
agenda. Vamos criar neste diretório os arquivos abaixo:
Nome do arquivo: AgendaInserir.php
<?php
/*
* Carregar automaticamente minhas classes
*/
include_once "../Classes/DAO/{$classe}.class.php";
}
$agenda = new MagicAgenda();

$agenda->nome=$_POST['tf_nome'];
$agenda->email=$_POST['tf_email'];
$agenda->telefone=$_POST['tf_telefone'];
- 151 -
$DAO = new AgendaDAO();

$DAO->Inserir($agenda);
?>
Nome do arquivo: FrmAgendaInserir.php

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0
Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-
transitional.dtd">
<html>
<head>
<title>Agenda - Inserir Dados</title>
</head>
<body>
<center>
<b>Cadastrar Contato</b><br />
<form id="form1" name="form1" method="post"
action="AgendaInserir.php">
<p>Nome: <input type="text" name="tf_nome"
id="tf_nome" autofocus /></p>
<p>E-mail: <input type="text" name="tf_email"
id="tf_email" /></p>
<p>Telefone: <input type="text" name="tf_telefone"
id="tf_telefone" /></p>
<p><input type="submit" name="Cadastrar"
id="Cadastrar" value="Cadastrar" /></p>
</form>
<div><font face=Arial size=2>[ <a
]</font></div>
</center>
</body>
</html>
- 152 -
Abra o projeto (http://localhost/dw3/POO/ProjetoAgenda/) para

inserir novos contatos na Agenda. Veja, através do PHPMyAdmin se os contatos
estão sendo inseridos com sucesso.
Exercício: Cadastre 05 (cinco) novos contatos na Agenda.
Vamos criar agora, ainda dentro do diretório Application os seguintes

arquivos.
Nome do arquivo: FrmAgendaListar.php

transitional.dtd">
<html>
<head>
<title>Agenda - Listar Dados</title>
</head>
<body>
<center>
<b>Gerenciar Contatos</b><br />
action="AgendaListar.php">
<p>Nome do Contato a ser procurado: <input type="text"
name="tf_nome" id="tf_nome" autofocus /></p>
<p><input type="submit" name="Pesquisar"
id="Pesquisar" value="Pesquisar" /></p>
</form>
]</font></div>
</center>
</body>
</html>
- 153 -
Nome do arquivo: AgendaListar.php

<?php
/*
* Carregar automaticamente minhas classes
*/
}
// Abaixo, não estou enviando query nenhuma. Listará todos

os registros da tabela
//$DAO->Listar();
// Abaixo, estou enviando uma query como parâmetro

$DAO->Listar("SELECT * FROM agenda where nome LIKE
'%".$_POST['tf_nome']."%'");
?>
Abra o projeto (http://localhost/dw3/POO/ProjetoAgenda/), clique no

menu Gerenciar Contatos e verifique os contatos cadastrados estão sendo listados,
de acordo com os parâmetros pesquisados.
Vamos criar agora, ainda dentro do diretório Application os seguintes

arquivos de alteração e de exclusão.
Nome do arquivo: FrmAgendaAlterar.php

transitional.dtd">
<html>
- 154 -
<head>
<title>Agenda - Alterar Dados</title>
</head>
<body>
<center>
<b>Alterar Contato</b><br />
action="AgendaAlterar.php">
<p>Id: <?php echo($_GET['tf_id']); ?></p>
<p>Nome: <input type="text" name="tf_nome"
id="tf_nome" value="<?php echo($_GET['tf_nome']); ?>"
autofocus /></p>
<p>E-mail: <input type="text" name="tf_email"
id="tf_email" value="<?php echo($_GET['tf_email']); ?>" /></p>
<p>Telefone: <input type="text" name="tf_telefone"
id="tf_telefone" value="<?php echo($_GET['tf_telefone']); ?>"
/></p>
<input type="hidden" name="tf_id" id="tf_id"
value="<?php echo($_GET['tf_id']); ?>" />
<p><input type="submit" name="Alterar" id="Alterar"
value="Alterar" /></p>
</form>
]</font></div>
</center>
</body>
</html>
Nome do arquivo: AgendaAlterar.php

<?php
/*
* Carregar as classes automaticamente
*/
- 155 -
}
$agenda = new MagicAgenda();

$agenda->nome=$_POST['tf_nome'];
$agenda->email=$_POST['tf_email'];
$agenda->telefone=$_POST['tf_telefone'];

$DAO->Alterar($agenda, $_POST['tf_id']);
?>
Nome do arquivo: AgendaDelete.php

<?php
/*
* Carregar minhas classes automaticamente
*/
}
$agenda = new AgendaDAO();

$DAO->Deletar($_GET['tf_id']);
?>
Pronto. Nosso projeto está completo. Faça alguns testes e veja se o mesmo
está funcionando corretamente.
- 156 -
Exercício: Converta o Exemplo Prático (Capítulo 10) que está utilizando o

paradigma estruturado, para o paradigma Orientado a Objetos, criando as classes, os
métodos e os atributos para o mesmo. Utilize os conceitos aprendidos no Capítulo 11
em Introdução à Orientação a Objetos em PHP.
Bom trabalho!!!
- 157 -
CONSIDERAÇÕES FINAIS
Vendo pela primeira vez, parece difícil, mais é só impressão. Esse tutorial
possui todos os códigos fontes necessários para realização dos testes, bastando
apenas que vocês criem as tabelas necessárias utilizando o PHPMyAdmin. Qualquer
dúvida é só mandar um email para dalamura@gmail.com
A linguagem PHP é uma ferramenta poderosa e simples de utilizar na
construção de sites dinâmicos para a World Wide Web, possibilitando uma maior
interação com o usuário e a armazenagem das informações em Bancos de Dados.
Deve ficar claro para o aluno, entretanto, que a combinação de scripts server-
side, como é o PHP, com scripts client-side, como JavaScript, por exemplo, possibilita
um maior aproveitamento dos recursos disponíveis para criar páginas dinâmicas, e
no processo de criação deve-se ponderar bastante para concluir qual dos dois tipos
de scripts deve ser utilizado para determinado fim.
Entre as linguagens de script server-side, PHP aparece como uma ótima
opção, por diversos motivos: o custo de aquisição, que não existe; a portabilidade,
permitindo que uma aplicação seja desenvolvida em uma plataforma para ser
executada em outra; a simplicidade, já que os scripts ficam no próprio código HTML,
e possuem uma sintaxe bastante simples; a possibilidade de trabalhar com diversos
bancos de dados e servidores HTTP, além do grande número de funções pré-
definidas, entre outras coisas.
Fonte: Exemplo Prático (estruturado) adaptado de Júlio César Martini

E-mail: baphp@imasters.com.br
Fonte: Exemplo Prático (POO) adaptado de Marcelo Caçapava Lopes

Site: cielosystem.com
- 158 -
REFERÊNCIAS BIBLIOGRÁFICAS
SILVA, Maurício Samy. HTML 5: A linguagem de marcação que revolucionou a
WEB. 2. Ed. São Paulo: Novatec, 2014.
FREEMAN, Eric. Use a Cabeça: Programação Java Script. Rio de Janeiro: Alta
Books, 2016.
WELLING, Luke; THOMSON, Laura. PHP e MySQL: Desenvolvimento Web. 3. Ed.

Rio de Janeiro: Campus, 2005.
BOWERS, Michael. Profissional Padrões de Projetos com CSS e HTML. Rio de

Janeiro: Alta Books, 2008.
NIEDERAUER, Juliano. PHP para quem conhece PHP. 5. Ed. São Paulo: Novatec,
2017.
MUTO, Claudio Adonai. PHP e MySQL: Guia Introdutório. 3. Ed. Rio de Janeiro:
Brasport, 2006.
PAULA FILHO, Wilson de Padua. Multimídia: conceitos e aplicações. 2. Ed. Rio

de Janeiro: LTC, 2011.
CONVERSE, Tim e PARK, Joyce. PHP, A Bíblia. Campus, 2003. 868 p.
Maual On-Line do PHP. Site Oficial PHP. Disponível em:

<http://www.php.net/manual/pt_BR/>. Acesso em 01 ago. 2017.
Manual On-Line do MySQL. Site Oficial MySQL. Dísponível em

<https://www.mysql.com/>. Acesso em 01 ago. 2017.
- 159 -
SITES SOBRE PHP E MYSQL
• http://www.php.net - Site Oficial da linguagem PHP. Estão disponíveis as

últimas notícias sobre a linguagem, manual on-line e download do software.
• http://imasters.com.br/secao/linguagens/php/ - Site em português
que traz artigos, notícias e modelos de scripts em PHP.
• http://www.phpbuilder.com - Site em inglês. Tutoriais e artigos sobre
PHP.
• http://www.hotscripts.com/category/scripts/php/ - Catálogo em
inglês com links para vários sites sobre PHP.
• http://www.devmedia.com.br/artigos/php - Tutotiais e artigos sobre
PHP, inclusive Introdução a Orientação a Objetos em PHP.
• https://www.youtube.com/playlist?list=PLHz_AreHm4dmGuLII3tsv
ryMMD7VgcT7x - Curso de POO PHP (Programação Orientada a Objetos).
• http://aprenderphpdozero.com/ - Aprender PHP do Zero.
- 160 -
CONTROLE DE VERSÕES
Data Versão Autor Observações

Versão inicial disponibilizada para os
Marcos Vinícius Alunos do 6º Período do Curso de
31/07/2016 1.0
Celeste Dalamura Sistemas de Informação da Universidade
Salgado de Oliveira - UNIVERSO JF.
01/02/2017 2.0
01/08/2017 3.0
02/08/2018 4.0
- 161 -

Apostila Versao 4.0 DWIII - ALUNO

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila Versao 4.0 DWIII - ALUNO

Enviado por

Direitos autorais:

Formatos disponíveis

UNIVERSO

UNIVERSIDADE SALGADO DE OLIVEIRA

Prof. Marcos Vinícius Celeste Dalamura

Variáveis enviadas pelo navegador .............................................. 48

CONSIDERAÇÕES FINAIS ................................................................ 158

REFERÊNCIAS BIBLIOGRÁFICAS ...................................................... 159

SITES SOBRE PHP E MYSQL ............................................................ 160

Esta disciplina é voltada a todos os estudantes e profissionais de informática

O que pode ser feito com PHP?

Basicamente, coletar dados de um formulário, gerar páginas dinamicamente

Como surgiu a linguagem PHP?

Inevitavelmente, todos os iniciantes em PHP passam por alguma dificuldade

Delimitando o Código PHP

O código PHP fica embutido no próprio HTML. O interpretador identifica

Os tipos de tags mais utilizados são o primeiro e o terceiro. Para utilizar a

Entre cada instrução em PHP é preciso utilizar o ponto-e-vírgula, assim como

echo “Hello, World”;

Comentários de uma linha:

<? echo “teste”; #isto é um teste ?>

Comentários de mais de uma linha:

Salve o arquivo como “exemplo1.php” no diretório de documentos do Web

Meu Primeiro Script usando PHP

Utilizando Formulários HTML

Ao clicar num botão “Submit” em um formulário HTML as informações dos

Ao salvar o arquivo acima (exemplo3.php) e carregá-lo no browser, o usuário

Isso ocorre porque o código PHP testa o conteúdo da variável $texto.

No exemplo a seguir (exemplo4.php), estaremos enviando a variável $texto

Interagindo com o Browser

PHP também permite interagir com informações do browser automaticamente.

Observe que o resultado mostra características de cada browser, como a

Neste exemplo, será apenas exibido um texto informando se está sendo

Inteiros (integer ou long)

$var = 1234; # inteiro positivo na base decimal

A diferença entre inteiros simples e long está no número de bytes utilizados

Números em Ponto Flutuante (double ou float)

$var = 1.234; = (1,234)

a) utilizando aspas simples ( ' ) – Desta maneira, o valor da variável será

A saída desse script será "---$teste--\n".

A tabela seguinte lista os caracteres de escape:

Equivalentemente, pode-se escrever:

list($a, $b, $c) = array(“a”, “b”, “c”);

O comando acima atribui valores às três variáveis simultaneamente. É bom

Vejamos um outro exemplo (exemplo11.php):

No Capítulo 11 (Introdução à Orientação a Objetos em PHP) estudaremos

Outras informações sobre a programação com objetos em PHP podem ser

$var = “1”; // $var é a string “1”

$var = 1 + “10.5”; // $var == 11.5

Transformação explícita de tipos

A sintaxe do typecast de PHP é semelhante ao C: basta escrever o tipo entre

$var = 15; // $var é integer (15)

Os tipos de cast permitidos são:

Com a função settype

$var = 15; // $var é integer

Exemplo Nome Resultado

Podem ser utilizados de duas formas: antes ou depois da variável. Quando

Ordem de Precedência dos Operadores

A tabela seguinte mostra a precedência dos operadores, da maior precedência

esquerda & Bit-a-bit e referências

Um bloco consiste de vários comandos agrupados com o objetivo de

Para que comando2 esteja relacionado ao if é preciso utilizar um bloco:

if ($x == $y){ //se ñ colocar as chaves, será entendido só 1º comando

Para incluir mais de um comando no if da primeira sintaxe, é preciso utilizar

A seguir, temos um exemplo do comando if utilizado com else: