ລະຫັດ Smell 286 - ການທັບຊ້ອນວິທີການພໍ່ແມ່-ລູກ

ເມື່ອວິທີການຂອງພໍ່ແມ່ ແລະລູກຕຳກັນ!

TL;DR: ຫຼີກເວັ້ນການໃຊ້ວິທີການສ່ວນຕົວໃນຫ້ອງຮຽນພໍ່ແມ່ທີ່ມີຊື່ທີ່ຫ້ອງຮຽນເດັກນ້ອຍສາມາດໃຊ້.

ບັນຫາ

• ການລະເມີດຫຼັກການທີ່ແປກໃຈຫນ້ອຍທີ່ສຸດ
• ພຶດຕິກໍາທີ່ບໍ່ຄາດຄິດແລະ ຂໍ້ບົກພ່ອງ
• ການເພິ່ງພາອາໄສທີ່ເຊື່ອງໄວ້
• ການຂະຫຍາຍຈໍາກັດ
• ລະຫັດບໍ່ຊັດເຈນ
• ການລະເມີດຫຼັກການເປີດ / ປິດ
• ການອອກແບບທີ່ເຂົ້າໃຈຜິດ

ວິທີແກ້ໄຂ

1. ຫຼີກເວັ້ນ ການລໍາດັບຊັ້ນ
2. ປ່ຽນຊື່ວິທີການສ່ວນຕົວ
3. ຮັກສາຊື່ທີ່ຊັດເຈນ
4. ຫຼີກເວັ້ນການທັບຊ້ອນກັນ
5. ຫຼີກເວັ້ນການ ວິທີການປ້ອງກັນ
6. ການຈັດປະເພດຍ່ອຍສໍາລັບ ການພົວພັນທີ່ສໍາຄັນ , ບໍ່ໃຫ້ ໃຊ້ລະຫັດຄືນໃຫມ່

ບໍລິບົດ

ເມື່ອທ່ານໃຊ້ຊື່ວິທີການດຽວກັນໃນຊັ້ນຮຽນຂອງພໍ່ແມ່ແລະເດັກ, ທ່ານສ້າງຄວາມສັບສົນ.

ວິທີການສ່ວນຕົວໃນຫ້ອງຮຽນພໍ່ແມ່ບໍ່ສາມາດຖືກລົບລ້າງໄດ້ເຖິງແມ່ນວ່າວິທີການສາທາລະນະທີ່ມີຊື່ດຽວກັນຢູ່ໃນຊັ້ນຮຽນເດັກນ້ອຍ.

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

ລະຫັດຕົວຢ່າງ

