สิ่งที่เป็นนามธรรม [ปิด]

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

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

หากคุณต้องการคำจำกัดความที่ดี: นามธรรมเป็นกระบวนการของการย้ายจากแนวคิดเฉพาะไปเป็นแนวคิดทั่วไป ตัวอย่างเช่นลองดูที่เมาส์ของคุณ มันไร้สายหรือไม่ เซ็นเซอร์ชนิดใดมี? มีกี่ปุ่ม? มันเหมาะกับการทำงานหรือไม่ มันใหญ่แค่ไหน? คำตอบสำหรับคำถามเหล่านี้ทั้งหมดสามารถอธิบายเมาส์ของคุณได้อย่างแม่นยำ แต่ไม่ว่าคำตอบคืออะไรมันยังคงเป็นเมาส์เพราะเป็นอุปกรณ์ตัวชี้ที่มีปุ่ม นั่นคือทั้งหมดที่ใช้เป็นเม้าส์ "Silver Logitech MX518" เป็นรูปธรรมรายการเฉพาะและ "mouse" เป็นสิ่งที่เป็นนามธรรม สิ่งสำคัญที่ต้องพิจารณาคือไม่มีวัตถุรูปธรรมเช่น "เมาส์" มันเป็นเพียงความคิด เม้าส์บนโต๊ะทำงานเป็นอะไรที่พิเศษกว่าเสมอ - มัน '

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

การเขียนโปรแกรมเชิงวัตถุถูกสร้างขึ้นบนแนวคิดของ abstractions และครอบครัวหรือกลุ่มของพวกเขา Good OOP หมายถึงการเลือก abstractions ที่เหมาะสมในระดับรายละเอียดที่เหมาะสมในโดเมนของโปรแกรมของคุณและไม่ "รั่วไหล" อดีตหมายถึงการจัดประเภทเมาส์เป็นวัตถุที่จะไม่กลิ้งบนระนาบแบบเอียงไม่สมเหตุสมผลสำหรับแอปพลิเคชันที่มีอุปกรณ์คอมพิวเตอร์คงเหลือ แต่อาจทำให้เหมาะสมสำหรับการจำลองทางฟิสิกส์ สิ่งหลังหมายถึงคุณควรพยายามหลีกเลี่ยง "การต่อสู้ด้วยตัวคุณเอง" ในลำดับชั้นที่ไม่เหมาะสมกับวัตถุบางประเภท ตัวอย่างเช่นในลำดับชั้นของฉันข้างต้นเราแน่ใจว่าทั้งหมดอุปกรณ์ต่อพ่วงคอมพิวเตอร์ขับเคลื่อนโดยไฟฟ้า? แล้วสไตลัสล่ะ? ถ้าเราต้องการจัดกลุ่มสไตลัสไว้ในหมวดหมู่ "อุปกรณ์ต่อพ่วง" เราจะมีปัญหาเพราะมันไม่ได้ใช้ไฟฟ้าและเรากำหนดอุปกรณ์ต่อพ่วงคอมพิวเตอร์เป็นวัตถุที่ใช้ไฟฟ้า ปัญหาวงกลม - วงรีเป็นตัวอย่างที่รู้จักกันดีที่สุดของปริศนานี้

ฉันไม่เห็นด้วยอย่างเด็ดขาดกับคำตอบส่วนใหญ่

นี่คือคำตอบของฉัน:

เมื่อกำหนดสองชุด G และ H การเชื่อมต่อของ Galois (อัลฟ่าเบต้า)สามารถกำหนดได้ระหว่างพวกเขา ย้อนกลับการเชื่อมต่อและหนึ่งเป็นนามธรรมของอื่น ๆ ฟังก์ชั่นเป็นฟังก์ชั่นการเชื่อมต่อและฟังก์ชั่นนามธรรม

นี่คือจากทฤษฎีการตีความที่เป็นนามธรรมของโปรแกรมคอมพิวเตอร์ซึ่งโดยทั่วไปจะเป็นวิธีการวิเคราะห์แบบคงที่จนถึงปัจจุบัน

