em

Aprenda OOP com PHP – Programação Orientada à Objeto

Programação Orientada à Objeto
Programação Orientada à Objeto

Vinha por anos olhando OOP (Object Oriented Programming) ou se preferir sua tradução, POO(Programação Orientada à Objeto) com PHP com medo de encarar seu aprendizado por estar confortável com a forma procedural, mas ao mesmo tempo que sentia este medo, a vontade de aprender coisas novas sempre foi maior.

Convido a todos que desejarem aprender de forma simples e fácil sobre o básico de PHP Orientado à Objeto, acompanhando este tutorial que postarei em duas partes.

O mais difícil de aprender e ensinar em PHP OO… é o básico. Mas uma vez que você tiver esse conhecimento básico, o resto virá muito facilmente.
De forma alguma se sinta desanimado! Como o próprio título deste tutorial diz, você acabou de encontrar o tutorial mais fácil para compreender o básico de OOP com PHP.

Tá bom, chega de bla, bla, bla e vamos ao que interessa.
Programação Orientada a Objetos(OOP) é um tipo de programação adicionada ao PHP com maior abrangência a partir do PHP, o que tornou a construção de aplicações web complexas, modulares e reutilizáveis muito mais fácil. Com o lançamento do PHP, programadores PHP tiveram um poder de codificação de gente grande (big boys). Da mesma forma que Java e C#, PHP finalmente adquiriu uma infraestrutura OOP completa.

Vou tentar guia-lo (passo-a-passo) através do processo de construção da estrutura usando PHP dentro das capacidades de OOP.

Ao mesmo tempo, você vai aprender:

– A diferença entre a construção de uma aplicação PHP a moda antiga (‘procedural’), em relação a maneira OOP.
– Quais são os princípios básicos de OOP e como usá-los em PHP.
– Quando você deverá usar OOP em seus scripts PHP.

As pessoas se perdem, ficam confusas na programação por causa da falta de compreensão dos princípios básicos. Com isto em mente, vamos lentamente descobrir estes princípios básicos de OOP ao criar nossos próprios objetos PHP. Com esse conhecimento, você será capaz de explorar OOP mais profundamente.

Para acompanhar este tutorial, você deve estar um pouco familiarizado com alguns conceitos básicos de PHP:
Funções, variáveis, condicionais e loops não podem lhe soar como algo de outro mundo rs*.

Para facilitar ainda mais as coisas, este tutorial está dividido em 23 etapas as quais veremos 11 etapas nessa primeira parte.

Etapa 1

PHP Orientado à Objetos – Começando

Primeira coisa que iremos fazer é criar dois arquivos PHP

index.php
class_lib.php

Falar em OOP é falar sobre a criação de código modular, nosso código PHP orientado à objeto estará incluído em todos arquivos PHP usando ‘include’.

Neste caso, todo o nosso código PHP OO vai estar no arquivo PHP:

class_lib.php

OOP gira em torno de uma construção que chamamos de ‘classe‘. Classes são modelos que são usados ​​para definir os objetos.

Etapa 2

Criar uma classe PHP

Em vez de ter um monte de funções, variáveis ​​à toa, para projetar seus scripts PHP ou bibliotecas de código, a maneira OOP você precisa definir/criar suas próprias classes.
Você define sua própria classe, começando com a palavra-chave ‘classe’ seguido do nome que você quiser dar a sua classe.

<?php class pessoa {} ?>

Etapa 3

Adicionar dados para sua classe

Uma das grandes diferenças entre as funções e classes é que uma classe contém ambos os dados, variáveis​ e funções que formam um pacote chamado: ‘objeto’.
Quando você cria uma variável dentro de uma classe, ela é chamada de ‘propriedade‘.

<?php 
class pessoa {
 var $name;
 }?>

Nota: Variáveis ​​dentro de uma classe (ex: var $name;) são chamadas de ‘propriedades’.

Etapa 4

Adicionar funções/métodos à classe

