ยิ่งฉันเขียนโปรแกรมที่ใช้งานได้มากเท่าไหร่ฉันก็ยิ่งรู้สึกว่ามันเพิ่มเลเยอร์สิ่งที่เป็นนามธรรมซึ่งดูเหมือนว่าเลเยอร์ของหอมหัวใหญ่เป็นอย่างไรรวมไปถึงเลเยอร์ก่อนหน้า

ฉันไม่รู้ว่านี่เป็นความจริงหรือเปล่าดังนั้นเพื่อปิดหลักการ OOP ที่ฉันเคยทำมานานหลายปีแล้วใครจะอธิบายได้ว่าการทำงานหรือไม่สามารถอธิบายสิ่งเหล่านี้ได้อย่างถูกต้อง: Encapsulation, Abstraction, Inheritance, Polymorphism

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

ฉันรู้ว่า Haskell สามารถตอบสนองความต้องการ "อินเทอร์เฟซ" แต่อีกครั้งไม่แน่ใจว่ามันเป็นวิธีการทำงานจริงหรือไม่ ฉันคาดเดาว่าความจริงที่ว่า functors มีพื้นฐานทางคณิตศาสตร์ที่คุณสามารถบอกได้ว่าสิ่งเหล่านี้เป็นสิ่งที่แน่นอนในการคาดหวังการทำงาน

โปรดให้รายละเอียดว่าคุณคิดว่าการทำงานทำหน้าที่หรือไม่ปฏิบัติตาม 4 หลักการของ OOP

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

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

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

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

ฉันพบว่าสัญชาตญาณต่อไปนี้มีประโยชน์ในการเปรียบเทียบ OOP และ FP

แทนที่จะคิดว่า FP เป็น superset ของ OOP ให้นึกถึง OOP และ FP เป็นสองทางเลือกในการดูรูปแบบการคำนวณพื้นฐานที่คล้ายกันซึ่งคุณมี:

1. การดำเนินการบางอย่างที่ดำเนินการ
2. อาร์กิวเมนต์อินพุตบางตัวสำหรับการดำเนินการ
3. ข้อมูล / พารามิเตอร์คงที่บางอย่างที่สามารถมีผลต่อความหมายของการดำเนินการ
4. ค่าผลลัพธ์บางส่วนและ
5. อาจเป็นผลข้างเคียง

ใน OOP สิ่งนี้จะถูกจับโดย

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

ใน FP สิ่งนี้ถูกจับโดย

1. การปิดที่ถูกประหารชีวิต
2. อาร์กิวเมนต์อินพุตของการปิด
3. ตัวแปรที่บันทึกได้ของการปิด
4. มูลค่าส่งคืนของการปิด
5. ผลข้างเคียงที่เป็นไปได้ของการปิด (ในภาษาบริสุทธิ์เช่น Haskell เกิดขึ้นในลักษณะที่ควบคุมได้มาก)

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

ฉันคิดว่ามุมมองที่แตกต่างมาจากความจริงที่ว่ามุมมองเชิงวัตถุอยู่ตรงกลางวัตถุ (ข้อมูล) ในขณะที่มุมมองการทำงานจะเน้นที่ฟังก์ชัน / การปิด (การดำเนินการ)

ขึ้นอยู่กับผู้ที่คุณขอคำจำกัดความของ OOP ถามคนห้าคนแล้วคุณจะได้คำจำกัดความหกคำ Wikipedia พูดว่า :

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

ดังนั้นเมื่อใดก็ตามที่ใครบางคนให้คำตอบที่ชัดเจนให้นำติดตัวไปด้วยเม็ดเกลือ

ที่กล่าวว่ามีการโต้แย้งที่ดีที่จะทำอย่างนั้นใช่ FP เป็น superset ของ OOP เป็นกระบวนทัศน์ โดยเฉพาะคำจำกัดความของ Alan Kay เกี่ยวกับการเขียนโปรแกรมเชิงวัตถุนั้นไม่ขัดแย้งกับแนวคิดนี้ (แต่Kristen Nygaard ) เคย์ทุกคนกังวลจริงๆว่าทุกอย่างเป็นวัตถุและตรรกะนั้นถูกนำไปใช้โดยการส่งข้อความระหว่างวัตถุ

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

var cls = function (x) {
    this.y = x;
    this.fun = function () { alert(this.y); };
    return this;
};

var inst = new cls(42);
inst.fun();

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

