Prinsip OOP

Hai! Dalam pelajaran hari ini, kita akan bercakap tentang Prinsip pengaturcaraan berorientasikan objek. Pernahkah anda terfikir mengapa Java direka bentuk dengan tepat? Maksud saya, anda mengisytiharkan kelas dan mencipta objek berdasarkan kelas, kelas mempunyai kaedah, dan lain-lain. Tetapi mengapa bahasa berstruktur supaya program terdiri daripada kelas dan objek, dan bukan sesuatu yang lain? Mengapakah konsep "objek" dicipta dan diletakkan di hadapan? Adakah semua bahasa direka dengan cara ini? Jika tidak, apakah kelebihan yang diberikan kepada Java? Seperti yang anda lihat, terdapat banyak soalan :) Mari cuba jawab setiap satu daripada mereka dalam pelajaran hari ini.

Apakah pengaturcaraan berorientasikan objek (OOP)?

Sudah tentu, Java tidak terdiri daripada objek dan kelas hanya untuk keseronokan. Mereka bukan kehendak pencipta Java, malah bukan ciptaan mereka. Terdapat banyak bahasa lain berdasarkan objek. Bahasa pertama seperti itu dipanggil "Simula". Ia dicipta pada tahun 1960-an di Norway. Lebih-lebih lagi, konsep "kelas" dan "kaedah" muncul dalam Simula. Mengikut piawaian pembangunan perisian, "Simula" kelihatan seperti bahasa purba, tetapi sesiapa sahaja boleh melihat "persamaan keluarga"nya dengan Java. Anda mungkin boleh membaca kod yang ditulis dalam bahasa ini dengan mudah dan menerangkan secara terperinci apa yang dilakukannya :)

Begin
	Class Rectangle (Width, Height); Real Width, Height;
			           
	 Begin
	    Real Area, Perimeter;  
	 
	    Procedure Update;      
	    Begin
	      Area := Width * Height;
              OutText("Rectangle is updating, Area = "); OutFix(Area,2,8); OutImage;
	      Perimeter := 2*(Width + Height);
              OutText("Rectangle is updating, Perimeter = "); OutFix(Perimeter,2,8); OutImage;
	    End of Update;
	 
	    Update;               
	    OutText("Rectangle created: "); OutFix(Width,2,6);
	    OutFix(Height,2,6); OutImage;
	 End of Rectangle;

       Rectangle Class ColouredRectangle (Color); Text Color;
			           
	Begin   	  
	    OutText("ColouredRectangle created, color = "); OutText(Color);
	    OutImage;
        End of ColouredRectangle;

 
      	 Ref(Rectangle) Cr;            
	 Cr :- New ColouredRectangle(10, 20, "Green"); 
End;

Kod sampel kod ini diambil daripada "Simula - 50 tahun OOP" oleh Weekly-geekly. Seperti yang anda lihat, Java tidak begitu berbeza dengan datuknya :) Ini disebabkan oleh fakta bahawa kemunculan Simula menandakan kelahiran konsep baharu: pengaturcaraan berorientasikan objek. Wikipedia mentakrifkan OOP seperti ini: "Pengaturcaraan Berorientasikan Objek (OOP) ialah paradigma pengaturcaraan berdasarkan konsep "objek", yang boleh mengandungi data, dalam bentuk medan (sering dikenali sebagai atribut), dan kod, dalam bentuk prosedur (sering dikenali sebagai kaedah)." Pada pendapat saya, ini adalah definisi yang sangat baik. Tidak lama dahulu anda mula belajar Java, tetapi definisi ini mungkin tidak mengandungi sebarang perkataan yang anda tidak tahu :) Hari ini OOP ialah metodologi pengaturcaraan yang paling biasa. Selain Jawa, Prinsip OOP digunakan dalam banyak bahasa popular yang mungkin anda pernah dengar. Contohnya, C++ (digunakan secara aktif dalam pembangunan permainan), Objective-C dan Swift (digunakan untuk menulis program untuk peranti Apple), Python (paling popular dalam pembelajaran mesin), PHP (salah satu bahasa pembangunan web yang paling popular), JavaScript ( lebih mudah untuk mengatakan apa yang tidak digunakan) dan banyak lagi. Jadi, apakah prinsip OOP pula? Kami akan memberitahu anda secara terperinci. apakah prinsip OOP pula? Kami akan memberitahu anda secara terperinci. apakah prinsip OOP pula? Kami akan memberitahu anda secara terperinci.

Prinsip OOP

Ini adalah asas asas. 4 ciri utama yang bersama-sama membentuk paradigma pengaturcaraan berorientasikan objek. Memahami mereka adalah penting untuk menjadi seorang pengaturcara yang berjaya.

Prinsip 1. Pewarisan