Da mesma forma que as variáveis ​​recebem um nome diferente quando criado dentro de uma classe (‘propriedades‘), funções também são chamadas por um nome diferente quando criado dentro de uma classe – chamamos de (‘métodos‘).

Métodos numa classe são usados ​​para manipular as suas próprias ‘propriedades‘.

<?php 
class pessoa { 
var $name; 
function set_name($new_name){
$this->name = $new_name; 
} 
function get_name()
{ return $this->name; }
}?>

Nota: Lembre-se que em uma classe, variáveis são chamadas de ‘propriedades‘.

Etapa 5

Funções/Métodos getter e setter

Criamos duas funções/métodos interessantes: get_name() e set_name().
Esses métodos seguem uma convenção de OOP comum que você vê em muitas línguagens (incluindo Java e Ruby) – onde você cria métodos para ‘set‘ e ‘get‘ (definir e obter) propriedades em uma classe.

Outra convenção (a convenção de nomenclatura), é que os nomes dos métodos ‘getter’ e ‘setter’ devem coincidir com os nomes das propriedades.

<?php 
class pessoa {
var $name; 
function set_name($new_name){
$this->name = $new_name; 
}
function get_name(){
 return $this->name; 
}
}?>

Nota: Observe que os nomes ‘getter’ e ‘setter’, coincidem com o nome da propriedade associada. Dessa forma, quando outros programadores PHP quiserem usar seus objetos, eles vão saber que se você tem um método/função chamada ‘set_name()’, haverá uma propriedade/variável chamada ‘name’.

Etapa 6

A variável ‘$this’

Você deve ter notado esta linha de código:

$this->name = $new_name.

O $this é uma variável interna (construída em todos os objetos) que aponta para o objeto atual, ou em outras palavras, $this é uma variável especial de auto-referência. Você pode usar $this para acessar as propriedades e chamar outros métodos da classe atual.

function get_name(){ return $this->name;}

Nota: Isto pode parecer um pouco confuso pra você que está vendo pela primeira vez um dos recursos internos de OO (construído em PHP) que automaticamente faz coisas para nós.Por agora, basta pensar em ‘$this’ como uma palavra-chave PHP OO especial. Quando o PHP da de cara com ‘$this’, o PHP sabe o que fazer.
… Espero que em breve, você também! rs*

Etapa 7

Incluindo nossa Classe no arquivo index.php

Você nunca deve criar suas classes diretamente dentro dos arquivos PHP relacionados com as páginas de seu sistema, pois desta forma estaria matando por completo o verdadeiro sentido da programação orientada à objeto!

Em vez disso sempre será a melhor prática criar as páginas php de seu site separadas dos arquivos que deverão conter apenas as classes. Para acessar suas classes deverá usar em suas páginas PHP, ‘include’ ou ‘require’.

<?php 
include("class_lib.php");
?>
<!DOCTYPE html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>Aprendendo OOP em PHP</title>
</head> 
<body>
</body> 
</html>

Nota: Observe como não fizemos nada com a nossa classe ainda apenas à incluímos no arquivo para que possamos acessa-la posteriormente. Faremos isso a seguir.

Etapa 8

Instanciar/criar o objeto

Classes na verdade, não se tornam objetos até que você faça algo que chamamos de ‘instanciar‘.
Instanciação é o processo de criação de uma instância de um objeto na memória.
Que memória? Memória do servidor, é claro!

<?php include("class_lib.php"); ?>...</head>
<body>
<?php $roberto = new pessoa(); ?>
</body>
</html>

Nota: A variável ‘$roberto’ torna-se uma referência ao nosso recém criado objeto ‘pessoa’. Eu digo que ‘$roberto’ é uma referência porque usaremos ‘$roberto’ para controlar e usar o objeto ‘pessoa’.

Se você executar o código PHP agora, você não vai ver nada exibido na tela. A razão para isso, é porque ainda não dissemos ao PHP para fazer alguma coisa com o objeto que acabamos de criar.

Etapa 9

A palavra-chave ‘new’

