PHP klass va obyekt (OOP asoslari)

Assotsiativ massiv ma’lumotni saqlaydi, lekin u bilan ishlaydigan funksiyalar boshqa joyda turadi. Klass ma’lumot va uni boshqaradigan kodni bir joyga jamlaydi.

Muammo

PHP

<?php
// Ma'lumot bir joyda
$talaba = ["ism" => "Aziz", "ball" => 85];

// Funksiyalar boshqa joyda — bog'liqlik ko'rinmaydi
function otdimi(array $t): bool {
  return $t["ball"] >= 60;
}

function tavsif(array $t): string {
  return $t["ism"] . " — " . $t["ball"] . " ball";
}

echo tavsif($talaba), "\n";
var_dump(otdimi($talaba));

// Hech kim to'sqinlik qilmaydi:
$talaba["ball"] = -500;
echo "Ball endi: ", $talaba["ball"];

Ikki muammo: funksiyalar ma’lumotdan ajralgan, va noto’g’ri qiymat yozilishiga hech narsa to’sqinlik qilmaydi.

Birinchi klass

PHP

<?php
class Talaba
{
  public string $ism;
  public int $ball;

  public function otdimi(): bool
  {
      return $this->ball >= 60;
  }

  public function tavsif(): string
  {
      return $this->ism . " — " . $this->ball . " ball";
  }
}

$aziz = new Talaba();
$aziz->ism = "Aziz";
$aziz->ball = 85;

echo $aziz->tavsif(), "\n";
var_dump($aziz->otdimi());

-> belgisi obyekt a’zosiga murojaat qiladi: $aziz->ism, $aziz->tavsif().

constructor — yaratishda to’ldirish

PHP

<?php
class Talaba
{
  public string $ism;
  public int $ball;

  public function __construct(string $ism, int $ball)
  {
      $this->ism = $ism;
      $this->ball = $ball;
  }

  public function tavsif(): string
  {
      return "{$this->ism} — {$this->ball} ball";
  }
}

$aziz = new Talaba("Aziz", 85);
$dilnoza = new Talaba("Dilnoza", 92);

echo $aziz->tavsif(), "\n";
echo $dilnoza->tavsif();

__construct — new paytida avtomatik chaqiriladigan maxsus metod. Endi obyekt yaratilishi bilan to’liq holatda bo’ladi.

Qisqa yozuv (PHP 8)

PHP

<?php
class Talaba
{
  public function __construct(
      public string $ism,
      public int $ball = 0,
  ) {}

  public function tavsif(): string
  {
      return "{$this->ism} — {$this->ball} ball";
  }
}

$a = new Talaba("Aziz", 85);
$b = new Talaba("Bobur");

echo $a->tavsif(), "\n";
echo $b->tavsif();

Constructor parametriga public yozilsa, PHP xossani o’zi yaratadi va to’ldiradi. Uch qator o’rniga bitta — zamonaviy PHP’da shu shakl ishlatiladi.

Ko’rinish darajalari

PHP

<?php
class Hisob
{
  public string $egasi;
  private int $balans = 0;

  public function __construct(string $egasi, int $boshlangich)
  {
      $this->egasi = $egasi;
      $this->balans = $boshlangich;
  }

  public function qoshish(int $summa): string
  {
      if ($summa <= 0) {
          return "Summa musbat bo'lishi kerak";
      }
      $this->balans += $summa;
      return "Yangi balans: {$this->balans}";
  }

  public function balans(): int
  {
      return $this->balans;
  }
}

$h = new Hisob("Aziz", 100000);

echo $h->qoshish(50000), "\n";
echo $h->qoshish(-999), "\n";
echo "Balans: ", $h->balans(), "\n";
echo "Egasi: ", $h->egasi, "\n";

try {
  echo $h->balans;
} catch (Error $e) {
  echo "Xato: private xossaga tashqaridan tegib bo'lmaydi";
}

Uch daraja

Daraja	Kimga ochiq
`public`	Hamma joydan
`private`	Faqat shu klass ichida
`protected`	Shu klass va undan meros olganlar

Qoida: xossalarni odatda private qiling, kerak bo’lsa metod orqali oching. Shunda noto’g’ri qiymat yozib bo’lmaydi — yuqoridagi misolda -999 tekshiruvdan o’tmadi.

Bu tamoyil inkapsulyatsiya deb ataladi: ma’lumot o’zini himoya qiladi.

Getter va setter

PHP

<?php
class Mahsulot
{
  private int $narx = 0;

  public function __construct(
      public readonly string $nom,
      int $narx,
  ) {
      $this->setNarx($narx);
  }

  public function getNarx(): int
  {
      return $this->narx;
  }

  public function setNarx(int $narx): void
  {
      if ($narx < 0) {
          throw new InvalidArgumentException("Narx manfiy bo'lolmaydi");
      }
      $this->narx = $narx;
  }

  public function narxMatn(): string
  {
      return number_format($this->narx, 0, ',', ' ') . " so'm";
  }
}

$m = new Mahsulot("Olma", 12000);
echo $m->nom, ": ", $m->narxMatn(), "\n";

