อะไรคือความแตกต่างระหว่างอินเตอร์เฟสและคลาสนามธรรม?

อินเตอร์เฟซ

อินเทอร์เฟซคือสัญญา : ผู้ที่เขียนอินเทอร์เฟซกล่าวว่า " เฮ้ฉันยอมรับสิ่งที่กำลังมองหาอยู่ " และผู้ที่ใช้อินเทอร์เฟซก็บอกว่า " ตกลงชั้นที่ฉันเขียนจะเป็นแบบนั้น "

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

ตัวอย่างเช่น (รหัสเทียม):

// I say all motor vehicles should look like this:
interface MotorVehicle
{
    void run();

    int getFuel();
}

// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }


    int getFuel()
    {
        return this.fuel;
    }
}

การใช้อินเทอร์เฟซนั้นใช้ CPU น้อยมากเพราะไม่ใช่คลาส แต่เป็นชื่อกลุ่มดังนั้นจึงไม่มีค่าใช้จ่ายในการค้นหามากนัก มันยอดเยี่ยมเมื่อมันมีความสำคัญเช่นในอุปกรณ์ฝังตัว

คลาสนามธรรม

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

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

ตัวอย่างเช่น:

// I say all motor vehicles should look like this:
abstract class MotorVehicle
{

    int fuel;

    // They ALL have fuel, so lets implement this for everybody.
    int getFuel()
    {
         return this.fuel;
    }

    // That can be very different, force them to provide their
    // own implementation.
    abstract void run();
}

// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
    void run()
    {
        print("Wrroooooooom");
    }
}

การดำเนินงาน

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

ใน Java กฎนี้มีการบังคับใช้อย่างมากในขณะที่ PHP ส่วนต่อประสานเป็นคลาสนามธรรมโดยไม่มีการประกาศวิธี

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

ตามปกติด้วยการเขียนโปรแกรมมีทฤษฎีการฝึกฝนและการฝึกฝนเป็นภาษาอื่น :-)

ความแตกต่างทางเทคนิคที่สำคัญระหว่างคลาสนามธรรมและอินเตอร์เฟสคือ:

• คลาสนามธรรมสามารถมีค่าคงที่สมาชิกสตับส์เมธอด (เมธอดที่ไม่มีเนื้อหา) และเมธอดที่กำหนดในขณะที่อินเตอร์เฟสสามารถมีค่าคงที่และสตับเท่านั้น

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

• เมื่อสืบทอดคลาสนามธรรมคลาสลูกคอนกรีตต้องกำหนดเมธอด abstractขณะที่คลาส abstract สามารถขยายคลาสนามธรรมและเมธอด abstract จากคลาสพาเรนต์ไม่ต้องถูกกำหนด

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

• คลาสเด็กสามารถขยายชั้นเดียวเท่านั้น(นามธรรมหรือรูปธรรม) ในขณะที่อินเทอร์เฟซสามารถขยายหรือคลาสสามารถใช้อินเทอร์เฟซอื่นหลายตัว

• คลาสเด็กสามารถกำหนดวิธีนามธรรมด้วยทัศนวิสัยที่ จำกัด หรือน้อยกว่าในขณะที่คลาสที่ใช้อินเตอร์เฟสต้องกำหนดวิธีการด้วยทัศนวิสัยเดียวกัน (สาธารณะ)

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

เอามาจาก:

http://www.dotnetbull.com/2011/11/difference-between-abstract-class-and.html

http://www.dotnetbull.com/2011/11/what-is-abstract-class-in-c-net.html http://www.dotnetbull.com/2011/11/what-is-interface-in -c-net.html

คำอธิบายมีอยู่ที่นี่: http://www.developer.com/lang/php/article.php/3604111/PHP-5-OOP-Interfaces-Abstract-Classes-and-the-Adapter-Pattern.htm

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

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

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

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

ในแง่ง่ายฉันอยากจะบอกว่า:

อินเทอร์เฟซ:การใช้สัญญาโดยวัตถุที่ไม่เกี่ยวข้องหลายรายการ

ระดับนามธรรม:เพื่อใช้พฤติกรรมที่เหมือนกันหรือแตกต่างระหว่างวัตถุที่เกี่ยวข้องหลายรายการ

จากเอกสารของ Oracle

พิจารณาใช้คลาสนามธรรมหาก:

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

พิจารณาใช้อินเตอร์เฟสหาก:

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

ระดับนามธรรมกำหนด "คือ" ความสัมพันธ์กับชั้นเรียนที่เป็นรูปธรรม อินเตอร์เฟสให้ความสามารถ "มี" สำหรับคลาส

