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

อะไรคือความแตกต่างระหว่างความสัมพันธ์การรวมตัวและการแต่งเพลง? โปรดอธิบายในแง่ของการใช้งาน

สำหรับสองวัตถุFooและBarสามารถกำหนดความสัมพันธ์ได้

การเชื่อมโยง - ฉันมีความสัมพันธ์กับวัตถุ Fooการใช้งานBar

public class Foo { 
    void Baz(Bar bar) {
    } 
};

องค์ประกอบ - ฉันเป็นเจ้าของวัตถุและฉันต้องรับผิดชอบตลอดชีวิตของมัน เมื่อFooตายไปแล้วBar

public class Foo {
    private Bar bar = new Bar(); 
}

การรวมตัว - ฉันมีสิ่งของที่ฉันขอยืมมาจากคนอื่น เมื่อFooตายBarอาจมีชีวิตอยู่ต่อไป

public class Foo { 
    private Bar bar; 
    Foo(Bar bar) { 
       this.bar = bar; 
    }
}

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

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

การรวมและองค์ประกอบเป็นส่วนย่อยของสมาคมซึ่งหมายถึงพวกเขาเป็นกรณีเฉพาะของสมาคม

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

สับสน?

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

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

สรุปมันขึ้นมา -

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

รายละเอียดเพิ่มเติมที่นี่ ฉันเป็นผู้เขียนhttp://opensourceforgeeks.blogspot.inและได้เพิ่มลิงก์ด้านบนไปยังโพสต์ที่เกี่ยวข้องสำหรับบริบทเพิ่มเติม

สมาคมเป็นแนวคิดทั่วไปของความสัมพันธ์ มันมีทั้งองค์ประกอบและการรวมตัว

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

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

ทั้งแสดงถึงความสัมพันธ์ระหว่างวัตถุและแตกต่างกันเพียงในความแข็งแกร่งของพวกเขา

เคล็ดลับในการจดจำความแตกต่าง: มีA - A รวมและO wn - c O mpositoin

ตอนนี้ให้สังเกตภาพต่อไปนี้

การเปรียบเทียบ:

องค์ประกอบ : ภาพต่อไปนี้คือองค์ประกอบภาพเช่นการใช้ภาพแต่ละภาพทำให้เป็นภาพเดียว

การรวม : การเก็บภาพไว้ในที่เดียว

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

การอ้างอิง (การอ้างอิง)
หมายถึงไม่มีการเชื่อมโยงเชิงความคิดระหว่างวัตถุสองรายการ เช่น EnrollmentService การอ้างอิงวัตถุนักเรียนและหลักสูตรวัตถุ (เป็นพารามิเตอร์วิธีหรือประเภทผลตอบแทน)

public class EnrollmentService {
    public void enroll(Student s, Course c){}
}

การเชื่อมโยง (มี -a)
หมายความว่ามีการเชื่อมโยงระหว่างวัตถุเกือบทุกครั้ง (มีความเกี่ยวข้อง) วัตถุใบสั่งมีวัตถุลูกค้า

public class Order {
    private Customer customer
}

Aggregation (has-a + ทั้งส่วน)
ชนิดพิเศษของสมาคมที่มีความสัมพันธ์ทั้งส่วนระหว่างวัตถุสอง พวกเขาอาจมีชีวิตอยู่ได้โดยปราศจากกันและกัน

public class PlayList{
    private List<Song> songs;
}

หมายเหตุ:ส่วนที่ยากที่สุดคือการแยกความแตกต่างจากการรวมปกติ สุจริตฉันคิดว่านี่เปิดให้ตีความแตกต่างกัน

องค์ประกอบ (มี + ทั้งส่วน + กรรมสิทธิ์)
การรวมชนิดพิเศษ Apartmentประกอบด้วยบางRooms ไม่สามารถอยู่ได้โดยไม่ต้องRoom Apartmentเมื่อลบพาร์ทเมนต์ห้องที่เกี่ยวข้องทั้งหมดจะถูกลบเช่นกัน

public class Apartment{
    private Room bedroom;
    public Apartment() {
       bedroom = new Room();
    }
}

จากโพสต์โดยRobert Martin ใน comp.object :

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

//[Example:]

//|A|----------->|B|

class A
{
  private:
    B* itsB;
};

