PHP meros, abstrakt klass va interfeys

Bir necha klass umumiy xususiyatga ega bo’lsa, ularni har birida qayta yozish shart emas. Meros umumiy qismni bitta joyda saqlashga imkon beradi.

extends — kengaytirish

PHP

<?php
class Inson
{
  public function __construct(
      protected string $ism,
      protected int $yosh,
  ) {}

  public function tanishtir(): string
  {
      return "{$this->ism}, {$this->yosh} yosh";
  }
}

class Talaba extends Inson
{
  public function __construct(string $ism, int $yosh, private string $guruh)
  {
      parent::__construct($ism, $yosh);
  }

  public function guruh(): string
  {
      return $this->guruh;
  }
}

$t = new Talaba("Aziz", 20, "IT-21");

echo $t->tanishtir(), "\n";
echo "Guruh: ", $t->guruh();

Talaba tanishtir() ni yozmagan, lekin u ishladi — ota klassdan meros qilib olindi.

Metodni qayta yozish

PHP

<?php
class Inson
{
  public function __construct(protected string $ism) {}

  public function tanishtir(): string
  {
      return "Men {$this->ism}";
  }
}

class Oqituvchi extends Inson
{
  public function __construct(string $ism, private string $fan)
  {
      parent::__construct($ism);
  }

  public function tanishtir(): string
  {
      return parent::tanishtir() . ", {$this->fan} o'qituvchisi";
  }
}

echo (new Inson("Aziz"))->tanishtir(), "\n";
echo (new Oqituvchi("Dilnoza", "Matematika"))->tanishtir();

Avlod ota metodini almashtiradi, lekin parent:: orqali uning natijasidan foydalanishi mumkin — noldan yozishdan yaxshiroq.

abstract — bajarilmagan shablon

PHP

<?php
abstract class Shakl
{
  abstract public function yuza(): float;
  abstract public function nomi(): string;

  // Umumiy metod — barcha avlodlarda tayyor keladi
  public function tavsif(): string
  {
      return sprintf("%s: yuzasi %.2f", $this->nomi(), $this->yuza());
  }
}

class Aylana extends Shakl
{
  public function __construct(private float $radius) {}

  public function yuza(): float { return M_PI * $this->radius ** 2; }
  public function nomi(): string { return "Aylana"; }
}

class Togriburchak extends Shakl
{
  public function __construct(private float $a, private float $b) {}

  public function yuza(): float { return $this->a * $this->b; }
  public function nomi(): string { return "To'g'riburchak"; }
}

$shakllar = [new Aylana(5), new Togriburchak(4, 6)];

foreach ($shakllar as $s) {
  echo $s->tavsif(), "\n";
}

try {
  new Shakl();
} catch (Error $e) {
  echo "Abstrakt klassdan obyekt yasab bo'lmaydi";
}

interface — shartnoma

PHP

<?php
interface Saqlanadigan
{
  public function saqla(): bool;
  public function yukla(int $id): bool;
}

interface Chizilinadigan
{
  public function html(): string;
}

class Maqola implements Saqlanadigan, Chizilinadigan
{
  public function __construct(
      private string $sarlavha,
      private string $matn = "",
  ) {}

  public function saqla(): bool
  {
      echo "  '{$this->sarlavha}' saqlandi\n";
      return true;
  }

  public function yukla(int $id): bool
  {
      echo "  #$id yuklandi\n";
      return true;
  }

  public function html(): string
  {
      return "<h2>" . htmlspecialchars($this->sarlavha) . "</h2>";
  }
}

$m = new Maqola("PHP interfeyslari");
$m->saqla();
$m->yukla(42);
echo $m->html(), "\n";

var_dump($m instanceof Saqlanadigan);
var_dump($m instanceof Chizilinadigan);

Interfeys va abstrakt klass farqi

	`abstract class`	`interface`
Tayyor metod	Bo’lishi mumkin	Yo’q (faqat imzo)
Xossa	Bo’ladi	Yo’q
Nechtasini olish mumkin	Bitta	Bir nechta
Ma’nosi	“bu shunday narsa”	“bu shunday qila oladi”

Talaba extends Inson — talaba inson. Maqola implements Saqlanadigan — maqolani saqlash mumkin.

Polimorfizm

PHP

<?php
interface Tolov
{
  public function tola(int $summa): string;
}

class Karta implements Tolov
{
  public function __construct(private string $raqam) {}

  public function tola(int $summa): string
  {
      $oxiri = substr($this->raqam, -4);
      return "Karta ****{$oxiri}: " . number_format($summa, 0, ',', ' ') . " so'm";
  }
}

class Naqd implements Tolov
{
  public function tola(int $summa): string
  {
      return "Naqd: " . number_format($summa, 0, ',', ' ') . " so'm";
  }
}

