หลักการชดเชย Liskov เข้ากันไม่ได้กับการวิปัสสนาหรือการพิมพ์ดีดเป็ด?

ฉันเข้าใจอย่างถูกต้องหรือไม่ว่าหลักการแทน Liskovไม่สามารถสังเกตได้ในภาษาที่วัตถุสามารถตรวจสอบตัวเองเช่นภาษาเป็ดที่พิมพ์เป็นปกติ

ยกตัวอย่างเช่นในทับทิมถ้าระดับBสืบทอดจากชั้นเรียนAแล้วสำหรับวัตถุทุกxของA, x.classเป็นไปได้กลับมาAแต่ถ้าxเป็นวัตถุของB, จะไม่กลับมาx.classA

นี่คือคำแถลงของ LSP:

Let Q (x)เป็นสถานที่ให้บริการสามารถพิสูจน์ได้เกี่ยวกับวัตถุxประเภทT จากนั้นQ (y)ควรจะสามารถพิสูจน์ได้สำหรับวัตถุYประเภทSที่Sเป็นชนิดย่อยของT

ดังนั้นใน Ruby เช่น

class T; end
class S < T; end

ละเมิด LSP ในแบบฟอร์มนี้ตามที่เห็นในคุณสมบัติq (x) =x.class.name == 'T'

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

ปรับปรุง สำหรับการอ้างอิงนี่เป็นอีกสูตรของ LSP ที่ฉันพบบนเว็บ:

ฟังก์ชันที่ใช้พอยน์เตอร์หรือการอ้างอิงไปยังคลาสพื้นฐานต้องสามารถใช้วัตถุของคลาสที่ได้รับโดยไม่ต้องรู้

เเละอีกอย่าง:

หาก S เป็นประเภทย่อยที่ประกาศไว้ของ T วัตถุประเภท S ควรทำงานเป็นวัตถุประเภท T ที่คาดว่าจะทำงานหากพวกเขาถือว่าเป็นวัตถุประเภท T

คนสุดท้ายมีคำอธิบายประกอบด้วย:

โปรดทราบว่า LSP นั้นเกี่ยวกับพฤติกรรมที่คาดหวังของวัตถุ หนึ่งสามารถติดตาม LSP หากมีความชัดเจนเกี่ยวกับพฤติกรรมที่คาดหวังของวัตถุ

สิ่งนี้ดูเหมือนจะอ่อนแอกว่าเดิมและอาจเป็นไปได้ที่จะสังเกต แต่ฉันอยากเห็นมันเป็นระเบียบโดยเฉพาะอธิบายว่าใครตัดสินใจว่าพฤติกรรมที่คาดหวังคืออะไร

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

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

class C; end
C.is_a?(Module) # => true
C.class # => Class
Class.superclass # => Module

module M; end
M.class # => Module

o = Object.new

o.extend(M) # ok
o.extend(C) # => TypeError: wrong argument type Class (expected Module)

นี่คือหลักการที่แท้จริง :

อนุญาตq(x)เป็นพิสูจน์คุณสมบัติเกี่ยวกับวัตถุชนิดx Tจากนั้นq(y)ควรจะสามารถพิสูจน์ได้สำหรับวัตถุyชนิดSที่เป็นชนิดย่อยของST

และสรุปวิกิพีเดียที่ยอดเยี่ยม:

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

และคำพูดที่เกี่ยวข้องจากกระดาษ:

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

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

ดังนั้นคำถาม:

ฉันเข้าใจอย่างถูกต้องหรือไม่ว่าหลักการแทน Liskov ไม่สามารถสังเกตได้ในภาษาที่วัตถุสามารถตรวจสอบตัวเองเช่นภาษาเป็ดที่พิมพ์เป็นปกติ

เลขที่

A.classส่งคืนคลาส
B.classส่งคืนคลาส

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

แต่ลองพิจารณาภาษาที่พิมพ์ด้วยโครงสร้าง (เป็ด) แบบสแตติก ในกรณีนี้A.classจะส่งคืนประเภทที่มีข้อ จำกัด ว่าจะต้องAเป็นประเภทย่อยAหรือ สิ่งนี้ให้การรับประกันแบบคงที่ว่าประเภทย่อยใด ๆ ของAต้องจัดให้มีวิธีการT.classที่ผลลัพธ์เป็นประเภทที่เป็นไปตามข้อ จำกัด นั้น

นี่เป็นการยืนยันที่แข็งแกร่งว่า LSP มีภาษาที่รองรับการพิมพ์เป็ดและการละเมิด LSP ในรูปแบบใด ๆ เช่น Ruby เกิดขึ้นมากขึ้นเนื่องจากการใช้งานผิดปกติแบบไดนามิกมากกว่าความไม่ลงรอยกันของการออกแบบภาษา

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

