อินเทอร์เฟซในจาวา

ฉันเป็นนักเล่าเรื่องที่ไม่ดีถ้าฉันไม่มีเป้าหมายในการอธิบายสิ่งที่ไม่สามารถเข้าใจให้กับใครบางคนที่มีคำขอเฉพาะเจาะจง ดังนั้นฉันจึงเข้าใจสิ่งง่ายๆ และสำหรับสิ่งหนึ่งที่ฉันจะเขียนเกี่ยวกับเรื่องนี้ที่นี่ ฉันไม่ทำตามตัวอย่างการสอน JavaRush ในการถามคำถามก่อนแล้วจึงบอกคุณว่าต้องทำอย่างไร ฉันเป็นผู้สนับสนุนการบอกก่อนแล้วถามเหมือนบอกแสดงก่อนแล้วจึงอธิบาย BS: Actions == behavior ถือเป็นคำพ้องความหมาย การกระทำนั้นเข้าใจได้ถูกต้องมากขึ้น มันเป็นสิ่งที่เคลื่อนไหวอยู่เสมอ และพฤติกรรมอาจไม่แสดงอะไรเลย

อินเทอร์เฟซ - อินเทอร์เฟซ

นี่คืออะไร? ตัวอย่างรายการอินเทอร์เฟซ (พร้อมข้อมูลทั่วไป):

public interface Store<T, ID> {
    void add(T t);
    void update(T t, ID i);
    void delete(ID i);
    T findOne(ID i);
    List<T> findAll();
}

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

void add (T t) {
	bookstore.add(t);
}

แทนที่จะเป็น T t จะมีการทดแทนคำทั่วไปบางอย่างแทน โดยสรุป นี่คือ TYPE ของตัวแปร ซึ่งเป็นเหตุผลว่าทำไมจึงมักแสดงเป็น T = Type ในตัวอย่างของเรา สมมติว่าอาจเป็นเช่นนี้:

void add (Book book) {
	bookstore.add(book);
}

โดยธรรมชาติแล้ว แทนที่ Book book คุณสามารถทดแทนตัวแปรใดๆ ที่คุณต้องการสำหรับการใช้งานของคุณได้ เพื่อให้เข้าใจ ในทางทฤษฎี คุณสามารถจินตนาการได้ว่า T = Object และเนื่องจากใน Java ทุกอย่างเป็น Object คุณจึงสามารถกำหนดคลาส/ตัวแปรใดๆ ของคุณที่นั่นได้ ปัญหาเดียวที่จะเกิดขึ้นในภายหลัง - ข้อยกเว้นหากคลาสเป็นศูนย์ ฯลฯ ในคำพูดของมันเอง มันเป็นโครงสร้างของโปรแกรมที่กำหนดความสัมพันธ์ระหว่างวัตถุโดยการแบ่งมันออกเป็นส่วนพฤติกรรมบางอย่าง วัตถุประสงค์ของอินเทอร์เฟซคือเพื่อกำหนดฟังก์ชันการทำงานสำหรับการนำไปใช้งานโดยคลาส นั่นคือคำอธิบายของลายเซ็นวิธีการ ภายในอินเทอร์เฟซมีชื่อของวิธีการที่ส่งคืนและป้อนค่าก็แค่นั้นแหละ คุณยังคงสามารถกำหนดตัวแปรบางตัวได้ แต่ตัวแปรเหล่านั้นจะกลายเป็นตัวแปรสุดท้ายแบบสาธารณะโดยปริยายทันที และสามารถเข้าถึงได้จากส่วนใดก็ได้ของโปรแกรม อินเทอร์เฟซอธิบายการกระทำและดังนั้นการกระทำเดียวกันเหล่านี้จึงมีอยู่ในนั้นเช่น ฟังก์ชั่นหรือวิธีการ เหตุใดจึงจำเป็น? สิ่งนี้ทำให้ง่ายขึ้นหรือมีข้อดีอะไรบ้าง? ลดความซับซ้อนของคำอธิบายการกระทำและพฤติกรรม เราบอกว่าต้องทำอะไร แต่แต่ละคลาสก็ใช้วิธีทำเอง ประหยัดเวลาในโครงการขนาดใหญ่ อินเทอร์เฟซถูกสร้างขึ้นในสถานการณ์ที่เรารู้ว่าจำเป็นต้องทำงานบางอย่าง แต่วิธีการอาจแตกต่างกันไป อินเทอร์เฟซอธิบายชื่อของการกระทำ - นี่เป็นเพียงทิศทางของสิ่งที่เป็นนามธรรม แม้ว่าอาจมีอินเทอร์เฟซที่ไม่มีวิธีการและฟิลด์ เช่น เครื่องหมาย เช่น Cloneable, Remote เป็นต้น มาดูตัวอย่างรถยนต์ที่ทุกคนชื่นชอบกันดีกว่า อินเทอร์เฟซภายในจะอธิบายการกระทำที่เป็นไปได้ของรถ การหมุนพวงมาลัยหรือทิศทางการเคลื่อนที่ ความเร็วที่เพิ่มขึ้น น้ำมันที่เหลืออยู่ ฯลฯ นั่นคือการกระทำแบบเดียวกับที่รถทุกคันสามารถมีได้ กล่าวอีกนัยหนึ่ง เราดำดิ่งลงสู่ป่าแห่งความเสื่อมโทรมจนถึงระดับต่ำสุดของการสร้างสรรค์รถยนต์คันแรก และด้วยสมองของเราเอง เราจึงรู้ว่ามันถูกสร้างขึ้นมาอย่างไรและมีอะไรบ้าง โดยปกติแล้ว เราจะอธิบายสิ่งนี้ในแบบนามธรรมและเพื่อการกระทำเท่านั้น รถคันแรกมีอะไรบ้าง? มีพวงมาลัยไหม? มันหมายถึงว่ามันกำลังหมุนไปที่ไหนสักแห่ง ทิศทางของพวงมาลัย/การเคลื่อนที่ มีล้อไหม? ใช่ นั่นหมายความว่าฉันกำลังขับรถด้วยความเร็วระดับหนึ่ง ความเร็วเปลี่ยนไป นั่นคืออินเทอร์เฟซทั้งหมด แต่โดยทั่วไปแล้ว อินเทอร์เฟซจะถูกสร้างขึ้นเพื่อการดำเนินการบางอย่าง เหล่านั้น. เราเขียนโปรแกรมสำหรับโปรแกรมที่เฉพาะเจาะจงมากกว่าโปรแกรมอื่นๆ ที่คุณคิดได้ ดังนั้นอินเทอร์เฟซจะมีวิธีการที่ชัดเจนและเฉพาะเจาะจงมากขึ้น แน่นอนว่ามันจะเป็นนามธรรมมากที่สุด อินเทอร์เฟซสามารถสืบทอดจากกันและกันเป็นคลาสได้

interface MyInterface extends NotMyinterface;

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

class NewClass extends OldClass implements MyInterface, NotMyinterface;

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

• วิธีการคงที่
• วิธีการส่วนตัว (รหัสซ้ำ)
• ตัวแปร/ค่าคงที่
• อินเทอร์เฟซที่ซ้อนกัน

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

line1: Volvo v = new VolvoV2();
line2: Volvo v = new VolvoV3();

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