หากคุณกำลังมองหาJavaภาษาการเขียนโปรแกรมต่อไปนี้คือการอัปเดตเพิ่มเติมบางประการ:

Java 8 ได้ลดช่องว่างระหว่างinterfaceและabstractคลาสในระดับหนึ่งโดยจัดเตรียมdefaultคุณลักษณะเมธอด อินเทอร์เฟซที่ไม่มีการใช้งานสำหรับวิธีการไม่ถูกต้องในขณะนี้

อ้างถึงหน้าเอกสารนี้สำหรับรายละเอียดเพิ่มเติม

ดูคำถาม SE นี้เพื่อดูตัวอย่างโค้ดเพื่อทำความเข้าใจให้ดีขึ้น

ฉันจะอธิบายความแตกต่างระหว่างอินเทอร์เฟซกับคลาสนามธรรมได้อย่างไร

ความแตกต่างที่สำคัญบางประการ:

ในรูปแบบของตาราง:

ตามที่ระบุโดย Joe จาก javapapers :

1. ความแตกต่างหลักคือวิธีการของส่วนต่อประสาน Java เป็นนามธรรมโดยปริยายและไม่สามารถใช้งานได้ คลาสนามธรรม Java สามารถมีวิธีการอินสแตนซ์ที่ดำเนินพฤติกรรมเริ่มต้น

2. ตัวแปรที่ประกาศในอินเตอร์เฟส Java นั้นเป็นค่าเริ่มต้นสุดท้าย คลาสนามธรรมอาจมีตัวแปรที่ไม่สิ้นสุด

3. สมาชิกของส่วนต่อประสาน Java เป็นสาธารณะโดยค่าเริ่มต้น คลาสนามธรรมของ Java สามารถมีสมาชิกคลาสได้ตามปกติเช่นส่วนตัวมีการป้องกัน ฯลฯ

ส่วนต่อประสาน 4.Java ควรจะใช้งานโดยใช้คำหลัก“ ดำเนินการ”; คลาสนามธรรมของ Java ควรถูกขยายโดยใช้คีย์เวิร์ด“ extends”

5. ส่วนต่อประสานสามารถขยายส่วนต่อประสาน Java อื่นเท่านั้นคลาสนามธรรมสามารถขยายคลาส Java อีกชั้นและใช้อินเทอร์เฟซ Java หลายตัว

6.A Java class สามารถใช้หลายอินเตอร์เฟส แต่สามารถขยายคลาส abstract เพียงคลาสเดียวเท่านั้น

7. อินเทอร์เฟซเป็นนามธรรมและไม่สามารถสร้างอินสแตนซ์ได้ คลาสนามธรรมของ Java ไม่สามารถสร้างอินสแตนซ์ได้ แต่สามารถเรียกใช้ได้ถ้ามี main () อยู่

8. ในการเปรียบเทียบกับคลาส abstract ของจาวาอินเทอร์เฟซ java จะช้าเนื่องจากต้องใช้การเปลี่ยนทิศทางเพิ่มเติม

ประเด็นหลักคือ:

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

เมื่อคุณต้องการให้พฤติกรรม polymorphic ในลำดับชั้นการสืบทอดให้ใช้คลาสนามธรรม

เมื่อคุณต้องการพฤติกรรม polymorphic สำหรับคลาสที่ไม่เกี่ยวข้องอย่างสมบูรณ์ให้ใช้อินเทอร์เฟซ

ฉันกำลังก่อสร้างอาคาร 300 ชั้น

ส่วนต่อประสานพิมพ์เขียวของอาคาร

• ตัวอย่างเช่น Servlet (I)

อาคารที่สร้างสูงถึง 200 ชั้น - สร้างเสร็จแล้วบางส่วน --- นามธรรม

• การใช้งานบางส่วนเช่น servlet ทั่วไปและ HTTP

ก่อสร้างอาคารเสร็จ - คอนกรีต

• การติดตั้งแบบสมบูรณ์ตัวอย่างเช่นเซิร์ฟเล็ตของตัวเอง

อินเตอร์เฟซ

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

นามธรรม

• การใช้งานบางส่วน
• มันมีวิธีนามธรรม นอกจากนี้ยังใช้คอนกรีต
• ไม่มีข้อ จำกัด สำหรับการดัดแปลงวิธีการเรียนนามธรรม
• ไม่มีข้อ จำกัด สำหรับตัวดัดแปลงตัวแปรคลาสนามธรรม
• เราไม่สามารถประกาศตัวดัดแปลงอื่น ๆ ได้ยกเว้นบทคัดย่อ
• ไม่มีข้อ จำกัด ในการเริ่มต้นตัวแปร