การรวม [... ] เป็นความสัมพันธ์ทั้งหมด / บางส่วนโดยทั่วไป นี่เป็นสิ่งเดียวกันกับการเชื่อมโยงกับข้อยกเว้นที่อินสแตนซ์ไม่สามารถมีความสัมพันธ์ในการรวมแบบวนซ้ำได้ (เช่นส่วนหนึ่งไม่สามารถมีทั้งหมดได้)

//[Example:]

//|Node|<>-------->|Node|

class Node
{
  private:
    vector<Node*> itsNodes;
};

ความจริงที่ว่านี่เป็นการรวมตัวหมายความว่าอินสแตนซ์ของโหนดไม่สามารถเกิดวงจรได้ ดังนั้นนี่คือ Tree of Nodes ไม่ใช่กราฟของ Node

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

//[Example:]

//|Car|<#>-------->|Carburetor|

class Car
{
  public:
    virtual ~Car() {delete itsCarb;}
  private:
    Carburetor* itsCarb
};

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

จากจุดการดำเนินงานในมุมมองของการรวมจะได้รับโดยมีสมาชิกชั้นเรียนโดยการอ้างอิง ตัวอย่างเช่นหากคลาส A รวมวัตถุของคลาส B คุณจะมีลักษณะดังนี้ (ใน C ++):

class A {
    B & element;
  // or B * element;
};

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

class A {
    B element;
};

ที่นี่เมื่อวัตถุ A ถูกทำลายวัตถุ B ที่อยู่ภายในจะถูกทำลายเช่นกัน วิธีที่ง่ายที่สุดในการบรรลุเป้าหมายนี้คือการเก็บสมาชิกตามค่า แต่คุณสามารถใช้ตัวชี้สมาร์ทหรือลบสมาชิกใน destructor:

class A {
    std::auto_ptr<B> element;
};

class A {
    B * element;

    ~A() {
        delete B;
    }
};

จุดสำคัญคือในการจัดองค์ประกอบวัตถุคอนเทนเนอร์เป็นเจ้าของวัตถุที่บรรจุอยู่ในขณะที่การรวมมันอ้างอิงมัน

มันน่าจะมีอยู่ความสับสนมากเกี่ยวกับความแตกต่างระหว่างสามความสัมพันธ์ของแนวคิดที่สมาคม ,การรวมและองค์ประกอบ

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

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

เท่าที่ฉันเห็นความสับสนนี้มีสองราก:

1. ในชุมชน C ++ คำว่า "การรวม" ถูกใช้ในความหมายของคลาสที่กำหนดแอตทริบิวต์สำหรับการอ้างอิงออบเจ็กต์ของคลาสอิสระอื่น (ดูเช่น [1]) ซึ่งเป็นความรู้สึกของความสัมพันธ์ในแผนภาพระดับ UML คำว่า "การประพันธ์" ถูกใช้สำหรับคลาสที่กำหนดวัตถุประกอบสำหรับวัตถุของพวกเขาเช่นว่าเมื่อการทำลายของวัตถุประกอบวัตถุประกอบเหล่านี้จะถูกทำลายเช่นกัน

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

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

ดูสิ่งนี้ด้วย คำตอบเพิ่มเติมของฉันสำหรับคำถาม SO ของเดือนเมษายน 2009 ที่แสดงด้านล่าง

และคุณสมบัติที่สันนิษฐานว่าจะนิยาม "องค์ประกอบ" ระหว่างวัตถุ OOP ในชุมชน C ++ (และความเชื่อนี้ยังคงมีอยู่อย่างกว้างขวาง): การพึ่งพาวงจรชีวิตของรันไทม์ระหว่างวัตถุทั้งสองที่เกี่ยวข้อง (คอมโพสิตและส่วนประกอบ) ไม่ได้มีลักษณะเฉพาะสำหรับ "การแต่งเพลง" เพราะเราสามารถมีการอ้างอิงดังกล่าวได้เนื่องจากความสมบูรณ์ของการอ้างอิงยังอยู่ในการเชื่อมโยงประเภทอื่น

ตัวอย่างเช่นรูปแบบรหัสต่อไปนี้สำหรับ "การแต่งเพลง" ถูกเสนอในคำตอบ SO :

final class Car {    
  private final Engine engine;

