นำมาใช้ vs ขยาย: เมื่อใดควรใช้ ความแตกต่างคืออะไร?

โปรดอธิบายด้วยภาษาที่เข้าใจง่ายหรือลิงค์ไปยังบทความบางส่วน

extendsสำหรับการขยายชั้นเรียน

implementsใช้สำหรับการนำอินเตอร์เฟสไปใช้

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

จาวายังไม่รองรับการสืบทอดหลายคลาส นี่คือการแก้ไขโดยใช้หลายอินเตอร์เฟส

 public interface ExampleInterface {
    public void doAction();
    public String doThis(int number);
 }

 public class sub implements ExampleInterface {
     public void doAction() {
       //specify what must happen
     }

     public String doThis(int number) {
       //specfiy what must happen
     }
 }

ตอนนี้ขยายชั้นเรียน

 public class SuperClass {
    public int getNb() {
         //specify what must happen
        return 1;
     }

     public int getNb2() {
         //specify what must happen
        return 2;
     }
 }

 public class SubClass extends SuperClass {
      //you can override the implementation
      @Override
      public int getNb2() {
        return 3;
     }
 }

ในกรณีนี้

  Subclass s = new SubClass();
  s.getNb(); //returns 1
  s.getNb2(); //returns 3

  SuperClass sup = new SuperClass();
  sup.getNb(); //returns 1
  sup.getNb2(); //returns 2

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

ฉันสังเกตเห็นว่าคุณมีคำถาม C ++ ในโปรไฟล์ของคุณ หากคุณเข้าใจถึงแนวคิดของการสืบทอดหลายค่าจาก C ++ (อ้างอิงถึงคลาสที่สืบทอดคุณสมบัติจากคลาสอื่นมากกว่าหนึ่งคลาส) Java ไม่อนุญาตสิ่งนี้ แต่มันมีคำสำคัญinterfaceซึ่งคล้ายกับคลาสเสมือนจริงใน C ++ ตามที่ผู้คนจำนวนมากพูดถึงคุณextendเป็นคลาส (และคุณสามารถขยายได้จากที่เดียว) และคุณimplementเป็นอินเทอร์เฟซ - แต่คลาสของคุณสามารถใช้อินเทอร์เฟซได้มากเท่าที่คุณต้องการ

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

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

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

การปฏิบัติ : คุณกำลังทำสัญญา คลาสที่ใช้อินเตอร์เฟส " มี " ความสามารถ

ด้วยรีลีส Java 8 รีลีสสามารถมีเมธอดดีฟอลต์ในอินเตอร์เฟสซึ่งจัดเตรียมการนำไปใช้งานในอินเตอร์เฟสเอง

อ้างถึงคำถามนี้ว่าเมื่อใดควรใช้แต่ละข้อ:

ส่วนต่อประสานกับบทคัดย่อระดับ (OO ทั่วไป)

ตัวอย่างที่จะเข้าใจสิ่งต่าง ๆ

public class ExtendsAndImplementsDemo{
    public static void main(String args[]){

        Dog dog = new Dog("Tiger",16);
        Cat cat = new Cat("July",20);

        System.out.println("Dog:"+dog);
        System.out.println("Cat:"+cat);

        dog.remember();
        dog.protectOwner();
        Learn dl = dog;
        dl.learn();

        cat.remember();
        cat.protectOwner();

        Climb c = cat;
        c.climb();

        Man man = new Man("Ravindra",40);
        System.out.println(man);

        Climb cm = man;
        cm.climb();
        Think t = man;
        t.think();
        Learn l = man;
        l.learn();
        Apply a = man;
        a.apply();

    }
}

abstract class Animal{
    String name;
    int lifeExpentency;
    public Animal(String name,int lifeExpentency ){
        this.name = name;
        this.lifeExpentency=lifeExpentency;
    }
    public void remember(){
        System.out.println("Define your own remember");
    }
    public void protectOwner(){
        System.out.println("Define your own protectOwner");
    }

    public String toString(){
        return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency;
    }
}
class Dog extends Animal implements Learn{

    public Dog(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " will protect owner");
    }
    public void learn(){
        System.out.println(this.getClass().getSimpleName()+ " can learn:");
    }
}
class Cat extends Animal implements Climb {
    public Cat(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " won't protect owner");
    }
    public void climb(){
        System.out.println(this.getClass().getSimpleName()+ " can climb");
    }
}
interface Climb{
    public void climb();
}
interface Think {
    public void think();
}

interface Learn {
    public void learn();
}
interface Apply{
    public void apply();
}

class Man implements Think,Learn,Apply,Climb{
    String name;
    int age;

