ความหลากหลายใน Java

สวัสดี! วันนี้เราสรุปชุดบทเรียนเกี่ยวกับหลักการของ OOP ในบทเรียนนี้ เราจะพูดถึง Java polymorphism ความแตกต่างคือความสามารถในการทำงานกับหลายประเภทราวกับว่าเป็นประเภทเดียวกัน นอกจากนี้ พฤติกรรมของวัตถุจะแตกต่างกันไปตามประเภทของวัตถุ ลองมาดูข้อความนี้ให้ละเอียดยิ่งขึ้น เรามาเริ่มกันที่ส่วนแรก: 'ความสามารถในการทำงานกับหลายประเภทราวกับว่าเป็นประเภทเดียวกัน' ประเภทต่างๆจะเหมือนกันได้อย่างไร? ฟังดูแปลกๆ :/ ความจริงแล้วทุกอย่างเรียบง่ายมาก ตัวอย่างเช่น สถานการณ์นี้เกิดขึ้นระหว่างการใช้มรดกตามปกติ เรามาดูกันว่ามันทำงานอย่างไร สมมติว่าเรามี คลาสพาเรนต์ Cat อย่างง่าย ด้วยเมธอดrun() เดียว :

public class Cat {

   public void run() {
       System.out.println("Run!");
   }
}

ตอน นี้ เราจะสร้างสามคลาสที่สืบทอดCat : Lion , TigerและCheetah

public class Lion extends Cat {

   @Override
   public void run() {
       System.out.println("Lion runs at 80 km/h");
   }
}

public class Tiger extends Cat {

   @Override
   public void run() {
       System.out.println("Tiger runs at 60 km/h");
   }
}

public class Cheetah extends Cat {

   @Override
   public void run() {
       System.out.println("Cheetah runs at up to 120 km/h");
   }
}

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

public class Dolittle {

   public void healLion(Lion lion) {

       System.out.println("Lion is healthy!");
   }

   public void healTiger(Tiger tiger) {

       System.out.println("Tiger is healthy!");
   }

   public void healCheetah(Cheetah cheetah) {

       System.out.println("Cheetah is healthy!");
   }
}

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

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
   }
}

วิธีhealCat()สามารถยอมรับวัตถุLion , TigerและCheetah — พวกมันล้วนเป็นอินสแตนซ์ของ Cat :

public class Main {

   public static void main(String[] args) {

       Dolittle dolittle = new Dolittle();

       Lion simba = new Lion();
       Tiger shereKhan = new Tiger();
       Cheetah chester = new Cheetah();

       dolittle.healCat(simba);
       dolittle.healCat(shereKhan);
       dolittle.healCat(chester);
   }
}

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

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
       cat.run();
   }
}

ลองใช้รหัสเดียวกันเพื่อรักษาสัตว์สามตัว:

public static void main(String[] args) {

   Dolittle dolittle = new Dolittle();

   Lion simba = new Lion();
   Tiger shereKhan = new Tiger();
   Cheetah chester = new Cheetah();

   dolittle.healCat(simba);
   dolittle.healCat(shereKhan);
   dolittle.healCat(chester);
}

และนี่คือลักษณะของผลลัพธ์: ผู้ป่วยมีสุขภาพแข็งแรง! สิงห์วิ่งด้วยความเร็ว 80 กม./ชม. ผู้ป่วยมีสุขภาพดี! เสือหมอบวิ่งที่ 60 กม./ชม. ผู้ป่วยมีสุขภาพดี! เสือชีตาร์วิ่งด้วยความเร็วสูงสุด 120 กม./ชม.ที่ นี่ เราเห็นชัดเจนว่าพฤติกรรมเฉพาะของวัตถุนั้นยังคงอยู่ แม้ว่าเราจะส่งสัตว์ทั้งสามไปยังวิธีการหลังจาก 'สรุป' พวกมันไปยังแมว เนื่องจากความแตกต่างหลากหลาย Java จำได้ดีว่าแมวเหล่านี้ไม่ใช่แค่แมวสามตัว พวกมันคือสิงโต เสือโคร่ง และเสือชีตาร์ ซึ่งแต่ละตัวจะวิ่งต่างกัน สิ่งนี้แสดงให้เห็นถึงข้อได้เปรียบหลักของความหลากหลาย: ความยืดหยุ่น เมื่อเราต้องการใช้ฟังก์ชันบางอย่างที่ใช้ร่วมกันในหลาย ๆ ชนิด สิงโต เสือ และเสือชีตาห์ก็กลายเป็น 'แมว' สัตว์ทุกตัวมีความแตกต่างกัน แต่ในบางสถานการณ์แมวก็คือแมว ไม่ว่าจะสายพันธุ์ไหนก็ตาม :) นี่คือวิดีโอยืนยันบางส่วนสำหรับคุณ เมื่อ 'ลักษณะทั่วไป' นี้ไม่เป็นที่ต้องการ และเราต้องการให้แต่ละสปีชีส์มีพฤติกรรมที่แตกต่างกันไป แต่ละสปีชีส์ต่างทำหน้าที่ของมันเอง ด้วยความหลากหลาย คุณสามารถสร้างอินเทอร์เฟซเดียว (ชุดเมธอด) สำหรับคลาสที่หลากหลาย ทำให้โปรแกรมมีความซับซ้อนน้อยลง แม้ว่าเราจะขยายโปรแกรมให้รองรับแมว 40 ชนิด เราก็ยังคงมีอินเทอร์เฟซที่ง่ายที่สุด: เมธอดrun() เดียว สำหรับแมวทั้งหมด 40 ตัว