คำถามที่สำคัญยิ่งกว่าก็คือ: การจำแนก OOP นี้มีความหมายหรือไม่? มันจะช่วยให้คิดว่ามันเป็นส่วนหนึ่งของการเขียนโปรแกรมการทำงานหรือไม่ ฉันคิดว่าในกรณีส่วนใหญ่มันไม่ใช่

FP อย่าง OO ไม่ใช่คำที่กำหนดชัดเจน มีโรงเรียนที่มีคำจำกัดความแตกต่างกันบางครั้งก็ขัดแย้งกัน หากคุณทำสิ่งที่พวกเขามีร่วมกันคุณได้ลงไปที่:

• ฟังก์ชั่นการเขียนโปรแกรมเป็นการเขียนโปรแกรมด้วยฟังก์ชั่นชั้นหนึ่ง

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

ทุกสิ่งทุกอย่างมีอยู่ที่อื่นหรือขาดหายไปในบางกรณี

FP และ OO เป็นเครื่องมือสร้างสอง abstractions พวกเขาแต่ละคนมีจุดแข็งและจุดอ่อนของตนเอง (ตัวอย่างเช่นพวกเขามีทิศทางการขยายที่ต้องการแตกต่างกันในปัญหาการแสดงออก) แต่ไม่มีใครมีพลังมากกว่าภายใน คุณสามารถสร้างระบบ OO ผ่านเคอร์เนล FP (CLOS เป็นหนึ่งในระบบดังกล่าว) คุณสามารถใช้กรอบ OO เพื่อรับฟังก์ชั่นชั้นหนึ่ง (ดูวิธีการกำหนดฟังก์ชั่นแลมบ์ดาใน C ++ 11 เป็นต้น)

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

ที่จริงคุณสามารถพิจารณาการเขียนโปรแกรมการทำงานย่อยของ OOP; ถ้าคุณทำให้คลาสทั้งหมดของคุณไม่เปลี่ยนรูปคุณอาจคิดว่าคุณมีการเขียนโปรแกรมที่ใช้งานได้บางอย่าง

ตอบ:

Wikipedia มีบทความที่ยอดเยี่ยมเกี่ยวกับ Function Programming พร้อมด้วยตัวอย่างที่คุณขอ @ Konrad Rudolph ได้จัดเตรียมลิงก์ไปยังบทความ OOPแล้ว

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

คำถามของคุณซับซ้อนยิ่งขึ้นโดยการนำ FP และ OOP ไปปฏิบัติทั้งหมด แต่ละภาษามีนิสัยใจคอของตนเองที่เกี่ยวข้องกับคำตอบที่ดีสำหรับคำถามของคุณ

การท่องเที่ยวเชิงเปรียบเทียบที่เพิ่มมากขึ้น:

ฉันชอบความคิดที่ว่าภาษาอย่างสกาล่าพยายามที่จะให้สิ่งที่ดีที่สุดแก่คุณทั้งสองโลก ฉันกังวลว่ามันจะช่วยให้คุณมีภาวะแทรกซ้อนของทั้งสองโลกเช่นกัน

Java เป็นภาษา OO แต่เวอร์ชัน 7 ได้เพิ่มคุณสมบัติ "ลองกับทรัพยากร" ซึ่งสามารถใช้ในการเลียนแบบการปิด ที่นี่มันลอกเลียนแบบการปรับปรุงตัวแปรท้องถิ่น "a" ที่อยู่ตรงกลางของฟังก์ชั่นอื่นโดยไม่ทำให้ฟังก์ชั่นนั้นมองเห็นได้ ในกรณีนี้ครึ่งแรกของฟังก์ชั่นอื่น ๆ คือคอนสตรัคเตอร์ ClosureTry () และครึ่งหลังเป็นเมธอด close ()

public class ClosureTry implements AutoCloseable {

    public static void main(String[] args) {
        int a = 1;
        try(ClosureTry ct = new ClosureTry()) {
            System.out.println("Middle Stuff...");
            a = 2;
        }
        System.out.println("a: " + a);
    }

    public ClosureTry() {
        System.out.println("Start Stuff Goes Here...");
    }

    /** Interface throws exception, but we don't have to. */
    public void close() {
        System.out.println("End Stuff Goes Here...");
    }
}

เอาท์พุท:

Start Stuff Goes Here...
Middle Stuff...
End Stuff Goes Here...
a: 2

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

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

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

ส่วนที่มีประโยชน์ที่สุดของการโปรแกรมเชิงฟังก์ชันคือความไม่สามารถเปลี่ยนแปลงได้ (โทเค็น / ค่าแทนตัวแปร), ฟังก์ชั่น (ไม่มีผลข้างเคียง) และการปิด

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