ชั้นเรียนในภาษา OOP และประเภท

ในทฤษฎีการเขียนโปรแกรมภาษาประเภทคือชุดของค่า เช่น type "int" คือชุดของค่าจำนวนเต็มทั้งหมด

ในภาษา OOP คลาสเป็นประเภทใช่หรือไม่

เมื่อชั้นเรียนมีสมาชิกมากกว่าหนึ่งคนเช่น

class myclass{
    int a; 
    double b;
}

เมื่อเราพูดถึงชั้นเรียนเราหมายถึง

• " (a,b)อยู่ที่ไหนaint และbเป็นสองเท่า" หรือ
• "{ (x,y)| xis int ใด ๆ , ydouble ใด ๆ }"?

ตัวอย่างmyclassหมายถึงอะไร

• " (a,b)อยู่ที่ไหนaint และbเป็นสองเท่า" หรือ
• วัตถุที่ใช้พื้นที่หน่วยความจำและที่ (ไม่จำเป็นต้องเช่นว่างเปล่า) ร้านค้า(x,y)ที่xใด int และyเป็นคู่ใด ๆ

ทั้ง

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

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

ประเภทไม่ได้ตั้งค่า

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

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

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

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

โดยทั่วไปจะได้รับอนุญาตให้ทับซ้อนกันโดยที่ไม่ได้อยู่ในชุดอื่น นี่เป็นเรื่องแปลกในทฤษฎีประเภทแม้ว่าบางภาษาจะสนับสนุนในรูปแบบของการสืบทอดหลาย ๆ ภาษาอื่นเช่น Java อนุญาตเฉพาะรูปแบบที่ จำกัด นี้หรือไม่อนุญาตทั้งหมด

มีประเภทที่ว่างเปล่าอยู่ (เรียกว่าประเภทด้านล่าง ) แต่ภาษาส่วนใหญ่ไม่รองรับหรือไม่ถือว่าเป็นประเภทที่มีระดับ "ประเภทที่มีประเภทอื่น ๆ ทั้งหมด" ก็มีอยู่ (เรียกว่าประเภทด้านบน ) และได้รับการสนับสนุนอย่างกว้างขวางซึ่งแตกต่างจากทฤษฎีเซต

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

ความคิดของ "subtyping" นั้นค่อนข้างแตกต่างจากแนวคิดของ "subset" หากXเป็นประเภทย่อยYหมายถึงเราสามารถทดแทนอินสแตนซ์ของYสำหรับอินสแตนซ์ของXและโปรแกรมจะยังคง "ทำงาน" ในบางกรณี นี่เป็นพฤติกรรมมากกว่าโครงสร้างแม้ว่าบางภาษา (เช่น Go, Rust, arguably C) ได้เลือกแบบหลังเพื่อความสะดวกไม่ว่าจะเป็นโปรแกรมเมอร์หรือการใช้ภาษา

ประเภทข้อมูลเกี่ยวกับพีชคณิตเป็นวิธีการอภิปรายนี้

มีสามวิธีพื้นฐานที่คุณสามารถรวมประเภทได้:

• สินค้า นั่นคือสิ่งที่คุณคิดโดยทั่วไป:

  struct IntXDouble{
    int a; 
    double b;
  }
  

  เป็นประเภทผลิตภัณฑ์ ค่าที่มีทั้งหมดรวมกันได้ (เช่น tuples) ของหนึ่งและเป็นหนึ่งในint doubleหากคุณพิจารณาประเภทของตัวเลขตามที่กำหนดแล้วความสำคัญของประเภทผลิตภัณฑ์นั้นในความเป็นจริงแล้วผลิตภัณฑ์ของความสำคัญของเขตข้อมูล

