หลังจากที่อธิบายเรื่อง Refactoring มาพอสมควรแล้ว
ซึ่งการ Refactoring ควรทำแบบค่อยเป็นค่อยไป แต่ทำบ่อยๆ
ถ้าเมื่อไรก็ตามที่ใช้เวลาในการ Refactoring นาน
แสดงว่า code ของคุณนั้นไม่เคยทำการ Refactoring หรือ Review อะไรเลย

ดังนั้นขอแนะนำให้ทำแบบเล็กๆ แต่บ่อยๆ
ตัวอย่างการ Refactoring แรกที่จะแนะนำก็คือ Overload constructor

ในบางครั้งเราอาจต้องการเปลี่ยนแปลงหรือเพิ่มวิธีการสร้าง object
ด้วยการเปลี่ยนแปลงที่ constructor ของการสร้างในปัจจุบัน
นั่นหมายความว่า คุณต้องไปทำการเปลี่ยนแปลง code ส่วนต่างๆ ที่เกี่ยวข้องด้วย เช่น

  • Class อื่นๆ ที่เรียกใช้งาน
  • Test ต่างๆ ที่ทำการทดสอบ class นี้

จะพบว่าเราต้องทำให้ทุกอย่างมันผ่านก่อน
เราจึงจะมั่นใจว่า สิ่งที่เราแก้ไขไปนั้นทำงานได้อย่างถูกต้อง
ในการแก้ไขลักษณะนี้ จะใช้เวลาในการแก้ไขนานมาก
แต่ก็ขึ้นอยู่กับความต้องการ

มาดูตัวอย่าง code กันดีกว่า

เริ่มต้นมี code ดังนี้

ต้องการทำการแก้ไข constructor ด้วยการเพิ่มจำนวน argument ไปอีก 1 ตัว
ซึ่งมีวิธีการต่างๆ ที่แตกต่างกัน ตามเป้าหมายในการสร้าง

แบบที่ 1 ทำการเพิ่ม argument ไปอีก 1 ตัวใน constructor เดิม

แบบที่ 2 ทำการสร้าง constructor พร้อมกับส่ง argument ใหม่เข้ามา
ก่อนที่จะไปทำการแก้ไข behavior ใหม่อีก ดังนี้

แบบที่ 3 ถ้าเราต้องการเก็บ constructor เดิมไว้ให้เป็นตัวหลัก
แล้ว argument ใหม่นั้นเป็น optional ไป สามารถทำได้ดังนี้

ลองดูว่าชอบแบบไหน และ แบบไหนมันตรงกับความต้องการมากที่สุด
ส่วนใหญ่ที่ผมมักใช้งาน จะเป็นแบบที่ 3 เนื่องจาก
ผมต้องการให้ code เดิมยังคง compile ผ่าน ในขณะที่แก้ไขและปรับปรุงโครงสร้าง code
เนื่องจากมันช่วยเพิ่มความมั่นใจในการทำงาน

ข้อคิดสะกิดใจ

เราจะไม่เก็บแนวทางการออกแบบเดิมไว้นานๆ นะครับ
เราต้องทำให้มั่นใจว่า code ของเราไปในทางใหม่ทั้งหมดโดยเร็วที่สุดเท่าที่จะเป็นไปได้
ไม่เช่นนั้นมันจะกลับมาทำร้ายคุณเอง รวมทั้งทีมของคุณ
เพราะว่า มันมีหลายเส้นทางเหลือเกิน ทำให้สับสนอย่างแรง
และสุดท้ายมันจะไม่มีใครกล้าเข้าไปแก้ไขนะครับ
ระวังไว้ด้วย …

เริ่มด้วยวิธีการง่ายๆ และ สม่ำเสมอครับ
จะได้ไม่ต้องไปใช้ท่ายาก …