หลักการของ OOP

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

หลักการพื้นฐานของ OOP:

• นามธรรม
• การห่อหุ้ม
• มรดก
• ความแตกต่าง

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

วัตถุคืออะไร?

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

OOP นามธรรม

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

public abstract class AbstractPhone {
    private int year;

    public AbstractPhone(int year) {
        this.year = year;
    }
    public abstract void call(int outputNumber);
    public abstract void ring (int inputNumber);
}

ตามคลาสนามธรรมนี้ เราจะสามารถสร้างโทรศัพท์ประเภทใหม่ในโปรแกรมโดยใช้หลักการ Java OOP พื้นฐานอื่น ๆ ซึ่งเราจะพิจารณาด้านล่าง

การห่อหุ้ม

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

การห่อหุ้มและการควบคุมการเข้าถึง

สมมติว่าในระหว่างการผลิต ข้อมูลเกี่ยวกับโทรศัพท์จะสลักไว้ที่ด้านหลังของโทรศัพท์: ปีที่ผลิตหรือโลโก้ของบริษัทผู้ผลิต ข้อมูลนี้เป็นลักษณะเฉพาะของรุ่นนี้โดยเฉพาะ - สภาพของมัน เราสามารถพูดได้ว่านักพัฒนาโทรศัพท์ดูแลความไม่เปลี่ยนแปลงของข้อมูลนี้ - ไม่น่ามีใครคิดที่จะลบการแกะสลักออก ในโลก Java สถานะของออบเจ็กต์ในอนาคตอธิบายไว้ในคลาสโดยใช้ฟิลด์ และพฤติกรรมของวัตถุนั้นอธิบายโดยใช้เมธอด ความสามารถในการเปลี่ยนสถานะและพฤติกรรมดำเนินการโดยใช้ตัวแก้ไขการเข้าถึงฟิลด์และวิธีการ - private, protected, publicและdefault(การเข้าถึงเริ่มต้น) ตัวอย่างเช่น เราตัดสินใจว่าปีที่สร้าง ชื่อของผู้ผลิตโทรศัพท์ และวิธีใดวิธีหนึ่งเป็นของการใช้งานภายในของคลาส และไม่สามารถเปลี่ยนแปลงโดยอ็อบเจ็กต์อื่นในโปรแกรมได้ การใช้โค้ดสามารถอธิบายคลาสได้ดังนี้:

public class SomePhone {

    private int year;
    private String company;
    public SomePhone(int year, String company) {
        this.year = year;
        this.company = company;
    }
private void openConnection(){
    //findComutator
    //openNewConnection...
}
public void call() {
    openConnection();
    System.out.println("I'm calling a number");
}

public void ring() {
    System.out.println("Дзынь-дзынь");
}

 }

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

มรดก

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

public abstract class WirelessPhone extends AbstractPhone {

    private int hour;

    public WirelessPhone(int year, int hour) {
        super(year);
        this.hour = hour;
    }
    }

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

public class CellPhone extends WirelessPhone {
    public CellPhone(int year, int hour) {
        super(year, hour);
    }

    @Override
    public void call(int outputNumber) {
        System.out.println("Calling a number" + outputNumber);
    }

    @Override
    public void ring(int inputNumber) {
        System.out.println("A subscriber is calling you" + inputNumber);
    }
}

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

public class Smartphone extends CellPhone {

    private String operationSystem;

    public Smartphone(int year, int hour, String operationSystem) {
        super(year, hour);
        this.operationSystem = operationSystem;
    }
public void install(String program){
    System.out.println("Installing" + program + "For" + operationSystem);
}

}

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

ความแตกต่าง

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

public class User {
    private String name;

    public User(String name) {
        this.name = name;
            }

    public void callAnotherUser(int number, AbstractPhone phone){
// here it is polymorphism - using the abstract type AbstractPhone phone in the code!
        phone.call(number);
    }
}
 }

ตอนนี้เรามาอธิบายโทรศัพท์รุ่นต่างๆ กัน หนึ่งในโทรศัพท์รุ่นแรกๆ:

public class ThomasEdisonPhone extends AbstractPhone {

public ThomasEdisonPhone(int year) {
    super(year);
}
    @Override
    public void call(int outputNumber) {
        System.out.println("Turn the Handle");
        System.out.println("Give me the phone number, sir");
    }

    @Override
    public void ring(int inputNumber) {
        System.out.println("Phone calls");
    }
}

โทรศัพท์บ้านปกติ:

public class Phone extends AbstractPhone {

    public Phone(int year) {
        super(year);
    }

    @Override
    public void call(int outputNumber) {
        System.out.println("I'm calling a number" + outputNumber);
    }

    @Override
    public void ring(int inputNumber) {
        System.out.println("Phone calls");
    }
}

และสุดท้าย โทรศัพท์วิดีโอสุดเจ๋ง:

public class VideoPhone extends AbstractPhone {

    public VideoPhone(int year) {
        super(year);
    }
    @Override
    public void call(int outputNumber) {
        System.out.println("I connect a video channel for the subscriber" + outputNumber );
    }
    @Override
    public void ring(int inputNumber) {
        System.out.println("You have an incoming video call..." + inputNumber);
    }
  }

มาสร้างวัตถุในวิธีการmain()และทดสอบวิธีการcallAnotherUser:

AbstractPhone firstPhone = new ThomasEdisonPhone(1879);
AbstractPhone phone = new Phone(1984);
AbstractPhone videoPhone=new VideoPhone(2018);
User user = new User("Andrey");
user.callAnotherUser(224466,firstPhone);
// Rotate the knob
// Tell me the number of the subscriber, sir
user.callAnotherUser(224466,phone);
//Call number 224466
user.callAnotherUser(224466,videoPhone);
//I connect the video channel for subscriber 224466

ด้วยการเรียกเมธอดเดียวกันบน object userเราได้ผลลัพธ์ที่ต่างกัน การเลือกวิธีการเฉพาะในการปรับใช้callภายในวิธีการนั้นcallAnotherUserถูกสร้างขึ้นแบบไดนามิกโดยขึ้นอยู่กับประเภทเฉพาะของอ็อบเจ็กต์การเรียกระหว่างการทำงานของโปรแกรม นี่คือข้อได้เปรียบหลักของความหลากหลาย - ทางเลือกของการนำไปใช้ระหว่างการทำงานของโปรแกรม ในตัวอย่างคลาสโทรศัพท์ด้านบน เราใช้วิธีเอาชนะ ซึ่งเป็นเทคนิคที่เปลี่ยนแปลงวิธีการใช้วิธีการที่กำหนดไว้ในคลาสพื้นฐานโดยไม่ต้องเปลี่ยนลายเซ็นของวิธีการ นี่เป็นการแทนที่เมธอดเป็นหลัก และเป็นเมธอดใหม่ที่กำหนดไว้ในคลาสย่อยที่ถูกเรียกเมื่อโปรแกรมรัน โดยทั่วไปแล้ว เมื่อแทนที่เมธอด จะมีการใช้คำอธิบายประกอบ@Overrideซึ่งบอกให้คอมไพเลอร์ตรวจสอบลายเซ็นของเมธอดที่ถูกแทนที่และแทนที่ ด้วยเหตุนี้เพื่อให้แน่ใจว่ารูปแบบของโปรแกรมของคุณสอดคล้องกับแนวคิดของ OOP และหลักการของ OOP java ให้ปฏิบัติตามเคล็ดลับเหล่านี้:

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