นำมาจากเว็บไซต์ DurgaJobs

ลองทำกับคำถามนี้อีกครั้ง:

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

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

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

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

มันค่อนข้างง่ายจริงๆ

คุณสามารถคิดถึงอินเทอร์เฟซเป็นคลาสที่ได้รับอนุญาตให้มีวิธีนามธรรมและไม่มีอะไรอื่น

ดังนั้นอินเตอร์เฟสสามารถ "ประกาศ" เท่านั้นและไม่ได้กำหนดพฤติกรรมที่คุณต้องการให้คลาสมี

คลาสนามธรรมช่วยให้คุณสามารถประกาศ (โดยใช้เมธอด abstract) รวมถึง define (โดยใช้วิธีการใช้งานแบบเต็ม) พฤติกรรมที่คุณต้องการให้คลาสมี

และคลาสปกติเท่านั้นอนุญาตให้คุณกำหนดไม่ประกาศพฤติกรรม / การกระทำที่คุณต้องการให้คลาสมี

สิ่งสุดท้าย,

ใน Java คุณสามารถใช้หลายอินเตอร์เฟส แต่คุณสามารถขยายได้เพียงหนึ่งคลาส (Abstract Class หรือ Class) ...

ซึ่งหมายความว่าการสืบทอดของพฤติกรรมที่กำหนดถูก จำกัด ให้อนุญาตเพียงหนึ่งต่อคลาส ... นั่นคือถ้าคุณต้องการคลาสที่ห่อหุ้มพฤติกรรมจากคลาส A, B & C คุณจะต้องทำสิ่งต่อไปนี้: คลาส A ขยาย B, คลาส C ขยาย A มันเป็นบิตของรอบเกี่ยวกับวิธีการมีหลายมรดก ...

อินเทอร์เฟซในอีกทางหนึ่งคุณสามารถทำได้: อินเตอร์เฟส C ใช้ A, B

ดังนั้นในความเป็นจริงแล้ว Java สนับสนุนการสืบทอดหลายรายการเฉพาะใน "การประกาศพฤติกรรม" เช่นอินเทอร์เฟซและการสืบทอดเดียวที่มีพฤติกรรมที่กำหนด .. เว้นแต่คุณจะทำรอบเกี่ยวกับวิธีที่ฉันอธิบาย ...

หวังว่ามันสมเหตุสมผล

การเปรียบเทียบอินเทอร์เฟซกับคลาสนามธรรมไม่ถูกต้อง ควรจะมีการเปรียบเทียบสองอื่น ๆ แทน: 1) ระดับเทียบกับอินเตอร์เฟซและ 2) นามธรรมเทียบชั้นสุดท้าย

อินเตอร์เฟสเทียบกับคลาส

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

interface Package {
  String address();
}

Classคือกลุ่มของวัตถุที่เชื่อฟังสัญญา เช่นฉันเป็นกล่องจากกลุ่ม "กล่อง" และฉันเชื่อฟังสัญญาที่บุรุษไปรษณีย์ต้องการ ในเวลาเดียวกันฉันเชื่อฟังสัญญาอื่น:

class Box implements Package, Property {
  @Override
  String address() {
    return "5th Street, New York, NY";
  }
  @Override
  Human owner() {
    // this method is part of another contract
  }
}

บทคัดย่อกับรอบชิงชนะเลิศ

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

abstract class GpsBox implements Package {
  @Override
  public abstract String address();
  protected Coordinates whereAmI() {
    // connect to GPS and return my current position
  }
}

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

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

final class DirectBox implements Package {
  private final String to;
  public DirectBox(String addr) {
    this.to = addr;
  }
  @Override
  public String address() {
    return this.to;
  }
}

ในภาษาส่วนใหญ่เช่น Java หรือ C ++ เป็นไปได้ที่จะมีเพียงคลาสเท่านั้น คลาสนี้สามารถสืบทอดและสามารถอินสแตนซ์ได้ ฉันไม่คิดว่าสิ่งนี้จะสอดคล้องกับกระบวนทัศน์เชิงวัตถุอย่างเคร่งครัด

อีกครั้งการเปรียบเทียบอินเทอร์เฟซกับคลาสนามธรรมไม่ถูกต้อง

ในระยะสั้นความแตกต่างดังต่อไปนี้:

ความแตกต่างทางไวยากรณ์ระหว่างอินเทอร์เฟซและคลาสนามธรรม :