  Car(EngineSpecs specs) {
    engine = new Engine(specs);
  }

  void move() {
    engine.work();
  }
}

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

[1] http://www.learncpp.com/cpp-tutorial/103-aggregation/

ภาคผนวก - รายการคำถามที่ถูกถามซ้ำ ๆ เกี่ยวกับการแต่งเพลงและการรวมใน StackOverflow ไม่สมบูรณ์

[ เม.ย. 2552 ] การ
รวมตัวกับองค์ประกอบ [ปิดตามความคิดเห็นเป็นหลักโดย]
[ เม.ย. 2552 ]
ความสัมพันธ์ระหว่างองค์ประกอบกับความสัมพันธ์คืออะไร?
[ พฤษภาคม 2009 ]
ความแตกต่างระหว่างความสัมพันธ์การรวมตัวและองค์ประกอบ
[ พฤษภาคม 2009 ]
ความแตกต่างระหว่างองค์ประกอบและการรวมตัวคืออะไร? [ซ้ำ]
[ ต.ค. 2009 ]
ความแตกต่างระหว่างการรวมองค์ประกอบและการพึ่งพาคืออะไร? [ทำเครื่องหมายว่าซ้ำกัน]
[ พ.ย. 2010 ]
สมาคมกับการรวม [ทำเครื่องหมายว่าซ้ำกัน]
[ส.ค. 2555 ]
ความแตกต่างของการใช้งานระหว่างการรวมและการจัดองค์ประกอบใน Java
[ Feb 2015 ]
UML - การเชื่อมโยงหรือการรวม (ตัวอย่างโค้ดแบบง่าย)

สมาคม

การเชื่อมโยงแสดงถึงความสัมพันธ์ระหว่างสองคลาสสามารถเป็นทิศทางเดียว (ทางเดียว) หรือแบบสองทิศทาง (สองทาง)

ตัวอย่างเช่น:

1. ทิศทางเดียว

ลูกค้าสั่งซื้อ

2. แบบสองทิศทาง

A แต่งงานกับ B

B แต่งงานกับ A

การรวมตัว

การรวมกันเป็นชนิดของการเชื่อมโยง แต่มีคุณลักษณะเฉพาะการปิดกั้นคือความสัมพันธ์ในคลาส "ทั้ง" ที่ใหญ่กว่าหนึ่งมีคลาส "ส่วน" ที่มีขนาดเล็กกว่าหนึ่งคลาสโดยทั่วไปคลาส "ส่วน" ที่เล็กกว่านั้นเป็นส่วนหนึ่งของคลาสที่ใหญ่กว่า .

ตัวอย่างเช่น:

สโมสรมีสมาชิก

สโมสร ("ทั้งหมด") ประกอบด้วยสมาชิกหลายสโมสร ("ส่วน") สมาชิกมีชีวิตนอกสโมสร ถ้าสโมสร ("ทั้งหมด") ตายสมาชิก ("ส่วน") จะไม่ตายด้วย เนื่องจากสมาชิกสามารถเป็นสมาชิกของหลายสโมสรได้ ("ทั้งหมด")

ส่วนประกอบ

นี่คือรูปแบบที่แข็งแกร่งของการรวมกลุ่ม "ทั้งหมด" เป็นผู้รับผิดชอบในการสร้างหรือทำลาย "ส่วน" ของมัน

ตัวอย่างเช่น:

โรงเรียนมีแผนกต่างๆ

ในกรณีนี้โรงเรียน ("ทั้งหมด") จะต้องตายแผนก ("ส่วน") จะต้องตายด้วย เพราะแต่ละส่วนสามารถเป็นของ "ทั้งหมด" ได้เพียงชิ้นเดียว

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

สมาคม

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

สมาคมอ่อนแอ

ClassA อาจเชื่อมโยงกับ ClassB เพื่อแสดงว่าหนึ่งในวิธีการของมันรวมถึงพารามิเตอร์ของอินสแตนซ์ ClassB หรือส่งคืนอินสแตนซ์ของ ClassB

สมาคมที่แข็งแกร่ง

ClassA อาจเชื่อมโยงกับ ClassB เพื่อแสดงว่ามีการอ้างอิงถึงอินสแตนซ์ ClassB

การรวม (สมาคมที่แบ่งปัน)

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

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