• รวม ในภาษาเชิงโพรซีเดอร์นี่เป็นเรื่องที่น่าอึดอัดใจที่จะแสดงโดยตรง (คลาสสิกมันทำกับสหภาพที่ติดแท็ก ) ดังนั้นเพื่อความเข้าใจที่ดีขึ้นนี่คือผลรวมประเภทใน Haskell:

  data IntOrDouble = AnInt Int
                   | ADouble Double
  

  ค่าของประเภทนี้มีทั้งแบบฟอร์มAnInt 345หรือADouble 4.23แต่มีตัวเลขเดียวเท่านั้นที่เกี่ยวข้อง (ซึ่งแตกต่างจากประเภทผลิตภัณฑ์ที่แต่ละค่ามีตัวเลขสองตัว) ดังนั้นความสำคัญ: คุณต้องระบุIntค่าทั้งหมดก่อนโดยแต่ละค่าจะต้องรวมกับตัวAnIntสร้าง พลัสทุกค่าแต่ละรวมกับDouble ADoubleดังนั้นประเภทผลรวม

• ยกกำลัง1 ฉันจะไม่พูดถึงรายละเอียดที่นี่เพราะไม่มีการโต้ตอบ OO ที่ชัดเจนเลย

แล้วคลาสล่ะล่ะ? ฉันจงใจใช้คำหลักstructมากกว่าสำหรับclass IntXDoubleสิ่งที่เป็นคลาสที่เป็นประเภทไม่ได้โดดเด่นด้วยเขตข้อมูลของพวกเขาเป็นเพียงรายละเอียดการใช้งาน ปัจจัยที่สำคัญค่อนข้างมีค่าที่แตกต่างสิ่งที่ชั้นสามารถมี

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

¹ _{นี่คือฟังก์ชั่น (ในแง่คณิตศาสตร์! ); ประเภทฟังก์ชั่นจะถูกแสดงโดยชี้แจงInt -> Double Double^Intไปไม่ดีถ้าภาษาของคุณไม่มีฟังก์ชั่นที่เหมาะสม ...}

ขออภัยที่ฉันไม่รู้เกี่ยวกับทฤษฎี "ดิบ" ฉันสามารถให้แนวทางปฏิบัติได้เท่านั้น ฉันหวังว่านี่เป็นที่ยอมรับของโปรแกรมเมอร์ ฉันไม่คุ้นเคยกับมารยาทที่นี่

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

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

    int areacode;
    int number;

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

การสร้างอินสแตนซ์อาจปฏิเสธตัวเลขติดลบใด ๆ บางทีการสร้างอาจจะทำให้ปกติของโหนดในบางวิธีหรือแม้กระทั่งการตรวจสอบจำนวนทั้งหมด คุณจึงจะจบลงมากใกล้กับคุณ"(a,b) where a is an int and b is a double"เพราะมันไม่แน่นอนใด ๆสอง int เก็บไว้ในชั้นเรียนที่

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

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

มีการออกแบบ patters เพื่อให้แน่ใจว่าการเปลี่ยนแปลงของการเป็นตัวแทนภายในสามารถทำได้โดยไม่ต้องลูกค้าได้ตระหนักถึงมัน (เช่น pimpl idiom ใน C ++ ซึ่งซ่อนสมาชิกข้อมูลใด ๆ ที่อยู่เบื้องหลังตัวชี้ทึบแสง )

• ประเภทคือคำอธิบายของหมวดหมู่ / ช่วงของค่าโครงสร้างสารหรือสิ่งที่มีคุณ OOPwise มันคล้ายกับ "อินเตอร์เฟส" (ในความหมายภาษาไม่เชื่อเรื่องพระเจ้า. ความรู้สึกเฉพาะภาษาไม่มาก. ใน Java เช่นintเป็นชนิดแต่มีความสัมพันธ์กับผู้ไม่มีinterface. สาธารณะ / รายละเอียดข้อมูลที่มีการป้องกันเป็นอย่างดีไม่ได้เป็นส่วนหนึ่งของการinterface, แต่เป็นส่วนหนึ่งของ "อินเตอร์เฟส" หรือประเภท )

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

• ระดับเป็นสำนึกของประเภทที่ เป็นแม่แบบที่กำหนดโครงสร้างภายในพฤติกรรมที่แนบมา ฯลฯ