ความแตกต่างระหว่างการทำงานร่วมกันและการมีเพศสัมพันธ์คืออะไร?

การมีเพศสัมพันธ์และการทำงานร่วมกันนำไปสู่การออกแบบซอฟต์แวร์ที่ดีหรือไม่ดีได้อย่างไร

มีตัวอย่างอะไรบ้างที่แสดงความแตกต่างระหว่างทั้งสองและผลกระทบที่มีต่อคุณภาพรหัสโดยรวม

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

ตัวอย่างการทำงานร่วมกันต่ำ:

-------------------
| Staff           |
-------------------
| checkEmail()    |
| sendEmail()     |
| emailValidate() |
| PrintLetter()   |
-------------------

ตัวอย่างการทำงานร่วมกันสูง

----------------------------
| Staff                   |
----------------------------
| -salary                 |
| -emailAddr              |
----------------------------
| setSalary(newSalary)    |
| getSalary()             |
| setEmailAddr(newEmail)  |
| getEmailAddr()          |
----------------------------

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

การออกแบบซอฟต์แวร์ที่ดีมีการทำงานร่วมกันในระดับสูงและการมีเพศสัมพันธ์ต่ำ

การเชื่อมต่อกันเป็นตัวบ่งชี้ความสัมพันธ์ภายในโมดูล

การแต่งงานกันเป็นการบ่งบอกความสัมพันธ์ระหว่างโมดูล

การติดต่อกัน

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

การมีเพศสัมพันธ์

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

ตรวจสอบลิงค์นี้

การรวมกันสูงภายในโมดูลและการมีเพศสัมพันธ์ต่ำระหว่างโมดูลมักจะถือเป็นที่เกี่ยวข้องกับคุณภาพสูงในภาษาการเขียนโปรแกรม OO

ตัวอย่างเช่นโค้ดภายในแต่ละคลาส Java ต้องมีการทำงานร่วมกันภายในสูง แต่จะต้องมีการเชื่อมโยงอย่างหลวม ๆ กับโค้ดในคลาส Java อื่น ๆ

บทที่ 3 ของการสร้างซอฟต์แวร์เชิงวัตถุของเมเยอร์ (รุ่นที่ 2)เป็นคำอธิบายที่ดีของปัญหาเหล่านี้

การทำงานร่วมกันเป็นตัวบ่งชี้ว่าเกี่ยวข้องและมุ่งเน้นความรับผิดชอบขององค์ประกอบซอฟต์แวร์อย่างไร

การมีเพศสัมพันธ์หมายถึงองค์ประกอบของซอฟต์แวร์ที่เชื่อมต่อกับองค์ประกอบอื่น ๆ อย่างยิ่ง

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

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

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

1. รองรับการเชื่อมต่อ
2. ปล่อยการเชื่อมต่อ
3. รับสถิติเกี่ยวกับการเชื่อมต่อกับการนับการใช้งาน
4. รับสถิติเกี่ยวกับการเชื่อมต่อกับเวลา
5. จัดเก็บการดึงข้อมูลการเชื่อมต่อและปล่อยข้อมูลไปยังฐานข้อมูลเพื่อการรายงานในภายหลัง

ด้วยการทำงานร่วมกันในระดับต่ำเราสามารถออกแบบConnectionPoolคลาสโดยการบรรจุฟังก์ชันการทำงาน / ความรับผิดชอบทั้งหมดไว้ในระดับเดียวดังด้านล่าง เราจะเห็นได้ว่าคลาสเดี่ยวนี้มีหน้าที่ในการจัดการการเชื่อมต่อการโต้ตอบกับฐานข้อมูลรวมถึงการรักษาสถิติการเชื่อมต่อ

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

เพื่อแสดงให้เห็นถึงการมีเพศสัมพันธ์ต่ำเราจะดำเนินการต่อด้วยConnectionPoolแผนภาพการทำงานร่วมกันสูงด้านบน ถ้าเราดูที่แผนภาพด้านบนถึงแม้ว่ามันจะรองรับการเชื่อมต่อที่สูง แต่ก็มีการเชื่อมConnectionPoolโยงกับConnectionStatisticsคลาสอย่างแน่นหนาและPersistentStoreมันจะโต้ตอบกับมันโดยตรง แทนที่จะลดการเชื่อมต่อเราสามารถแนะนำConnectionListenerอินเทอร์เฟซและให้ทั้งสองคลาสใช้อินเทอร์เฟซและให้พวกเขาลงทะเบียนกับConnectionPoolคลาส และConnectionPoolจะย้ำผ่านผู้ฟังเหล่านี้และแจ้งให้พวกเขาเชื่อมต่อรับและปล่อยกิจกรรมและช่วยให้มีเพศสัมพันธ์น้อยลง