นามธรรมคือการมุ่งเน้นเพิ่มเติมเกี่ยวกับและน้อยลงในWhat Howหรือคุณสามารถพูดรู้เฉพาะสิ่งที่คุณต้องการและเชื่อใจผู้ให้บริการสำหรับบริการอื่น ๆ ทั้งหมด บางครั้งมันยังซ่อนตัวตนของผู้ให้บริการ

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

ตัวอย่างอื่น ๆ :

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

• API ใด ๆ จะซ่อนรายละเอียดการติดตั้งทั้งหมดที่ให้บริการแก่โปรแกรมเมอร์อื่น ๆ

• ชั้นเรียนใน OOP ซ่อนสมาชิกส่วนตัวและการดำเนินการตามสมาชิกสาธารณะที่ให้บริการเพื่อเรียกสมาชิกสาธารณะ

• ในขณะที่ใช้วัตถุประเภทInterfaceหรือabstract classใน Java หรือ C ++ การใช้งานจริงจะถูกซ่อนไว้ และไม่เพียง แต่ซ่อนไว้การใช้งานของวิธีการที่ประกาศในInterfaceนั้นก็มีแนวโน้มที่จะแตกต่างกันไปในชั้นเรียนที่นำไปปฏิบัติ / สืบทอด แต่ในขณะที่คุณได้รับบริการเดียวกันอย่าเพิ่งไปรบกวนHowการนำไปใช้งานและWho/ / Whatกำลังให้บริการอย่างแน่นอน

• การซ่อนข้อมูลส่วนบุคคล : สำหรับประโยค "ฉันรู้ว่าแซมสามารถเขียนโปรแกรมคอมพิวเตอร์" สิ่งที่เป็นนามธรรมสามารถ - "แซมเป็นโปรแกรมเมอร์โปรแกรมเมอร์รู้วิธีการเขียนโปรแกรมคอมพิวเตอร์" ในคำแถลงที่สองบุคคลนั้นไม่สำคัญ แต่ความสามารถของเขาในการเขียนโปรแกรมเป็นสิ่งสำคัญ

นามธรรมการเขียนโปรแกรมเป็นรูปแบบของปัญหาที่ง่ายขึ้น

ตัวอย่างเช่นการเชื่อมต่อ TCP / IP เป็นนามธรรมผ่านการส่งข้อมูล คุณเพียงใส่ที่อยู่ IP และหมายเลขพอร์ตแล้วส่งไปที่ API คุณไม่ต้องกังวลกับรายละเอียดทั้งหมดของสายสัญญาณรูปแบบข้อความและความล้มเหลว

นามธรรมเป็นเพียงเวอร์ชันการเขียนโปรแกรมของทฤษฎีบท

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

ในฟังก์ชั่นการเขียนโปรแกรมความคิดของโปรแกรมที่เป็นคำสั่งทางคณิตศาสตร์นั้นแข็งแกร่งมากและบ่อยครั้งที่ระบบประเภท (ในภาษาที่มีความแข็งแกร่งและมีการพิมพ์แบบคงที่เช่น Haskell, F # หรือ OCAML) สามารถใช้สำหรับทดสอบทฤษฎีบทผ่านการพิสูจน์

ตัวอย่างเช่นให้เราบอกว่าเรามีการตรวจสอบเพิ่มเติมและความเท่าเทียมกันในการดำเนินการดั้งเดิมและจำนวนเต็มและบูลีนเป็นชนิดข้อมูลดั้งเดิม นี่คือสัจพจน์ของเรา ดังนั้นเราสามารถพูดได้ว่า1 + 3 == 2 + 2เป็นทฤษฎีบทจากนั้นใช้กฎการบวกและจำนวนเต็มและความเท่าเทียมกันเพื่อดูว่านั่นเป็นข้อความจริงหรือไม่

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

ref x (*) y := loop y times {x +}) 0

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

