PHP Academy · Aula

Classes, propriedades e métodos

Defina uma classe PHP com propriedades e métodos.

Classes, propriedades e métodos é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.

Introdução: classes PHP

Uma classe é um modelo para criar objetos. Ela define propriedades (dados) e métodos (comportamento). Os recursos de OO do PHP tornam o código mais modular, reutilizável e fácil de manter.

Conceitos centrais

Conceitos principais das classes PHP:

Use class ClassName {} para definir uma classe
As propriedades armazenam dados e os métodos definem comportamentos
Crie instâncias com new ClassName()
Acesse membros com a seta ->

Definindo uma classe

Exemplo:

<?php
class Car {
    public string $brand;
    public int    $year;
    public float  $price;

    public function describe(): string {
        return "{$this->year} {$this->brand}";
    }
}

$car = new Car();
$car->brand = 'Toyota';
$car->year  = 2022;
$car->price = 25000.0;

echo $car->describe(); // 2022 Toyota

Modificadores de acesso

Continuação:

<?php
class BankAccount {
    public  string $owner;
    private float  $balance;
    protected string $currency;

    // public: accessible everywhere
    // private: only within this class
    // protected: this class + subclasses
}

Propriedades com tipos

Prática:

<?php
class Product {
    public string  $name;
    public float   $price;
    public int     $stock = 0;  // default value
    public bool    $active = true;

    public function inStock(): bool {
        return $this->stock > 0;
    }
}

Métodos de instância

Aprofundamento:

<?php
class Counter {
    private int $count = 0;

    public function increment(): void { $this->count++; }
    public function decrement(): void { $this->count--; }
    public function reset(): void    { $this->count = 0; }
    public function value(): int      { return $this->count; }
}

$c = new Counter();
$c->increment();
$c->increment();
echo $c->value();  // 2

Encadeamento de métodos

Uso avançado:

<?php
class QueryBuilder {
    private string $table = '';
    private int    $limit = 100;

    public function from(string $t): static { $this->table = $t; return $this; }
    public function limit(int $n): static   { $this->limit = $n; return $this; }
    public function build(): string {
        return "SELECT * FROM {$this->table} LIMIT {$this->limit}";
    }
}

echo (new QueryBuilder())->from('users')->limit(10)->build();

Constantes de classe

Padrão do mundo real:

<?php
class HttpStatus {
    const OK        = 200;
    const NOT_FOUND = 404;
    const ERROR     = 500;

    public static function message(int $code): string {
        return match($code) {
            self::OK        => 'OK',
            self::NOT_FOUND => 'Not Found',
            default         => 'Error',
        };
    }
}

echo HttpStatus::message(HttpStatus::NOT_FOUND);  // Not Found

Propriedades readonly (PHP 8.1)

Práticas recomendadas:

<?php
class Point {
    public function __construct(
        public readonly float $x,
        public readonly float $y,
    ) {}

    public function distanceTo(Point $other): float {
        return sqrt(($this->x - $other->x) ** 2 + ($this->y - $other->y) ** 2);
    }
}

$p1 = new Point(0, 0);
$p2 = new Point(3, 4);
echo $p1->distanceTo($p2);  // 5

Padrão prático

Reunindo tudo com um padrão prático para classes PHP.

Armadilhas comuns

Evite estes erros comuns com classes PHP:

Use modificadores de acesso para encapsular o estado
Prefira a promoção do construtor para classes compactas
Defina constantes com const para valores fixos
Use encadeamento de métodos (interface fluente) para criar APIs legíveis

Verificação rápida

Qual modificador de acesso torna uma propriedade acessível somente dentro da própria classe?

Recapitulação: classes PHP

Você estudou as classes PHP. Pontos principais para lembrar:

Use modificadores de acesso para encapsular o estado
Prefira a promoção do construtor para classes compactas
Defina constantes com const para valores fixos
Use encadeamento de métodos (interface fluente) para criar APIs legíveis

Perguntas Frequentes

A aula “Classes, propriedades e métodos” é grátis?

Sim — o texto completo de “Classes, propriedades e métodos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.

O que vou aprender em “Classes, propriedades e métodos”?

Defina uma classe PHP com propriedades e métodos. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar PHP Academy?

Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Classes, propriedades e métodos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de PHP Academy?

Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para PHP Academy