หลักการของอปท

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

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

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

สิ่งที่เป็นนามธรรม

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

public abstract class AbstractPhone {
    private int year;

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

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

การห่อหุ้ม

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

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

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

public class SomePhone {

    private int year;
    private String company;
    public SomePhone(int year, String company) {
        this.year = year;
        this.company = company;
    }
private void openConnection(){
    // findSwitch
    // openNewConnection...
}
public void call() {
    openConnection();
    System.out.println("Calling");
}

public void ring() {
    System.out.println("Ring-ring");
}

 }

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

มรดก

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

public abstract class CordlessPhone extends AbstractPhone {

    private int hour;

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

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

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

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

    @Override
    public void ring(int incomingNumber) {
        System.out.println("Incoming call from " + incomingNumber);
    }
}

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

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);
}

}

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

ความหลากหลาย

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

public class User {
    private String name;

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

    public void callAnotherUser(int number, AbstractPhone phone){
// And here's polymorphism: using the AbstractPhone type in the code!
        phone.call(number);
    }
}
 }

ตอนนี้เราจะอธิบายโทรศัพท์หลายประเภท หนึ่งในโทรศัพท์เครื่องแรก:

public class ThomasEdisonPhone extends AbstractPhone {

public ThomasEdisonPhone(int year) {
    super(year);
}
    @Override
    public void call(int outgoingNumber) {
        System.out.println("Crank the handle");
        System.out.println("What number would you like to connect to?");
    }

    @Override
    public void ring(int incomingNumber) {
        System.out.println("The phone is ringing");
    }
}

โทรศัพท์บ้านธรรมดา:

public class Phone extends AbstractPhone {

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

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

    @Override
    public void ring(int incomingNumber) {
        System.out.println("The phone is ringing");
    }
}

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

public class VideoPhone extends AbstractPhone {

    public VideoPhone(int year) {
        super(year);
    }
    @Override
    public void call(int outgoingNumber) {
        System.out.println("Connecting video call to " + outgoingNumber);
    }
    @Override
    public void ring(int incomingNumber) {
        System.out.println("Incoming video call from " + incomingNumber);
    }
  }

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

AbstractPhone firstPhone = new ThomasEdisonPhone(1879);
AbstractPhone phone = new Phone(1984);
AbstractPhone videoPhone=new VideoPhone(2018);
User user = new User("Jason");
user.callAnotherUser(224466, firstPhone);
// Crank the handle
// What number would you like to connect to?
user.callAnotherUser(224466, phone);
// Calling 224466
user.callAnotherUser(224466, videoPhone);
// Connecting video call to 224466

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

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