DEV Community: Carlos Viana

Modelo de Maturidade Richardson

Carlos Viana — Wed, 25 Jun 2025 03:15:52 +0000

Modelo de Maturidade de Richardson: Entenda os 4 Níveis de REST

O Modelo de Maturidade de Richardson, criado por Leonard Richardson, é uma forma de avaliar o quão RESTful uma API é. Ele mede o grau de aderência aos princípios do REST, dividindo a maturidade em quatro níveis (0 a 3) — do menos ao mais alinhado ao estilo arquitetural REST.

Nível 0 – The Swamp of POX (Pântano de POX)

Descrição: APIs neste nível usam o HTTP apenas como transporte, sem aplicar os princípios do REST. É comum ter um único endpoint e um único método HTTP (geralmente POST) para todas as operações, lembrando chamadas RPC. O termo POX significa Plain Old XML, mas também pode envolver JSON ou outros formatos.
Características:
- Um único URI (ex.: /api) para qualquer requisição.
- Uso exclusivo de POST.
- Não aproveita recursos do HTTP (métodos, códigos de status etc.).
- Respostas trazem resultados de ações, não representações de recursos.
Exemplo:

  POST /api
  <action>getUser</action>
  <id>123</id>

Problema: Baixa interoperabilidade, difícil manutenção e pouca escalabilidade.

Nível 1 – Recursos

Descrição: O primeiro passo rumo ao REST. Aqui, a API identifica recursos individuais por URIs distintas, mas ainda não usa corretamente os métodos HTTP.
Características:
- Recursos possuem URIs próprias (ex.: /users/123).
- Geralmente ainda usa apenas POST para qualquer ação.
- Não diferencia operações por métodos HTTP.
Exemplo:

POST /users/123 tanto para obter quanto para atualizar o usuário 123.
Benefício: Organiza melhor os dados e facilita a identificação de recursos.
Limitação: Ainda ignora a semântica do HTTP.

Nível 2 – Verbos HTTP

Descrição: Aqui, a API usa métodos HTTP corretamente (GET, POST, PUT, DELETE) e passa a explorar códigos de status HTTP. Muitas APIs REST modernas ficam nesse nível.
Características:
- Métodos alinhados às operações:
- GET /users/123 → obtém usuário.
- POST /users → cria usuário.
- PUT /users/123 → atualiza usuário.
- DELETE /users/123 → remove usuário.
- Uso de códigos HTTP (200, 201, 404, 400 etc.).
- URIs representam recursos, não ações.
Exemplo:

GET /books/1 retorna um livro com status 200 OK.

POST /books cria um novo livro e retorna 201 Created.
Benefício: Maior clareza, interoperabilidade e aderência ao protocolo.
Limitação: Ainda não fornece navegação entre recursos.

Nível 3 – HATEOAS (Hypermedia as the Engine of Application State)

Descrição: O topo da maturidade REST. A API oferece links nas respostas para guiar o cliente na interação com outros recursos. Assim, o cliente descobre as possibilidades de forma dinâmica, como navegamos na web.
Características:
- Respostas incluem links para ações relacionadas.
- Cliente não precisa conhecer URIs fixas.
- A API conduz a navegação via hipermídia.
Exemplo:

  {
    "id": 123,
    "name": "John",
    "_links": {
      "self": { "href": "/users/123" },
      "orders": { "href": "/users/123/orders" },
      "delete": { "href": "/users/123", "method": "DELETE" }
    }
  }

Benefício: Máxima flexibilidade, descoberta de funcionalidades e resiliência a mudanças.
Limitação: Complexo de implementar e muitas vezes desnecessário em APIs simples.

Resumo dos Níveis

Nível 0 → HTTP como transporte, sem recursos nem métodos (RPC-like).
Nível 1 → Recursos com URIs, mas uso limitado do HTTP.
Nível 2 → Métodos e códigos HTTP corretos (padrão mais comum).
Nível 3 → HATEOAS e navegação dinâmica.

Observações

Nível 2 atende à maioria dos casos: Embora o Nível 3 seja o ideal para APIs realmente autodescritivas, ele é mais complexo e raramente essencial.
Use como guia, não como regra: O nível ideal depende do projeto, prazos e objetivos.

📚 Saiba mais: Richardson Maturity Model – Martin Fowler

O que é REST ?