1. วิธีการและสมาชิกของคลาสนามธรรมสามารถมองเห็นได้ วิธีการทั้งหมดของอินเตอร์เฟซจะต้องเป็นของประชาชน // ไม่ถือจริงจาก Java 9 อีกต่อไป
2. คลาสย่อยที่เป็นรูปธรรมของคลาสAbstractต้องกำหนดเมธอด abstract ทั้งหมด บทคัดย่อชั้นเด็กสามารถมีวิธีการที่เป็นนามธรรม อินเตอร์เฟซการขยายความจำเป็นในอินเตอร์เฟซที่อื่นได้ให้การเริ่มต้นใช้งานสำหรับวิธีการรับมรดกมาจากอินเตอร์เฟซผู้ปกครอง
3. คลาสลูกสามารถขยายชั้นเดียวเท่านั้น อินเตอร์เฟซที่สามารถขยายการเชื่อมต่อหลาย คลาสสามารถใช้หลายอินเตอร์เฟส
4. คลาสเด็กสามารถกำหนดวิธีนามธรรมด้วยการมองเห็นที่ จำกัด หรือน้อยกว่าในขณะที่คลาสที่ใช้อินเตอร์เฟซจะต้องกำหนดวิธีการอินเตอร์เฟซทั้งหมดเป็นสาธารณะ
5. เรียนบทคัดย่อสามารถมีการก่อสร้าง แต่ไม่อินเตอร์เฟซ
6. อินเตอร์เฟสจาก Java 9 มีเมธอดสแตติกส่วนตัว

ในส่วนต่อประสานตอนนี้:

public static- สนับสนุน
public abstract- สนับสนุน
public default- สนับสนุน
private static- สนับสนุน
private abstract- ข้อผิดพลาดในการ
private defaultคอมไพล์
private- ข้อผิดพลาดในการรวบรวม- รองรับ

ข้อแตกต่างเพียงอย่างเดียวคือสามารถมีส่วนร่วมในการสืบทอดหลายอย่างและอื่น ๆ ไม่สามารถทำได้

คำจำกัดความของอินเทอร์เฟซมีการเปลี่ยนแปลงเมื่อเวลาผ่านไป คุณคิดว่าส่วนต่อประสานมีเพียงการประกาศเมธอดเท่านั้นและเป็นเพียงสัญญาหรือไม่ สิ่งที่เกี่ยวกับตัวแปรสุดท้ายคงที่และสิ่งที่เกี่ยวกับคำนิยามเริ่มต้นหลังจาก Java 8?

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

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

ดูเหตุใด Java จึงอนุญาตให้ใช้ตัวแปรสุดท้ายแบบคงที่ในอินเทอร์เฟซเมื่อมีวัตถุประสงค์เพื่อเป็นสัญญาเท่านั้น .

ส่วนต่อประสาน: เลี้ยว (เลี้ยวซ้ายเลี้ยวขวา)

ระดับนามธรรม: ล้อ

ชั้น: พวงมาลัยที่เกิดขึ้นจากล้อจะเปิดเผยอินเตอร์เฟสแบบหมุน

หนึ่งสำหรับการจัดหมวดหมู่พฤติกรรมที่สามารถนำเสนอในช่วงที่หลากหลายของสิ่งที่อื่น ๆ สำหรับการสร้างแบบจำลองภววิทยาของสิ่งต่าง ๆ

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

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงสิ่งนี้

คลาสนามธรรมใน Java:

abstract class animals
{
    // They all love to eat. So let's implement them for everybody
    void eat()
    {
        System.out.println("Eating...");
    }
    // The make different sounds. They will provide their own implementation.
    abstract void sound();
}

class dog extends animals
{
    void sound()
    {
        System.out.println("Woof Woof");
    }
}

class cat extends animals
{
    void sound()
    {
        System.out.println("Meoww");
    }
}

ต่อไปนี้คือการใช้อินเตอร์เฟซใน Java:

interface Shape
{
    void display();
    double area();
}

class Rectangle implements Shape 
{
    int length, width;
    Rectangle(int length, int width)
    {
        this.length = length;
        this.width = width;
    }
    @Override
    public void display() 
    {
        System.out.println("****\n* *\n* *\n****"); 
    }
    @Override
    public double area() 
    {
        return (double)(length*width);
    }
} 

class Circle implements Shape 
{
    double pi = 3.14;
    int radius;
    Circle(int radius)
    {
        this.radius = radius;
    }
    @Override
    public void display() 
    {
        System.out.println("O"); // :P
    }
    @Override
    public double area() 
    { 
        return (double)((pi*radius*radius)/2);
    }
}

ประเด็นสำคัญที่สำคัญบางประการ:

1. ตัวแปรที่ประกาศในอินเตอร์เฟส Java เป็นค่าเริ่มต้นสุดท้าย คลาสนามธรรมสามารถมีตัวแปรที่ไม่สิ้นสุด

2. ตัวแปรที่ประกาศในอินเตอร์เฟส Java นั้นเป็นค่าเริ่มต้นคงที่ คลาสนามธรรมสามารถมีตัวแปรแบบไม่คงที่

3. สมาชิกของอินเตอร์เฟส Java เป็นแบบสาธารณะโดยค่าเริ่มต้น คลาสนามธรรมของ Java สามารถมีสมาชิกคลาสได้ตามปกติเช่นส่วนตัวมีการป้องกัน ฯลฯ

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

อินเทอร์เฟซและคลาสนามธรรมแม้ว่าจะคล้ายกันจากมุมมองทางเทคนิค แต่มีความหมายและวัตถุประสงค์ที่แตกต่างกันโดยสิ้นเชิง

สรุป

1. อินเตอร์เฟซที่กำหนดในสัญญาว่าการดำเนินการบางอย่างที่จะตอบสนองสำหรับคุณ

2. คลาสนามธรรมให้พฤติกรรมเริ่มต้นที่การใช้งานของคุณสามารถนำมาใช้ใหม่

สรุปทางเลือก

1. อินเทอร์เฟซสำหรับการกำหนด API สาธารณะ
2. คลาสนามธรรมสำหรับใช้ภายในและเพื่อกำหนด SPIs

เกี่ยวกับความสำคัญของการซ่อนรายละเอียดการใช้งาน

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

ในทางกลับกันผู้ใช้ระดับสูงของรายการไม่สนใจว่าจะมีการใช้งานจริง ๆ อย่างไรและพวกเขาควรได้รับการปกป้องจากรายละเอียดเหล่านี้ ลองนึกภาพว่า Java ไม่ได้เปิดเผยListอินเตอร์เฟส แต่มีListคลาสที่เป็นรูปธรรมเท่านั้นที่จริงแล้วLinkedListตอนนี้เป็นอย่างไร นักพัฒนา Java ทั้งหมดจะปรับแต่งรหัสเพื่อให้เหมาะกับรายละเอียดการใช้งาน: หลีกเลี่ยงการเข้าถึงแบบสุ่มเพิ่มแคชเพื่อเพิ่มความเร็วในการเข้าถึงหรือเพียงแค่นำมาใช้ใหม่ArrayListด้วยตนเองแม้ว่ามันจะไม่เข้ากันกับรหัสอื่น ๆ ทั้งหมดListเพียง นั่นน่ากลัว ... แต่ตอนนี้ลองนึกภาพว่าจาวาจาวาตระหนักแล้วว่ารายการที่เชื่อมโยงนั้นแย่มากสำหรับกรณีการใช้งานจริงและตัดสินใจเปลี่ยนไปใช้รายการอาเรย์สำหรับพวกเขาเท่านั้นListชั้นเรียนที่มีอยู่ สิ่งนี้จะส่งผลต่อประสิทธิภาพของทุกโปรแกรม Java ในโลกและผู้คนจะไม่มีความสุขกับมัน และผู้ร้ายหลักคือรายละเอียดการใช้งานมีอยู่และนักพัฒนาสันนิษฐานว่ารายละเอียดเหล่านั้นเป็นสัญญาถาวรที่พวกเขาสามารถไว้วางใจได้ นี่คือเหตุผลที่เป็นสิ่งสำคัญในการซ่อนรายละเอียดการใช้งานและกำหนดสัญญาแบบนามธรรมเท่านั้น นี่คือจุดประสงค์ของอินเทอร์เฟซ: กำหนดชนิดของวิธีการที่รับเข้าและชนิดของเอาต์พุตที่คาดไว้โดยไม่เปิดเผยความกล้าทั้งหมดที่จะดึงดูดโปรแกรมเมอร์ให้ปรับแต่งรหัสของพวกเขาเพื่อให้เหมาะกับรายละเอียดภายในที่อาจเปลี่ยนแปลงได้ .

คลาสนามธรรมอยู่ตรงกลางระหว่างอินเตอร์เฟสและคลาสที่เป็นรูปธรรม มันควรจะช่วยให้การใช้งานร่วมกันรหัสทั่วไปหรือน่าเบื่อ ตัวอย่างเช่นAbstractCollectionจัดเตรียมการนำไปใช้งานพื้นฐานสำหรับisEmptyขนาดเป็น 0 containsตามที่วนซ้ำและเปรียบเทียบaddAllเป็นซ้ำaddและอื่น ๆ วิธีนี้ช่วยให้การใช้งานเน้นไปที่ส่วนสำคัญที่แยกความแตกต่างระหว่างพวกเขา: วิธีการจัดเก็บและดึงข้อมูลจริง