"คุณสมบัติ" ดังกล่าวอาจมีfoo()วิธีการที่ไม่มีค่าตอบแทน (และเป็นไปตามสัญญาที่กำหนดไว้ในเอกสารประกอบ)

ตรวจสอบให้แน่ใจว่าคุณไม่ได้สับสนคำนี้ด้วย "คุณสมบัติ" ในขณะที่ " classเป็นคุณสมบัติของทุกวัตถุในทับทิม" "คุณสมบัติ" ดังกล่าวอาจเป็น "คุณสมบัติ LSP" แต่มันไม่เหมือนกันโดยอัตโนมัติ!

ตอนนี้คำตอบสำหรับคำถามของคุณขึ้นอยู่กับความเข้มงวดของคุณในการกำหนด "คุณสมบัติ" ถ้าคุณพูดว่า "คุณสมบัติของคลาสAนั้น.classจะคืนค่าชนิดของวัตถุ" ดังนั้นBจริงๆแล้วจะมีคุณสมบัตินั้น

แต่ถ้าคุณกำหนด "ทรัพย์สิน" ให้เป็น " .classผลตอบแทนA" แล้วเห็นได้ชัดBไม่ได้มีทรัพย์สินที่

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

ตามที่ฉันเข้าใจแล้วไม่มีอะไรเกี่ยวกับวิปัสสนาที่จะขัดกับ LSP โดยพื้นฐานตราบเท่าที่วัตถุรองรับวิธีการเดียวกันกับอีกวิธีหนึ่งวัตถุทั้งสองควรเปลี่ยนได้ นั่นคือถ้ารหัสของคุณคาดว่าAddressวัตถุนั้นมันไม่สำคัญว่าจะเป็นCustomerAddressหรือWarehouseAddressตราบใดที่ทั้งสองให้ (เช่น) getStreetAddress(), getCityName(), และgetRegion() getPostalCode()แน่นอนคุณสามารถสร้างมัณฑนากรบางประเภทที่ใช้วัตถุประเภทอื่นและใช้วิปัสสนาเพื่อให้วิธีการที่ต้องการ (เช่นDestinationAddressคลาสที่ใช้Shipmentวัตถุและนำเสนอที่อยู่ผู้รับสินค้าเป็นAddress) แต่มันไม่จำเป็นและไม่ต้องการแน่นอน ไม่ป้องกัน LSP จากการใช้งาน

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

ก่อนอื่นคำว่า"พิสูจน์ได้"มีความสำคัญในคำจำกัดความ ไม่ได้อธิบายไว้ในบทความ Wikipedia และมีการกล่าวถึง "ข้อ จำกัด " ที่อื่นโดยไม่มีการอ้างอิง

นี่คือคำพูดที่สำคัญครั้งแรกจากกระดาษ:

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

และนี่คือข้อที่สองอธิบายว่าสเปคประเภทคืออะไร:

ข้อมูลจำเพาะชนิดรวมถึงข้อมูลต่อไปนี้:

• ชื่อประเภท
• คำอธิบายของพื้นที่ค่าของประเภท;
• สำหรับวิธีการแต่ละประเภท:
  • ชื่อของมัน;
  • ลายเซ็นของมัน (รวมถึงข้อยกเว้นสัญญาณ);
  • พฤติกรรมในแง่ของเงื่อนไขก่อนและหลังเงื่อนไข

ดังนั้น LSP จึงเหมาะสมกับข้อกำหนดของประเภทที่กำหนดเท่านั้นและสำหรับข้อกำหนดประเภทที่เหมาะสม (สำหรับตัวอย่างที่ว่างเปล่า) ก็สามารถทำได้ในภาษาใดก็ได้

ฉันคิดว่าคำตอบของ Telastynนั้นใกล้เคียงกับสิ่งที่ฉันค้นหามากที่สุดเพราะ "ข้อ จำกัด " ถูกกล่าวถึงอย่างชัดเจน

ในการอ้างอิงบทความของ Wikipedia เกี่ยวกับ LSP "การแทนที่เป็นหลักการในการเขียนโปรแกรมเชิงวัตถุ" มันเป็นหลักการและเป็นส่วนหนึ่งของการออกแบบโปรแกรมของคุณ หากคุณเขียนรหัสที่ขึ้นอยู่กับx.class == Aว่ามันเป็นรหัสของคุณที่ละเมิด LSP โปรดทราบว่ารหัสที่ใช้ไม่ได้ประเภทนี้สามารถใช้กับ Java ได้โดยไม่จำเป็นต้องพิมพ์เป็ด

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

ความคิดเพิ่มเติม: ไม่ได้ตรวจสอบอย่างชัดเจนว่าคลาสของวัตถุนั้นเอาชนะเป้าหมายของการพิมพ์เป็ดได้หรือไม่