Carlos Viana — Wed, 25 Jun 2025 03:09:51 +0000

Introdução ao REST

REST (Representational State Transfer — Transferência Representacional de Estado) é um estilo arquitetural voltado para o design de sistemas distribuídos, especialmente APIs (Application Programming Interfaces) na web. Proposto por Roy Fielding em sua tese de doutorado em 2000, o REST busca estruturar serviços web de forma simples, escalável e baseada nos princípios do HTTP (Hypertext Transfer Protocol).

Ao contrário de um protocolo ou padrão rígido, o REST é um conjunto de diretrizes que orienta a comunicação entre sistemas de maneira stateless (sem manter estado no servidor), utilizando recursos como entidades identificáveis.

Sua popularidade se deve à capacidade de aproveitar os recursos nativos da web:

URIs (Uniform Resource Identifiers) para identificar recursos.
Métodos HTTP para realizar operações.
Representações como JSON ou XML para transmitir dados.

Princípios Fundamentais

Os princípios do REST derivam de restrições propostas por Fielding para tornar sistemas mais previsíveis, performáticos e interoperáveis.

Cliente-Servidor (Client-Server)
Separação clara entre cliente e servidor. Cada parte pode evoluir de forma independente, facilitando manutenção e escalabilidade.
Sem Estado (Stateless)
Cada requisição deve conter todas as informações necessárias para ser processada. O servidor não armazena sessão, o que facilita o escalonamento horizontal.
Cacheável (Cacheable)
Respostas podem ser cacheadas para reduzir latência e tráfego, melhorando desempenho.
Interface Uniforme (Uniform Interface)
Padroniza a interação com recursos por meio de:
- Identificação de recursos por URIs (ex.: /usuarios/123).
- Manipulação por representações (ex.: JSON ou XML).
- Mensagens auto-descritivas com metadados (ex.: Content-Type).
- HATEOAS (Hypermedia as the Engine of Application State): inclusão de links para ações possíveis.
Sistema em Camadas (Layered System)
A arquitetura pode conter várias camadas (balanceadores, firewalls, caches), mantendo o isolamento de cada nível.
Código Sob Demanda (Code on Demand) – opcional
Possibilidade de o servidor enviar código executável (ex.: JavaScript) ao cliente para ampliar funcionalidades.

Como Funciona

Em uma API RESTful, recursos (usuários, produtos, pedidos, etc.) são expostos como endpoints acessíveis via HTTP. O modelo segue a lógica CRUD (Create, Read, Update, Delete), mapeada para métodos HTTP:

GET – Ler um recurso.
POST – Criar um novo recurso.
PUT – Atualizar recurso existente.
PATCH – Atualizar parcialmente um recurso.
DELETE – Remover um recurso.

Elementos principais de uma requisição:

URI – Identifica o recurso (ex.: /agents/e370fa57-4757-3604-3648-499e1f642d3f).
Headers – Metadados (ex.: Content-Type: application/json).
Body – Dados enviados (em POST, PUT, PATCH).
Query Params – Filtros e parâmetros opcionais (ex.: ?idade=30).

Elementos comuns de uma resposta:

Código de Status HTTP – Resultado da operação (200 OK, 201 Created, 404 Not Found, etc.).
Body – Representação do recurso (JSON, XML, etc.).
Headers – Informações adicionais (ex.: Content-Type, Date).

Por ser stateless, cada requisição é independente — autenticação e contexto devem ser enviados a cada chamada (ex.: via JWT).

Vantagens

Simplicidade – Usa padrões HTTP já conhecidos.
Escalabilidade – Arquitetura stateless facilita expansão.
Interoperabilidade – Compatível com qualquer linguagem que suporte HTTP.
Performance com Cache – Reduz carga no servidor.
Separação de responsabilidades – Cliente e servidor evoluem de forma independente.

Desvantagens

Falta de padronização rígida – Implementações variam.
Overfetching/Underfetching – Pode retornar dados de mais ou de menos.
Segurança – Depende de implementação correta (HTTPS, autenticação).
HATEOAS pouco usado – Complexidade elevada e baixa adoção prática.

Em resumo, REST mudou a forma como desenvolvemos APIs, oferecendo uma abordagem simples, escalável e integrada à própria web.

Criando uma API REST com Laravel

Carlos Viana — Tue, 29 Oct 2024 18:26:41 +0000