Para criar um objeto de uma classe, você precisa usar a palavra ‘new‘.
Ao criar/instanciar uma classe, você pode opcionalmente adicionar suportes para o nome da classe, como eu fiz no exemplo abaixo. Para ser claro, você pode ver no código abaixo como eu posso criar vários objetos da mesma classe.

<?php include ("class_lib.php"); ?>...</head> 
<body> 
<?php $roberto = new pessoa();
$juliana = new pessoa(); 
?>
</body> 
</html>

Nota: Ao criar um objeto, não se esqueça de citar o nome da classe.

Por exemplo:

$roberto = new 'pessoa';

… Você irá obter um erro.

Etapa 10

Definir as propriedades de objetos

Agora que nós criamos/instanciamos nossos dois objetos baseados na classe ‘pessoa’, podemos definir suas propriedades usando os métodos (setters) que criamos.
Por favor tenha em mente que, embora ambos os nossos objetos de ‘pessoa’ ($roberto e $juliana) estarem baseados na mesma classe ‘pessoa’, eles são objetos totalmente diferentes.

<?php include ("class_lib.php"); ?>... </head> 
<body> 
<?php $roberto = new pessoa();
$juliana = new pessoa();
$roberto->set_name("Roberto Lunelli");
$juliana->set_name("Juliana Ferreira"); 
?> 
</body>
</html>

Etapa 11

Acessando dados de um objeto

Agora vamos usar os métodos ‘getter’ para acessar os dados contidos em nossos objetos… isto é, os mesmos dados inseridos em nossos objetos utilizando os métodos ‘setter’.
Ao acessar métodos e propriedades de uma classe, você pode usar o operador seta (->).

<?php include ("class_lib.php");
 ?>...</head> 
<body> 
<?php $roberto = new pessoa();
$juliana = new pessoa();
$roberto->set_name("Roberto Lunelli");
$juliana->set_name("Juliana Ferreira");
echo "Nome completo de Roberto é: " . $roberto->get_name();
echo "Nome completo de Juliana é: " . $juliana->get_name();
?> 
</body>
</html>

Nota: O operador seta (->) não é o mesmo operador usado com ‘arrays associativos’ (=>).

Parabéns, você chegou à metade deste tutorial!
Hora de fazer uma pequena pausa e tomar um chá … OK, talvez uma cerveja.

Veja o que você já fez em um curto espaço de tempo:

• Projetou uma classe PHP.
• Gerou/criou um par de objetos com base em sua classe.
• Inseriu dados em seus objetos.
• Retirou dados de seus objetos.

Nada mau para o seu primeiro dia trabalhando com PHP OO.

Se você não tiver feito ainda, agora é um bom momento para escrever o código e vê-lo em ação.

Este tutorial continua e nossos estudos também.
Vamos para 2ª e última parte deste simples e fácil tutorial PHP orientado à objetos

Etapa 12

Acessar diretamente as propriedades – Não faça isso!

Você pode querer não usar métodos para acessar as propriedades de objetos, talvez pense em acessar as propriedades diretamente usando o operador seta (->) seguido do nome da variável.

Por exemplo

Com a propriedade $name (no objeto $roberto), você poderia obter o seu valor assim:

$roberto->name

Apesar de possível, é considerado uma má prática, porque pode levar à problemas no decorrer do caminho.
Em vez disso você deve usa métodos ‘getter‘ conforme vimos na primeira parte deste tutorial.

<?php include ("class_lib.php"); ?>... 
</head> <body> 
<?php 
$roberto = new pessoa();
$juliana = new pessoa();
$roberto->set_name("Roberto Lunelli");
$juliana->set_name("Juliana Ferreira");
// Acessar diretamente as propriedades de uma classe -> 
// Não faça isso. echo "Nome completo de Roberto é: " . $roberto->name;?> </body> </html>

Etapa 13

Contructors OOP

Todos os objetos podem ter um método especial embutido chamado ‘constructor‘.
Constructors permitem que você inicialize as propriedades do seu objeto (tradução: dar valores à suas propriedades) quando você instanciar (criar) um objeto.

