วิธีปรับปรุงรหัสทับทิมของคุณอย่างมากด้วยหลักการ OOP พื้นฐาน

หลักการเชิงวัตถุที่สำคัญที่สุดสองประการคือการทำงานร่วมกันและการมีเพศสัมพันธ์

ความสามัคคี เป็นเรื่องเกี่ยวกับความสัมพันธ์ระหว่างเมธอดทั้งหมดภายในคลาส พวกเขาใช้ชุดตัวแปรและพารามิเตอร์ของอินสแตนซ์ชุดเดียวกันหรือไม่ ทั้งหมดทำงานร่วมกันเพื่อเป้าหมายเดียวกัน ? หรือทุกวิธีรู้สึกแยกจากกัน?

ข้อต่อ คือการพึ่งพาคลาสกับคลาสอื่นอย่างไร "ผูกเข้าด้วยกัน" กับส่วนที่เหลือของระบบอย่างไร และความสามารถของคลาสนี้ที่จะใช้แยกกัน

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

เพื่อผลลัพธ์ที่ดีที่สุด คุณต้องการมุ่งสู่ความสามัคคีสูง &ข้อต่อต่ำ .

ตัวอย่างความสามัคคี

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

คุณสามารถสัมผัสได้ แต่มันยากที่จะวัด คุณไม่สามารถหาตัวเลขที่บอกคุณได้ว่าชั้นเรียนของคุณเหนียวแน่นแค่ไหน เพื่อให้ เข้าใจง่าย ฉันต้องการแสดงตัวอย่างโค้ดที่เห็นได้ชัดเจน

ไปเลย:

class Library
  def lend_book
  end

  def return_book
  end

  def make_coffee
  end
end

ในตัวอย่างนี้ make_coffee มีความโดดเด่นไม่น้อย แม้ว่าห้องสมุดนี้จะมีโรงอาหาร แต่ก็ไม่สมเหตุสมผลสำหรับ Library คลาสเรียนชงกาแฟ 🙂

โรงอาหารไม่ต้องการข้อมูลใดๆ เกี่ยวกับหนังสือที่มีอยู่ วิธีการให้ยืมหนังสือ ฯลฯ

และห้องสมุดก็ไม่จำเป็นต้องรู้ว่ากาแฟเหลือเท่าไหร่หรือทำอย่างไร

นั่นคือสิ่งที่เราหมายถึงการทำงานร่วมกันในระดับต่ำ

แน่นอน :

มันไม่ได้ชัดเจนเสมอไป บางครั้งคุณต้องให้ความสนใจ และมองข้ามชื่อเมธอด

• วิธีการเหล่านี้กำลังทำอะไรอยู่
• ใช้ข้อมูลอะไร
• วัตถุอะไรที่ทำงานร่วมกัน?

คำถามเหล่านี้ควรให้แนวคิดเกี่ยวกับระดับการทำงานร่วมกันในชั้นเรียนของคุณ

คุณแก้ไขการเกาะติดกันต่ำได้อย่างไร

คุณจะต้องแยกเมธอดที่ไม่ได้อยู่ในคลาสนี้ไปใช้กับคลาสอื่น ซึ่งมักจะเป็นเมธอดใหม่

ตัวอย่างการเชื่อมต่อ

มาดูข้อต่อกัน

นี่คือตัวอย่าง :

class ShoppingCart
  attr_accessor :items

  def initialize
    @items = []
  end
end

class Order
  def process_order(cart)
    cart.items.map(&:price).inject(:+)
  end
end

ในตัวอย่างนี้ Order ควบคู่ไปกับ ShoppingCart เพราะมันรู้เรื่องมากไป มันรู้ว่ามี items ตัวแปร &มันกำลังคำนวณอยู่บ้าง

ตอนนี้ถ้าคุณเปลี่ยน ShoppingCart การใช้งาน items คุณจะต้องเปลี่ยน Order . ด้วย .

ไม่ดี!

เราแก้ไขได้แบบนี้ :

class ShoppingCart
  attr_accessor :items

  def initialize
    @items = []
  end

  def calculate_total
    items.map(&:price).inject(:+)
  end
end

class Order
  def process_order(cart)
    cart.calculate_total
  end
end

เรามี ลดข้อต่อ โดยย้ายรายละเอียดการคำนวณไปไว้ที่ใด

หากคุณต้องการคำเปรียบเทียบสำหรับสิ่งนี้ ลองนึกถึงโทรศัพท์มือถือที่มาพร้อมกับแบตเตอรี่แบบคงที่ นั่นคือข้อต่อสูง .

หากคุณเปลี่ยนแบตเตอรี่ได้ แสดงว่าข้อต่อต่ำ .

สังเกตว่าคุณยังต้องการการเชื่อมต่อในระดับหนึ่ง โทรศัพท์จะไม่ทำงานหากไม่มีแบตเตอรี่ &Order คลาสจะไม่ทำงานโดยไม่รู้ว่าจะเรียกเก็บเงินจากลูกค้าเป็นจำนวนเท่าใด

สรุป

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

คุณสามารถใช้สิ่งนี้กับหนึ่งในโครงการของคุณ เปิดมันขึ้นมา &ดูบางชั้นเรียนของคุณ . คุณจะปรับปรุงพวกเขาโดยใช้สิ่งที่คุณเพิ่งเรียนรู้ได้อย่างไร

ขอบคุณที่อ่าน! อย่าลืม แชร์ &สมัครรับจดหมายข่าวถ้าคุณยังไม่ได้ 🙂