API กับ SPIs

ส่วนต่อประสานคือเกตเวย์ที่มีการเกาะติดกันต่ำระหว่างส่วนต่าง ๆ ของรหัส พวกเขาอนุญาตให้ไลบรารีมีอยู่และมีวิวัฒนาการโดยไม่ทำลายผู้ใช้ไลบรารีทุกคนเมื่อมีบางสิ่งเปลี่ยนแปลงภายใน มันเรียกว่าApplication Programming Interfaceไม่ใช่ Application Programming Classes ในขนาดที่เล็กลงพวกเขายังอนุญาตให้นักพัฒนาหลายคนทำงานร่วมกันได้สำเร็จในโครงการขนาดใหญ่โดยแยกโมดูลที่แตกต่างกันผ่านทางเอกสารที่มีอินเตอร์เฟสที่ดี

คลาสนามธรรมเป็นตัวช่วยที่เชื่อมโยงกันสูงที่จะใช้เมื่อนำอินเตอร์เฟสมาใช้โดยสมมติว่ามีรายละเอียดของการนำไปปฏิบัติบางระดับ อีกทางเลือกหนึ่งคลาสนามธรรมใช้สำหรับกำหนด SPIs, Service Provider Interfaces

ความแตกต่างระหว่าง API และ SPI นั้นบอบบาง แต่สำคัญ: สำหรับ API โฟกัสอยู่ที่ใครใช้และสำหรับ SPI นั้นโฟกัสอยู่ที่ว่าใครจะใช้มัน

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

หมายเหตุเกี่ยวกับ Java 8 และวิธีการเริ่มต้น

แม้ว่า Java 8 จะแนะนำวิธีการเริ่มต้นสำหรับอินเตอร์เฟสซึ่งทำให้เส้นแบ่งระหว่างอินเตอร์เฟสและคลาส abstract แม้จะพร่ามัว แต่ก็ไม่ได้ทำให้การใช้งานสามารถนำรหัสมาใช้ใหม่ได้ แต่เพื่อให้ง่ายต่อการเปลี่ยนอินเตอร์เฟสที่ให้บริการทั้ง API (หรือใช้ผิดเพื่อกำหนด SPIs แทนคลาสนามธรรม)

จะใช้อันไหนดี?

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

ข้อสรุป: วิธีอื่น ๆ มักจะทำผิดพลาด: เมื่อใช้สิ่งของพยายามใช้คลาส / ส่วนต่อประสานที่คุณต้องการ ในคำอื่น ๆ อย่าประกาศตัวแปรของคุณArrayList theList = new ArrayList()ยกเว้นว่าคุณมีการพึ่งพาอย่างมากในการเป็นรายการอาร์เรย์และไม่มีรายการประเภทอื่นที่จะตัดให้คุณ ใช้List theList = new ArrayListแทนหรือแม้ว่าCollection theCollection = new ArrayListความจริงที่ว่ามันเป็นรายการและไม่มีคอลเลกชันประเภทอื่น ๆ ไม่สำคัญ

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

ฉันมีความรู้ จำกัด เกี่ยวกับ OOP แต่การเห็นส่วนต่อประสานที่เทียบเท่ากับคำคุณศัพท์ในไวยากรณ์นั้นใช้ได้สำหรับฉันจนถึงตอนนี้ (แก้ไขให้ฉันถ้าวิธีนี้เป็นของปลอม!) ตัวอย่างเช่นชื่ออินเทอร์เฟซเป็นเหมือนแอตทริบิวต์หรือความสามารถที่คุณสามารถมอบให้กับคลาสและคลาสสามารถมีได้หลายรายการ: ISerializable, ICountable, IList, ICacheable, IHappy, ...

มรดกถูกนำมาใช้เพื่อวัตถุประสงค์สองประการ:

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

• เพื่อให้การอ้างอิงไปยังวัตถุประเภทหนึ่งที่จะใช้รหัสซึ่งคาดว่าการอ้างอิงไปยังวัตถุประเภท supertype

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

คลาส Abstract อาจมีข้อมูลสมาชิกและการใช้งานเมธอด แต่สามารถสืบทอดได้เฉพาะคลาสที่ไม่ได้รับสืบทอดจากคลาสอื่น ๆ อินเทอร์เฟซแทบไม่มีข้อ จำกัด ในประเภทที่นำมาใช้ แต่ไม่สามารถรวมข้อมูลสมาชิกหรือวิธีการใช้งาน

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