Nota: Se você criar uma função/método ‘__contruct()’, a escolha é sua, pois o PHP automaticamente chama a função/método ‘__contruct()’ quando você cria um objeto de sua classe.

O método ‘__contruct()’ começa com dois underlines seguidos da palavra ‘construct’. Você ‘alimenta’ o método ‘construct’ fornecendo uma lista de argumentos (como numa função), após o nome da classe.

<?php 
class pessoa {
var $name; 
function __construct($person_names){
$this->name = $person_names; 
}
function set_name($new_name){
$this->name = $new_name; 
} 
function get_name(){ 
return $this->name; 
}
}
?>

Durante o resto do tutorial irei parar de lembrar que:

• Funções = Métodos
• Variáveis ​​= Propriedades

… Como este é um tutorial PHP OO vamos usar a terminologia OO a partir de agora.

Etapa 14

Criar um objeto com um método ‘constructor‘

Agora que nós criamos um método ‘constructor‘, podemos fornecer um valor para a propriedade $name quando criar objetos de nossa classe ‘pessoas’.

Por exemplo:

$roberto = new pessoa(“Roberto Lunelli”);

Isso nos poupa de ter que chamar o método set_name() e reduz a quantidade de código.
Constructors são comuns e são usados ​​frequentemente em PHP, Java, etc.

<?php 
include("class_lib.php"); ?>...</head>
<body>
<?php
$roberto = new pessoa("Roberto Lunelli");
echo "Nome completo de Roberto é: " . $roberto->get_name();
?>
</body>
</html>

Este é apenas um pequeno exemplo de como os mecanismos embutidos em PHP OO podem fazer com que você economize tempo e reduza a quantidade de código que precisará escrever. Menos código significa menos bugs.

Etapa 15

Restringir o acesso à propriedades usando ‘modificadores de acesso‘

Um dos princípios fundamentais de OOP é ‘encapsulation’.
A ideia é que você cria um código melhor e mais limpo se você restringir o acesso às estruturas de dados (propriedades) em seus objetos.
Você restringe o acesso à propriedades da classe usando o que chamamos de ‘modificadores de acesso‘.

Existem 3 modificadores de acesso:

1. public
2. private
3. protected

‘public’ é o modificador padrão.

<?php
class pessoa { 
var $name;
public $height; 
protected $social_insurance;
private $pinn_number;
function __construct($persons_name) {
$this->name = $persons_name; 
} 
function set_name($new_name) {
 $this->name = $new_name;
} 
function get_name() {
 return $this->name; 
}
}
?>

Nota: Quando você declara uma propriedade com a palavra chave ‘var‘, esta propriedade será considerada ‘public’.

Etapa 16

Restringir o acesso à propriedades: Parte 2

Quando você declarar uma propriedade como ‘private‘, somente a classe poderá acessar a propriedade.
Quando uma propriedade é declarada ‘protected‘, somente a classe e classes derivadas dessa classe podem acessar sua propriedade – isso tem a ver com a herança (veremos mais sobre isso mais tarde). Propriedades declaradas como ‘públic‘ não têm restrições de acesso, ou seja, qualquer um pode acessá-las.

Para ajudar você a entender este aspecto nebuloso de OOP, experimente o seguinte código e veja como o PHP reage.

Dica: Leia os comentários no código para maiores informações

<?php include ("class_lib.php"); ?>...</head>
<body>
<?php $roberto = new pessoa("Roberto Lunelli");
echo "Nome completo de Roberto é: " . $roberto->get_name();
/*Desde que $pinn_number foi declarado como 'private', 
esta linha do código irá gerar um erro. Tente isto! */
echo "Mostre-me algo privado: " . $roberto->$pinn_number;
?>
</body> 
</html>

Etapa 17

Restringir o acesso à métodos

Como nas propriedades, você pode controlar o acesso aos métodos que utilizem um dos três modificadores de acesso:

1. public
2. protected
3. private

Por que temos modificadores de acesso?