หมายเหตุ / คำหรือข้อควรระวัง:สำหรับสถานการณ์อย่างง่าย ๆ นี้มันอาจดูเหมือน overkill แต่ถ้าเราจินตนาการถึงสถานการณ์แบบเรียลไทม์ที่แอปพลิเคชันของเราต้องการโต้ตอบกับบริการของบุคคลที่สามหลายแห่งเพื่อทำธุรกรรมให้สมบูรณ์: เชื่อมโยงรหัสของเราโดยตรง จะหมายความว่าการเปลี่ยนแปลงใด ๆ ในบริการของบุคคลที่สามอาจส่งผลให้เกิดการเปลี่ยนแปลงรหัสของเราในหลาย ๆ สถานที่ แต่เราอาจมีFacadeการโต้ตอบกับบริการที่หลากหลายเหล่านี้ภายในและการเปลี่ยนแปลงใด ๆ ของบริการจะกลายเป็นท้องถิ่นFacadeและบังคับใช้การมีเพศสัมพันธ์ต่ำ บริการ

การทำงานร่วมกันที่เพิ่มขึ้นและการมีเพศสัมพันธ์ลดลงนำไปสู่การออกแบบซอฟต์แวร์ที่ดี

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

Decouplingช่วยให้คุณสามารถเปลี่ยนการใช้งานโดยไม่ส่งผลกระทบต่อส่วนอื่น ๆ ของซอฟต์แวร์ของคุณ

การทำงานร่วมกันทำให้มั่นใจได้ว่าการใช้งานเฉพาะเจาะจงกับฟังก์ชั่นและในเวลาเดียวกันก็ง่ายต่อการบำรุงรักษา

วิธีที่มีประสิทธิภาพมากที่สุดของการมีเพศสัมพันธ์ลดลงและเพิ่มการทำงานร่วมกันคือการออกแบบโดยอินเตอร์เฟซ

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

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

ตัวอย่าง (ร่างมาก):

public interface IStackoverFlowQuestion
      void SetAnswered(IUserProfile user);
      void VoteUp(IUserProfile user);
      void VoteDown(IUserProfile user);
}

public class NormalQuestion implements IStackoverflowQuestion {
      protected Integer vote_ = new Integer(0);
      protected IUserProfile user_ = null;
      protected IUserProfile answered_ = null;

      public void VoteUp(IUserProfile user) {
           vote_++;
           // code to ... add to user profile
      }

      public void VoteDown(IUserProfile user) {
          decrement and update profile
      }

      public SetAnswered(IUserProfile answer) {
           answered_ = answer
           // update u
      }
}