ฉันยังสามารถตรวจสอบระบบประเภทของฉัน (*) มีประเภทของ int -> int -> int มันใช้เวลา 2 ints และส่งออกเป็น int การเติมมีประเภทของ int -> int -> int ดังนั้น 0 + (ที่พัก) จะเก็บตราบเท่าที่ (พัก) ส่งผลให้เป็น int ลูปของฉันสามารถทำทุกสิ่งได้ แต่ฉันบอกว่ามันจะส่งผลให้ฟังก์ชั่น curried นั้น (x + (x + (x ... + 0))) เป็นผลลัพธ์ รูปแบบของการเพิ่มโซ่นั้นเป็นเพียง (int -> (int -> (int ... -> int))) ดังนั้นฉันรู้ว่าผลลัพธ์สุดท้ายของฉันจะเป็น int ดังนั้นระบบพิมพ์ของฉันจึงจัดทำผลการพิสูจน์อื่น ๆ ของฉัน!

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

คำตอบของ Wikipedia จะดีพอไหม http://en.wikipedia.org/wiki/Abstraction_%28programming%29

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

ในทางคณิตศาสตร์ "จำนวนเต็ม" เป็นสิ่งที่เป็นนามธรรม และเมื่อคุณทำการพิสูจน์อย่างเป็นทางการเช่นนั้น x + y = y + x สำหรับจำนวนเต็มทั้งหมดคุณกำลังทำงานกับสิ่งที่เป็นนามธรรม "จำนวนเต็ม" มากกว่าตัวเลขเฉพาะเช่น 3 หรือ 4 สิ่งเดียวกันนี้เกิดขึ้นในการพัฒนาซอฟต์แวร์เมื่อคุณโต้ตอบกับ เครื่องที่ระดับเหนือการลงทะเบียนและตำแหน่งหน่วยความจำ คุณสามารถคิดความคิดที่มีประสิทธิภาพมากขึ้นในระดับที่เป็นนามธรรมมากขึ้นในกรณีส่วนใหญ่

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

อนุญาตให้ฉันโกรธ ...

สิ่งที่น่ารำคาญใจในรายการของฉันคือเมื่อมีคนพูดถึง "เลเยอร์ของสิ่งที่เป็นนามธรรม" ราวกับว่ามันเป็นสิ่งที่ดี พวกเขาสร้าง "wrappers" รอบ ๆ คลาสหรือกิจวัตรที่พวกเขาไม่ชอบและเรียกพวกเขาว่า "นามธรรมมากกว่า" ราวกับว่ามันจะทำให้ดีขึ้น จำนิทานของ "Princess and the Pea" ได้หรือไม่? เจ้าหญิงช่างบอบบางเหลือเกินว่าถ้ามีถั่วอยู่ใต้ที่นอนเธอจะไม่สามารถนอนหลับได้และการเพิ่มชั้นของที่นอนจะไม่ช่วยอะไร แนวคิดที่ว่าการเพิ่มเลเยอร์ "abstraction" มากขึ้นจะช่วยได้เช่นนั้น - โดยปกติจะไม่ หมายความว่าการเปลี่ยนแปลงใด ๆ กับเอนทิตีฐานจะต้องมีการกระเพื่อมผ่านเลเยอร์ของโค้ด

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

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

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

สิ่งที่เป็นนามธรรมเกี่ยวข้องกับการห่อหุ้มและแยกส่วนและแนวคิดเหล่านี้มักเข้าใจผิด

ในListตัวอย่างการห่อหุ้มสามารถใช้เพื่อซ่อนรายละเอียดการนำไปใช้ของรายการที่ลิงก์ ยกตัวอย่างเช่นในภาษาเชิงวัตถุคุณสามารถสร้างnextและพpreviousอยน์เตอร์ส่วนตัวได้ซึ่งอนุญาตให้มีการใช้งานรายการเท่านั้นเพื่อเข้าถึงฟิลด์เหล่านี้

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

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

