วันนี้คุณรู้จัก SOLID
หลักการออกแบบโปรแกรมเชิงวัตถุ ที่ดีหรือยัง ว่าเป็นยังไง?
.
SOLID เป็นหลักการออกแบบการเขียนโปรแกรมเชิงวัตถุที่ดี (Object Oriented Design) นำเสนอโดย Robert C. Martin (ลุง Bob. )
:
SOLID ไม่ได้หมายถึง “ของแข็ง”
แต่มันมาจากชื่อพยัญชนะแรกของ 5 คำต่อไปนี้
– Single-responsibility Principle
– Open-closed Principle
– Liskov substitution principle
– Interface segregation principle
– Dependency Inversion principle
:
รายละเอียดก็จะประมาณเนี่ย สรุปให้คร่าวๆ
? 1) Single-responsibility Principle
หลักการนี้ จะให้คลาส 1 อัน รับผิดชอบงานเดียว
ถ้าอนาคตจะมี change เกิดขึ้น
ก็เปลี่ยนเฉพาะงานนี้งานเดียว ที่คลาสนี้ที่เดียวเท่านั้น
จะไม่มีการ change มากกว่า 2 งานภายในคลาสเดียวกันประมาณเนี่ย
มิฉะนั้นจะตีกันตายได้
:
? 2) Open-closed Principle
หลักการนี้ อ็อบเจ็กต์ หรือพวก คลาส มอดูล ฟังก์ชั่น แพ็กเกจ ไลบรารี่
เมื่อสร้างแล้วก็ควรฟิกไว้ ไม่ควรแก้ไข (เพราะมันอาจเทสเรียบร้อยแล้ว)
ถ้ามี change เกิดขึ้นมา ก็ต้องเปิดโอกาสให้ขยายต่อเติมได้
โดยเราจะไม่ไปแตะต้องโค้ดที่เคยเขียนขึ้นมาเด็ดขาด
:
? 3) Liskov substitution principle
มันพัฒนามาจากหลักการข้อ 2 อีกที กล่าวคือ
คลาสแม่ควรจะฟิกไว้ ไม่ควรแก้ไข ไม่ควร change อีกแล้ว
(เพราะอาจเทสเรียบร้อย หรือออกแบบมาเรียบร้อย)
ถ้าจะ change ก็ให้ไปลงที่คลาสลูกเลย
โดยให้สร้างคลาสลูก ที่ขยายมาจากคลาสแม่อีกที
.
สำหรับหลักการข้อ 3 นี้ คลาสลูกจะสามารถเสียบแทนที่คลาสแม่ได้
โดยจะไม่ไปแก้ไขหน้าที่ (functionality) ของโค้ดหลักทั้งหมด
:
? 4) Interface segregation principle
การออกแบบ interface ที่ดี ควรมีเมธอดที่จำเป็นเท่านั้น
คลาสลูกที่มา implement ไม่ควรได้เมธอดที่ไม่จำเป็นเกินมา
.
กล่าวอีกนัยหนึ่งการออกแบบ interface ที่ดี
ไม่ควรให้ interface มันทำงานครอบจักราล
ไม่ต้องใจดี เผื่อเมธอดเกินมา
ให้มีพอเพียง พอดีกับคลาสลูกก็พอนะครัช
:
? 5) Dependency Inversion principle
หลักการนี้จะกล่าวถึง
– High level classess (อาจมองว่าเป็นมอดูลที่มีแต่ business logic ที่ซับซ้อนก็ได้)
– กับ Low Level Classes (อาจมองว่าเป็นมอดูลที่มีแต่ logic พื้นฐาน ทำงานระดับล่างๆ)
.
ซึ่ง class ทั้งสองระดับดังกล่าว
เวลาจะติดต่อกัน ก็ให้ทำผ่านทาง Abstraction Layer เท่านั้น
ไม่ควรติดต่อกันตรงๆ โต้งๆ
.
Abstraction Layer ก็คิดง่ายๆ
มันก็คือ Interface หรือ abstraction class นั่นแหละ
คือมีแต่รายละเอียดให้รู้เฉยๆ ยังไม่มีส่วน implements
เพราะเดียวจะมีคลาสมา implements แล้วมา plugin เสียบเข้าภายหลัง
.
..เขียนเป็นภาพก็ประมาณเนี่ย
High Level Classes –> Abstraction Layer –> Low Level Classes
:
++++++++
สำหรับคอนเซปต์ SOLID อาจยากต่อการเข้าใจนิดหนึ่งนะ
มันต้องเห็นโค้ดตัวอย่างด้วย
ยิ่งถ้าใครไม่เชียวชาญการเขียนโปรแกรมเชิงวัตถุ (Object Oriented programming)
หรือไม่ได้ลงมือเขียนจริงๆ จังเท่าไร
ก็อาจสงสัยมีมันทำไม?
.
แต่ทว่าการเขียนโปรแกรมเชิงวัตถุ ถ้าออกแบบไม่ดีนี้ ….บอกตรงๆ
..โค้ดจะเละ เทอะทะ ใหญ่โต
..อ่านโค้ดก็ยาก ย๊าก คลาสเยอะแยะมากมาย
.
ยังไงอ่านเพิ่มเติม ดูโค้ดตัวอย่างที่ออกแบบตามหลัก SOLID
ตามลิงค์นี้เขียนดี
https://www.oodesign.com/design-principles.html
https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design
.
? โชคดีทุกท่านครับ ไปแหละ
?เขียนโดยแอดมินโฮ โอน้อยออก
Please like Fanpage