A razão para utilizar modificadores de acesso se resume à controlar: é faz sentido controlar como as pessoas usam as classes.

Se formos ver mais profundamente as razões para utilizar modificadores de acesso e outras construções OO, pode ficar complicado de entender já que somos apenas iniciantes no assunto. Então, vamos devagar e sempre. 😉

Dito isto, acho que podemos resumir e dizer que existem muitas construções OOP, e ter em mente que muitos programadores estão trabalhando nisso.

<?php class pessoa {
 var $name; 
public $height; 
protected $social_insurance; 
private $pinn_number; 
function __construct($persons_name){
$this->name = $persons_name; 
} 
private function get_pinn_number(){
return $this->$pinn_number; 
}
}
?>

Nota: Desde que o método ‘get_pinn_number()’ é ‘private’, o único lugar que você pode usar esse método está na mesma classe – normalmente em um outro método. Se você quisesse chamar/usar esse método diretamente em suas páginas PHP, você precisaria declará-lo ‘públic’.

Nota²: Novamente, é importante (à medida que avançamos), que você realmente tente executar os códigos. Faz uma diferença ENORME!

Etapa 18

Reutilizando o código de OOP: Herança (inheritance)

Herança é uma fundamental capacidade/construção em OOP, onde você pode usar uma classe, como base para outra classe… ou muitas outras classes

Por que isso?

Isso permite que você de forma eficiente reutilize o código encontrado em sua classe base.
Digo, se você criar uma nova classe ‘empregado’… já poderá dizer que ‘empregado’ é um tipo de ‘pessoa’, eles irão compartilhar propriedades e métodos comuns.

… Fazendo algum sentido?

Neste tipo de situação, a herança pode tornar seu código mais leve… porque você está reutilizando o mesmo código em duas classes diferentes.

Ao contrário da forma ‘procedural’ (old-school) de escrever em PHP:

1. Você só precisará digitar o código uma vez.
2. O código que está sendo reutilizado, pode ser reutilizado em várias classes (ilimitado), mas só é digitado em um único lugar.

Dê uma olhada no código de exemplo:

// 'extends' é uma palavra-chave que habilita a
//  herançaclass empregado extends pessoa { function __construct($employee_name){ } }

Etapa 19

Reutilizar o código com Herança (inheritance): Parte 2

A classe ‘empregado’ se baseia na classe ‘pessoa’, e por isso ‘empregado’ automaticamente tem todas as propriedades public, protected e os métodos da classe ‘pessoa’.

O código:

// 'extends' é uma palavra-chave que habilita a herançaclass 
// empregado extends pessoa { function __construct($employee_name){ $this->set_name($employee_name); }}

Observe como somos capazes de usar set_name() em ‘empregado’, apesar de não declarar esse método na classe ‘empregado’. Isso é porque nós já criamos o método set_name() na classe ‘pessoa’.

Nota: A classe ‘pessoa’ é chamada como a classe ‘base’ ou classe ‘parent’, porque é a classe a qual a classe ‘empregado’ é baseada. Esta hierarquia de classes pode se tornar importante no decorrer do teu caminho, mais precisamente quando teus projetos tornarem-se mais complexos.

Etapa 20

Reutilizar o código com Herança (inheritance): Parte 3

Como você pode ver no trecho de código abaixo, nós podemos chamar o método get_name() no objeto da classe ‘empregado’ como uma cortesia da classe ‘pessoa’.
Este é um classico exemplo de como OOP pode reduzir o número de linhas de código (não devemos escrever os mesmos métodos duas vezes) enquanto estiver mantendo seu código em formato modular, será muito fácil a manutenção.

<?php include ("class_lib.php"); ?>...</head>
<body> 
<?php // Using our PHP objects in our PHP pages. 
$roberto = new pessoa("Roberto Lunelli");
echo "Nome completo de Roberto é: " . $roberto->get_name();
$james = new empregado("James Souza");
echo "---> " . $james->get_name();?> 
</body> 
</html>

Etapa 21

Sobrescrevendo métodos