Criando uma API RESTful Completa com Laravel

Neste tutorial, vamos construir uma API RESTful completa em Laravel para gerenciar tarefas, aproveitando todo o poder do framework — que é voltado para produtividade, clareza e robustez.

O Laravel foi criado e é mantido por Taylor Otwell, sendo um framework opiniativo que prioriza convenções sobre configurações. Isso significa menos tempo gasto com ajustes manuais e mais foco na lógica de negócio.

O que é uma API RESTful?

Antes de codificar, é importante entender o conceito.

REST (Representational State Transfer) é um estilo arquitetural para comunicação entre sistemas, normalmente usando o protocolo HTTP.
Nas APIs RESTful:

Os endpoints representam recursos.
Os verbos HTTP indicam ações:
- GET → Recuperar recursos
- POST → Criar recursos
- PUT → Atualizar recursos
- DELETE → Excluir recursos

Cada requisição é sem estado (stateless), ou seja, o servidor não guarda contexto entre chamadas.

Passo 1 — Criando o projeto Laravel

Com PHP e Composer instalados, crie o projeto:

composer create-project laravel/laravel task-api

Abra o projeto no VS Code ou no editor de sua preferência.

Passo 2 — Configurando o banco de dados

No arquivo .env, ajuste para o seu ambiente:

DB_DATABASE=task_api
DB_USERNAME=seu_usuario
DB_PASSWORD=sua_senha

Passo 3 — Criando a migration

As migrations permitem versionar e criar tabelas no banco.
Execute:

php artisan make:migration create_tasks_table --create=tasks

Defina a estrutura em database/migrations/xxxx_xx_xx_create_tasks_table.php:

Schema::create('tasks', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('description')->nullable();
    $table->boolean('completed')->default(false);
    $table->timestamps();
});

Crie a tabela:

php artisan migrate

Passo 4 — Criando Model e Controller

Laravel segue o padrão MVC.

php artisan make:model Task
php artisan make:controller TaskController --api

No modelo app/Models/Task.php:

class Task extends Model
{
    use HasFactory;

    protected $fillable = ['title', 'description', 'completed'];
}

Passo 5 — Definindo rotas

No routes/api.php:

Route::apiResource('tasks', TaskController::class);

Isso já cria automaticamente todas as rotas CRUD.

Passo 6 — Implementando o Controller

Em app/Http/Controllers/TaskController.php:

<?php 

namespace App\Http\Controllers; 
use App\Models\Task; 
use Illuminate\Http\Request; 

class TaskController extends Controller { 
    public function index()
    {
        return response()->json(Task::all(), 200);
    }

    public function store(Request $request)
    {
        $request->validate([
            'title' => 'required|string|max:255',
            'description' => 'nullable|string'
        ]);

        $task = Task::create($request->all());
        return response()->json($task, 201);
    }

    public function show(Task $task)
    {
        return response()->json($task, 200);
    }

    public function update(Request $request, Task $task)
    {
        $request->validate([
            'title' => 'required|string|max:255',
            'description' => 'nullable|string',
            'completed' => 'boolean'
        ]);

        $task->update($request->all());
        return response()->json($task, 200);
    }

    public function destroy(Task $task)
    {
        $task->delete();
        return response()->json(null, 204);
    }
}

Passo 7 — Testando a API

Você pode testar com Postman, Insomnia ou com a extensão REST Client no VS Code.

Exemplo de requisição .http:

### Criar nova tarefa
POST http://127.0.0.1:8000/api/tasks
Content-Type: application/json

{
    "title": "Estudar Laravel"
}

### Listar tarefas
GET http://127.0.0.1:8000/api/tasks

Passo 8 — Automatizando testes com PHPUnit

Crie uma factory:

php artisan make:factory TaskFactory

database/factories/TaskFactory.php:

public function definition(): array
{
    return [
        'title' => fake()->sentence(),
        'description' => fake()->paragraph(),
        'completed' => false,
    ];
}

Crie o teste:

php artisan make:test TaskApiTest

tests/Feature/TaskApiTest.php (exemplo de teste de criação):

<?php

namespace Tests\Feature;