ຜິດ

 <? class ParentClass { private function greet() { // This method is private return "Hello from ParentClass"; } public function callGreet() { return $this->greet(); } } class ChildClass extends ParentClass { public function greet() { // Overriding a concrete method is a code smell // Compilers SHOULD warn you return "Hello from ChildClass"; } } $child = new ChildClass(); echo $child->callGreet(); // When callGreet() is invoked on the $child object, // it executes the following: // It calls $this->greet(), // which refers to the greet() method of ParentClass // because the original method is private // and cannot be overridden or accessed from ChildClass. // The unexpected output is 'Hello from ParentClass'

ສິດ

 <? class ParentClass { protected function greet() { // notice the 'protected qualifier' return "Hello from ParentClass"; } public function callGreet() { return $this->greet(); } } class ChildClass extends ParentClass { public function greet() { return "Hello from ChildClass"; } } $child = new ChildClass(); echo $child->callGreet(); // The output is "Hello from ChildClass" // This is the standard (and wrong) solution // Also fixed by most AIs

 <? abstract class ParentClass { // Declare greet() as an abstract method // Following the template-method design pattern abstract protected function greet(); public function callGreet() { return $this->greet(); } } class ChildClass extends ParentClass { protected function greet() { return "Hello from ChildClass"; } } class OtherChild extends ParentClass { protected function greet() { return "Hello from OtherChild"; } } $child = new ChildClass(); echo $child->callGreet(); // Output: Hello from ChildClass $otherChild = new OtherChild(); echo $otherChild->callGreet(); // Output: Hello from OtherChild

ການກວດຫາ

• [x] ເຄິ່ງອັດຕະໂນມັດ

ທ່ານສາມາດກວດພົບກິ່ນນີ້ໂດຍການຊອກຫາວິທີການສ່ວນຕົວໃນຫ້ອງຮຽນພໍ່ແມ່ແລະກວດເບິ່ງວ່າຊັ້ນຮຽນຂອງເດັກກໍານົດວິທີການທີ່ມີຊື່ດຽວກັນ. ນອກນັ້ນທ່ານຍັງຕ້ອງທົດສອບວິທີການພໍ່ແມ່ໂທຫາວິທີການເອກະຊົນ.

ປ້າຍກຳກັບ

• ລຳດັບ

ລະດັບ

• [x] ລະດັບປານກາງ

ເປັນຫຍັງການປະທະກັນຈຶ່ງສຳຄັນ

ລະ​ຫັດ​ທີ່​ຈະ​ແຈ້ງ​ແລະ​ຄາດ​ຄະ​ເນ​ຄວນ​ຈະ​ສະ​ທ້ອນ​ໃຫ້​ເຫັນ​ລໍາ​ດັບ ​ຂອງ​ໂລກ​ທີ່​ແທ້​ຈິງ ​ຂອງ​ມັນ​ແບບ​ຈໍາ​ລອງ​.

ເມື່ອທ່ານໃຊ້ວິທີການສ່ວນຕົວທີ່ມີຊື່ທັບຊ້ອນກັນ, ທ່ານສ້າງຊ່ອງຫວ່າງ Bijection ລະຫວ່າງຕົວແບບແລະການຈັດຕັ້ງປະຕິບັດ.

ຊ່ອງຫວ່າງນີ້ເຮັດໃຫ້ນັກພັດທະນາສັບສົນ, ເພີ່ມຂໍ້ບົກພ່ອງ, ແລະລະເມີດຫຼັກການລະຫັດທີ່ສະອາດ.

ລຸ້ນ AI

ເຄື່ອງຜະລິດ AI ມັກຈະສ້າງກິ່ນຫອມນີ້ເມື່ອພວກເຂົາສ້າງຄວາມສໍາພັນລະຫວ່າງພໍ່ແມ່ກັບລູກຂອງ boilerplate.

ເຂົາເຈົ້າອາດຈະບໍ່ກວດສອບລະດັບການເຂົ້າເຖິງ ຫຼືພິຈາລະນາຜົນກະທົບຕໍ່ການສືບທອດ.

ການກວດຫາ AI

ເຄື່ອງມື AI ສາມາດແກ້ໄຂກິ່ນນີ້ໄດ້ດ້ວຍຄໍາແນະນໍາທີ່ຊັດເຈນ.

ທ່ານສາມາດຮ້ອງຂໍໃຫ້ AI ກວດເບິ່ງຊື່ວິທີການທັບຊ້ອນກັນແລະລໍາດັບຊັ້ນຂອງ refactor.

ລອງໃຊ້ພວກມັນ!

ຈືຂໍ້ມູນການ: ຜູ້ຊ່ວຍ AI ເຮັດຜິດພາດຫຼາຍ

ສະຫຼຸບ

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

ຫຼີກເວັ້ນການວິທີການສ່ວນຕົວທີ່ທັບຊ້ອນກັບວິທີການຂອງເດັກນ້ອຍ. ນີ້ເຮັດໃຫ້ລະຫັດຂອງທ່ານສາມາດອ່ານໄດ້, ສາມາດຂະຫຍາຍໄດ້, ແລະສອດຄ່ອງກັບຫຼັກການລະຫັດທີ່ສະອາດ.

ພາສາເຊັ່ນ Python ຊ່ວຍໃຫ້ທ່ານສາມາດລົບລ້າງວິທີການຂອງພໍ່ແມ່ໂດຍບໍ່ຄໍານຶງເຖິງຊື່ຂອງພວກເຂົາ, ໃນຂະນະທີ່ Java ບັງຄັບໃຊ້ລະດັບການເຂົ້າເຖິງຢ່າງເຂັ້ມງວດ.

C# ມີລັກສະນະຄ້າຍຄືກັນກັບ Java . ຄວາມແຕກຕ່າງເຫຼົ່ານີ້ຫມາຍຄວາມວ່າທ່ານຈໍາເປັນຕ້ອງເຂົ້າໃຈກົດລະບຽບສະເພາະຂອງພາສາທີ່ທ່ານກໍາລັງເຮັດວຽກກັບເພື່ອຫຼີກເວັ້ນການປະພຶດທີ່ບໍ່ຄາດຄິດ.

ການພົວພັນ

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxviii

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xii

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iii-t7h3zkv

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxv

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-viii-8mn3352

ການສືບທອດແມ່ນດີ, ແຕ່ທ່ານບໍ່ຄວນລືມວ່າມັນແນະນໍາການເຊື່ອມແຫນ້ນ.

Robert C. Martin