ທ່ານສາມາດອະທິບາຍຄວາມແຕກຕ່າງລະຫວ່າງການຂຽນໂປແກຼມຂັ້ນຕອນແລະ OOP ໄດ້ບໍ?


ຕອບ 1:

ຄຳ ຖາມຕົ້ນສະບັບ:

ທ່ານສາມາດອະທິບາຍຄວາມແຕກຕ່າງລະຫວ່າງການຂຽນໂປແກຼມຂັ້ນຕອນແລະ OOP ໄດ້ບໍ?

ຄຳ ຕອບ:

ກ່ອນອື່ນ, ຂໍໃຫ້ ກຳ ນົດຄວາມ ໝາຍ ຂອງການຂຽນໂປແກຼມທີ່ເນັ້ນໃສ່ລະບຽບການແລະຈຸດປະສົງ.

ນິຍາມ - ພາສາລະບຽບການມີຄວາມ ໝາຍ ແນວໃດ? ພາສາລະບຽບການແມ່ນປະເພດຂອງພາສາການຂຽນໂປແກຼມຄອມພິວເຕີ້ເຊິ່ງລະບຸຂັ້ນຕອນແລະຂັ້ນຕອນທີ່ມີໂຄງສ້າງທີ່ດີໃນສະພາບການຂຽນໂປແກຼມຂອງພວກເຂົາໃນການສ້າງໂປແກຼມ. ມັນມີລະບົບ ຄຳ ສັ່ງ, ໜ້າ ທີ່ແລະ ຄຳ ສັ່ງທີ່ເປັນລະບົບ ສຳ ລັບການປະຕິບັດວຽກງານຄອມພິວເຕີ້ຫລືໂປແກຼມ. ພາສາລະບຽບການຍັງຖືກເອີ້ນວ່າພາສາທີ່ ຈຳ ເປັນ. ເຕັກໂນໂລຢີອະທິບາຍພາສາລະບຽບການ A ພາສາລະບຽບການ, ຄືກັບທີ່ຊື່ໄດ້ແນະ ນຳ, ແມ່ນອີງໃສ່ຂັ້ນຕອນແລະ ໜ້າ ທີ່ທີ່ໄດ້ ກຳ ນົດໄວ້ລ່ວງ ໜ້າ ແລະຈັດຕັ້ງປະຕິບັດໄດ້ດີຫລືມີລະບົບຍ່ອຍຢູ່ໃນສະຖາປັດຕະຍະ ກຳ ຂອງໂປແກຼມ, ໂດຍ ກຳ ນົດທຸກບາດກ້າວທີ່ຄອມພິວເຕີຕ້ອງປະຕິບັດເພື່ອບັນລຸສະຖານະພາບຫລືຜົນຜະລິດທີ່ຕ້ອງການ. ບັນລຸ. ພາສາລະບຽບການແຍກໂຄງການອອກເປັນຕົວແປ, ໜ້າ ທີ່, ຄຳ ແນະ ນຳ ແລະຜູ້ປະຕິບັດງານທີ່ມີເງື່ອນໄຂ. ຂັ້ນຕອນຫລື ໜ້າ ທີ່ຖືກຈັດຕັ້ງປະຕິບັດຕາມຂໍ້ມູນແລະຕົວປ່ຽນຕ່າງໆເພື່ອປະຕິບັດວຽກງານໃດ ໜຶ່ງ. ຂັ້ນຕອນເຫຼົ່ານີ້ສາມາດຖືກເອີ້ນ / ເອີ້ນວ່າທຸກບ່ອນລະຫວ່າງ ລຳ ດັບຊັ້ນຂອງໂຄງການແລະຈາກຂັ້ນຕອນອື່ນໆ. ໂປແກຼມທີ່ຂຽນເປັນພາສາລະບຽບການມີ ໜຶ່ງ ຫຼືຫຼາຍຂັ້ນຕອນ. ພາສາລະບຽບການແມ່ນ ໜຶ່ງ ໃນພາສາການຂຽນໂປແກຼມທີ່ຖືກ ນຳ ໃຊ້ຫຼາຍທີ່ສຸດເຊິ່ງມີພາສາທີ່ສັງເກດໄດ້ເຊັ່ນ: C / C ++, Java, ColdFusion ແລະ PASCAL.

ຕອນນີ້ຂໍອະທິບາຍການຂຽນໂປແກມທີ່ແນໃສ່ວັດຖຸ.

