PHP OOP Part-Composition vs Inheritance and Dependency Suntikan

Dalam siri ini, saya akan membincangkan asas-asas Pengaturcaraan Berorientasikan Objek PHP (OOP). Kandungan akan disusun mengikut bahagian berurutan, setiap satu memfokuskan pada topik tertentu. Jika anda seorang pemula atau tidak biasa dengan konsep OOP, siri ini direka bentuk untuk membimbing anda langkah demi langkah. Dalam bahagian ini, saya akan membincangkan tentang Komposisi vs Inheritance dan Suntikan Ketergantungan dalam PHP. Mari kita mulakan perjalanan belajar PHP OOP bersama-sama!

Komposisi vs Warisan

Kami telah mengetahui tentang hubungan antara kelas induk dan anak dalam pengaturcaraan berorientasikan objek, di mana kami melihat bahawa kelas anak boleh mewarisi kelas induk dan mengakses segala-galanya daripadanya. Ini dikenali sebagai Warisan.

Sebaliknya, Komposisi merujuk kepada menetapkan kelas induk sebagai nilai harta dalam kelas anak, dan bukannya mewarisinya. Melalui ini, kita boleh mengakses segala-galanya daripada kelas induk. Ini dikenali sebagai Komposisi.

Di bawah ialah contoh yang menggambarkan Komposisi dan Warisan.

Contoh Kod

class Link
{
   public string $name;
   public string $type;

   public function create($name, $type)
   {
      $this->name = $name;
      $this->type = $type;
   }

   public function show()
   {
      echo "name: $this->name, type: $this->type";
   }
}


// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}


// Composition example
class User
{
   public Link $link;

   public function __construct()
   {
      $this->link = new Link();
   }
   // other functionalities
}

$user = new User();
$user->link->create("Jamir", "Short");

Dalam contoh pertama, kita dapat melihat bahawa kelas ShoLink mewarisi kelas Pautan. Sebaliknya, dalam contoh kedua, kelas Pengguna tidak mewarisi kelas Pautan. Sebaliknya, ia memberikan contoh kelas Pautan kepada salah satu sifatnya. Hasilnya, kami boleh mengakses segala-galanya daripada kelas Pautan dalam kedua-dua kelas kanak-kanak.

Sekarang, persoalan mungkin timbul: jika kita sudah boleh mengakses segala-galanya dengan menggunakan warisan, mengapa kita perlu menggunakan gubahan? Lagipun, dengan komposisi, kita perlu mengisytiharkan harta tambahan dan menetapkan nilainya melalui pembinaan. Ini kelihatan seperti kerja tambahan—jadi apakah faedah menggunakan gubahan?

Nah, kami tahu bahawa warisan menjadikan segala-galanya dalam kelas induk boleh diakses dalam kelas anak. Akibatnya, walaupun kita tidak mahu menggunakan kaedah tertentu kelas induk atau jika beberapa sifat atau kaedah kelas induk tidak diperlukan dalam kelas anak, kaedah tersebut masih boleh diakses dalam kelas anak jika mereka ahli awam atau dilindungi. .

Untuk menyelesaikan isu ini, gubahan digunakan. Dengan gubahan, kami hanya boleh menjadikan bahagian kelas induk yang diperlukan boleh diakses dalam kelas anak. Mari kita jelaskan perkara ini dengan contoh lain.

Jika kita melihat dengan teliti pada kelas Pautan, kita dapat melihat bahawa ia mempunyai kaedah persembahan. Menggunakan kaedah ini, kami boleh memaparkan terus pautan yang dibuat dalam kelas ShoLink.

Bagaimanapun, bagaimana jika kita mahu kelas Pengguna menghalang sesiapa daripada melihat terus pautan yang dibuat untuk pengguna? Sebaliknya, kami mungkin mahu memaparkan pautan pengguna bersama profil mereka.

Inilah sebabnya, dalam kelas Pengguna, bukannya mewarisi kelas Pautan, kami mengaksesnya melalui gubahan. Akibatnya, tiada siapa yang boleh terus melihat pautan pengguna melalui kelas Pengguna, tetapi mereka boleh terus melihat pautan kelas ShoLink.

Mengutamakan Komposisi berbanding Warisan

Sekarang kami mempunyai sedikit pemahaman tentang komposisi dan masa untuk menggunakannya dan bukannya warisan untuk menyelesaikan masalah tertentu. Dalam OOP, terdapat prinsip yang dipanggil "Komposisi Favor daripada Warisan", yang bermaksud mengutamakan komposisi daripada warisan. Dalam erti kata lain, untuk kelas kanak-kanak yang tidak perlu mengakses segala-galanya daripada kelas induk, kita harus sentiasa mengutamakan gubahan daripada warisan.

Sekarang, persoalan timbul: bagaimana kita memutuskan bila hendak menggunakan gubahan dan bila hendak menggunakan warisan?

Dalam kes ini, kita perlu mendasarkan keputusan kita pada dua jenis perhubungan:

1. ialah -> perhubungan. Jika hubungan itu "adalah", kita harus menggunakan warisan.
2. mempunyai -> perhubungan. Jika perhubungan itu "mempunyai", kita harus menggunakan gubahan.

Contoh Kod

class Link
{
   public string $name;
   public string $type;

   public function create($name, $type)
   {
      $this->name = $name;
      $this->type = $type;
   }