Berita baik: anda sudah mengetahui beberapa prinsip OOP! :) Kami telah menemui warisan beberapa kali dalam pelajaran, dan kami berjaya menggunakannya. Warisan ialah mekanisme yang membolehkan anda menerangkan kelas baharu berdasarkan kelas (ibu bapa) sedia ada. Dengan berbuat demikian, kelas baharu meminjam sifat dan kefungsian kelas induk. Untuk apa harta pusaka dan apa kelebihannya? Di atas semua, penggunaan semula kod. Medan dan kaedah yang diisytiharkan dalam kelas induk boleh digunakan dalam kelas keturunan. Jika semua jenis kereta mempunyai 10 medan biasa dan 5 kaedah yang sama, anda hanya perlu memindahkannya ke dalam Autokelas ibu bapa. Anda boleh menggunakannya dalam kelas keturunan tanpa sebarang masalah. Kelebihan pepejal: kedua-dua kuantitatif (kurang kod) dan, sebagai hasilnya, kualitatif (kelas menjadi lebih mudah). Selain itu, warisan adalah sangat fleksibel — anda boleh menambah fungsi tulis berasingan yang tiada keturunan (beberapa medan atau tingkah laku yang khusus untuk kelas tertentu). Secara umum, seperti dalam kehidupan sebenar, kita semua agak serupa dengan ibu bapa kita, tetapi juga berbeza daripada mereka :)

Prinsip 2. Abstraksi

Ini adalah prinsip yang sangat mudah. Abstraksi bermaksud untuk mengenal pasti ciri-ciri utama, paling ketara sesuatu, pada masa yang sama membuang apa-apa yang kecil dan tidak penting. Tidak perlu mencipta semula roda. Mari kita ingat contoh dari pelajaran lama tentang kelas. Katakan kita sedang mencipta sistem pemfailan untuk pekerja syarikat. Untuk mencipta objek "pekerja", kami telah menulis kelas Pekerja . Apakah ciri yang penting untuk menerangkannya dalam sistem pemfailan syarikat? Nama, tarikh lahir, SSN dan ID pekerja. Tetapi tidak mungkin kami memerlukan ketinggian pekerja, warna mata atau warna rambut untuk jenis rekod ini. Syarikat tidak memerlukan maklumat sedemikian tentang pekerja. Jadi, dalam kelas Pekerja , kami mengisytiharkan pembolehubah berikut:, umur int , int socialSecurityNumber dan int employeeId . Dan kami mengasingkan maklumat yang tidak perlu seperti warna mata. Walau bagaimanapun, jika kami membuat sistem pemfailan untuk agensi model, keadaan berubah secara mendadak. Ketinggian, warna mata dan warna rambut model adalah ciri penting, tetapi SSNnya sama sekali tidak relevan kepada kami. Jadi, dalam kelas Model , kami mencipta pembolehubah berikut: Ketinggian rentetan , Rambut rentetan , Mata rentetan .

Prinsip 3. Enkapsulasi

Kami telah pun menghadapi perkara ini. Di Jawa, enkapsulasi bermaksud menyekat keupayaan untuk membaca dan menukar data. Seperti yang anda lihat, istilah ini berdasarkan perkataan "kapsul". Kami akan menggunakan "kapsul" untuk menyembunyikan beberapa data penting yang kami tidak mahu orang lain mengubahnya. Berikut adalah contoh mudah dari kehidupan sebenar. Anda mempunyai nama pertama dan nama keluarga. Semua rakan anda mengenali mereka. Tetapi mereka tidak mempunyai keupayaan untuk menukar nama pertama atau nama keluarga anda. Kami mungkin mengatakan bahawa proses untuk melakukan itu "dirangkumkan" oleh sistem mahkamah: anda boleh menukar nama keluarga anda hanya melalui kerani mahkamah, dan hanya anda boleh melakukannya. "Pengguna" lain mempunyai akses "baca sahaja" kepada nama pertama dan nama keluarga anda :) Contoh ilustrasi lain ialah wang tunai yang disimpan di rumah. Membiarkannya di hadapan mata di tengah-tengah bilik anda bukanlah idea yang baik. Mana-mana "pengguna" (orang yang datang ke rumah anda) akan dapat menukar jumlah wang anda, iaitu mereka boleh mengambil wang anda. Adalah lebih baik untuk membungkusnya dalam peti besi. Kemudian akses akan tersedia hanya untuk anda dan hanya dengan menggunakan kod khas. Contoh pengkapsulan yang jelas yang telah anda gunakan ialah pengubah suai akses (peribadi, awam, dsb.), serta penetap dan pengambil. Jika anda tidak merangkumkanMedan umur kelas kucing , maka sesiapa sahaja boleh menulis:

Cat.age = -1000;

Mekanisme enkapsulasi membolehkan kami melindungi medan umur dengan kaedah penetap, di mana kami boleh memastikan umur tidak boleh ditetapkan kepada nombor negatif.

Prinsip 4. Polimorfisme

Polimorfisme ialah keupayaan untuk bekerja dengan beberapa jenis seolah-olah mereka adalah jenis yang sama. Selain itu, tingkah laku objek akan berbeza bergantung pada jenisnya. Adakah itu terdengar rumit? Mari kita fahaminya sekarang. Ambil contoh paling mudah: haiwan. Buat kelas Haiwan dengan kaedah speak() tunggal dan dua subkelas — Cat dan Dog .

public class Animal {

   public void speak() {
      
       System.out.println("Hello!");
   }
}