การซ่อนข้อมูลนั้นได้รับความช่วยเหลือจากการห่อหุ้ม (เพื่อให้รหัสของคุณไม่ได้ขึ้นอยู่กับรายละเอียดการติดตั้งที่ไม่เสถียร) แต่การห่อหุ้มนั้นไม่จำเป็นสำหรับการแยกส่วน ตัวอย่างเช่นคุณสามารถใช้Listโครงสร้างใน C เปิดเผย ' next' และ ' prevชี้' ไปทั่วโลก แต่ยังให้อินเตอร์เฟซที่มีinitList(), addToList()และremoveFromList()ฟังก์ชั่น. โดยมีเงื่อนไขว่าจะปฏิบัติตามกฎของอินเทอร์เฟซคุณสามารถรับประกันได้ว่าคุณสมบัติบางอย่างจะมีอยู่เสมอเช่นการทำให้มั่นใจว่าโครงสร้างข้อมูลอยู่ในสถานะที่ถูกต้องเสมอ [กระดาษคลาสสิกของ Parnas บนโมดุลถูกเขียนด้วยตัวอย่างในการประกอบ อินเทอร์เฟซเป็นสัญญาและรูปแบบของการสื่อสารเกี่ยวกับการออกแบบมันไม่จำเป็นต้องถูกตรวจสอบทางกลไกแม้ว่าจะเป็นสิ่งที่เราวางใจในวันนี้]

แม้ว่าจะใช้คำอย่าง abstract, modular และ encapsulated เป็นคำอธิบายการออกแบบเชิงบวก แต่สิ่งสำคัญคือต้องตระหนักว่าการมีคุณสมบัติเหล่านี้ไม่ได้ช่วยให้คุณมีการออกแบบที่ดีโดยอัตโนมัติ:

• หากอัลกอริทึม n ^ 3 เป็น "encapsulated อย่าง" มันจะยังคงทำงานได้แย่กว่าอัลกอริทึม n log n ที่ได้รับการปรับปรุง

• หากอินเทอร์เฟซที่ใช้กับระบบปฏิบัติการเฉพาะจะไม่มีการรับรู้ประโยชน์ของการออกแบบแบบแยกส่วนเมื่อกล่าวว่าวิดีโอเกมจำเป็นต้องได้รับการย้ายจาก Windows ไปยัง iPad

• หากสิ่งที่เป็นนามธรรมที่สร้างขึ้นมีรายละเอียดที่ไม่จำเป็นมากเกินไปมันจะล้มเหลวในการสร้างสิ่งปลูกสร้างใหม่ด้วยการดำเนินงานของมันเอง: มันจะเป็นเพียงชื่ออื่นในสิ่งเดียวกัน

ตกลงฉันคิดว่าฉันเข้าใจสิ่งที่คุณถาม: "อะไรคือคำจำกัดความที่เข้มงวดทางคณิตศาสตร์ของ 'An Abstraction'"

หากเป็นเช่นนั้นฉันคิดว่าคุณไม่มีโชค - 'abstraction' เป็นคำศัพท์ทางสถาปัตยกรรม / การออกแบบซอฟต์แวร์และไม่มีการสนับสนุนทางคณิตศาสตร์เท่าที่ฉันทราบ ที่นี่) มากกว่า "การแต่งงานกัน" หรือ "การซ่อนข้อมูล" มีคำจำกัดความทางคณิตศาสตร์

สิ่งที่เป็นนามธรรมคือเมื่อคุณเพิกเฉยต่อรายละเอียดที่ถือว่าไม่เกี่ยวข้องกับผู้ที่เกี่ยวข้อง

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

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

เป็นนามธรรมไม่ใช่สิ่งที่คุณประกาศว่ามันเป็นสิ่งที่คุณทำ

เป็นวิธีการอธิบายให้คนอื่นฉันจะไปทางอื่นจากผลลัพธ์กลับ:

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

หากคุณต้องการขยายที่คุณสามารถเพิ่ม:

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

นอกเหนือจากนั้นฉันคิดว่าคุณต้องเริ่มเป็นตัวอย่าง ...

คุณอาจต้องการตรวจสอบการวัดของ Bob Martin

http://en.wikipedia.org/wiki/Software_package_metrics