การรวมกับ การเชื่อมโยงการเชื่อมโยงการเชื่อมโยงสามารถแทนที่การรวมการเชื่อมโยงในทุกสถานการณ์ในขณะที่การรวมไม่สามารถแทนที่การเชื่อมโยงในสถานการณ์ที่มีเพียง 'การเชื่อมโยงที่อ่อนแอ' ระหว่างคลาสเช่น ClassA มีวิธี / s ที่ประกอบด้วยพารามิเตอร์ของ ClassB แต่ ClassA ไม่ พักการอ้างอิงกับอินสแตนซ์ ClassB

Martin Fowler แนะนำว่าไม่ควรใช้ลิงก์การรวมเนื่องจากไม่ได้เพิ่มคุณค่าใด ๆ และรบกวนความมั่นคง Quoting Jim Rumbaugh "คิดว่ามันเป็นแบบหลอก"

องค์ประกอบ (สมาคมที่ไม่แบ่งปัน)

เราควรเจาะจงมากขึ้นและใช้ลิงค์องค์ประกอบในกรณีที่นอกเหนือจากส่วนของความสัมพันธ์ระหว่าง ClassA และ ClassB - มีการพึ่งพาวงจรชีวิตที่แข็งแกร่งระหว่างทั้งสองซึ่งหมายความว่าเมื่อลบ ClassA แล้ว ClassB จะถูกลบเป็นผล

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

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

การวัดความซับซ้อนของระบบ

สามารถวัดความซับซ้อนของระบบได้ง่ายๆโดยดูที่แผนภาพคลาส UML และประเมินการเชื่อมโยงการรวมตัวและความสัมพันธ์ขององค์ประกอบ วิธีการวัดความซับซ้อนคือการกำหนดจำนวนคลาสที่สามารถรับผลกระทบจากการเปลี่ยนคลาสเฉพาะ หากคลาส A แสดงคลาส B ดังนั้นคลาสใดก็ตามที่ใช้คลาส A จะได้รับผลกระทบทางทฤษฎีจากการเปลี่ยนแปลงคลาส B ผลรวมของจำนวนคลาสที่อาจได้รับผลกระทบสำหรับทุกคลาสในระบบคือความซับซ้อนของระบบทั้งหมด

คุณสามารถอ่านเพิ่มเติมได้ที่บล็อกของฉัน: http://aviadezra.blogspot.com/2009/05/uml-association-aggregation-composition.html

องค์ประกอบ (ถ้าคุณลบ "ทั้ง", "ส่วน" จะถูกลบโดยอัตโนมัติ - "ความเป็นเจ้าของ")

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

• โดยทั่วไปใช้ตัวแปรสมาชิกปกติ

• สามารถใช้ค่าตัวชี้หากคลาสการจัดองค์ประกอบจัดการการจัดสรร / การจัดสรรคืนอัตโนมัติที่รับผิดชอบในการสร้าง / ทำลายคลาสย่อย

องค์ประกอบใน C ++

#include <iostream>
using namespace std;
/********************** Engine Class ******************/
class Engine
{
    int nEngineNumber;
    public:
    Engine(int nEngineNo);
    ~Engine(void);
};
Engine::Engine(int nEngineNo)
{
    cout<<" Engine :: Constructor " <<endl;
}
Engine::~Engine(void)
{
    cout<<" Engine :: Destructor " <<endl;
}
/********************** Car Class ******************/
class Car
{
    int nCarColorNumber;
    int nCarModelNumber;
    Engine objEngine;
    public:
    Car (int, int,int);
    ~Car(void);
};
Car::Car(int nModelNo,int nColorNo, int nEngineNo):
nCarModelNumber(nModelNo),nCarColorNumber(nColorNo),objEngine(nEngineNo)
{
    cout<<" Car :: Constructor " <<endl;
}
Car::~Car(void)
{
    cout<<" Car :: Destructor " <<endl;
    Car
    Engine
    Figure 1 : Composition
}
/********************** Bus Class ******************/
class Bus
{
    int nBusColorNumber;
    int nBusModelNumber;
    Engine* ptrEngine;
    public:
    Bus(int,int,int);
    ~Bus(void);
};
Bus::Bus(int nModelNo,int nColorNo, int nEngineNo):
nBusModelNumber(nModelNo),nBusColorNumber(nColorNo)
{
    ptrEngine = new Engine(nEngineNo);
    cout<<" Bus :: Constructor " <<endl;
}
Bus::~Bus(void)
{
    cout<<" Bus :: Destructor " <<endl;
    delete ptrEngine;
}
/********************** Main Function ******************/
int main()
{
    freopen ("InstallationDump.Log", "w", stdout);
    cout<<"--------------- Start Of Program --------------------"<<endl;
    // Composition using simple Engine in a car object
    {
        cout<<"------------- Inside Car Block ------------------"<<endl;
        Car objCar (1, 2,3);
    }
    cout<<"------------- Out of Car Block ------------------"<<endl;
    // Composition using pointer of Engine in a Bus object
    {
        cout<<"------------- Inside Bus Block ------------------"<<endl;
        Bus objBus(11, 22,33);
    }
    cout<<"------------- Out of Bus Block ------------------"<<endl;
    cout<<"--------------- End Of Program --------------------"<<endl;
    fclose (stdout);
}