public class CommunityWikiQuestion implements IStackoverflowQuestion {
     public void VoteUp(IUserProfile user) { // do not update profile }
     public void VoteDown(IUserProfile user) { // do not update profile }
     public void SetAnswered(IUserProfile user) { // do not update profile }
}

ที่อื่นใน codebase ของคุณคุณสามารถมีโมดูลที่ประมวลผลคำถามโดยไม่คำนึงถึงสิ่งที่พวกเขา:

public class OtherModuleProcessor {
    public void Process(List<IStackoverflowQuestion> questions) {
       ... process each question.
    }
}

คำอธิบายที่ดีที่สุดของการทำงานร่วมกันมาจากรหัสสะอาดของลุงบ๊อบ:

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

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

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

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

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

ประเภทของรหัสจากการทำงานร่วมกันและมุมมองของการมีเพศสัมพันธ์:

อุดมคติคือรหัสที่เป็นไปตามแนวทาง มันเป็นคู่ที่หลวมและเหนียวแน่น เราสามารถแสดงรหัสดังกล่าวด้วยภาพนี้:

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

Decoupling แบบทำลายเป็นสิ่งที่น่าสนใจที่สุด บางครั้งมันเกิดขึ้นเมื่อโปรแกรมเมอร์พยายาม decouple ฐานรหัสมากจนรหัสนั้นสูญเสียการโฟกัส:

อ่านเพิ่มเติมได้ที่นี่

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

การมีเพศสัมพันธ์ด้วยคำพูดง่ายๆคือส่วนประกอบหนึ่งเท่าไหร่ (อีกครั้งลองนึกภาพชั้นเรียนถึงแม้ว่าจะไม่จำเป็น) จะรู้เกี่ยวกับผลงานภายในหรือองค์ประกอบภายในของอีกองค์ประกอบหนึ่งนั่นคือความรู้ที่มีอยู่ในองค์ประกอบอื่น ๆ

ฉันเขียนโพสต์บล็อกเกี่ยวกับเรื่องนี้ถ้าคุณต้องการอ่านรายละเอียดเพิ่มเติมเล็กน้อยพร้อมตัวอย่างและภาพวาด ฉันคิดว่ามันตอบคำถามส่วนใหญ่ของคุณ

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

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

การทำงานร่วมกัน (การทำงานร่วมกัน): Coซึ่งหมายถึงการร่วมกัน , hesionซึ่งหมายถึงการที่จะติด ระบบการรวมตัวกันของอนุภาคของสารต่าง ๆ

สำหรับตัวอย่างในชีวิตจริง: img มารยาท

ทั้งหมดมีค่ามากกว่าผลรวมของชิ้นส่วน -Aototle

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

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

ฉันคิดว่าความแตกต่างสามารถทำได้ดังนี้:

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

ในโพสต์บล็อกนี้ฉันเขียนเกี่ยวกับรายละเอียดเพิ่มเติม

การทำงานร่วมกันเป็นตัวบ่งชี้ความแข็งแรงของการทำงานสัมพัทธ์ของโมดูล

• โมดูลเหนียวทำหน้าที่เดียวที่ต้องมีการโต้ตอบเล็กน้อยกับส่วนประกอบอื่น ๆ ในส่วนอื่น ๆ ของโปรแกรม กล่าวอย่างง่าย ๆ ว่าโมดูลที่เหนียวควรทำในสิ่งเดียว

• view มุมมองทั่วไป:

  "ใจเดียว" ของโมดูล

• OOมุมมอง:

  การรวมตัวกันหมายถึงว่าส่วนประกอบหรือคลาสห่อหุ้มเฉพาะคุณสมบัติและการดำเนินการที่เกี่ยวข้องอย่างใกล้ชิดกับคนอื่นและกับชั้นเรียนหรือส่วนประกอบเอง

• ev ระดับการทำงานร่วมกัน

  Functional

  Layer

  Communicational

  Sequential

  Procedural

  Temporal

  utility

การแต่งงานกันเป็นการบ่งบอกถึงการพึ่งพาซึ่งกันและกันระหว่างโมดูล

• การเชื่อมต่อขึ้นอยู่กับความซับซ้อนของอินเตอร์เฟซระหว่างโมดูลจุดที่รายการหรือการอ้างอิงถูกสร้างขึ้นกับโมดูลและข้อมูลใดที่ผ่านข้ามอินเทอร์เฟซ

• มุมมองทั่วไป: ระดับที่ส่วนประกอบเชื่อมต่อกับส่วนประกอบอื่นและกับโลกภายนอก

• มุมมอง OO: การวัดเชิงคุณภาพของระดับที่เชื่อมต่อกับคลาส

• ระดับของการแต่งงาน

  Content

  Common

  Control

  Stamp

  Data

  การโทรประจำ

  use ประเภทการใช้งาน

  ข้อสรุปหรือการนำเข้า

  ภายนอก #

การเชื่อมต่อ = การโต้ตอบ / ความสัมพันธ์ระหว่างสองโมดูล ... การทำงาน ร่วมกัน = การทำงานร่วมกันระหว่างสององค์ประกอบภายในโมดูล

ซอฟต์แวร์ประกอบด้วยหลายโมดูล โมดูลประกอบด้วยองค์ประกอบ พิจารณาโมดูลเป็นโปรแกรม ฟังก์ชั่นภายในโปรแกรมเป็นองค์ประกอบ

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

ภายในโปรแกรมเดียวเอาต์พุตของฟังก์ชันจะถูกส่งไปยังฟังก์ชันอื่น สิ่งนี้เรียกว่าปฏิสัมพันธ์ขององค์ประกอบภายในโมดูล สิ่งนี้เรียกว่าเป็น Cohesion

ตัวอย่าง:

การมีเพศสัมพันธ์ = การสื่อสารระหว่าง 2 ครอบครัวที่แตกต่างกัน ... การ ติดต่อกัน = การสื่อสารระหว่างพ่อ - แม่ - ลูกภายในครอบครัว

พูดง่าย ๆ คือการรวมกันหมายความว่าคลาสควรเป็นตัวแทนของแนวคิดเดียว

อินเทอร์เฟซสาธารณะของคลาสจะเหนียวแน่นถ้าคุณลักษณะของคลาสทั้งหมดเกี่ยวข้องกับแนวคิดที่คลาสนั้นแสดง ตัวอย่างเช่นแทนที่จะมีคลาส CashRegister การมีคุณสมบัติการทำงานร่วมกันของ CashRegister และ Coin ทำให้แบ่งออกเป็น 2 คลาส - ระดับ CashRegister และ Coin

ในการแต่งงานกันชั้นหนึ่งขึ้นอยู่กับอีกชั้นหนึ่งเนื่องจากมันใช้วัตถุของชั้นเรียน

ปัญหาของการมีเพศสัมพันธ์สูงก็คือมันสามารถสร้างผลข้างเคียง การเปลี่ยนแปลงหนึ่งครั้งในคลาสหนึ่งอาจทำให้เกิดข้อผิดพลาดที่ไม่คาดคิดในคลาสอื่นและอาจทำให้รหัสทั้งหมดแตก

โดยทั่วไปการเชื่อมโยงที่สูงและการมีเพศสัมพันธ์ต่ำถือเป็น OOP ที่มีคุณภาพสูง

การรวมตัวกันของคำศัพท์นั้นเป็นสิ่งที่ค่อนข้างง่ายสำหรับความหมายในการออกแบบซอฟต์แวร์

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

บางทีเราอาจคิดแบบนี้ ส่วนหนึ่งมีการเกาะติดกันมากที่สุดเมื่อเป็นส่วนเดียว (ทำเพียงสิ่งเดียวและไม่สามารถแยกย่อยได้อีก) นี่คือสิ่งที่ต้องการในการออกแบบซอฟต์แวร์ การรวมตัวกันเป็นเพียงชื่ออื่นสำหรับ "ความรับผิดชอบเดี่ยว" หรือ "การแยกความกังวล"

คำว่าการมีเพศสัมพันธ์ในมือค่อนข้างใช้งานง่ายซึ่งหมายความว่าเมื่อโมดูลไม่ขึ้นอยู่กับโมดูลอื่น ๆ มากเกินไปและผู้ที่จะเชื่อมต่อกับสามารถเปลี่ยนได้อย่างง่ายดายเช่นการเชื่อฟังหลักการ Liskov เปลี่ยนตัว

ความแตกต่างของทฤษฎี

การติดต่อกัน

• การทำงานร่วมกันเป็นตัวบ่งชี้ความแข็งแรงการทำงานสัมพัทธ์ของโมดูล
• โมดูลเหนียวทำหน้าที่เดียวที่ต้องมีการโต้ตอบเล็กน้อยกับส่วนประกอบอื่น ๆ ในส่วนอื่น ๆ ของโปรแกรม
• โมดูลที่มีการเชื่อมต่อสูงและการเชื่อมต่อต่ำถูกกล่าวว่าเป็นหน้าที่อิสระของโมดูลอื่น ๆ

การจำแนกประเภทของการเกาะติดกัน

1. บังเอิญ 2. ตรรกะ 3. ชั่วคราว 4. กระบวนการ 5. การสื่อสาร 6. พิเศษ 7. ฟังก์ชั่น

การมีเพศสัมพันธ์

• การแต่งงานกันเป็นการบ่งบอกถึงการพึ่งพาซึ่งกันและกันระหว่างโมดูล
• ระดับของการเชื่อมต่อระหว่างสองโมดูลขึ้นอยู่กับความซับซ้อนของอินเตอร์เฟส