ประเด็นสำคัญ:

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

ความได้เปรียบ:

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

ค้นหารายละเอียดได้ที่นี่ ... http://pradeepatkari.wordpress.com/2014/11/20/interface-and-abstract-class-in-c-oops/

วิธีที่สั้นที่สุดในการสรุปคือว่าinterface:

1. นามธรรมอย่างสมบูรณ์นอกเหนือจากdefaultและstaticวิธีการ; ในขณะที่มันมีคำจำกัดความ (วิธีลายเซ็น + การใช้งาน) defaultและstaticวิธีการ แต่ก็มีการประกาศ (ลายเซ็นวิธีการ) สำหรับวิธีการอื่น ๆ
2. อยู่ภายใต้กฎของคนขี้หลีกว่าคลาส (คลาสสามารถใช้หลายinterfaces และinterfaceสามารถสืบทอดจากหลายinterfaces) ตัวแปรทั้งหมดเป็นค่าคงที่โดยนัยไม่ว่าจะระบุpublic static finalหรือไม่ก็ตาม สมาชิกทุกคนโดยปริยายpublicไม่ว่าจะระบุเช่นนั้นหรือไม่
3. โดยทั่วไปใช้เป็นเครื่องยืนยันว่าคลาสที่ใช้งานจะมีคุณสมบัติที่ระบุและ / หรือเข้ากันได้กับคลาสอื่น ๆ ซึ่งใช้อินเทอร์เฟซเดียวกัน

ในขณะเดียวกันabstractชั้นเรียนคือ:

1. ที่ใดก็ได้จากบทคัดย่ออย่างเต็มที่ถึงการดำเนินการอย่างเต็มที่ด้วยแนวโน้มที่จะมีวิธีการอย่างน้อยหนึ่งabstractวิธี abstractสามารถมีทั้งการประกาศและคำจำกัดความที่มีการประกาศทำเครื่องหมายว่าเป็น
2. คลาสที่เต็มเปี่ยมและอยู่ภายใต้กฎที่ควบคุมคลาสอื่น ๆ (สามารถสืบทอดจากคลาสเดียวเท่านั้น) โดยมีเงื่อนไขว่าไม่สามารถสร้างอินสแตนซ์ได้ (เนื่องจากไม่มีการรับประกันว่าจะใช้งานได้อย่างสมบูรณ์) สามารถมีตัวแปรสมาชิกไม่คงที่ สามารถดำเนินการควบคุมการเข้าถึงสมาชิก จำกัด เป็นสมาชิกprotected, privateหรือแพคเกจเอกชน (ไม่ได้ระบุ)
3. โดยทั่วไปจะใช้เพื่อให้การใช้งานมากที่สุดเท่าที่สามารถใช้ร่วมกันโดย subclasses หลายหรือเพื่อให้การดำเนินการมากที่สุดเท่าที่โปรแกรมเมอร์สามารถที่จะจัดหา

หรือถ้าเราต้องการที่จะต้มมันลงไปประโยคเดียว: การinterfaceคือสิ่งที่ระดับการใช้มีแต่abstractระดับคือสิ่งที่ประเภทรองคือ

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

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

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

ความแตกต่างระหว่างคลาสนามธรรมและอินเตอร์เฟสในนามของการใช้งานจริง

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

กรณีการใช้งานอื่นที่เราควรใช้ส่วนต่อประสาน

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

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

ตัวอย่างคลาสนามธรรม:

 public abstract class DesireCar
  {

 //It is an abstract method that defines the prototype.
     public abstract void Color();

  // It is a default implementation of a Wheel method as all the desire cars have the same no. of wheels.   
 // and hence no need to define this in all the sub classes in this way it saves the code duplicasy     

  public void Wheel() {          

               Console.WriteLine("Car has four wheel");
                }
           }


    **Here is the sub classes:**

     public class DesireCar1 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red color Desire car");
            }
        }

        public class DesireCar2 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red white Desire car");
            }
        }

ตัวอย่างของอินเทอร์เฟซ:

  public interface IShape
        {
          // Defines the prototype(template) 
            void Draw();
        }


  // All the sub classes follow the same template but implementation can be different.

    public class Circle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Circle");
        }
    }

    public class Rectangle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Rectangle");
        }
    }

คุณสามารถค้นหาความแตกต่างที่ชัดเจนระหว่างอินเทอร์เฟซและคลาสนามธรรม

อินเตอร์เฟซ

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

ชั้นนามธรรม

• ชั้นนามธรรมประกอบด้วยวิธีนามธรรมและไม่ใช่นามธรรม