เอาท์พุต

--------------- Start Of Program --------------------
------------- Inside Car Block ------------------
Engine :: Constructor
Car :: Constructor
Car :: Destructor
Engine :: Destructor
------------- Out of Car Block ------------------
------------- Inside Bus Block ------------------
Engine :: Constructor
Bus :: Constructor
Bus :: Destructor
Engine :: Destructor
------------- Out of Bus Block ------------------
--------------- End Of Program --------------------

การรวม (หากคุณลบ "ทั้ง", "ส่วน" สามารถมีอยู่ - "ไม่มีความเป็นเจ้าของ")

• การรวมเป็นประเภทเฉพาะขององค์ประกอบที่ไม่มีความเป็นเจ้าของระหว่างวัตถุที่ซับซ้อนและ subobjects โดยนัย เมื่อผลรวมถูกทำลาย subobjects จะไม่ถูกทำลาย

• โดยทั่วไปใช้ตัวแปรตัวชี้ / ตัวแปรอ้างอิงที่ชี้ไปที่วัตถุที่อยู่นอกขอบเขตของคลาสรวม

• สามารถใช้ค่าอ้างอิงที่ชี้ไปยังวัตถุที่อยู่นอกขอบเขตของคลาสรวม

• ไม่รับผิดชอบในการสร้าง / ทำลายคลาสย่อย

รหัสการรวมใน C ++

#include <iostream>
#include <string>
using namespace std;
/********************** Teacher Class ******************/
class Teacher
{
    private:
    string m_strName;
    public:
    Teacher(string strName);
    ~Teacher(void);
    string GetName();
};
Teacher::Teacher(string strName) : m_strName(strName)
{
    cout<<" Teacher :: Constructor --- Teacher Name :: "<<m_strName<<endl;
}
Teacher::~Teacher(void)
{
    cout<<" Teacher :: Destructor --- Teacher Name :: "<<m_strName<<endl;
}
string Teacher::GetName()
{
    return m_strName;
}
/********************** Department Class ******************/
class Department
{
    private:
    Teacher *m_pcTeacher;
    Teacher& m_refTeacher;
    public:
    Department(Teacher *pcTeacher, Teacher& objTeacher);
    ~Department(void);
};
Department::Department(Teacher *pcTeacher, Teacher& objTeacher)
: m_pcTeacher(pcTeacher), m_refTeacher(objTeacher)
{
    cout<<" Department :: Constructor " <<endl;
}
Department::~Department(void)
{
    cout<<" Department :: Destructor " <<endl;
}
/********************** Main Function ******************/
int main()
{
    freopen ("InstallationDump.Log", "w", stdout);
    cout<<"--------------- Start Of Program --------------------"<<endl;
    {
        // Create a teacher outside the scope of the Department
        Teacher objTeacher("Reference Teacher");
        Teacher *pTeacher = new Teacher("Pointer Teacher"); // create a teacher
        {
            cout<<"------------- Inside Block ------------------"<<endl;
            // Create a department and use the constructor parameter to pass the teacher to it.
            Department cDept(pTeacher,objTeacher);
            Department
            Teacher
            Figure 2: Aggregation
        } // cDept goes out of scope here and is destroyed
        cout<<"------------- Out of Block ------------------"<<endl;
        // pTeacher still exists here because cDept did not destroy it
        delete pTeacher;
    }
    cout<<"--------------- End Of Program --------------------"<<endl;
    fclose (stdout);
}