$m->setNarx(15000);
echo "Yangilandi: ", $m->narxMatn(), "\n";

try {
  $m->setNarx(-100);
} catch (InvalidArgumentException $e) {
  echo "Ushlandi: ", $e->getMessage(), "\n";
}

try {
  $m->nom = "Boshqa";
} catch (Error $e) {
  echo "readonly xossa o'zgarmaydi";
}

readonly (PHP 8.1) — bir marta o’rnatiladi va keyin o’zgarmaydi. Identifikator va nom kabi maydonlar uchun ideal.

static — klassning o’ziga tegishli

PHP

<?php
class Hisoblagich
{
  private static int $soni = 0;

  public static function oshir(): int
  {
      return ++self::$soni;
  }

  public static function soni(): int
  {
      return self::$soni;
  }
}

echo Hisoblagich::oshir(), "\n";
echo Hisoblagich::oshir(), "\n";
echo Hisoblagich::oshir(), "\n";
echo "Jami: ", Hisoblagich::soni();

static a’zolar obyektga emas, klassga tegishli — new shart emas, :: bilan chaqiriladi. Ichkarida $this emas, self:: ishlatiladi.

Klass doimiylari

PHP

<?php
class Buyurtma
{
  public const KUTILMOQDA = "kutilmoqda";
  public const YUBORILDI = "yuborildi";
  public const YETKAZILDI = "yetkazildi";

  public function __construct(
      public readonly int $id,
      private string $holat = self::KUTILMOQDA,
  ) {}

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

  public function yubor(): void
  {
      $this->holat = self::YUBORILDI;
  }
}

$b = new Buyurtma(101);
echo "Holat: ", $b->holat(), "\n";

$b->yubor();
echo "Holat: ", $b->holat(), "\n";
echo "Doimiy: ", Buyurtma::YETKAZILDI;

Doimiy const bilan e’lon qilinadi va Klass::NOM orqali o’qiladi. Bu “sehrli matn” ("yuborildi") larni kod bo’ylab tarqatmaslik uchun.

Obyektlar havola bo’yicha uzatiladi

PHP

<?php
class Quti
{
  public function __construct(public int $qiymat) {}
}

$a = new Quti(10);
$b = $a;
$b->qiymat = 99;

echo "Obyekt: a = ", $a->qiymat, "\n";

$c = clone $a;
$c->qiymat = 1;
echo "clone'dan keyin: a = ", $a->qiymat, ", c = ", $c->qiymat, "\n";

$x = 10;
$y = $x;
$y = 99;
echo "Oddiy o'zgaruvchi: x = ", $x;

Amaliy misol — savat

PHP

<?php
class Savat
{
  private array $mahsulotlar = [];

  public function qosh(string $nom, int $narx, int $soni = 1): self
  {
      $this->mahsulotlar[] = [
          "nom" => $nom, "narx" => $narx, "soni" => $soni,
      ];
      return $this;
  }

  public function soni(): int
  {
      return array_sum(array_column($this->mahsulotlar, "soni"));
  }

  public function jami(): int
  {
      $j = 0;
      foreach ($this->mahsulotlar as $m) {
          $j += $m["narx"] * $m["soni"];
      }
      return $j;
  }

  public function chek(): string
  {
      $qatorlar = [];
      foreach ($this->mahsulotlar as $m) {
          $qatorlar[] = sprintf("%-8s %2d × %7s = %8s",
              $m["nom"], $m["soni"],
              number_format($m["narx"], 0, ',', ' '),
              number_format($m["narx"] * $m["soni"], 0, ',', ' '));
      }
      $qatorlar[] = str_repeat("-", 32);
      $qatorlar[] = sprintf("%-22s %9s", "Jami:",
          number_format($this->jami(), 0, ',', ' '));
      return implode("\n", $qatorlar);
  }
}

$savat = (new Savat())
  ->qosh("Olma", 12000, 3)
  ->qosh("Non", 5000, 2)
  ->qosh("Sut", 14000);

echo $savat->chek(), "\n\n";
echo "Mahsulotlar soni: ", $savat->soni();

Metod return $this qaytarsa, chaqiruvlarni zanjir qilib yozish mumkin — bu “fluent interface” naqshi.

Amaliy mashq

Kitob klassini yozing: nom, muallif, yil xossalari bilan;
__construct qo’shib, obyekt yaratishda to’ldiring;
PHP 8 qisqa yozuviga o’tkazing;
yil ni private qilib, getter/setter yozing;
setter’da kelajakdagi yilni rad eting;
static hisoblagich bilan nechta kitob yaratilganini sanang.

Qisqacha xulosa

Klass — shablon, obyekt — undan yasalgan nusxa (new).
Xossa va metodga -> bilan murojaat qilinadi; ichkarida $this.
__construct obyekt yaratilganda avtomatik ishlaydi.
PHP 8 da constructor parametriga public yozib xossa yaratiladi.
private xossa faqat klass ichida ko’rinadi — inkapsulyatsiya.
readonly bir marta o’rnatiladi; static klassga tegishli (::).
Obyektlar havola bo’yicha uzatiladi — nusxa uchun clone.

Keyingi darsda meros va interfeys — klasslarni kengaytirish.