    public Man(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void think(){
        System.out.println("I can think:"+this.getClass().getSimpleName());
    }
    public void learn(){
        System.out.println("I can learn:"+this.getClass().getSimpleName());
    }
    public void apply(){
        System.out.println("I can apply:"+this.getClass().getSimpleName());
    }
    public void climb(){
        System.out.println("I can climb:"+this.getClass().getSimpleName());
    }
    public String toString(){
        return "Man :"+name+":Age:"+age;
    }
}

เอาท์พุท:

Dog:Dog:Tiger:16
Cat:Cat:July:20
Dog can remember for 5 minutes
Dog will protect owner
Dog can learn:
Cat can remember for 16 hours
Cat won't protect owner
Cat can climb
Man :Ravindra:Age:40
I can climb:Man
I can think:Man
I can learn:Man
I can apply:Man

ประเด็นสำคัญที่ควรเข้าใจ:

1. สุนัขและแมวเป็นสัตว์และพวกมันก็ขยายremember() และprotectOwner() โดยการแบ่งปันname,lifeExpentencyจากAnimal
2. แมวสามารถปีน () แต่สุนัขไม่ได้ สุนัขสามารถคิด () แต่แมวไม่ได้ ความสามารถเฉพาะเหล่านี้จะถูกเพิ่มเข้าCatและDogด้วยการใช้ความสามารถนั้น
3. มนุษย์ไม่ใช่สัตว์ แต่เขาสามารถทำได้ Think,Learn,Apply,Climb

เมื่อทำตามตัวอย่างเหล่านี้คุณสามารถเข้าใจได้

คลาสที่ไม่เกี่ยวข้องสามารถมีความสามารถผ่านอินเทอร์เฟซ แต่คลาสที่เกี่ยวข้องกับพฤติกรรมการแทนที่ผ่านส่วนขยายของคลาสฐาน

extendsสำหรับเมื่อคุณสืบทอดจากคลาสฐาน (เช่นการขยายฟังก์ชันการทำงาน)

implementsสำหรับเมื่อคุณกำลังดำเนินการอินเตอร์เฟซ

นี่คือสถานที่ที่ดีที่จะเริ่มต้น: การเชื่อมต่อและการถ่ายทอด

A classสามารถ "นำไปใช้" interfaceเท่านั้น ชั้นเท่านั้น "ขยาย" classซึ่งเป็น ในทำนองเดียวกันการสามารถขยายอีกinterfaceinterface

A classสามารถขยายได้อีกอันหนึ่งclassเท่านั้น A classสามารถติดตั้งได้หลายinterfaceตัว

หากคุณสนใจที่จะรู้ว่าจะใช้abstract classes และinterfaces เมื่อใดให้อ้างอิงหัวข้อนี้: Interface vs Abstract Class (OO ทั่วไป)

อินเทอร์เฟซคือคำอธิบายของการกระทำที่วัตถุสามารถทำได้ ... ตัวอย่างเช่นเมื่อคุณพลิกสวิตช์ไฟแสงจะสว่างขึ้นคุณไม่สนใจว่ามันจะทำอย่างไร ในการเขียนโปรแกรมเชิงวัตถุอินเทอร์เฟซคือคำอธิบายของฟังก์ชันทั้งหมดที่วัตถุต้องมีเพื่อให้เป็น "X" อีกครั้งตัวอย่างเช่นทุกสิ่งที่ "ACTS LIKE" มีน้ำหนักเบาควรมีเมธอด turn_on () และเมธอด turn_off () วัตถุประสงค์ของอินเทอร์เฟซคือเพื่อให้คอมพิวเตอร์สามารถบังคับใช้คุณสมบัติเหล่านี้และรู้ว่าวัตถุของ TYPE T (ไม่ว่าอินเตอร์เฟสใด) จะต้องมีฟังก์ชันที่เรียกว่า X, Y, Z เป็นต้น

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

ดังแสดงในรูปที่ระบุด้านล่างคลาสขยายคลาสอื่นอินเทอร์เฟซขยายอินเทอร์เฟซอื่น แต่คลาสที่ใช้อินเทอร์เฟซ

สำหรับรายละเอียดเพิ่มเติม

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

การนำไปใช้ : สิ่งนี้ใช้เพื่อสร้างอินเตอร์เฟส (คลาสพาเรนต์ที่มีฟังก์ชันลายเซ็นเท่านั้น แต่ไม่ได้นิยามไว้) โดยกำหนดไว้ในคลาสลูก

มีเงื่อนไขพิเศษอย่างหนึ่ง: "ถ้าฉันต้องการให้อินเทอร์เฟซใหม่เป็นลูกของอินเทอร์เฟซที่มีอยู่แล้ว" ในเงื่อนไขข้างต้นส่วนต่อประสานลูกขยายส่วนต่อประสานหลัก

• A ขยาย B:

  A และ B เป็นทั้งคลาสหรืออินเตอร์เฟสทั้งสอง

• การดำเนินการ B

  A เป็นคลาสและ B เป็นอินเทอร์เฟซ

• เคสที่เหลืออยู่ซึ่ง A คืออินเตอร์เฟสและ B เป็นคลาสไม่ถูกกฎหมายใน Java

การดำเนินการจะใช้สำหรับการเชื่อมต่อและการขยายจะใช้ในการขยายชั้นเรียน

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

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

หมายเหตุเพิ่มเติม:

อินเทอร์เฟซสามารถขยายอินเทอร์เฟซอื่น

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

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

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

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

เราใช้SubClassขยายSuperClassเฉพาะเมื่อคลาสย่อยต้องการใช้ฟังก์ชั่นบางอย่าง (เมธอดหรือตัวแปรอินสแตนซ์) ที่ประกาศไว้แล้วในSuperClassหรือถ้าฉันต้องการปรับเปลี่ยนการทำงานเล็กน้อยของSuperClass (การแทนที่เมธอด) แต่พูดเช่นฉันมี Animal class ( SuperClass ) และ Dog class ( SubClass ) และมีวิธีการบางอย่างที่ฉันได้กำหนดไว้ใน Animal class เช่น doEat (); , doSleep (); ... และอื่น ๆ อีกมากมาย.

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

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

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

ดังนั้นฉันต้องการสร้างคลาสนามธรรมที่ไม่มีใครสามารถสร้างอินสแตนซ์ได้ แต่สามารถใช้เป็นเทมเพลตสำหรับคลาสอื่นได้

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

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

ฉันจะแบ่งปันรหัสกับคุณ: คุณลองใช้ชุดอินพุตที่แตกต่างกันและดูผลลัพธ์

class AnimalClass {

public void doEat() {

    System.out.println("Animal Eating...");
}

public void sleep() {

    System.out.println("Animal Sleeping...");
}

}

public class Dog extends AnimalClass implements AnimalInterface, Herbi{

public static void main(String[] args) {

    AnimalInterface a = new Dog();
    Dog obj = new Dog();
    obj.doEat();
    a.eating();

    obj.eating();
    obj.herbiEating();
}

public void doEat() {
    System.out.println("Dog eating...");
}

@Override
public void eating() {

    System.out.println("Eating through an interface...");
    // TODO Auto-generated method stub

}

@Override
public void herbiEating() {

    System.out.println("Herbi eating through an interface...");
    // TODO Auto-generated method stub

}


}

อินเทอร์เฟซที่กำหนด :

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}

คำหลักทั้งสองจะใช้เมื่อสร้างคลาสใหม่ของคุณเองในภาษา Java

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

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

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

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

ขยาย :

public class Bicycle {
    //properties and methods
}
public class MountainBike extends Bicycle {
    //new properties and methods
}

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

public interface Relatable {
    //stuff you want to put
}
public class RectanglePlus implements Relatable {
    //your class code
}

หากคุณยังมีความสับสนอ่านได้ที่: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html https://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html

การเรียนการสอนและการเชื่อมต่อทั้งสองสัญญา พวกเขามีวิธีการและคุณสมบัติส่วนอื่น ๆ ของแอปพลิเคชันอาศัย

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

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

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

Extendsถูกใช้เมื่อคุณต้องการคุณลักษณะของคลาสแม่ / อินเทอร์เฟซในคลาสลูก / อินเตอร์เฟสและimplementsใช้เมื่อคุณต้องการคุณลักษณะของอินเทอร์เฟซในคลาสของคุณ

ตัวอย่าง:

1. ขยายการใช้คลาส

   ผู้ปกครองระดับ

   }

   ชั้นเรียนเด็กขยายผู้ปกครอง {

   }

2. ขยายการใช้ส่วนต่อประสาน

   อินเตอร์เฟสผู้ปกครอง {

   }

   อินเตอร์เฟสเด็กขยายพาเรนต์ {

   }

3. นำไปปฏิบัติ

อินเตอร์เฟส A {

}

คลาส B ใช้ A {

}

การรวมกันของการขยายและการดำเนินการ

interface A{

}

class B

{

}

class C implements A,extends B{

}

ขยาย

• ชั้นขยายเพียงชั้นเดียว
• อินเตอร์เฟสขยายหนึ่งอินเตอร์เฟสขึ้นไป

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

• คลาสใช้อินเตอร์เฟสตั้งแต่หนึ่งอินเตอร์เฟสขึ้นไป
• อินเทอร์เฟซ 'ไม่สามารถ' นำสิ่งใดไปใช้

คลาสนามธรรมยังทำหน้าที่เหมือนคลาสพร้อมกับขยายและนำไปใช้

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