เอาท์พุต

--------------- Start Of Program --------------------
Teacher :: Constructor --- Teacher Name :: Reference Teacher
Teacher :: Constructor --- Teacher Name :: Pointer Teacher
------------- Inside Block ------------------
Department :: Constructor
Department :: Destructor
------------- Out of Block ------------------
Teacher :: Destructor --- Teacher Name :: Pointer Teacher
Teacher :: Destructor --- Teacher Name :: Reference Teacher
--------------- End Of Program --------------------

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

ฉันรวบรวมจากการอ่านสั้น ๆ ของโพสต์มากมายเกี่ยวกับ SO และเอกสาร UML บางอย่างที่มีการเชื่อมโยงคลาสหลัก 4 รูปแบบ:

1. การจัดองค์ประกอบ: A ประกอบไปด้วย A B ไม่มีอยู่หากไม่มี A เช่นห้องในบ้าน
2. การรวมตัว: A has-a B; B สามารถอยู่ได้หากไม่มี A เช่นเดียวกับนักเรียนในห้องเรียน
3. การพึ่งพา: A use-a B; ไม่มีการพึ่งพาวงจรชีวิตระหว่าง A และ B เช่นพารามิเตอร์การเรียกเมธอดค่าส่งคืนหรือสร้างขึ้นชั่วคราวระหว่างการเรียกใช้เมธอด
4. การวางนัยทั่วไป: A is-a B

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

ฉันเดาว่า "สมาคมสามัญ" มีวัตถุประสงค์เพื่อใช้เป็นหลักในสองสถานการณ์:

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

ฉันคิดว่าลิงก์นี้จะทำการบ้านของคุณ: http://ootips.org/uml-hasa.html

เพื่อทำความเข้าใจเงื่อนไขที่ฉันจำตัวอย่างในวันแรกของการเขียนโปรแกรม:

หากคุณมีวัตถุ 'กระดานหมากรุก' ที่มีวัตถุ 'กล่อง' ที่เป็นองค์ประกอบเพราะถ้าลบ 'กระดานหมากรุก' จะไม่มีเหตุผลที่กล่องจะมีอยู่อีกต่อไป

หากคุณมีวัตถุ 'สี่เหลี่ยม' ที่มีวัตถุ 'สี' และสี่เหลี่ยมได้รับการลบวัตถุ 'สี' อาจยังคงอยู่นั่นคือการรวม

ทั้งสองเป็นสมาคมความแตกต่างที่สำคัญคือแนวความคิด

ส่วนประกอบ : นี่คือที่ที่เมื่อคุณทำลายวัตถุ (โรงเรียน) วัตถุอื่น (ห้องเรียน) ซึ่งถูกผูกไว้กับวัตถุก็จะถูกทำลายเช่นกัน ทั้งคู่ไม่สามารถอยู่ได้อย่างอิสระ

การรวม : นี่คือ sorta ตรงกันข้ามกับการCompositionเชื่อมโยง( ) ด้านบนซึ่งเมื่อคุณฆ่าวัตถุ ( Company) วัตถุอื่น ( Employees) วัตถุอื่น ( ) ซึ่งถูกผูกไว้กับวัตถุนั้นสามารถมีอยู่ได้ด้วยตัวเอง

สมาคม
องค์ประกอบและการรวมเป็นสองรูปแบบของความสัมพันธ์

    Simple rules:
    A "owns" B = Composition : B has no meaning or purpose in the system 
    without A
    A "uses" B = Aggregation : B exists independently (conceptually) from A
    A "belongs/Have" B= Association; And B exists just have a relation
    Example 1:

    A Company is an aggregation of Employees.
    A Company is a composition of Accounts. When a Company ceases to do 
    business its Accounts cease to exist but its People continue to exist. 
    Employees have association relationship with each other.

    Example 2: (very simplified)
    A Text Editor owns a Buffer (composition). A Text Editor uses a File 
    (aggregation). When the Text Editor is closed,
    the Buffer is destroyed but the File itself is not destroyed.

ในประโยคที่ง่ายมาก: การ
รวมและองค์ประกอบเป็นส่วนย่อยของสมาคม