public class Dog extends Animal {
  
   @Override
   public void speak() {
       System.out.println ("Woof-woof!");
   }
}

public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

Sekarang kita akan cuba mengisytiharkan pembolehubah rujukan Haiwan dan menetapkan objek Anjing kepadanya.

public class Main {

   public static void main(String[] args) {

       Animal dog = new Dog();
       dog.speak();
   }
}

Apakah kaedah yang anda fikir akan dipanggil? Animal.speak() atau Dog.speak() ? Kaedah dalam kelas Anjing akan dipanggil: Woof-woof! Kami mencipta rujukan Haiwan , tetapi objek itu berkelakuan seperti Anjing . Jika perlu, ia boleh berkelakuan seperti kucing, kuda atau haiwan lain. Perkara penting ialah menetapkan subkelas khusus kepada pembolehubah rujukan Haiwan umum . Ini masuk akal, kerana semua anjing adalah haiwan. Itulah yang kami fikirkan apabila kami berkata "tingkah laku objek akan berbeza bergantung pada jenisnya." Jika kita mencipta objek Cat ...

public static void main(String[] args) {

   Animal cat = new Cat();
   cat.speak();
}

kaedah speak () akan memaparkan "Meow!" Tetapi apakah yang kita maksudkan dengan 'keupayaan untuk bekerja dengan beberapa jenis seolah-olah mereka adalah jenis yang sama'? Ini juga agak mudah. Bayangkan kita sedang mencipta kedai gunting rambut untuk haiwan. Kedai gunting rambut kami sepatutnya boleh memberi mana-mana haiwan trim, jadi kami mencipta kaedah trim() dengan parameter Haiwan (haiwan itu mendapat potongan rambut).

public class AnimalBarbershop {

   public void trim(Animal animal) {

       System.out.println("The haircut is done!"); 
   }
}

Dan kini kita boleh menghantar objek Kucing dan Anjing kepada kaedah trim() !

public static void main(String[] args) {

   Cat cat = new Cat();
   Dog dog = new Dog();

   AnimalBarbershop barbershop = new AnimalBarbershop();

   barbershop.trim(cat);
   barbershop.trim(dog);
}

Dan inilah contoh yang jelas: kelas AnimalBarbershop berfungsi dengan jenis Kucing dan Anjing seolah-olah mereka adalah jenis yang sama. Pada masa yang sama, Kucing dan Anjing mempunyai tingkah laku yang berbeza: mereka masing-masing bercakap secara berbeza.

Mengapa kita memerlukan OOP?

Mengapakah OOP pernah timbul sebagai konsep pengaturcaraan baharu? Pengaturcara mempunyai alat yang berfungsi, seperti bahasa prosedur. Apakah yang mendorong mereka mencipta sesuatu yang pada asasnya baru? Di atas semua, kerumitan tugas yang mereka hadapi. Jika 60 tahun yang lalu, tugas pengaturcara adalah seperti "menilai beberapa ungkapan matematik", kini ia boleh menjadi seperti "melaksanakan 7 pengakhiran yang berbeza untuk permainan STALKER, bergantung pada gabungan keputusan pemain yang dibuat pada titik A, B, C, DE , dan F dalam permainan." Seperti yang anda lihat, tugas-tugas itu jelas menjadi lebih rumit sejak beberapa dekad yang lalu. Dan akibatnya, jenis data menjadi lebih rumit. Ini adalah satu lagi sebab mengapa OOP muncul. Ungkapan matematik boleh dinilai dengan mudah menggunakan primitif biasa. Tiada objek diperlukan di sini. Tetapi tugas dengan pengakhiran permainan sukar untuk diterangkan tanpa menggunakan kelas tersuai. Yang berkata, agak mudah untuk menerangkannya menggunakan kelas dan objek. Jelas sekali, kami memerlukan beberapa kelas: Permainan, Stalker, Ending, PlayerDecision, GameEvent dan sebagainya. Dalam erti kata lain, walaupun tanpa mula menyelesaikan masalah, kita boleh dengan mudah "melakar" penyelesaian dalam kepala kita. Kerumitan tugas yang semakin meningkat memaksa pengaturcara membahagikannya kepada beberapa bahagian. Tetapi ini tidak begitu mudah dilakukan dalam pengaturcaraan prosedur. Dan selalunya program adalah seperti pokok dengan banyak cabang yang mewakili semua laluan pelaksanaan yang mungkin. Bergantung pada syarat tertentu, satu cabang program atau yang lain telah dilaksanakan. Untuk program kecil, ini mudah, tetapi sangat sukar untuk membahagikan masalah besar kepada bahagian. Ini adalah satu lagi sebab untuk kemunculan OOP. Paradigma ini memberi pengaturcara keupayaan untuk membahagikan program kepada sekumpulan "modul" (kelas), yang masing-masing melakukan bahagian kerjanya sendiri. Dengan berinteraksi antara satu sama lain, semua objek mencapai kerja program kami. Di samping itu, kami boleh menggunakan semula kod kami di tempat lain dalam program, yang juga menjimatkan banyak masa.