As vezes (quando usa-se herança), você pode precisar alterar a forma como um método funciona a partir da classe base.
Por exemplo, digamos que o método set_name() na classe ‘empregado’, tenha que fazer algo diferente do que faz na classe ‘pessoa’. Você sobrescreverá a versão set_name() da classe ‘pessoa’, declarando o mesmo método em ‘empregado’.

O código:

<?php class pessoa { 
// declarar explicitamente as propriedades de uma classe é opcional - mas uma boa prática 
var $name; 
function __construct($persons_name){
$this->name = $persons_name; 
} 
public function get_name(){
return $this->name; 
} 
// métodos e propriedades protegidas restringem o acesso à estes elementos 
protected function set_name($new_name) {
if (name != "Jimmy Two Guns") {
$this->name = strtoupper($new_name); 
} 
} 
}
// 'extends' é uma palavra-chave que habilita a herança 
class empregado extends pessoa {
protected function set_name($new_name) {
if ($new_name == "Roberto Lunelli") {
$this->name = $new_name; 
} 
} 
function __construct($employee_name) {
$this->set_name($employee_name); 
} 
} 
?>

Note como set_name() é diferente na classe ‘empregado’ em relação a versão na classe ‘parent‘: ‘pessoa’.

Etapa 22

Sobrescrevendo métodos: Parte 2

Às vezes você pode precisar acessar na classe base (‘parent‘) a versão original do método que você sobrescreveu na classe derivada (‘child‘).
Em nosso exemplo, substituiremos o método set_name() da classe ‘empregado’ e chamaremos o método set_name() da classe ‘pessoa’.

Usaremos essa linha de código…

person::set_name($new_name);

… para acessar a versão do método set_name() da classe ‘parent‘ (‘pessoa’)

O código:

<?php class pessoa {
// Declarar explicitamente as propriedades de uma classe é opcional - mas é boa prática 
var $name; 
function __construct($persons_name){
$this->name = $persons_name; 
}
public function get_name(){
return $this->name;
} 
// Métodos e propriedades protegidos restringem o acesso à estes elementos
protected function set_name($new_name){ 
if (name != "Jimmy Two Guns"){ 
$this->name = strtoupper($new_name); 
} 
}
}// 'extends' é a palavra-chave que habilita a herançaclass
empregado extends pessoa {
protected function set_name($new_name){
if ($new_name == "Roberto Lunelli"){
$this->name = $new_name; 
} else if($new_name == "Johnny Fingers"){
pessoa::set_name($new_name); 
} 
} 
function __construct($employee_name){ 
$this->set_name($employee_name); 
}
}
?>

Etapa 23

Sobrescrevendo métodos: Parte 3

Usando ( :: ) permite à você informar o nome da classe onde você deseja que o PHP procure um método especifico, ou seja, pessoa::set_name(), diz ao PHP para procurar set_name () na classe ‘pessoa’.

Há também um atalho se você quiser apenas se referir à classe pai atual usando a palavra chave ‘parent’.

O código:

<?php class pessoa { 
// Declarar explicitamente as propriedades de uma classe é opcional 
// mas uma boa prática 
var $name; 
function __construct($persons_name){ 
$this->name = $persons_name; 
} 
public function get_name(){
return $this->name;
} 
// Métodos e propriedades protegidas restringem o acesso à esses elementos. 
protected function set_name($new_name){
if ($new_name != "Jimmy Two Guns"){
$this->name = strtoupper($new_name); 
} 
}
}
// 'extends' é uma palavra-chave que habilita a herançaclass 
empregado extends pessoa {
protected function set_name($new_name){
if ($new_name == "Roberto Lunelli"){ 
$this->name = $new_name; 
} else if($new_name == "Johnny Fingers"){
parent::set_name($new_name); 
}
}
 function __construct($employee_name){
 $this->set_name($employee_name); 
}
}
?>

Comentários Finais