   public function show()
   {
      echo "name: $this->name, type: $this->type";
   }
}


// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}


// Composition example
class User
{
   public Link $link;

   public function __construct()
   {
      $this->link = new Link();
   }
   // other functionalities
}

$user = new User();
$user->link->create("Jamir", "Short");

Jika anda melihat contoh kelas ShoLink di atas, anda akan melihat bahawa kelas ShoLink mewarisi daripada kelas Pautan. Jadi, jika saya mentakrifkan perhubungan antara mereka, perhubungan itu ialah ShoLink ialah Pautan kerana ShoLink pada asasnya ialah sejenis Pautan.

Contoh Kod

// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}

Sekarang, jika kita melihat contoh kelas Pengguna di atas, kita dapat melihat bahawa kelas Pengguna menggunakan komposisi dengan kelas Pautan. Jadi, jika saya mentakrifkan hubungan antara mereka, perhubungan itu ialah Pengguna mempunyai Pautan kerana Pengguna bukan Pautan, tetapi Pengguna boleh mempunyai Pautan atau mungkin memilikinya.

Saya harap kini anda mempunyai pemahaman yang lebih jelas tentang gubahan dan warisan, termasuk masa untuk menggunakan setiap satu dan yang mana satu untuk diutamakan dalam situasi yang berbeza.

Suntikan Ketergantungan

Sebelum memahami suntikan kebergantungan, kita perlu memahami dahulu apa itu kebergantungan. Kebergantungan ialah apabila kelas kanak-kanak menggunakan ahli kelas lain, sama ada melalui pewarisan atau gubahan. Dalam kes itu, kelas induk menjadi tanggungan kelas anak.

Dalam contoh di atas, kami melihat bahawa apabila kami menggunakan gubahan dan bukannya warisan, kami perlu mengisytiharkan harta dalam kelas anak dan menetapkan contoh kelas induk kepada harta itu melalui pembina. Oleh itu, jika kita ingin menggunakan kelas Pengguna, kita mesti membuat instantiate kelas Pautan dalam pembinanya kerana kelas Pengguna bergantung pada kelas Pautan. Dengan kata lain, kelas Pautan adalah kebergantungan untuk kelas Pengguna. Isu di sini ialah proses instantiasi kelas Pautan digandingkan rapat dalam kelas Pengguna.

Masalahnya ialah instantiasi kelas Pautan adalah terhad dan khusus untuk kelas Pengguna. Jika kami ingin menghantar mana-mana kelas lain dan bukannya kelas Pautan dari luar ke dalam kelas Pengguna, kami tidak boleh melakukannya kerana kami secara eksplisit mencipta contoh kelas Pautan dalam pembina dan memberikannya kepada harta Pautan. Ini dipanggil Ketergantungan Berganding Ketat, bermakna kita tidak boleh mengubah kebergantungan ini dari luar.

Walau bagaimanapun, jika kami tidak menggunakan kelas Pautan sendiri dalam pembina dan sebaliknya menyerahkannya kepada pengguna, bermakna apabila pengguna menggunakan kelas Pengguna kami, mereka akan menyerahkan pergantungan kelas Pautan ke dalam kelas Pengguna, masalah kami akan menjadi diselesaikan.

Jom lihat contoh kod di bawah.

Contoh Kod

class Link
{
   public string $name;
   public string $type;

   public function create($name, $type)
   {
      $this->name = $name;
      $this->type = $type;
   }

   public function show()
   {
      echo "name: $this->name, type: $this->type";
   }
}


// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}


// Composition example
class User
{
   public Link $link;

   public function __construct()
   {
      $this->link = new Link();
   }
   // other functionalities
}

$user = new User();
$user->link->create("Jamir", "Short");

Dalam contoh ini, kita dapat melihat bahawa bukannya membuat contoh kelas Pautan dalam pembina kelas Pengguna, kita meneruskan kebergantungan kelas Pautan ke dalam kelas Pengguna dari luar. Proses menghantar kebergantungan ke dalam kelas Pengguna melalui pengguna dipanggil Suntikan Ketergantungan. Dalam erti kata lain, kami menyuntik atau menolak pergantungan kelas Pautan dari luar. Ini dikenali sebagai Loosely Coupled Dependency, bermakna kita boleh menukar kebergantungan ini dari luar dengan mudah.

Kini, jika kelas Pautan juga mempunyai kebergantungan sendiri, kami juga boleh menyuntik kebergantungan tersebut ke dalamnya dari luar melalui kelas Pengguna. Kemudian, kita hanya boleh menyuntik contoh kelas Pautan ke dalam kelas Pengguna. Akibatnya, kami tidak perlu risau tentang kebergantungan kelas Pautan dalam kelas Pengguna, kerana pengguna akan mengendalikannya dari luar.

Mari lihat contoh kod di bawah.

Contoh Kod

// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}

Dengan cara ini, kita boleh menyuntik seberapa banyak kebergantungan yang kita mahu dari luar, dan ia akan menjadi lebih fleksibel. Itu sahaja untuk hari ini; kita bincang dalam pelajaran seterusnya.

Anda boleh berhubung dengan saya di GitHub dan Linkedin.

Atas ialah kandungan terperinci PHP OOP Part-Composition vs Inheritance and Dependency Suntikan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!