1. O que são classes e porque utiliza-las?
2. Definindo uma classe
3. Definindo uma extensão de uma classe
4. Definindo variáveis globais
5. Definindo uma função
6. Definindo variáveis locais
7. Passando argumentos para as funções
8. Retornando valor nas funções

1. O que são classes e porque utiliza-las?

Já vi e ouvi muitas vezes essa pergunta “O que são
classes e porque utiliza-las?”. Bem, classes nada mais é do que uma coleção
de funções, ou seja, é uma maneira de “reciclar” os códigos
desenvolvidos.
Imagine, por exemplo, um programador que desenvolve
um site para comércio eletrônico, onde existe um cadastro de produtos, um
cadastro de clientes, um cadastro de fornecedores, etc. Agora imagine que ele
tem que escrever a mesma função para conectar ao banco de dados, para cada
script que ele tiver, até que não é tão problemático fazer isso, não é
mesmo?
Agora imagine que depois que está pronto o sistema,
alguém pede a esse programador que altere o local onde está armazenado o banco
de dados, bem agora o nosso programador vai ter que alterar arquivo por arquivo
o host do banco de dados, que trabalhão não acha?.
E se o nosso programador tivesse desenvolvido uma
classe com funções para conectar ao banco de dados, então seria necessário
ele alterar somente um arquivo e todos os script que estivesse usando seriam
alterado automaticamente. Simples não?.
2. Definindo uma classe
Neste momento veremos como definir e instanciar uma
classe. Para tal, começamos com o seguinte comando:

# para esse arquivo daremos o nome de mysql_class.php
class TMySQL {
//….
}
?>

Eis que nasce a criança! Agora nossa classe está criada, o que falta é algumas funções
que veremos nos capítulos seguintes, para utilizarmos esta classe precisamos
instanciá-la dentro de um script php, para isso fazemos o seguinte:

# para esse arquivo daremos o nome de myfile.php

$MySQL = new TMySQL();

?>

Neste momento já instanciamos a nossa classe, e agora se tivéssemos funções
definidas dentro da nossa classe já poderíamos utiliza-las.

3. Definindo uma extensão de uma classe

Extensão de uma classe poderíamos dizer que é uma função pertencente a uma classe,
que tem todas as propriedades da classe base e mais as definidas nela mesmo,
para tal utiliza-se a seguinte sintaxe

# para esse arquivo daremos o nome de mysql_class.php
class TMySQL {
//….
}
class construtor extends TMySQL {
//….
}
?>

E agora, poderíamos criar funções dentro da classe, e que pertenceriam também a sua extensão.

4. Definindo variáveis globais

As variáveis globais normalmente são definidas quando se deseja utiliza-la em toda classe,
para tal, fazemos o seguinte:

# para esse arquivo daremos o nome de mysql_class.php
class TMySQL {
var $host; // qual o servidor
var $db; // qual a base
var $user; // qual o username
var $pass; // qual a senha
var $socket; //socket da conexao com o banco
}
?>

5. Definindo uma função

Função como o próprio nome diz, é um bloco de códigos destinado a fazer algo específico,
alguma função, vejamos como utiliza-la:

# para esse arquivo daremos o nome de mysql_class.php
class TMySQL {
var $host; // qual o servidor
var $db; // qual a base
var $user; // qual o username
var $pass; // qual a senha
var $socket; //socket da conexao com o banco
function connect($host, $db, $user, $pass) {
$this->host = $host;
$this->db = $db;
$this->user = $user;
$this->pass = $pass;
$this->socket=mysql_connect($this->host,$this->user,$this->pass);
if (!$this->socket) {
echo “Não foi possível conectar-se ao Bando de Dados MySQL”;
}
else
{
if (!mysql_select_db($this->db,$this->socket)){
echo “Banco de dados não encontrado”;
}
else
{
echo “Banco de dados conectado!”;
}
}
}
}
?>

Definimos a função connect(); para conectarmos o banco de dados MySql, vejamos como
instanciar a classe e utilizar a função dentro de um script:

# para esse arquivo daremos o nome de myfile.php
MySQL = new TMySQL();
MySQL->connect($host, $db, $user, $pass);
?>

Observe que instanciamos a classe, e chamamos a função passando alguns argumentos
necessários para nossa conexão.

6. Definindo variáveis locais
Variáveis locais são utilizadas sempre que se queira uma variável de momento, ou seja,
ao término da função o valor que a variável assumiu durante a execução de
determinada função não será mais necessária. Vejamos como fazer:

# para esse arquivo daremos o nome de mysql_class.php
class TMySQL {
var $host; // qual o servidor
var $db; // qual a base
var $user; // qual o username
var $pass; // qual a senha
var $socket; //socket da conexao com o banco
function connect($host, $db, $user, $pass) {
$this->host = $host;
$this->db = $db;
$this->user = $user;
$this->pass = $pass;
$this->socket=mysql_connect($this->host,$this->user,$this->pass);
if (!$this->socket) {
echo “Não foi possível conectar-se ao Bando de Dados MySQL”;
}
else
{
if (!mysql_select_db($this->db,$this->socket)){
echo “Banco de dados não encontrado”;
}
else
{
echo “Banco de dados conectado!”;
}
}
}
function ultimo_reg() {
var $ultimo;
$this->ultimo = mysql_insert_id($this->socket);
echo “$this->ultimo”;
}
}
?>

Veja agora, acima definimos a função ultimo_reg(); para
recuperarmos o último registro inserido e não é necessária informação no
restante da classe, sendo assim definimos a variável $ultimo para utilizarmos
somente dentro da classes.

7. Passando argumentos para as funções

Passar argumento para as funções é muito utilizado dentro do contexto classes, pois
os valores podem ser utilizados em qualquer parte do script, mesmo que se tenha
definido como um valor local. Vejamos um exemplo:

# para esse arquivo daremos o nome de mysql_class.php
class TMySQL {
var $host; // qual o servidor
var $db; // qual a base
var $user; // qual o username
var $pass; // qual a senha
var $socket; // socket da conexao com o banco function connect($host, $db, $user, $pass) {
$this->host = $host;
$this->db = $db;
$this->user = $user;
$this->pass = $pass;
$this->socket=mysql_connect($this->host,$this->user,$this->pass);
if (!$this->socket) {
echo “Não foi possível conectar-se ao Bando de Dados MySQL”;
}
else
{
if (!mysql_select_db($this->db,$this->socket)) {
echo “Banco de dados não encontrado”;
}
else
{
echo “Banco de dados conectado!”;
}
}
}

function ultimo_reg() {
var $ultimo;
$this->ultimo = mysql_insert_id($this->socket);
echo “$this->ultimo”;
}

function query ($string) {
var $myquery;
$this->myquery = mysql_query($string,$this->socket);
if (!$this->myquery) {
echo “Erro manipulando query!”;
}
else
{
if (substr($string,0,6)==”select”) {
echo “Comando aceito!”;
}
else
{
echo “Isso não é um select”;
}
}
}
}
?>

Agora, para manipularmos a função acima podemos instanciar a classe dentro de um
script e utilizar a função para verificar se o comando passado é válido:

# para esse arquivo daremos o nome de myfile.php
MySQL = new TMySQL();
MySQL->connect($host, $db, $user, $pass);
MySQL->query(”select * from fornecedores”);
?>

8. Retornando valor nas funções

Utilizando funções, podemos passar argumentos, como podemos retornar valores em um
contexto classes, retornar valores é utilizado tanto quanto passar argumentos.
Para tal, fazemos o seguinte:

# para esse arquivo daremos o nome de mysql_class.php
class TMySQL {
var $host; // qual o servidor
var $db; // qual a base
var $user; // qual o username
var $pass; // qual a senha
var $socket; // socket da conexao com o banco function connect($host, $db, $user, $pass) {
$this->host = $host;
$this->db = $db;
$this->user = $user;
$this->pass = $pass;
$this->socket=mysql_connect($this->host,$this->user,$this->pass);
if (!$this->socket) {
echo “Não foi possível conectar-se ao Bando de Dados MySQL”;
}
else
{
if (!mysql_select_db($this->db,$this->socket)) {
echo “Banco de dados não encontrado”;
}
else
{
echo “Banco de dados conectado!”;
}
}
}
function ultimo_reg() {
var $ultimo;
$this->ultimo = mysql_insert_id($this->socket);
echo “$this->ultimo”;
}
function query ($string) {
var $myquery;
$this->myquery = mysql_query($string,$this->socket);
if (!$this->myquery) {
echo “Erro manipulando query!”;
}
else
{
if (substr($string,0,6)==”select”) {
echo “Comando aceito!”;
}
else
{
echo “Isso não é um select”;
}
}
$this->retorno($string)
}

function retorno ($string){
echo “Comando $string é invalido”;
}
}
?>

Observe que na função retorno(); é passada a mesma $string que foi passada como
argumento na função query(); e então temos o retorno de um valor.