ນິຍາມ - ການ ກຳ ນົດໂປແກຼມ Object Oriented Programming (OOP) ໝາຍ ຄວາມວ່າແນວໃດ? ການຂຽນໂປແກຼມທີ່ເນັ້ນໃສ່ວັດຖຸ (OOP) ແມ່ນຮູບແບບການຂຽນໂປແກຼມໂປແກຼມໂປຼແກຼມທີ່ສ້າງຂື້ນຮອບວັດຖຸ. ຮູບແບບນີ້ແບ່ງຂໍ້ມູນອອກເປັນວັດຖຸ (ທົ່ງນາຂໍ້ມູນ) ແລະອະທິບາຍເນື້ອໃນແລະພຶດຕິ ກຳ ຂອງວັດຖຸໂດຍປະກາດຊັ້ນຮຽນ (ວິທີການ). ໜ້າ ທີ່ຂອງ OOP ປະກອບມີ: ການເຂົ້າລະຫັດ: ສິ່ງນີ້ເຮັດໃຫ້ມັນງ່າຍຕໍ່ການຈັດການໂຄງສ້າງ, ເພາະວ່າການຈັດຕັ້ງປະຕິບັດແລະສະຖານະພາບຂອງແຕ່ລະວັດຖຸຖືກປິດບັງຂໍ້ ກຳ ນົດທີ່ດີ. Polymorphism: ໝາຍ ຄວາມວ່າ ໜ່ວຍ ງານທີ່ບໍ່ມີຕົວຕົນໄດ້ຖືກຈັດຕັ້ງປະຕິບັດດ້ວຍຫຼາຍຮູບແບບ. ມູນມໍລະດົກ: ສິ່ງນີ້ ໝາຍ ເຖິງການຈັດລະບົບ ລຳ ດັບຊັ້ນຂອງຊິ້ນສ່ວນການຈັດຕັ້ງປະຕິບັດ. ການຂຽນໂປແກຼມທີ່ມີຈຸດປະສົງເຮັດໃຫ້ການຂຽນໂປແກຼມງ່າຍດາຍ. ຜົນປະໂຫຍດລວມມີການ ນຳ ໃຊ້ຄືນ ໃໝ່, ການປັບ ໃໝ່, ການຂະຫຍາຍ, ການຮັກສາແລະປະສິດທິພາບ. Techopedia ອະທິບາຍກ່ຽວກັບ OOP ການຂຽນໂປແກຼມວັດຖຸທີ່ມີຈຸດປະສົງ (OOP) ເປັນຕົວແບບການຂຽນໂປແກຼມຂອງການເລືອກໃນເວລາຢ່າງ ໜ້ອຍ ໜຶ່ງ ທົດສະວັດ ໂຄງສ້າງແບບໂມດູນຂອງ OOP ຊ່ວຍໃຫ້ນັກຂຽນໂປແກຼມສາມາດສ້າງໂປແກຼມໃນທ່ອນທີ່ສາມາດຄວບຄຸມໄດ້ແທນທີ່ຈະເປັນລະຫັດຕາມ ລຳ ດັບ. ໜຶ່ງ ໃນຂໍ້ໄດ້ປຽບທີ່ດີຂອງ OOP ແມ່ນການປັບຂະ ໜາດ ໄດ້, ເຊິ່ງວັດຖຸແລະນິຍາມບໍ່ມີຂອບເຂດ ຈຳ ກັດ. ການແຍກຂໍ້ມູນແລະວິທີການຕ່າງໆຍັງປ້ອງກັນບັນຫາທົ່ວໄປທີ່ເກີດຂື້ນໃນພາສາຊອບແວທີ່ມີເສັ້ນເກົ່າ. ຖ້າຂໍ້ຜິດພາດເກີດຂື້ນໃນລະຫັດເສັ້ນ, ມັນສາມາດຖືກແປໂດຍລະບົບແລະເຮັດໃຫ້ເກີດຄວາມຜິດພາດຕ່າງໆທີ່ຍາກທີ່ຈະຕິດຕາມ. ກົງກັນຂ້າມ, ໂປແກຼມ OOP ທີ່ມີວິທີການແລະຂໍ້ມູນແຍກຕ່າງຫາກແມ່ນບໍ່ມີຄວາມສ່ຽງຕໍ່ຄວາມຜິດພາດທີ່ເພີ່ມຂື້ນດັ່ງກ່າວ. ພາສາ OOP ທີ່ໄດ້ຮັບຄວາມນິຍົມປະກອບມີ Java, ຄອບຄົວພາສາ C, ຮ້ານ VB.NET ແລະ Python. ອັນທີ່ເອີ້ນວ່າພາສາ OOP“ ບໍລິສຸດ” ເຫຼົ່ານີ້ລວມມີ Scala, Ruby, Eiffel, JADE, Smalltalk ແລະ Emerald.

ແຫຼ່ງຂອງ ຄຳ ນິຍາມແມ່ນມາຈາກ What is Object Oriented Programming (OOP)? - ນິຍາມຈາກ Techopedia ແລະພາສາລະບຽບການແມ່ນຫຍັງ? - ຄໍານິຍາມຂອງ Techopedia

ດຽວນີ້. ຂໍໃຫ້ພິຈາລະນາຄວາມແຕກຕ່າງໃນການຈັດຕັ້ງປະຕິບັດ.

ພວກເຮົາຈະເລີ່ມຕົ້ນກັບຂະບວນການ, ແລະວິທີທີ່ງ່າຍທີ່ສຸດໃນການເຮັດສິ່ງນີ້ແມ່ນການໃຊ້ພາສາ C ໂດຍສະເພາະ ສຳ ລັບ Arduino, ດັ່ງທີ່ຂ້ອຍຮູ້ແລ້ວ.

ຂ້ອຍໄດ້ເລືອກເອົາການສອນແບບກະພິບເພາະມັນແມ່ນ ໜຶ່ງ ໃນການຈັດຕັ້ງປະຕິບັດຂັ້ນພື້ນຖານ.