class Hamyon implements Tolov
{
  public function __construct(private string $nom) {}

  public function tola(int $summa): string
  {
      return "{$this->nom}: " . number_format($summa, 0, ',', ' ') . " so'm";
  }
}

// Bu funksiya qaysi usul kelishini BILMAYDI — shunchaki interfeysga tayanadi
function buyurtmaniYakunla(Tolov $usul, int $summa): void
{
  echo "  ", $usul->tola($summa), "\n";
}

$usullar = [
  new Karta("8600123456789012"),
  new Naqd(),
  new Hamyon("Payme"),
];

foreach ($usullar as $u) {
  buyurtmaniYakunla($u, 250000);
}

Tur sifatida interfeys

PHP

<?php
interface Jurnal
{
  public function yoz(string $xabar): void;
}

class EkranJurnali implements Jurnal
{
  public function yoz(string $xabar): void
  {
      echo "  [ekran] $xabar\n";
  }
}

class XotiraJurnali implements Jurnal
{
  private array $qatorlar = [];

  public function yoz(string $xabar): void
  {
      $this->qatorlar[] = $xabar;
  }

  public function hammasi(): array
  {
      return $this->qatorlar;
  }
}

class Buyurtma
{
  // Aniq klassga emas, INTERFEYSGA bog'lanamiz
  public function __construct(private Jurnal $jurnal) {}

  public function yakunla(int $id): void
  {
      $this->jurnal->yoz("Buyurtma #$id yakunlandi");
  }
}

echo "Ekranga:\n";
(new Buyurtma(new EkranJurnali()))->yakunla(101);

echo "Xotiraga (sinov uchun):\n";
$xotira = new XotiraJurnali();
(new Buyurtma($xotira))->yakunla(102);
print_r($xotira->hammasi());

Buyurtma qanday jurnal ishlatilishini bilmaydi — bu tashqaridan beriladi. Shu tufayli sinovda haqiqiy jurnal o’rniga xotiradagisini qo’yish mumkin. Bu naqsh bog’liqlikni kiritish (dependency injection) deb ataladi.

final — kengaytirishni taqiqlash

PHP

<?php
class Asos
{
  final public function muhim(): string
  {
      return "Bu metodni o'zgartirib bo'lmaydi";
  }

  public function oddiy(): string
  {
      return "Buni almashtirish mumkin";
  }
}

final class Yopiq extends Asos
{
  public function oddiy(): string
  {
      return "Almashtirildi";
  }
}

$y = new Yopiq();
echo $y->muhim(), "\n";
echo $y->oddiy(), "\n";
echo "final klassdan meros olib bo'lmaydi";

final metod qayta yozilmaydi, final klassdan meros olinmaydi. Xatti-harakat buzilmasligi muhim bo’lgan joylarda ishlatiladi.

Meros o’rniga kompozitsiya

Chuqur meros — muammo

Uch-to’rt darajali meros zanjiri kodni tushunishni qiyinlashtiradi: metod qayerdan kelganini topish uchun butun zanjirni ko’rish kerak.

Ko’p hollarda kompozitsiya yaxshiroq — obyektni meros olish o’rniga ichida saqlash:

// ❌ Avtomobil dvigateldan meros olmaydi
class Avtomobil extends Dvigatel {}

// ✅ Avtomobilda dvigatel BOR
class Avtomobil {
    public function __construct(private Dvigatel $dvigatel) {}
}

Amaliy qoida: “bu shunday narsa” — meros; “bunda shunday narsa bor” — kompozitsiya.

Amaliy mashq

Hayvon klassi va undan It, Mushuk avlodlarini yozing;
ovoz() metodini har avlodda qayta yozing;
avlod constructor’ida parent::__construct chaqiring;
Shakl abstrakt klassi va ikki avlod yasang;
Tolov interfeysi bilan uch xil usul yozing;
instanceof bilan turlarni tekshiring.

5-qadam polimorfizmning butun foydasini ko’rsatadi.

Qisqacha xulosa

extends avlod klassni ota asosida yaratadi; parent:: ota a’zosiga murojaat.
protected — shu klass va avlodlar uchun.
Abstrakt klassdan obyekt yasab bo’lmaydi; abstract metodni avlod yozishi shart.
Interfeys — shartnoma: nima qila olishini aytadi, qanday qilishini emas.
Bir klass bitta klassdan meros oladi, lekin ko’p interfeys bajaradi.
Polimorfizm: bir chaqiruv turli obyektlarda turlicha ishlaydi.
Chuqur meros o’rniga ko’pincha kompozitsiya afzal.

Keyingi darsda sessiya va cookie — foydalanuvchini eslab qolish.