Nós apenas falamos sobre os conceitos básicos de PHP OO. Mas você teve informação suficiente para se sentir confortável para seguir em frente.
Lembre-se que a melhor maneira de realmente aprender sobre este material que vimos é escrever o código e se divertir, testando de várias formas e jogando com o que foi dito, pois isso que irá despertar interesse por seguir no caminho e aprender mais.

Gostaria de sugerir a criação de 10 objetos simples que façam coisas simples, e então usar esses objetos reais em páginas PHP. Uma vez que você tiver feito isso, você vai se sentir muito confortável com os objetos.

Por que aprender OOP em PHP? (Uma outra análise)

Para as pessoas iniciantes em OOP e que estão confortáveis com o modo ‘procedural clássico’ de programar em PHP, você poderá se perguntar por que deveria se preocupar em aprender conceitos orientados a objeto… por que passar por toda essa dificuldade. Continue lendo e veja se responde esse tipo de dúvida.

O mundo PHP

PHP está se movendo em uma direção OOP. Por exemplo, muitas extensões importantes do PHP como PEAR e Smarty são baseados em OOP. Então, para realmente entender e usar essas estruturas corretamente, você precisa entender PHP orientado a objetos.

As vantagens funcionais/práticas

Para projetos menores, usar PHP orientado a objetos pode ser um exagero. Dito isto, PHP orientado a objetos realmente começa a brilhar quando o projeto se torna mais complexo, e quando você tiver mais de uma pessoa participando da programação.

Por exemplo: Se tiver que usar 10-20 ou mais funções e você achar que algumas das funções estão fazendo coisas semelhantes… é hora de considerar usar OOP.

OOP e sua carreira como programador

OOP é a maneira moderna de desenvolvimento de software e todos as principais linguagens (Java, Perl, PHP, C #, Ruby) utilizam esta estrutura de programação. Como um desenvolvedor de software/programador, ela só faz sentido (em termos de carreira), para manter suas habilidades up-to-date.

Além de fazer-lhe um programador PHP mais valorizado, entender OOP em PHP lhe dará conhecimento (conhecimento OOP) que tornará você capaz de adentrar com mais facilidade em outras linguagens. Quando você aprende… OOP em PHP, você pode aprender programação orientada a objeto em qualquer linguagem baseada em OO.

Você vai descobrir com o tempo que a criação de projetos baseados em OOP PHP, só vai tornar a sua vida como programador muito mais fácil. Como um bônus adicionado, em breve você irá desenvolver a sua própria coleção de objetos reutilizáveis, onde você será capaz de alavancar outros projetos.
Finalmente, você também vai descobrir que PHP OOP é muito mais fácil de manter e atualizar.

OOP Desafios

PHP OO apresenta alguns desafios quando você está começando, porque você vai precisar aprender a pensar sobre seus projetos PHP de uma forma diferente. Você vai precisar conceituar o projeto em termos de objetos.

Mais detalhes …

Uma maneira comum de iniciar um projeto orientado a objetos é começar através da elaboração de diagramas simples de seus objetos. Quando você começar a trabalhar com diagramas de objeto, você vai achar que eles realmente ajudam a tornar o desenvolvimento de projetos baseados em PHP OOP muito mais fácil.

Aqui estão algumas dicas sobre o desenho de objetos, diagramas:

• Use um lápis e papel
• Desenhe caixas para representar cada objeto
• Nas caixas, liste seus métodos e suas propriedades
• Use as setas e linhas entre as caixas para denotar relações ‘parent‘ – ‘child‘ (pai – filho) entre os objetos.

Então se você tem ficado em cima do muro esperando para mergulhar de cabeça em PHP OO, agora é a melhor hora para começar.

Este tutorial foi baseado (traduzido alguns trechos) no tutorial que me iniciou em PHP OO de Stefan Mischook

Texto de Sovrn

Publicado por Ivanilton Quinto

Empresário viciado em tecnologia, Ivanilton Quinto adora desenvolver e brincar com soluções que tenham o poder de facilitar nossa rotina digital!

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Drones: Conheça suas diversas aplicações

bate papo online

Bate Papo Online – Eles Ainda Existem!