use App\Models\Task;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class TaskApiTest extends TestCase
{
    use RefreshDatabase;

    public function test_can_create_task(): void
    {
        $response = $this->postJson('/api/tasks', [
            'title' => 'Nova Tarefa',
            'description' => 'Descrição da tarefa',
            'completed' => false,
        ]);

        $response->assertStatus(201);
        $response->assertJson([
            'title' => 'Nova Tarefa',
            'description' => 'Descrição da tarefa',
            'completed' => false,
        ]);
    }

    public function test_can_list_tasks(): void
    {
        Task::factory()->count(3)->create();

        $response = $this->getJson('/api/tasks');

        $response->assertStatus(200);
        $response->assertJsonCount(3);
    }

    public function test_can_show_task(): void
    {
        $task = Task::factory()->create();

        $response = $this->getJson("/api/tasks/{$task->id}");

        $response->assertStatus(200);
        $response->assertJson([
            'title' => $task->title,
        ]);
    }

    public function test_can_update_task(): void
    {
        $task = Task::factory()->create();

        $response = $this->putJson("/api/tasks/{$task->id}", [
            'title' => 'Tarefa Atualizada',
            'description' => 'Nova descrição',
            'completed' => true,
        ]);

        // Mantendo 201 para compatibilidade com o seu controller atual
        $response->assertStatus(201);
        $response->assertJson([
            'title' => 'Tarefa Atualizada',
            'description' => 'Nova descrição',
            'completed' => true,
        ]);
    }

    public function test_can_delete_task(): void
    {
        $task = Task::factory()->create();

        $response = $this->deleteJson("/api/tasks/{$task->id}");

        $response->assertStatus(204);
    }
}

Execute:

php artisan test

Trabalhando com Strings no PHP

Carlos Viana — Wed, 09 Oct 2024 16:54:21 +0000

Trabalhando com Strings no PHP