• A ใช้ B -> นี่เป็นการรวมตัว

• ความต้องการ B -> คือการจัดองค์ประกอบ

อ่านเพิ่มเติมที่นี่

ฉันต้องการแสดงให้เห็นว่ามีการนำคำศัพท์ทั้งสามมาใช้ใน Rails อย่างไร ActiveRecord เรียกความสัมพันธ์ประเภทใดก็ได้ระหว่างสองรุ่นassociationและ หนึ่งจะไม่พบบ่อยข้อกำหนดcompositionและaggregationเมื่ออ่านเอกสารหรือบทความที่เกี่ยวข้องกับ ActiveRecord การเชื่อมโยงถูกสร้างขึ้นโดยการเพิ่มมาโครคลาสการเชื่อมโยงหนึ่งตัวไปยังเนื้อความของคลาส บางส่วนของแมโครเหล่านี้มีbelongs_to, has_one, has_manyฯลฯ ..

หากเราต้องการตั้งค่า a compositionหรือaggregationเราจำเป็นต้องเพิ่มbelongs_toโมเดลที่เป็นเจ้าของ (หรือที่เรียกว่า child) และhas_oneหรือhas_manyไปยังโมเดลที่เป็นเจ้าของ (หรือที่เรียกว่า parent) ไม่ว่าเราจะตั้งค่าcompositionหรือaggregationขึ้นอยู่กับตัวเลือกที่เราส่งผ่านไปยังการbelongs_toโทรในรุ่นลูก ก่อนหน้า Rails 5 การตั้งค่าbelongs_toโดยไม่สร้างตัวเลือกใด ๆaggregationเด็กอาจมีอยู่ได้โดยไม่มีพาเรนต์ หากเราต้องการcompositionเราจำเป็นต้องประกาศสิ่งนี้อย่างชัดเจนโดยเพิ่มตัวเลือกrequired: true:

class Room < ActiveRecord::Base
  belongs_to :house, required: true
end

ใน Rails 5 การเปลี่ยนแปลงนี้ ตอนนี้การประกาศความbelongs_toสัมพันธ์สร้างcompositionโดยค่าเริ่มต้นลูกไม่สามารถอยู่ได้โดยไม่มีผู้ปกครอง ดังนั้นตัวอย่างข้างต้นสามารถเขียนใหม่เป็น:

class Room < ApplicationRecord
  belongs_to :house
end

หากเราต้องการอนุญาตให้วัตถุลูกอยู่โดยไม่มีผู้ปกครองเราต้องประกาศนี้อย่างชัดเจนผ่านตัวเลือก optional

class Product < ApplicationRecord
  belongs_to :category, optional: true
end

จาก: Remo H. Jansen หนังสือ“ Beginning React: Learning TypeScript 2.x - Second Edition”:

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

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

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

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

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

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

https://www.linkedin.com/pulse/types-relationships-object-oriented-programming-oop-sarah-el-dawody/

ส่วนประกอบ:เป็นความสัมพันธ์ "ส่วนหนึ่งของ"

ตัวอย่างเช่น "เครื่องยนต์เป็นส่วนหนึ่งของรถ", "หัวใจเป็นส่วนหนึ่งของร่างกาย"

สมาคม:เป็นความสัมพันธ์ประเภท "มี -a"

ตัวอย่างเช่นสมมติว่าเรามีสองคลาสจากนั้นทั้งสองคลาสจะถูกกล่าวว่าเป็นความสัมพันธ์แบบ“ มี - a” หากทั้งสองหน่วยงานเหล่านี้แบ่งปันออบเจ็กต์ของกันและกันสำหรับงานบางงานและในเวลาเดียวกันพวกเขาสามารถมีอยู่ได้ ชีวิตของตัวเอง

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

การรวม:ขึ้นอยู่กับความสัมพันธ์ "มี - a" และเป็น \\ เป็นรูปแบบการเชื่อมโยงพิเศษ

เช่น "นักเรียน" และ "ที่อยู่" นักเรียนแต่ละคนจะต้องมีที่อยู่ดังนั้นความสัมพันธ์ระหว่างชั้นเรียนและชั้นที่อยู่จะเป็นความสัมพันธ์ประเภท "Has-A" แต่ในทางกลับกันไม่เป็นความจริง