// ໜ້າ ທີ່ການຕັ້ງຄ່າຈະຖືກປະຕິບັດ ໜຶ່ງ ຄັ້ງເມື່ອທ່ານກົດປຸ່ມຕັ້ງຄ່າ ໃໝ່ ຫຼືເຮັດໃຫ້ບັດບໍ່ເຮັດວຽກ. void setup () {// ເລີ່ມຕົ້ນ pin ດິຈິຕອນ LED_BUILTIN ເປັນຜົນຜະລິດ. pinMode (LED_BUILTIN, OUTPUT); } // ໜ້າ ທີ່ loop ເຮັດວຽກອີກຄັ້ງແລະອີກເທື່ອ ໜຶ່ງ ຕະຫຼອດໄປ loop loop () {digitalWrite (LED_BUILTIN, HIGH); // ເປີດໄຟ LED (HIGH ແມ່ນລະດັບແຮງດັນໄຟຟ້າ) ຄວາມຊັກຊ້າ (1000); // ລໍຖ້າ digitalWrite ທີສອງ (LED_BUILTIN, LOW); // ປິດໄຟ LED ໂດຍການເລື່ອນກະແສໄຟຟ້າໃຫ້ LOW (1000). // ລໍຖ້າວິນາທີ}

ຕອນນີ້ໃຫ້ຂ້ອຍອະທິບາຍລະຫັດດີກ່ວານີ້. ພວກເຂົາມີສອງ ໜ້າ ທີ່, ການຕັ້ງຄ່າແລະວົງຈອນ. loop ເອີ້ນວ່າຊ້ ຳ ຊ້ ຳ ແລະການຕັ້ງຄ່າເອີ້ນພຽງຄັ້ງດຽວ. ທ່ານສົ່ງ ຄຳ ສັ່ງ digitalWrite ໃສ່ໄຟ LED ເພື່ອ ກຳ ນົດ ອຳ ນາດນາມໃຫ້ສູງຫລືຕ່ ຳ. ຄວາມຊັກຊ້າສະແດງເຖິງຄວາມຍາວຂອງແສງສະຫວ່າງຢູ່ໃນຫລືປິດ, ໃນກໍລະນີນີ້ 1000 ms ຫຼືປະມານ 1 ວິນາທີ. ຂ້ອນຂ້າງງ່າຍດາຍ, ແຕ່ສິ່ງນັ້ນສະແດງໃຫ້ເຫັນວ່າທ່ານຮູ້ພື້ນຖານຂອງການຂຽນໂປແກຼມຂັ້ນຕອນ. ທ່ານຂຽນຂັ້ນຕອນຫລື ຄຳ ແນະ ນຳ ແລະສິ່ງນີ້ຖືກເຮັດຊ້ ຳ ຈົນກວ່າມັນສິ້ນສຸດລົງ. ບໍ່ມີຄວາມສັບສົນເພີ່ມເຕີມຂອງລະຫັດທີ່ຕ້ອງການ.

C # ແລະ OOP ເວລາຕົວຢ່າງ.