ที่กล่าวว่าฉันไม่คิดว่า "Abstractness" ของเขาเหมือนกับของคุณ "การขาดการนำไปใช้กับคลาส" ของเขานั้นมีความหมายมากกว่าการใช้อินเตอร์เฟส / คลาสนามธรรม ความไม่เสถียรและระยะทางจาก Main Sequence อาจเล่นได้มากกว่าในสิ่งที่คุณกำลังมองหา

Merriam-webster นิยามบทคัดย่อว่าเป็นคำคุณศัพท์: แยกส่วนจากอินสแตนซ์เฉพาะใด ๆ

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

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

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

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

อย่างที่คนอื่น ๆ พูดกันมันเป็นรูปแบบที่เรียบง่าย มันเป็นเครื่องมือที่ใช้ในการเข้าใจระบบที่ซับซ้อนได้ดียิ่งขึ้น

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

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

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

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

วิธีหนึ่งที่ฉันพยายามอธิบายให้คนอื่นเห็นอาจไม่ใช่วิธีที่ดีที่สุด

พิจารณาโปรแกรมที่เพิ่ม 2 + 2 และเอาท์พุท 4

พิจารณาโปรแกรมที่เพิ่มการใส่ตัวเลขสองตัวโดยผู้ใช้ x + y = z

ข้อไหนมีประโยชน์และทั่วไปมากขึ้น?

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

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

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

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

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

ข้อดีของนามธรรมบางประการคือ:

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

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

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

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

การอ้อมระดับพิเศษ

คุณไม่ต้องการที่จะสนใจว่าวัตถุที่คุณใช้เป็นCatหรือDogเพื่อให้คุณผ่านตารางฟังก์ชั่นเสมือนจริงเพื่อหาmakeNoise()ฟังก์ชั่นที่เหมาะสม

ฉันแน่ใจว่านี้สามารถนำไปใช้ 'ลด' และระดับ 'สูง' เป็นอย่างดี - คิดว่าคอมไพเลอร์ที่กำลังมองถึงการเรียนการสอนที่เหมาะสมในการใช้งานสำหรับการประมวลผลที่กำหนดหรือของ Haskell Monads สรุปผลกระทบมากกว่าการคำนวณโดยการเรียกทุกอย่างและreturn>>=

นี่คือสิ่งที่ฉันต้องการบล็อกจริง ๆ เป็นเวลานาน แต่ฉันไม่เคยได้รับมัน โชคดีที่ฉันเป็นซอมบี้ตัวแทนและยังมีเงินรางวัลอีกด้วย โพสต์ของฉันเปิดออกค่อนข้างยาวแต่นี่คือสาระสำคัญ:

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

[ ... ]

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

หวังว่าจะช่วย

นี่คือคำตอบที่ไม่เกี่ยวกับคณิตศาสตร์:

การเขียนโปรแกรมไปในทางที่ผิดนั้นทำให้คุณไม่สนใจรายละเอียดในขณะนี้ แต่จริงๆแล้วคุณควรใส่ใจพวกเขาตลอดเวลา มันทำท่าโดยทั่วไป

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

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

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

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

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

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

ฉันขอเหรียญตอนนี้ได้ไหม

คำถามที่น่าสนใจ ฉันไม่ทราบคำจำกัดความเดียวของสิ่งที่เป็นนามธรรมซึ่งถูกพิจารณาว่ามีอำนาจเมื่อพูดถึงการเขียนโปรแกรม แม้ว่าคนอื่น ๆ จะมีลิงก์ไปยังคำจำกัดความจากสาขาทฤษฎีหรือคณิตศาสตร์ CS ที่หลากหลาย ฉันชอบคิดในทำนองเดียวกันกับ "ผู้ควบคุม" ดูhttp://en.wikipedia.org/wiki/Supervenience

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

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

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

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

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

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

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

ดังนั้นโดยสรุปการเขียนโปรแกรมนามธรรมเป็นวิธีการที่ช่วยให้เราเข้าใจปัญหามันเป็นวิธีที่จะได้รับบางสิ่งบางอย่าง แต่มันไม่ได้เป็นของจริง