• ไม่บังคับให้ผู้ใช้ใช้วิธีการทั้งหมดเมื่อสืบทอดคลาส abstract

• มีตัวแปรทุกชนิดรวมถึงแบบดั้งเดิมและแบบดั้งเดิม

• ประกาศโดยใช้คำหลักที่เป็นนามธรรม

• วิธีการและสมาชิกของคลาสนามธรรมสามารถกำหนดได้ด้วยการมองเห็นใด ๆ

• คลาสเด็กสามารถขยายชั้นเดียวเท่านั้น (นามธรรมหรือคอนกรีต)

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

อินเทอร์เฟซคือพิมพ์เขียว / แม่แบบของวิธีการ (เช่นบ้านบนกระดาษได้รับ (บ้านอินเตอร์เฟซ) และสถาปนิกที่แตกต่างกันจะใช้ความคิดของพวกเขาในการสร้างมัน (ชั้นเรียนของสถาปนิกที่ใช้อินเตอร์เฟซบ้าน) วิธีการนามธรรม, วิธีการเริ่มต้น, วิธีการคงที่, ตัวแปรสุดท้ายและคลาสที่ซ้อนกันสมาชิกทั้งหมดจะได้รับอนุญาตไม่ว่าจะเป็นตัวระบุสุดท้ายหรือสาธารณะ, การป้องกันและการเข้าถึงส่วนตัวไม่อนุญาตให้มีการสร้างวัตถุ การนำอินเตอร์เฟสไปใช้และเพื่อแทนที่เมธอด abstract ที่ประกาศไว้ในอินเตอร์เฟสอินเตอร์เฟสเป็นตัวอย่างที่ดีของการมีเพศสัมพันธ์แบบหลวม ใช้งานคลาสสำหรับเช่นมี 'บริษัท รถยนต์ sa และต้องการให้คุณสมบัติบางอย่างเหมือนกันสำหรับรถทุกคันที่ผลิตดังนั้น บริษัท จะสร้างรถยนต์ส่วนต่อประสานซึ่งจะมีคุณสมบัติเหล่านั้นและรถยนต์ประเภทต่างๆ (เช่น Maruti Suzkhi, Maruti 800) จะแทนที่ คุณสมบัติเหล่านั้น (ฟังก์ชั่น)

ทำไมอินเตอร์เฟสเมื่อเรามีคลาสนามธรรม? Java รองรับการสืบทอดหลายระดับและลำดับชั้นเท่านั้น แต่ด้วยความช่วยเหลือของอินเทอร์เฟซที่เราสามารถใช้หลายมรดก

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

ในอินเทอร์เฟซวิธีการทั้งหมดจะต้องเป็นคำจำกัดความเท่านั้นไม่ควรดำเนินการอย่างใดอย่างหนึ่ง

แต่ในคลาสนามธรรมจะต้องมีวิธีนามธรรมที่มีคำจำกัดความเท่านั้น แต่วิธีอื่นสามารถอยู่ในคลาสนามธรรมด้วยการใช้ ...

เรามีโครงสร้าง / การสร้างประโยคต่างกันระหว่างอินเตอร์เฟสและคลาสนามธรรม ความแตกต่างบางอย่างคือ

[1] ความแตกต่างตามสถานการณ์ :

คลาสนามธรรมถูกใช้ในสถานการณ์เมื่อเราต้องการ จำกัด ผู้ใช้เพื่อสร้างออบเจ็กต์ของคลาสพาเรนต์และเราเชื่อว่าจะมีการเพิ่มเมธอดนามธรรมในอนาคต

อินเทอร์เฟซจะต้องใช้เมื่อเราแน่ใจว่าจะไม่มีวิธีที่เป็นนามธรรมเหลือให้ให้ จากนั้นจะมีการเผยแพร่เฉพาะส่วนต่อประสาน

[2] ความแตกต่างทางแนวคิด :

"เราจำเป็นต้องให้วิธีการที่เป็นนามธรรมมากขึ้นในอนาคตหรือไม่" ถ้าใช่ทำให้มันเป็นนามธรรมและถ้าไม่ทำให้มันเป็นอินเทอร์เฟซ

(เหมาะสมที่สุดและใช้ได้จนถึง java 1.7)

โดยปกติแล้วคลาสนามธรรมจะใช้สำหรับแกนกลางของบางอย่าง

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

อินเตอร์เฟสมีช่วงกว้างของนามธรรมมากกว่าคลาสนามธรรม คุณสามารถเห็นสิ่งนี้ได้ในการผ่านข้อโต้แย้งดูตัวอย่างนี้:

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