Uma string é um tipo de dado usado em programação para representar uma sequência de caracteres. Esses caracteres podem ser letras, números, espaços, símbolos, etc.
Na maioria das linguagens de programação, uma string é delimitada por aspas simples (') ou aspas duplas (").

Concatenação de Strings

Concatenação é o processo de juntar duas ou mais strings.

<?php
$name = "John";
$lastname = "Smith";

// Concatenar strings usando o operador "."
$fullname = $name . " " . $lastname;
echo $fullname; // Saída: John Smith
?>

No exemplo acima, o operador . é usado para unir as variáveis $name e $lastname, separadas por um espaço.

Tamanho de uma String

Para saber o número de caracteres em uma string, utilizamos a função strlen().

<?php
$text = "Hello, World!";
$size = strlen($text);
echo $size; // Saída: 13
?>

A função strlen() conta todos os caracteres, incluindo espaços e pontuação.

Substituir Parte de uma String

A função str_replace() substitui todas as ocorrências de um trecho dentro de uma string.

<?php
$sentence = "I like apples";
$newSentence = str_replace("apples", "bananas", $sentence);
echo $newSentence;  // Saída: I like bananas
?>

Aqui, a palavra "apples" foi substituída por "bananas" na string original.

Converter para Maiúsculas ou Minúsculas

strtoupper() converte uma string para maiúsculas.
strtolower() converte para minúsculas.

<?php
$text = "Hello, World!";
$uppercase = strtoupper($text);
$lowercase = strtolower($text);

echo $uppercase;  // Saída: HELLO, WORLD!
echo $lowercase;  // Saída: hello, world!
?>

Essas funções são úteis para padronizar o formato do texto.

Obter Parte de uma String

Para extrair uma parte específica de uma string, usamos substr().

<?php
$text = "Learning PHP is fun!";
$part = substr($text, 9, 3);
echo $part;  // Saída: PHP
?>

A função começa na posição 9 (considerando que o índice inicial é 0) e retorna 3 caracteres.

Remover Espaços no Início e no Fim

A função trim() remove espaços (ou outros caracteres especificados) do início e fim de uma string.

<?php
$text = "    Hello, World!    ";
$clean = trim($text);
echo $clean;  // Saída: "Hello, World!"
?>

Muito útil para limpar textos recebidos de formulários ou entradas de usuário.

Dividir uma String em um Array

A função explode() transforma uma string em um array, com base em um delimitador.

<?php
$sentence = "PHP,JavaScript,Python";
$languages = explode(",", $sentence);

print_r($languages);
// Saída: Array ( [0] => PHP [1] => JavaScript [2] => Python )
?>

No exemplo, a string foi dividida usando a vírgula como separador.

Unir Elementos de um Array em uma String

O implode() faz o oposto de explode(), unindo os elementos de um array em uma única string.

<?php
$languages = array("PHP", "JavaScript", "Python");
$sentence = implode(" | ", $languages);

echo $sentence;  // Saída: PHP | JavaScript | Python
?>

Encontrar a Posição de um Texto

A função strpos() retorna a posição da primeira ocorrência de uma substring.

<?php
$sentence = "I like to program in PHP";
$position = strpos($sentence, "PHP");

echo $position;  // Saída: 23
?>

Se o texto não for encontrado, a função retorna false.

Inverter uma String

Para inverter uma string, usamos strrev().

<?php
$text = "Hello, World!";
$reversed = strrev($text);

echo $reversed;  // Saída: !dlroW ,olleH
?>

💡 Você pode executar esses exemplos no site: OneCompiler - PHP

Trabalhando com Arrays no PHP

Carlos Viana — Fri, 04 Oct 2024 12:54:02 +0000

Trabalhando com Arrays no PHP

Um array é uma estrutura de dados que armazena uma coleção de elementos, geralmente do mesmo tipo, em uma única variável.
Esses elementos podem ser números, strings, objetos ou até mesmo outros arrays.
Os arrays permitem armazenar e acessar múltiplos valores de forma ordenada, usando índices.

Criando um Array

Você pode criar arrays usando a função array() ou a sintaxe curta [].

<?php

// Usando a função array()
$frutas1 = array("Maçã", "Banana", "Laranja");

var_dump($frutas1);

// Usando a sintaxe curta
$frutas2 = ["Maçã", "Banana", "Laranja"];

var_dump($frutas2);

Acessando Elementos do Array

Para acessar um elemento, utilize seu índice (que começa em 0).

<?php

$frutas = ["Maçã", "Banana", "Laranja"];

echo $frutas[0]; // Saída: Maçã

Adicionando Elementos ao Array

Você pode usar array_push() ou simplesmente atribuir um valor a um novo índice.

<?php

$frutas = ["Maçã", "Banana", "Laranja"];

// Adicionando com array_push()
array_push($frutas, "Uva");

// Adicionando atribuindo diretamente
$frutas[] = "Manga";

var_dump($frutas);

Removendo Elementos do Array

Existem várias maneiras de remover elementos: unset(), array_pop() e array_shift().

<?php 

$frutas = ["Maçã", "Banana", "Laranja"];

// Remove o último elemento
array_pop($frutas);

// Remove o primeiro elemento
array_shift($frutas);

// Remove pelo índice
unset($frutas[1]); // Remove Banana

var_dump($frutas);

Percorrendo um Array

O foreach() é a forma mais simples de iterar sobre um array.

<?php

$frutas = ["Maçã", "Banana", "Laranja"];

foreach ($frutas as $fruta) {
    echo $fruta . "\n";
}

Unindo Arrays

Use array_merge() para combinar arrays.

<?php 

$frutas = ["Maçã", "Banana", "Laranja"];
$maisFrutas = ["Abacaxi", "Melancia"];

$todasFrutas = array_merge($frutas, $maisFrutas);

var_dump($todasFrutas);

Ordenando Arrays

O PHP oferece diversas funções para ordenação, como sort(), rsort(), asort() e ksort().

<?php 

$frutas = ["Maçã", "Banana", "Laranja"];

sort($frutas); // Ordena em ordem crescente

var_dump($frutas);

💡 Você pode executar todos esses exemplos no site: OneCompiler - PHP

Object-Oriented PHP: Inheritance vs Composition

Carlos Viana — Fri, 27 Sep 2024 14:56:09 +0000

Inheritance vs. Composition in PHP 🚗

When programming with Object-Oriented Programming (OOP), it's important to understand the difference between Inheritance and Composition:

Inheritance: It's one of the fundamental principles of OOP and allows a class to inherit properties and methods from another class. In simple terms, inheritance enables the creation of a new class (called a subclass or child class) that reuses, extends, or modifies the behavior of an existing class (called a superclass or parent class).

<?php 

// Defining an Engine class that has a start method
class Engine
{
    // The start method simulates the operation of an engine
    public function start()
    {
        return "Engine Started!";
    }
}

// The Car class extends the Engine class, meaning it inherits
// all properties and methods from the Engine class
class Car extends Engine
{
    // Here, we are overriding the start method from the Engine class
    // This allows us to customize the behavior of the method in the child class
    public function start()
    {
        return "The car engine is started!";
    }
}

// We create an instance of the Car class
$car = new Car();

// Since the start method was overridden in the Car class, it executes the new behavior
echo $car->start(); // Output: The car engine is started!

Composition Now, imagine that we are modeling a car that is composed of several parts, like an engine and wheels. Instead of creating a single "Car" class with all the details, we can break down these functionalities into smaller classes. The car will be composed of objects from other classes, such as an Engine.

<?php

// Defining an Engine class with the start method
class Engine
{
    // The start method simulates the operation of an engine
    public function start()
    {
        return "Engine Started!";
    }
}

// The Car class is composed of an Engine object, rather than inheriting from Engine
class Car
{
    // Private property to store the instance of Engine
    private Engine $engine;

    // The constructor receives an instance of Engine as a dependency
    // This is an example of dependency injection
    public function __construct(Engine $engine)
    {
        // We assign the Engine object to the private property
        $this->engine = $engine;
    }

    // The start method delegates the responsibility of starting the engine to the Engine object
    public function start()
    {
        // Here we call the start method of the Engine object
        return $this->engine->start();
    }
}

// We create an instance of Engine
$v4Engine = new Engine();

// We create an instance of Car, passing the Engine as a parameter
$car = new Car($v4Engine);

// When we call the start method, it delegates the task to the Engine object

echo $car->start(); // Output: Engine Started!

Understanding Instead of the Car class containing the logic to start the engine directly, it delegates that responsibility to the Engine object. This keeps the Car class focused on its own responsibility, making the code more modular and easier to maintain. In the future, you can modify or improve the Engine without needing to change the Car class's code.

Advantages This approach is more flexible because it allows the car to have different types of engines (for example, a V4, V6, or electric engine) without needing to change the Car class. This modularity makes it easier to maintain and expand the system.

You can run the code at https://onecompiler.com/php

Object-Oriented PHP: A Practical Guide

Carlos Viana — Sun, 22 Sep 2024 17:57:28 +0000

Object-Oriented Programming is a programming paradigm that organizes code around "objects," which are instances of "classes." These objects can have properties (data) and methods (functions) that define their behavior.

Classes
A class is like a "blueprint" or "template" that defines the characteristics and behaviors of an object. It describes the attributes (data) and methods (actions) that objects of that class will have.

Think of a class as the description of a type of object. It defines what the object can do (methods) and what the object has (properties/attributes), but it doesn't create the object itself.

Object
An object is an instance of a class. It is created from the class and represents an individual entity with defined attribute values and the ability to execute the methods specified in the class.

Think of an object as the concrete realization of a class. While the class is the plan, the object is the final product created from that plan.

Class and Object Example

<?php 

// Defining a class
class Car {
    // Properties
    public $color;
    public $model;

    // Method
    public function start() {
        return "The car is started!";
    }
}

// Creating an object
$myCar = new Car();

// Assigning the object's properties
$myCar->color = "Red";
$myCar->model = "Beetle";

// Using a method
echo $myCar->start(); // Output: The car is started!

Inheritance
Inheritance is one of the core principles of Object-Oriented Programming (OOP), allowing a class to inherit properties and methods from another class. In simple terms, inheritance enables the creation of a new class (called a subclass or child class) that reuses, extends, or modifies the behavior of an existing class (called a superclass or parent class).

<?php 

// Parent class (superclass)
class Vehicle {
    public $brand;
    public $model;

    public function drive() {
        echo "The vehicle is being driven.";
    }
}

// Child class (subclass) that inherits from Vehicle
class Car extends Vehicle {
    public $numberOfDoors;

    // Method specific to the child class
    public function openDoor() {
        echo "Opening a car door.";
    }

    // Overriding a method from the parent class
    public function drive() {
        echo "The car is being driven.";
    }
}

// Creating an object of the child class Car
$myCar = new Car();
$myCar->brand = "Toyota";
$myCar->model = "Corolla";
$myCar->numberOfDoors = 4;

// Accessing methods from the parent and child classes
$myCar->drive();     // Outputs "The car is being driven."
$myCar->openDoor();  // Outputs "Opening a car door."

Encapsulation
Encapsulation is the practice of hiding the internal details of an object and exposing only what is necessary for interacting with it. In other words, encapsulation allows you to control how an object's data is accessed and modified, protecting it from undue external interference.

This is achieved through access modifiers (like public, private, and protected) to determine which parts of an object can be accessed from outside the class.

public: Properties and methods can be accessed from anywhere.
private: Properties and methods can only be accessed within the class itself.
protected: Properties and methods can be accessed within the class and in subclasses.

<?php

class BankAccount {
    private $balance;

    public function __construct($initialBalance) {
        $this->balance = $initialBalance;
    }

    // Public method for deposit
    public function deposit($amount) {
        if ($amount > 0) {
            $this->balance += $amount;
        }
    }

    // Public method to view balance
    public function getBalance() {
        return $this->balance;
    }

    // Private method, accessible only inside the class
    private function applyFee() {
        $this->balance -= 5; // Maintenance fee
    }
}

$account = new BankAccount(100);
$account->deposit(50);
echo $account->getBalance(); // Outputs 150

Polymorphism
Polymorphism is one of the fundamental principles of Object-Oriented Programming (OOP) and refers to the ability of different classes to use methods with the same name but different behaviors. In other words, polymorphism allows the same method to be implemented in different ways in different classes.

The term "polymorphism" comes from Greek and means "many forms," indicating that a single method name can function differently depending on the object that invokes it.

<?php

// Parent class
class Animal {
    public function makeSound() {
        echo "The animal makes a sound.";
    }
}

// Child classes that override the makeSound method
class Dog extends Animal {
    public function makeSound() {
        echo "The dog barks.";
    }
}

class Cat extends Animal {
    public function makeSound() {
        echo "The cat meows.";
    }
}

// Function demonstrating polymorphism
function letAnimalMakeSound(Animal $animal) {
    $animal->makeSound();
}

// Creating objects of different classes
$dog = new Dog();
$cat = new Cat();

// Calling the method with polymorphic behavior
letAnimalMakeSound($dog);  // Outputs "The dog barks."
letAnimalMakeSound($cat);  // Outputs "The cat meows."

You can run the code at https://onecompiler.com/php

PHP Orientado a Objetos: Uma Introdução

Carlos Viana — Fri, 20 Sep 2024 14:14:21 +0000

Programação Orientada a Objetos (POO)

A Programação Orientada a Objetos (POO) é um paradigma de programação que organiza o código em torno de "objetos", que são instâncias de "classes". Esses objetos combinam dados (propriedades ou atributos) e comportamentos (métodos ou funções), promovendo modularidade, reutilização de código e facilidade de manutenção.

Este artigo explora os conceitos fundamentais da POO — Classes, Objetos, Herança, Encapsulamento e Polimorfismo — com exemplos práticos em PHP.

Classes

Uma classe é um modelo ou blueprint que define as propriedades (dados) e métodos (comportamentos) de um objeto. Ela funciona como um molde, especificando o que um objeto pode fazer e quais dados ele armazena, sem criar o objeto em si. Por exemplo, uma classe Carro pode definir atributos como cor e modelo, além de métodos como ligar().

Objetos

Um objeto é uma instância de uma classe, ou seja, um elemento concreto criado a partir do molde da classe. Cada objeto possui valores específicos para os atributos definidos na classe e pode executar os métodos associados. Por exemplo, um objeto da classe Carro pode ter cor = "Vermelho" e modelo = "Fusca".

Exemplo de Classe e Objeto

<?php

// Definindo uma classe
class Carro {
    // Propriedades
    public $cor;
    public $modelo;

    // Método
    public function ligar() {
        return "O carro {$this->modelo} está ligado!";
    }
}

// Criando um objeto
$meuCarro = new Carro();

// Atribuindo valores às propriedades
$meuCarro->cor = "Vermelho";
$meuCarro->modelo = "Fusca";

// Executando o método
echo $meuCarro->ligar() . PHP_EOL; // Saída: O carro Fusca está ligado!

?>

Herança

A herança permite que uma classe (subclasse ou classe filha) herde propriedades e métodos de outra classe (superclasse ou classe pai). Isso promove reutilização de código e a criação de hierarquias de classes, onde a subclasse pode estender ou modificar o comportamento da superclasse. Por exemplo, uma classe Carro pode herdar de uma classe Veiculo, adicionando funcionalidades específicas.

Exemplo de Herança

<?php

// Classe pai (superclasse)
class Veiculo {
    public $marca;
    public $modelo;

    public function dirigir() {
        return "O veículo {$this->modelo} está sendo dirigido.";
    }
}

// Classe filha (subclasse) que herda de Veiculo
class Carro extends Veiculo {
    public $numeroDePortas;

    // Método específico da classe filha
    public function abrirPorta() {
        return "Abrindo uma porta do carro com {$this->numeroDePortas} portas.";
    }

    // Sobrescrevendo o método da classe pai
    public function dirigir() {
        return "O carro {$this->modelo} está sendo dirigido com estilo!";
    }
}

// Criando um objeto da classe filha
$meuCarro = new Carro();
$meuCarro->marca = "Toyota";
$meuCarro->modelo = "Corolla";
$meuCarro->numeroDePortas = 4;

// Acessando métodos
echo $meuCarro->dirigir() . PHP_EOL;    // Saída: O carro Corolla está sendo dirigido com estilo!
echo $meuCarro->abrirPorta() . PHP_EOL; // Saída: Abrindo uma porta do carro com 4 portas.

?>

Encapsulamento

O encapsulamento é a prática de proteger os dados internos de um objeto, controlando o acesso a eles por meio de modificadores de acesso (public, private, protected). Isso garante que os dados sejam manipulados apenas de maneira controlada, protegendo a integridade do objeto.

public: Acessível de qualquer lugar.
private: Acessível apenas dentro da própria classe.
protected: Acessível dentro da classe e em suas subclasses.

Exemplo de Encapsulamento

<?php

class ContaBancaria {
    private $saldo;

    public function __construct($saldoInicial) {
        $this->saldo = $saldoInicial;
    }

    // Método público para depositar
    public function depositar($quantia) {
        if ($quantia > 0) {
            $this->saldo += $quantia;
            $this->aplicarTaxa();
            return "Depósito de R$ $quantia realizado com sucesso.";
        }
        return "Quantia inválida para depósito.";
    }

    // Método público para consultar o saldo
    public function obterSaldo() {
        return "Saldo atual: R$ {$this->saldo}";
    }

    // Método privado para aplicar taxa
    private function aplicarTaxa() {
        $this->saldo -= 5; // Taxa de manutenção
    }
}

// Criando um objeto
$conta = new ContaBancaria(100);
echo $conta->depositar(50) . PHP_EOL; // Saída: Depósito de R$ 50 realizado com sucesso.
echo $conta->obterSaldo() . PHP_EOL;  // Saída: Saldo atual: R$ 145

?>

Polimorfismo

O polimorfismo permite que diferentes classes implementem métodos com o mesmo nome, mas com comportamentos distintos. Isso possibilita que objetos de classes diferentes sejam tratados de forma uniforme, chamando o mesmo método, mas obtendo resultados específicos de cada classe. O termo "polimorfismo" significa "muitas formas", refletindo a flexibilidade desse conceito.

Exemplo de Polimorfismo

<?php

// Classe pai
class Animal {
    public function emitirSom() {
        return "O animal faz um som genérico.";
    }
}

// Classes filhas que sobrescrevem o método emitirSom
class Cachorro extends Animal {
    public function emitirSom() {
        return "O cachorro late: Au au!";
    }
}

class Gato extends Animal {
    public function emitirSom() {
        return "O gato mia: Miau!";
    }
}

// Função que demonstra polimorfismo
function fazerAnimalEmitirSom(Animal $animal) {
    return $animal->emitirSom();
}

// Criando objetos
$cachorro = new Cachorro();
$gato = new Gato();

// Demonstrando polimorfismo
echo fazerAnimalEmitirSom($cachorro) . PHP_EOL; // Saída: O cachorro late: Au au!
echo fazerAnimalEmitirSom($gato) . PHP_EOL;     // Saída: O gato mia: Miau!

?>

A Programação Orientada a Objetos é um paradigma poderoso que organiza o código de forma modular e reutilizável. Com classes e objetos, você define estruturas de dados e comportamentos; com herança, reutiliza e estende funcionalidades; com encapsulamento, protege dados sensíveis; e com polimorfismo, garante flexibilidade e comportamentos específicos.

Você pode testar os códigos apresentados em plataformas como OneCompiler.