These two examples show the differe

These two examples show the difference between objects and data structures. Objects hide
their data behind abstractions and expose functions that operate on that data. Data structure
expose their data and have no meaningful functions. Go back and read that again.
Notice the complimentary nature of the two definitions. They are virtual opposites. This
difference may seem trivial, but it has far-reaching implications.
Consider, for example, the procedural shape example in Listing 6-5. The Geometry
class operates on the three shape classes. The shape classes are
Object-oriented programmers might wrinkle their noses at this and complain that it
is procedural—and they’d be right. But the sneer may not be warranted. Consider what
would happen if a perimeter() function were added to Geometry. The shape classes would
be unaffected! Any other classes that depended upon the shapes would also be unaffected!
On the other hand, if I add a new shape, I must change all the functions in Geometry to
deal with it. Again, read that over. Notice that the two conditions are diametrically
opposed.
Now consider the object-oriented solution in Listing 6-6. Here the area() method is
polymorphic. No Geometry class is necessary. So if I add a new shape, none of the existing
functions are affected, but if I add a new function all of the shapes must be changed
Again, we see the complimentary nature of these two definitions; they are virtual
opposites! This exposes the fundamental dichotomy between objects and data structures:
Procedural code (code using data structures) makes it easy to add new functions without
changing the existing data structures. OO code, on the other hand, makes it easy to add
new classes without changing existing functions.
The complement is also true:
Procedural code makes it hard to add new data structures because all the functions must
change. OO code makes it hard to add new functions because all the classes must change.
So, the things that are hard for OO are easy for procedures, and the things that are
hard for procedures are easy for OO!
In any complex system there are going to be times when we want to add new data
types rather than new functions. For these cases objects and OO are most appropriate. On
the other hand, there will also be times when we’ll want to add new functions as opposed
to data types. In that case procedural code and data structures will be more appropriate.
Mature programmers know that the idea that everything is an object is a myth. Sometimes
you really do want simple data structures with procedures operating on them.

ผลลัพธ์ (ไทย) 1:

ตัวอย่างเหล่านี้แสดงความแตกต่างระหว่างวัตถุและโครงสร้างข้อมูล วัตถุที่ซ่อนข้อมูลของพวกเขาอยู่เบื้องหลัง abstractions และฟังก์ชันที่เปิดเผยที่ทำงานบนข้อมูล โครงสร้างข้อมูลเปิดเผยข้อมูล และมีฟังก์ชันที่ไม่มีความหมาย กลับ มาอ่านที่อีกครั้งสังเกตลักษณะของคำนิยามที่สองฟรี พวกเขาเป็นเสมือนตรงกันข้าม นี้ความแตกต่างอาจดูเหมือนเล็กน้อย แต่มันมีผลกระทบกว้างขวางพิจารณา เช่น ตัวอย่างรูปร่างขั้นตอนในรายการ 6-5 รูปทรงเรขาคณิตชั้นทำงานบนชั้นสามร่าง เรียนรูปร่างเขียนโปรแกรมเชิงวัตถุอาจริ้วรอยจมูกของพวกเขาที่นี่ และบ่นว่า มันเป็นขั้นตอน — และพวกเขาจะมีสิทธิ์ แต่ไม่อาจจะรับประกัน sneer พิจารณาอะไรจะเกิดขึ้นถ้าฟังก์ชัน perimeter() ได้เพิ่มรูปทรงเรขาคณิต ต้องเรียนร่างได้รับผลกระทบ ชั้นเรียนอื่น ๆ ที่รูปร่างพร้อมยังได้รับผลกระทบบนมืออื่น ๆ หากฉันเพิ่มรูปร่างใหม่ ฉันต้องเปลี่ยนฟังก์ชั่นทั้งหมดในเรขาคณิตการจัดการกับมัน อีกครั้ง อ่านที่ผ่าน ขอให้สังเกตว่า เงื่อนไขที่สองเป็นเชียรคัดค้านได้ตอนนี้ พิจารณาการแก้ไขเชิงวัตถุในรายการ 6-6 นี่คือวิธีการ area()polymorphic เรขาคณิตชั้นไม่จำเป็น ดังนั้นหากเพิ่มรูปร่างใหม่ ไม่มีของที่มีอยู่ฟังก์ชันที่ได้รับผลกระทบ แต่ถ้าฉันเพิ่มฟังก์ชันใหม่ ทั้งหมดของรูปทรงต้องเปลี่ยนแปลงอีกครั้ง เราเห็นลักษณะของข้อกำหนดเหล่านี้สอง ฟรี พวกเขาเป็นเสมือนตรงกันข้าม นี่ exposes ขั้วพื้นฐานระหว่างวัตถุและโครงสร้างข้อมูล:ขั้นตอน (รหัสโดยใช้โครงสร้างข้อมูล) ทำให้ง่ายต่อการเพิ่มฟังก์ชั่นใหม่โดยไม่ต้องการเปลี่ยนแปลงโครงสร้างข้อมูลที่มีอยู่ รหัส OO คง ทำให้มันง่ายต่อการเพิ่มชั้นเรียนใหม่โดยไม่เปลี่ยนแปลงฟังก์ชันที่มีอยู่เติมเต็มความเป็นจริง:รหัสขั้นตอนทำให้มันยากเพื่อเพิ่มโครงสร้างข้อมูลใหม่เนื่องจากต้องทำงานทั้งหมดเปลี่ยนแปลง รหัส OO ทำให้ยากที่จะเพิ่มฟังก์ชันใหม่เนื่องจากต้องการเปลี่ยนแปลงทั้งนี้ดังนั้น สิ่งที่ยากสำหรับ OO ได้ง่ายสำหรับวิธีการ และสิ่งที่ยากสำหรับขั้นตอนง่ายสำหรับ OOในระบบที่ซับซ้อนใดๆ มีกำลังจะมีบางครั้งเมื่อเราต้องการเพิ่มข้อมูลใหม่ชนิดมากกว่าฟังก์ชันใหม่ สำหรับกรณีนี้ วัตถุและ OO ได้เหมาะสมสุด บนกลับกัน นอกจากนี้ยังมีเวลาเมื่อเราจะต้องการเพิ่มฟังก์ชันใหม่เมื่อเทียบชนิดข้อมูล ในกรณีที่ โครงสร้างข้อมูลและรหัสขั้นตอนจะเหมาะสมโปรแกรมเมอร์ผู้ใหญ่รู้ว่า ความคิดที่ว่า ทุกอย่างเป็นวัตถุที่เป็นตำนาน บางทีคุณจริง ๆ ต้องโครงสร้างข้อมูลที่ง่ายขั้นตอนการดำเนินงานนั้น

ผลลัพธ์ (ไทย) 2:

สองคนนี้เป็นตัวอย่างที่แสดงให้เห็นความแตกต่างระหว่างวัตถุและโครงสร้างข้อมูล วัตถุที่ซ่อน
ข้อมูลของพวกเขาที่อยู่เบื้องหลังแนวคิดและแสดงฟังก์ชั่นที่ทำงานกับข้อมูลที่ โครงสร้างข้อมูล
เปิดเผยข้อมูลของพวกเขาและไม่มีฟังก์ชั่นที่มีความหมาย กลับไปอ่านอีกครั้ง.
ขอให้สังเกตธรรมชาติฟรีของทั้งสองคำจำกัดความ พวกเขาจะตรงข้ามเสมือน นี้
ความแตกต่างอาจดูเหมือนเล็กน้อย แต่มันก็มีความหมายกว้างขวาง.
พิจารณาตัวอย่างเช่นตัวอย่างรูปร่างขั้นตอนในรายชื่อ 6-5 เรขาคณิต
ระดับดำเนินการในสามชั้นรูปทรง เรียนรูปร่าง
โปรแกรมเมอร์เชิงวัตถุอาจย่นจมูกของพวกเขาที่นี้และบ่นว่ามัน
เป็นขั้นตอนและพวกเขาต้องการจะขวา แต่หัวเราะเยาะอาจจะไม่ได้รับการรับประกัน พิจารณาสิ่งที่
จะเกิดขึ้นถ้าปริมณฑล () ฟังก์ชันที่ถูกเพิ่มเรขาคณิต เรียนรูปร่างจะ
ได้รับผลกระทบ! ชั้นเรียนอื่น ๆ ที่ขึ้นอยู่กับรูปร่างก็จะได้รับผลกระทบ!
ในทางตรงกันข้ามถ้าฉันจะเพิ่มรูปลักษณ์ใหม่ฉันจะต้องเปลี่ยนแปลงการทำงานทั้งหมดในเรขาคณิตที่จะ
จัดการกับมัน อีกครั้งอ่านที่มากกว่า สังเกตเห็นว่าทั้งสองเงื่อนไขที่เชียร
ตรงข้าม.
ตอนนี้พิจารณาการแก้ปัญหาเชิงวัตถุในรายชื่อ 6-6 นี่คือพื้นที่ () วิธีการคือ
polymorphic ไม่มีระดับเรขาคณิตเป็นสิ่งที่จำเป็น ดังนั้นถ้าฉันจะเพิ่มรูปลักษณ์ใหม่ไม่มีของที่มีอยู่
ฟังก์ชั่นได้รับผลกระทบ แต่ถ้าฉันจะเพิ่มฟังก์ชั่นใหม่ของรูปร่างต้องมีการเปลี่ยนแปลง
อีกครั้งเราจะเห็นธรรมชาติฟรีของทั้งสองคำจำกัดความ; พวกเขาเป็นเสมือน
ตรงกันข้าม! นี้ exposes ขั้วพื้นฐานระหว่างวัตถุและโครงสร้างข้อมูล:
ประมวลกฎหมายวิธีพิจารณา (รหัสใช้โครงสร้างข้อมูล) ทำให้ง่ายต่อการเพิ่มฟังก์ชั่นใหม่โดยไม่ต้อง
เปลี่ยนโครงสร้างข้อมูลที่มีอยู่ รหัส OO บนมืออื่น ๆ ที่ทำให้ง่ายต่อการเพิ่ม
ชั้นเรียนใหม่โดยไม่ต้องเปลี่ยนฟังก์ชั่นที่มีอยู่.
ส่วนประกอบยังเป็นจริง:
ประมวลกฎหมายวิธีทำให้ยากที่จะเพิ่มโครงสร้างข้อมูลใหม่เพราะการทำงานทั้งหมดจะต้อง
เปลี่ยน รหัส OO ทำให้ยากที่จะเพิ่มฟังก์ชั่นใหม่เพราะทุกชั้นเรียนต้องเปลี่ยน.
ดังนั้นสิ่งที่ยากสำหรับ OO เป็นเรื่องง่ายสำหรับขั้นตอนและสิ่งที่
ยากสำหรับกระบวนการที่ง่ายสำหรับ OO!
ในระบบที่ซับซ้อนใด ๆ ที่มีจะ จะเป็นช่วงเวลาที่เราต้องการเพิ่มข้อมูลใหม่
ประเภทมากกว่าฟังก์ชั่นใหม่ สำหรับกรณีนี้วัตถุและ OO มีความเหมาะสมมากที่สุด บน
มืออื่น ๆ ที่มีก็จะเป็นเวลาที่เราจะต้องการที่จะเพิ่มฟังก์ชันใหม่เมื่อเทียบ
กับประเภทข้อมูล ในกรณีที่ว่ารหัสและข้อมูลในการดำเนินการโครงสร้างจะมีความเหมาะสมมากขึ้น.
โปรแกรมเมอร์ผู้ใหญ่รู้ว่าความคิดที่ว่าทุกอย่างเป็นวัตถุที่เป็นตำนาน บางครั้ง
คุณจริงๆต้องการโครงสร้างข้อมูลที่เรียบง่ายด้วยขั้นตอนการดำเนินการกับพวกเขา