ການ ນຳ ໃຊ້ລະບົບ; ການນໍາໃຊ້ System.Collections.Generic; ການນໍາໃຊ້ System.Linq; ການນໍາໃຊ້ System.Text; Namespace oops {ລູກຄ້າຊັ້ນສາທາລະນະ {// ຕົວປ່ຽນສະມາຊິກຂອງສາທາລະນະ CustID; ຊື່ສາທາລະນະ; ທີ່ຢູ່ສະຕິງສາທາລະນະ; // ຜູ້ກໍ່ສ້າງ ສຳ ລັບລູກຄ້າໃນເຂດເລີ່ມຕົ້ນ () {CustID = 1101; ຊື່ = "ທອມ"; ທີ່ຢູ່ = "USA"; } // ວິທີການ ສຳ ລັບການສະແດງບັນທຶກຂອງລູກຄ້າ (ການ ທຳ ງານ) ສາທາລະນະ void displayData () {Console.WriteLine ("Customer =" + CustID); Console.WriteLine ("ຊື່ =" + ຊື່); Console.WriteLine ("ທີ່ຢູ່ =" + ທີ່ຢູ່); } // ລະຫັດ ສຳ ລັບຈຸດເຂົ້າ}} ໂປແກມຊັ້ນຮຽນ {static void main (ຊ່ອຍແນ່ [] ໂຕ້ຖຽງ) {// object instantiation ລູກຄ້າ obj = ລູກຄ້າ ໃໝ່ (); // ວິທີການທີ່ເອີ້ນວ່າ obj.displayData (); // ທົ່ງນາທີ່ເອີ້ນວ່າ Console.WriteLine (obj.CustID); Console.WriteLine (obj.Name); Console.WriteLine (obj.Address); }}}

ນີ້ແມ່ນຕົວຢ່າງແບບເກົ່າຂອງ OOP. ທ່ານມີຊັ້ນລູກຄ້າທີ່ ກຳ ນົດວັດຖຸທັງ ໝົດ ທີ່ມີໃຫ້ທ່ານ. ທ່ານຍັງມີ ໜ້າ ທີ່ / ວິທີການໃນການຂຽນ. ຄວາມແຕກຕ່າງຕົ້ນຕໍ, ຢ່າງໃດກໍ່ຕາມ, ທ່ານຕ້ອງການແຍກແຕ່ລະວິທີການ / ໜ້າ ທີ່ຕາມ ໜ້າ ວຽກຂອງມັນ. ຈາກນັ້ນ, ວິທີການຕົ້ນຕໍຂອງທ່ານແມ່ນຈຸດເຂົ້າຂອງໂປແກມແລະຄວນມີລະຫັດ ສຳ ຄັນຂອງທ່ານຢູ່ນີ້.


ຕອບ 2:

ແນວຄວາມຄິດ OOPS ໃນ Java

ພາສາລະບຽບການແມ່ນອີງໃສ່ ໜ້າ ທີ່, ແຕ່ພາສາທີ່ແນໃສ່ວັດຖຸແມ່ນອີງໃສ່ວັດຖຸທີ່ແທ້ຈິງ. ພາສາລະບຽບການເຮັດໃຫ້ມີຄວາມ ໝາຍ ຕໍ່ ຄຳ ສັ່ງທີ່ ໜ້າ ທີ່ໄດ້ປະຕິບັດ, ແຕ່ພາສາທີ່ແນໃສ່ວັດຖຸເຮັດໃຫ້ມີຄວາມ ໝາຍ ຕໍ່ລັດແລະພຶດຕິ ກຳ ຂອງວັດຖຸ. ພາສາລະບຽບການເຮັດໃຫ້ຂໍ້ມູນສາມາດໃຊ້ໄດ້ກັບໂປແກຼມທັງ ໝົດ. ເຖິງຢ່າງໃດກໍ່ຕາມ, ພາສາທີ່ເນັ້ນໃສ່ວັດຖຸປະຕິບັດຕາມຮູບແບບການຂຽນໂປຼແກຼມຕັ້ງແຕ່ເທິງຫາລຸ່ມ, ແຕ່ພາສາທີ່ເນັ້ນໃສ່ວັດຖຸປະຕິບັດຕາມຮູບແບບການຂຽນໂປຼແກຼມຕັ້ງແຕ່ລຸ່ມຫາເທິງ. ພາສາລະບຽບການແມ່ນສັບສົນໃນ ທຳ ມະຊາດ, ເຮັດໃຫ້ມັນມີຄວາມຫຍຸ້ງຍາກໃນການດັດແປງ, ຂະຫຍາຍແລະຮັກສາ, ແຕ່ພາສາທີ່ເນັ້ນໃສ່ວັດຖຸແມ່ນມີຄວາມສັບສົນ ໜ້ອຍ. ພາສາລະບຽບການມີວິທີການ ໜ້ອຍ ໃນການ ນຳ ໃຊ້ລະຫັດ, ແຕ່ພາສາທີ່ແນໃສ່ວັດຖຸມີຫລາຍວິທີໃນການ ນຳ ໃຊ້ລະຫັດ.


ຕອບ 3:

ການຂຽນໂປແກຼມຂັ້ນຕອນແມ່ນການຂຽນໂປແກຼມທີ່ມີຂັ້ນຕອນຕ່າງໆເປັນກົນໄກການລົບກວນຂັ້ນຕົ້ນ. Huh.

ຂັ້ນຕອນແມ່ນຫຍັງ? ມັນແມ່ນລະຫັດທີ່ມີຊື່ທີ່ສາມາດເອີ້ນໂດຍຊື່ແລະໄດ້ຮັບຄຸນຄ່າແລະການອ້າງອີງຈາກສະພາບການທີ່ມັນຖືກເອີ້ນວ່າ, ຕົວກໍານົດການ, ແລະຫຼັງຈາກການເຮັດວຽກບາງຢ່າງອາດຈະກັບຄືນຄ່າແລະການອ້າງອີງໃສ່ສະພາບການນັ້ນ.

ມູນຄ່າທີ່ແນ່ນອນມັກຈະຖືກມອບໃຫ້ເປັນມູນຄ່າຜົນຕອບແທນພາຍໃນຂັ້ນຕອນ. ໃນພາສາທີ່ສະ ໜັບ ສະ ໜູນ ຂັ້ນຕອນ, ພວກມັນມັກຖືກ ນຳ ໃຊ້ຄືກັບວ່າມັນເປັນ ໜ້າ ທີ່, ໂດຍມີພາລາມິເຕີຕ່າງໆທີ່ຖືວ່າເປັນການໂຕ້ຖຽງແລະມູນຄ່າການກັບຄືນພາຍໃນຂັ້ນຕອນຄິດໄລ່ເປັນຄ່າຂອງ ໜ້າ ທີ່ ສຳ ລັບການໂຕ້ຖຽງເຫຼົ່ານັ້ນ. ເຖິງຢ່າງໃດກໍ່ຕາມ, ມັນຍັງເປັນ idiomatic ຖ້າຂັ້ນຕອນສົ່ງຄືນ ໜຶ່ງ ຫຼືຫຼາຍມູນຄ່າຜ່ານພາລາມິເຕີໃນສະພາບການໂທຂອງພວກເຂົາ, ບໍ່ວ່າຈະເປັນພາລາມິເຕີ "ພາສາ" ຖ້າພາສານັ້ນສະ ໜັບ ສະ ໜູນ ມັນຫຼືໂດຍການປ່ຽນແປງຄ່າທີ່ສົ່ງຜ່ານການອ້າງອີງ, ແລະມູນຄ່າການສົ່ງຄືນເອງ ທຸງ, ສະຖານະພາບຫລືການສະແດງຂໍ້ຜິດພາດແມ່ນຖືກໃຊ້. ໃນວັດທະນະ ທຳ ການຂຽນໂປແກຼມທີ່ໄດ້ຮັບຜົນກະທົບຢ່າງ ໜັກ ຈາກ Unix, 0 ມັກຈະກັບມາສະແດງຜົນ ສຳ ເລັດ (ຫຼືຢ່າງ ໜ້ອຍ ກໍ່ບໍ່ມີຂໍ້ບົກພ່ອງທີ່ຮູ້ຈັກ) ແລະຕົວເລກລົບເພື່ອສະແດງຮູບແບບການລົ້ມເຫຼວທີ່ຮູ້.

ມັນບໍ່ ຈຳ ເປັນຢ່າງເຂັ້ມງວດ ສຳ ລັບຮູບແບບ, ແຕ່ຂ້ອຍບໍ່ສາມາດຈິນຕະນາການພາສາທີ່ ນຳ ໃຊ້ຂັ້ນຕອນຕ່າງໆເປັນກົນໄກການລົບກວນ ສຳ ຄັນ, ບໍ່ມີກະແສຄວບຄຸມ, ເຊິ່ງໃຊ້ວິທີການແບບເຄິ່ງມະຫັດສະຈັນທີ່ຄ້າຍຄືກັນກັບ:

ຖ້າ (ເງື່ອນໄຂ) {doThisThing ()} ອີກ {doThatThing ()}

ແລະ

ໃນຂະນະທີ່ (ເງື່ອນໄຂ) {keepOnDoingThisThing ()}

ຂ້ອຍຄິດໃນໃຈຂອງນັກຂຽນໂປແກຼມສ່ວນຫຼາຍ, ການຂຽນໂປແກຼມ "ຂັ້ນຕອນ" ແມ່ນມີສ່ວນກ່ຽວຂ້ອງຫຼາຍກັບ "ການຂຽນໂປແກຼມທີ່ມີໂຄງສ້າງ". ກັບມາເມື່ອການຂຽນໂປແກຼມທີ່ມີໂຄງສ້າງ ໃໝ່, ມັນໄດ້ຖືກຄົ້ນພົບວ່າມີຕົວຈິງຂອງການຄວບຄຸມກະແສການຄວບຄຸມເຊິ່ງຮູບແບບກະແສການຄວບຄຸມທີ່ຕ້ອງການສາມາດສ້າງໄດ້ພາຍໃນຂັ້ນຕອນ:

ເລືອກທາງເລືອກອື່ນ

  • ຖ້າຈາກນັ້ນຖ້າບໍ່ດັ່ງນັ້ນ (ສອງທາງເລືອກໂດຍອີງໃສ່ຄ່າ Boolean) ກໍລະນີຫຼືປ່ຽນ (ມີຫລາຍທາງເລືອກໂດຍອີງໃສ່ ຈຳ ນວນເງິນໃດກໍ່ຕາມ)

ການຄ້າງຫ້ອງ

ມີຂອບເຂດຈໍາກັດທີ່ຮູ້ຈັກ:

  • ສຳ ລັບວົງແຫວນ (ໂດຍປົກກະຕິແລ້ວ ຈຳ ນວນທີ່ແນ່ນອນຂອງມັນ) ເຮັດໃຫ້ສາຍແອວຂື້ນມາ (ສ່ວນຫຼາຍແມ່ນເທົ່າກັບຂະ ໜາດ ຂອງການລວບລວມ, ອາດຈະເປັນໄປຕາມສະມາຊິກເອງ)

ມີຂອບເຂດ ຈຳ ກັດການໂຄສະນາ:

  • ໃນຂະນະທີ່ເຮັດ (0 ຫຼືຫຼາຍກວ່າ iterations) ເຮັດໃນຂະນະທີ່ (1 ຫຼືຫຼາຍກວ່າ iterations)

ແລະຄົນທີ່ບໍ່ນິຍົມໃຊ້:

  • ອອກໃນເວລາທີ່ loop

ນີ້ເຮັດວຽກລະຫັດຢ່າງ ໜ້ອຍ ໜຶ່ງ ຄັ້ງກ່ອນທີ່ຈະອອກແລະລະຫັດເລກສູນຫຼືຫຼາຍກວ່ານັ້ນຫຼັງຈາກທີ່ອອກ.

ໂຄງສ້າງເຫຼົ່ານີ້ສາມາດຈັດຕັ້ງປະຕິບັດໄດ້ເຊິ່ງພົວພັນກັບກັນແລະກັນ, ແຕ່ນີ້ແມ່ນເລື່ອງຍາກທີ່ ໜ້າ ປະຫລາດໃຈໃນບາງກໍລະນີ. ບັນດາ ຄຳ ເວົ້າສະຫຼັບ / ກໍລະນີແມ່ນມີຄວາມຫຍຸ້ງຍາກຫຼາຍທີ່ຈະເຮັດຕາມຕົວຢ່າງຂອງເຕົ້າໂຮມ. ເພື່ອຈຸດປະສົງຂອງພວກເຮົາ, ມັນເປັນສິ່ງ ສຳ ຄັນທີ່ພວກເຂົາເກືອບຈະຖືກລວມເຂົ້າໃນການຈັດຕັ້ງປະຕິບັດພາສາແລະສາມາດເຮັດສິ່ງຕ່າງໆທີ່ທ່ານ, ເປັນນັກຂຽນໂປແກຼມທີ່ເຮັດວຽກ, ມີຄວາມຫຍຸ້ງຍາກໃນການຂຽນລະຫັດ. ໃນພາສາລະບຽບການທີ່ບໍລິສຸດຫຼືຕົ້ນຕໍທີ່ຂ້ອຍສາມາດຈິນຕະນາການໄດ້, ມັນຈະເປັນການຍາກຫຼາຍແລະໃນຫຼາຍໆກໍລະນີທີ່ເປັນໄປບໍ່ໄດ້ແທ້ໆທີ່ຈະຂຽນໂຄງສ້າງຄວບຄຸມຂອງທ່ານເອງທີ່ເຮັດວຽກຄືກັນກັບສິ່ງທີ່ສ້າງມາ. ດັ່ງນັ້ນທ່ານໃຊ້ສິ່ງທີ່ສ້າງຢູ່. ຂັ້ນຕອນການຂຽນໂປແກຼມທີ່ມີໂຄງສ້າງແມ່ນໂລກ ຈຳ ກັດຫຼາຍ.

ຕາມກົດລະບຽບ, ພາສາການຂຽນໂປແກຼມດ້ານລະບຽບການຍັງມີປະເພດແນວຄວາມຄິດແບບໂມດູນ, ຊື່ພາຊະນະ ສຳ ລັບຂັ້ນຕອນຕ່າງໆ. ບາງຂັ້ນຕອນເຫຼົ່ານີ້ແມ່ນສາມາດເບິ່ງເຫັນໄດ້ແລະສາມາດໃຊ້ໄດ້ຢູ່ນອກໂມດູນ, ສ່ວນອື່ນໆແມ່ນສາມາດເບິ່ງເຫັນໄດ້ແລະສາມາດໃຊ້ໄດ້ພາຍໃນໂມດູນ, ໝາຍ ຄວາມວ່າຜ່ານຂັ້ນຕອນອື່ນໆກໍ່ຢູ່ໃນໂມດູນດຽວກັນ. ໃນພາສາສ່ວນໃຫຍ່ທີ່ມີໂມດູນ, ໂມດູນຍັງສາມາດມີຕົວແປທີ່ສາມາດເບິ່ງເຫັນແລະແບ່ງປັນໂດຍຂັ້ນຕອນທີ່ໄດ້ ກຳ ນົດໄວ້ໃນໂມດູນ. ເຖິງແມ່ນວ່າ C ສາມາດເຮັດໄດ້ເຊັ່ນນັ້ນ. ລະບົບໂມດູນດັ່ງກ່າວຊ່ວຍໃຫ້ລະດັບ encapsulation ແລະເຊື່ອງຂໍ້ມູນບາງຢ່າງ: ຂັ້ນຕອນແລະຕົວແປເຫຼົ່ານີ້ຢູ່ພາຍໃນໂມດູນ, ເຊິ່ງຊ່ວຍໃຫ້ການຈັດຕັ້ງປະຕິບັດຂັ້ນຕອນທີ່ສາມາດເຫັນໄດ້ຢູ່ນອກໂມດູນ, ສາມາດຊ່ວຍໃນການສົມທົບກັນໃນທົ່ວໂຄງສ້າງຂອງລະບົບ ການຄວບຄຸມ. ເຊິ່ງງາມ.

ຖ້າທ່ານກ້າວໄປອີກບາດກ້າວ ໜຶ່ງ ແລະອະນຸຍາດໃຫ້ ນຳ ໃຊ້ຫລາຍໂມດູນດຽວກັນ, ໂດຍການ ນຳ ໃຊ້ແຕ່ລະຕົວມີຕົວແປ ສຳ ເນົາຂອງຕົວມັນເອງທີ່ ກຳ ນົດໄວ້ໃນໂມດູນ, ໂມດູນເບິ່ງຄືກັບວັດຖຸປະເພດເດີມ. ແລະຫຼັງຈາກນັ້ນຖ້າທ່ານສ້າງຕົວຢ່າງຂອງໂມດູນກັບຕົວແປຕ່າງໆເປັນສິ່ງຫຼັກແລະແບ່ງຂັ້ນຕອນລະຫວ່າງມັນເພື່ອໃຫ້ທ່ານມີພຽງແຕ່ ສຳ ເນົາດຽວເທົ່ານັ້ນ, ທ່ານກໍ່ໃກ້ຊິດກັບສິ່ງທີ່ C ++ ເຮັດ. ການຂຽນໂປແກຼມທີ່ມີໂຄງສ້າງທີ່ ເໝາະ ສົມ, ບໍ່ແມ່ນການຂຽນໂປຼແກຼມທີ່ມີຈຸດປະສົງ.

ການຂຽນໂປແກຼມທີ່ເນັ້ນໃສ່ວັດຖຸແມ່ນການຂຽນໂປແກຼມທີ່ມີວັດຖຸເປັນກົນໄກການບໍ່ເອົາໃຈໃສ່ຂັ້ນຕົ້ນ. Huh.

ວັດຖຸແມ່ນຫຍັງ? ມັນແມ່ນຫົວ ໜ່ວຍ ຄອມພິວເຕີ້ທີ່ມີອາຍຸຍືນທີ່ສາມາດຂໍໃຫ້ເຮັດບາງສິ່ງບາງຢ່າງໄດ້. ຕົວຢ່າງຕົວຢ່າງເດີມແລະຕົວຢ່າງຂອງການຂຽນໂປແກມທີ່ແນໃສ່ວັດຖຸແມ່ນ Smalltalk. ໃນ Smalltalk, ທຸກໆຄ່າແມ່ນວັດຖຸ (ຫລືຢ່າງ ໜ້ອຍ ຄຸນຄ່າທີ່ບໍ່ແມ່ນວັດຖຸມີລັກສະນະຄືກັບ). ການຄິດໄລ່ແມ່ນເຮັດໂດຍວັດຖຸທີ່ສົ່ງຂໍ້ຄວາມຫາກັນ. ການປະຕິບັດຂອງ Smalltalk ແຕກຕ່າງກັນເລັກນ້ອຍ, ແຕ່ນີ້ແມ່ນຄວາມຄິດທົ່ວໄປ:

ຈຸດປະສົງໃນຄວາມຊົງ ຈຳ. ເມື່ອວັດຖຸຕ້ອງການໃຫ້ວັດຖຸອື່ນເຮັດບາງສິ່ງບາງຢ່າງ, ມັນຈະສ້າງຂໍ້ຄວາມຮຽກຮ້ອງແລະສົ່ງມັນໄປທີ່ວັດຖຸປະສົງທີ່ຕ້ອງການ. ຂໍ້ຄວາມແມ່ນວັດຖຸ. ຈຸດປະສົງແມ່ນຮັບຜິດຊອບໃນການຮັກສາສະຖານະພາບ, ເຊັ່ນວ່າມັນມີຕົວແປ. ເຈົ້າຍັງບໍ່ໄດ້ແລ່ນລະຫັດໃດໆ. ເມື່ອວັດຖຸໃດ ໜຶ່ງ ໄດ້ຮັບຂໍ້ຄວາມ, ມັນສົ່ງຕໍ່ໄປຊັ້ນຮຽນຂອງມັນ. ຫ້ອງຮຽນແມ່ນວັດຖຸ. ຫ້ອງຮຽນມີ ໜ້າ ທີ່ຮັບຜິດຊອບໃນການສ້າງແລະຄຸ້ມຄອງວັດຖຸ, ພວກເຂົາບໍ່ແລ່ນລະຫັດ. ຫ້ອງຮຽນສົ່ງຕໍ່ຂໍ້ຄວາມຫາ metaclass. ຫ້ອງຮຽນ Meta ແມ່ນວັດຖຸ. ຫ້ອງຮຽນ Meta ແມ່ນຮັບຜິດຊອບໃນການຄຸ້ມຄອງວິທີການຕ່າງໆ. metaclass ກວດເບິ່ງວິທີການຕ່າງໆຂອງມັນແລະພົບວ່າເຄື່ອງທີ່ສອດຄ້ອງກັບຂໍ້ຄວາມ. ວິທີການແມ່ນວັດຖຸ. ຕາມວິທີທາງການ, ວັດຖຸຂໍ້ຄວາມໄດ້ຖືກຕົກແຕ່ງດ້ວຍຂໍ້ມູນເພີ່ມເຕີມຕ່າງໆ, ລວມທັງການອ້າງອິງເຖິງວັດຖຸທີ່ໄດ້ຮັບຂໍ້ຄວາມ. ວິທີການແມ່ນມີຄວາມຮັບຜິດຊອບໃນການປະຕິບັດລະຫັດໂດຍໃຊ້ຂໍ້ໂຕ້ຖຽງທັງ ໝົດ ທີ່ສົ່ງຜ່ານຂໍ້ຄວາມຕົ້ນສະບັບ. ວິທີການປະຕິບັດລະຫັດຂອງມັນໃນແງ່ຂອງວັດຖຸທີ່ໄດ້ຮັບຂໍ້ຄວາມ. ລະຫັດວິທີການແມ່ນພຽງແຕ່ສະຄິບທີ່ມີຂໍ້ຄວາມທີ່ຈະສ້າງແລະສົ່ງໄປຫາວັດຖຸອື່ນໆ. ຖ້າ metaclass ບໍ່ພົບວິທີການທີ່ກົງກັບຂໍ້ຄວາມ, metaclasses ຂອງຊັ້ນພໍ່ແມ່ຂອງຊັ້ນຂອງວັດຖຸຈະຖືກຄົ້ນຫາ. ອັນນີ້ເອີ້ນວ່າ "ມໍລະດົກ".

ມັນອາດຈະແມ່ນວ່າໃນການຈັດຕັ້ງປະຕິບັດ ໜຶ່ງ ຫຼືອີກວິທີ ໜຶ່ງ, ວິທີການບາງຢ່າງໄດ້ຖືກລວມເຂົ້າໃນການຈັດຕັ້ງປະຕິບັດດ້ວຍເຫດຜົນທີ່ມີປະສິດທິພາບ, ແຕ່ວ່າໃນຫຼັກການແລ້ວລະບົບການສົນທະນາຂະ ໜາດ ນ້ອຍທັງ ໝົດ ສາມາດເຮັດວຽກໄດ້ຄືກັນ.

ໃນ Smalltalk, ການຂຽນໂປແກຼມ ໝາຍ ເຖິງການລວມເອົາຂໍ້ຄວາມແບບອັກສອນທີ່ຖືກສົ່ງໄປໃນວິທີການຕ່າງໆແລະການສ້າງຊັ້ນຮຽນ ໃໝ່ (ດ້ວຍ metaclasses) ສຳ ລັບວິທີການໃນການ ດຳ ລົງຊີວິດ. ນີ້ໃຊ້ກັບການທຽບເທົ່າຂອງກະແສຄວບຄຸມລວມທັງສິ່ງອື່ນໆ.

ໃນພາສາທາງດ້ານລະບຽບການ, ທ່ານສາມາດ ດຳ ເນີນການ ສຳ ລັບສະມາຊິກຂອງການເກັບ ກຳ ຂໍ້ມູນໃດ ໜຶ່ງ ໂດຍໃຊ້ລະຫັດຄ້າຍຄືກັບ pseudocode ນີ້:

foreach (theThing ໃນການສະທ້ອນ) doThisActionOn (theThing)

ໃນບົດສົນທະນາເລັກໆນ້ອຍໆ, ອັກສອນທີ່ສອດຄ້ອງກັນໃນການສົ່ງຂໍ້ຄວາມສາມາດມີລັກສະນະດັ່ງນີ້:

aCollection ເຮັດ: [aThing | aThing takeThisAction].

ຕໍ່ໄປນີ້ takeThisAction ແມ່ນຂໍ້ຄວາມທີ່ຖືກສົ່ງໄປຫາທຸກໆຈຸດປະສົງທີ່ຫຍໍ້ທໍ້ໃນວົງໂຄຈອນ. (ໂດຍບັງເອີນ, ລະຫັດໃນວົງເລັບສີ່ຫລ່ຽມແມ່ນບລັອກທີ່ Smalltalk ເອີ້ນວ່າ Lambda. ມັນແມ່ນວັດຖຸ.) ຖ້າພວກເຮົາປຽບທຽບສອງຢ່າງນີ້, ພວກເຮົາເຫັນບາງລັກສະນະທີ່ ສຳ ຄັນຂອງການຂຽນໂປແກຼມແນໃສ່ວັດຖຸທີ່ກົງກັນຂ້າມກັບລະບຽບການ:

  • ໃນລະຫັດລະບຽບການ, ພວກເຮົາເລືອກວິທີທີ່ສະມາຊິກຂອງການເກັບ ກຳ ຄວນຜ່ານ, ແລະພວກເຮົາເລືອກກົນໄກໃນການ ນຳ ໃຊ້. ໃນລະຫັດທີ່ແນໃສ່ວັດຖຸ, ພວກເຮົາຂໍໃຫ້ການລວບລວມເພື່ອປະຕິບັດການລ້າໆ. ພວກເຮົາບໍ່ຮູ້ວ່າວິທີການນີ້ເຮັດໄດ້ແນວໃດ. ໃນລະຫັດຂັ້ນຕອນ, ລະຫັດການໂທຕ້ອງມີການເຂົ້າເຖິງຂັ້ນຕອນທີ່ມີຊື່ doThisActionOn, ໃນລະຫັດທີ່ແນໃສ່ວັດຖຸ takeThisAction ແມ່ນສັນຍາລັກເທົ່ານັ້ນ. ພວກເຮົາບໍ່ຮູ້ວ່າວັດຖຸສິ່ງຂອງໃນການເກັບ ກຳ ຈະຕີຄວາມ ໝາຍ ແນວໃດ.

ນີ້ແມ່ນເນື້ອໃນ ສຳ ຄັນຂອງການຂຽນໂປແກຼມທີ່ມີຈຸດປະສົງແລະໄດ້ຖືກອະທິບາຍວ່າ "ການຂຽນໂປແກຼມໂດຍການໂອນເງິນ". ໃນການຂຽນໂປແກຼມດ້ານລະບຽບການ, ໃນທາງກັບກັນ, ພວກເຮົາຕ້ອງລະບຸຢ່າງຊັດເຈນວ່າການຄິດໄລ່ແຕ່ລະຢ່າງເຮັດຫຍັງ.