สวัสดีสวัสดี! ปัจจุบัน Java Developer เป็นที่ต้องการอย่างมาก แน่นอนว่าฉันไม่สามารถหาตำแหน่งที่ว่างให้คุณได้ แต่ฉันจะพยายามช่วยให้คุณได้รับความรู้ใหม่ๆ และปิดช่องว่างบางส่วน ดังนั้นเราจึงวิเคราะห์คำถามสัมภาษณ์มากกว่า 250 ข้อ สำหรับนักพัฒนา Java ต่อไป ลิงก์ไปยังส่วนก่อนหน้าของการวิเคราะห์อยู่ท้ายบทความ
ความหมายปรากฏขึ้นเมื่อมีการแนะนำวิธีการคงที่ในอินเทอร์เฟซกับ Java 8 เท่านั้น แต่สิ่งนี้ไม่ได้เปลี่ยนความจริงที่ว่าอินเทอร์เฟซไม่สามารถสรุปได้ ฉันพูดถึงอินเทอร์เฟซแบบผิวเผินมาก เพราะ... นี่เป็นหัวข้อกว้างๆ อ่านเพิ่มเติมเกี่ยวกับสิ่งนี้ในบทความเกี่ยวกับอินเทอร์เฟซใน Javaและ ความ แตกต่างระหว่างคลาสนามธรรมและอินเทอร์เฟซ
สมมติว่าเรามีAnimal interface บ้าง :
หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับหัวข้อนี้ ฉันขอแนะนำให้อ่านบทความนี้
โดยละเอียดยิ่งขึ้น
39. Access Modifiers ใน Java คืออะไร? ตั้งชื่อพวกเขา พวกเขาใช้ทำอะไร?
ก่อนหน้านี้ฉันได้อธิบายตัวดัดแปลงการเข้าถึงในคำถามเกี่ยวกับองค์ประกอบการห่อหุ้ม Java แต่ฉันจะเตือนคุณต่อไป ตัวแก้ไขการเข้าถึงใน Java คือคีย์เวิร์ดที่อธิบายระดับการเข้าถึงที่มอบให้กับส่วนประกอบ Java เฉพาะ ตัวแก้ไขการเข้าถึงอาจเป็น:- สาธารณะ — องค์ประกอบที่มีตัวแก้ไขนี้จะสามารถเข้าถึงได้แบบสาธารณะ เหล่านั้น. ฟิลด์และวิธีการ คลาสที่ประกาศด้วยตัวดัดแปลงสาธารณะจะมองเห็นได้จากคลาสอื่น ๆ ทั้งจากแพ็คเกจปัจจุบันและจากแพ็คเกจภายนอก
- protected - องค์ประกอบที่มีตัวแก้ไขนี้จะสามารถเข้าถึงได้จากทุกที่ในคลาสปัจจุบันของแพ็คเกจปัจจุบันหรือในคลาสที่สืบทอดแม้ว่าจะอยู่ในแพ็คเกจอื่นก็ตาม
- defaultหรือตัวแก้ไขหายไป - ตัวแก้ไขนี้ถูกใช้โดยปริยายเมื่อไม่ได้ระบุตัวแก้ไขการเข้าถึงเลย คล้ายกับคลาสก่อนหน้า ยกเว้นว่าอนุญาตให้มองเห็นได้ในคลาสสืบทอดที่อยู่ในแพ็คเกจอื่น
- privateเป็นส่วนตัวที่สุดในบรรดาโมดิฟายเออร์ทั้งหมด อนุญาตให้เข้าถึงองค์ประกอบเฉพาะภายในคลาสปัจจุบันเท่านั้น

40. ตั้งชื่อคุณลักษณะหลักของวิธีคงที่และตัวแปร
สูตรที่แปลกมาก - "วิธีการแปรผัน" แน่นอนว่านี่หมายถึงวิธีการธรรมดาที่ไม่คงที่ ดังนั้นความแตกต่างที่สำคัญคือวิธีการแบบคงที่เป็นของคลาสและในความเป็นจริงคุณไม่จำเป็นต้องสร้างอินสแตนซ์ของคลาสนี้สำหรับพวกเขา: สามารถเรียกได้โดยใช้ประเภทคลาสเท่านั้น ตัวอย่างเช่น เรามีวิธีคงที่ในการเลี้ยงแมว:public class CatService {
public static void petTheCat(Cat cat) {
System.out.println("Погладить кота - " + cat.getName());
}
เราไม่จำเป็นต้องมีอินสแตนซ์ของคลาส CatService เพื่อเรียกมันว่า:
Cat cat = new Cat(7, "Bobi");
CatService.petTheCat(cat);
ในขณะที่วิธีการทั่วไปถูกผูกไว้กับ (เป็นของ) วัตถุ และเพื่อที่จะเรียกพวกมัน คุณต้องมีอินสแตนซ์ (วัตถุ) ที่จะเรียกใช้วิธีการนั้น ตัวอย่างเช่น แมวมีวิธีการที่ไม่คงที่ - การร้องเหมียว:
class Cat {
public void mew() {
System.out.println("Meow! Meow! Meow!");
}
หากต้องการเรียกเมธอดนี้ เราจำเป็นต้องมีตัวอย่างเฉพาะของ cat:
Cat cat = new Cat(7, "Bobi");
cat.mew();
41. อะไรคือข้อจำกัดหลักสำหรับวิธีคงที่และวิธี "ตัวแปร"?
อย่างที่ผมได้กล่าวไปก่อนหน้านี้ ข้อจำกัดหลักของวิธีการทั่วไปก็คือ จะต้องมีบางกรณีที่จะมีการเรียกใช้วิธีการนั้นเสมอ แต่วิธีการคงที่ไม่ต้องการสิ่งนี้ แต่ไม่สามารถอ้างอิงถึง การอ้างอิง นี้ - ไปยังองค์ประกอบของวัตถุปัจจุบัน - เนื่องจากไม่มีวัตถุปัจจุบันอยู่42. คำหลักคงที่หมายถึงอะไร? วิธีการคงที่สามารถแทนที่หรือโอเวอร์โหลดได้หรือไม่?
องค์ประกอบที่กำหนดโดย คีย์เวิร์ดแบบคงที่ไม่ได้เป็นของวัตถุของคลาส แต่เป็นของคลาส และจะถูกโหลดเมื่อมีการโหลดคลาสนั้นเอง องค์ประกอบแบบคงที่เป็นเพียงองค์ประกอบเดียวสำหรับทั้งโปรแกรม และองค์ประกอบปกติเป็นองค์ประกอบเดียวสำหรับวัตถุเฉพาะ คงที่สามารถ:- ฟิลด์คลาส;
- บล็อกการเริ่มต้นคลาส
- วิธีการเรียน
- คลาสภายในของคลาส (อย่างไรก็ตาม นั่นยังคงเป็นเรื่องซ้ำซาก)
43. วิธีการสามารถเป็นแบบคงที่และนามธรรมในเวลาเดียวกันได้หรือไม่?
ฉันได้กล่าวไปแล้วในบทความที่แล้ว: วิธีการไม่สามารถเป็นนามธรรมและคงที่ในเวลาเดียวกันได้ ความเป็นนามธรรมของวิธีการหมายความว่าจะต้องถูกแทนที่ในตัวสืบทอด ในเวลาเดียวกัน วิธีการคงที่เป็นของคลาสและไม่สามารถแทนที่ได้ ซึ่งจะทำให้เกิดความขัดแย้ง ซึ่งคอมไพเลอร์จะเห็นและเริ่มสาปแช่ง หากคุณมีสถานการณ์เช่นนี้ คุณควรคิดอย่างจริงจังเกี่ยวกับความถูกต้องของสถาปัตยกรรมแอปพลิเคชันของคุณ (ท้ายที่สุดแล้ว มีบางอย่างผิดปกติเกิดขึ้นอย่างชัดเจน)
44. เป็นไปได้ไหมที่จะใช้วิธีคงที่ระหว่างวิธีปกติ? ในทางกลับกัน? ทำไม
สามารถใช้วิธีการแบบคงที่ได้ตามปกติเนื่องจากไม่มีสิ่งใดป้องกันสิ่งนี้ได้ ในเวลาเดียวกัน สถานการณ์ย้อนกลับเป็นไปไม่ได้: วิธีแบบคงที่ไม่สามารถใช้วิธีปกติได้โดยไม่ต้องอ้างอิงถึงอินสแตนซ์เฉพาะของคลาสนี้ และดังที่เราจำได้ การอ้างอิง นี้ ไม่พร้อมใช้งานสำหรับสมาชิกคลาส แบบคงที่: สามารถมีอ็อบเจ็กต์เฉพาะของคลาสได้มากเท่าที่คุณต้องการ และแต่ละรายการจะมีการอ้างอิงถึงตัวเองภายใน - this แล้วคุณจะเข้าใจได้อย่างไรว่าคุณต้องใช้ ลิงค์ นี้ โดยเฉพาะ? แต่ไม่มีทาง ดังนั้นองค์ประกอบแบบคงที่จึงไม่สามารถอ้างถึงองค์ประกอบที่ไม่คงที่ได้ หากไม่มีการอ้างอิงถึงวัตถุเฉพาะ จริงๆ แล้ว วิธีการแบบคงที่สามารถใช้วิธีแบบไม่คงที่ได้ก็ต่อเมื่อมีการอ้างอิงถึงอ็อบเจ็กต์เฉพาะเท่านั้น ตัวอย่างเช่นอันที่มาเป็นข้อโต้แย้ง:public static void petTheCat(Cat cat) {
System.out.println("Погладить кота - " + cat.getName());
}
ที่นี่เรา จะ เห็นว่าเมธอดคงที่petTheCatเรียกเมธอดปกติและไม่คงที่ของ วัตถุ Cat - getName
45. อินเทอร์เฟซคืออะไร? สามารถมีอินเทอร์เฟซสุดท้ายได้หรือไม่?
อย่างที่เราจำได้ Java ไม่มีการสืบทอดหลายรายการ อินเทอร์เฟซเป็นสิ่งที่เป็นทางเลือกแทน อินเทอร์เฟซดูเหมือนคลาสที่ถูกแยกออกมาก พวกเขากำหนดฟังก์ชันการทำงานโดยไม่มีการใช้งานเฉพาะซึ่งถูกนำไปใช้โดยคลาสที่ใช้ (ใช้งาน) อินเทอร์เฟซเหล่านี้ ตัวอย่างอินเทอร์เฟซ:public interface Animal {
void voice();
}
ตัวอย่างการใช้งานอินเทอร์เฟซโดยคลาส:
class Cat implements Animal {
@Override
public void voice() {
System.out.println("Meow! Meow! Meow!");
}
}
สิ่งสำคัญที่คุณต้องรู้เกี่ยวกับการใช้อินเทอร์เฟซคือ:
- วิธีการอินเทอร์เฟซควรมีเฉพาะส่วนหัว โดยไม่มีเนื้อหาของวิธีการเฉพาะ เช่น ต้องเป็นนามธรรม (แต่โดยไม่ต้องใช้ abstractคำหลัก) ข้อยกเว้นนี้คือวิธีการแบบคงที่และเป็นค่าเริ่มต้น ซึ่งจำเป็นต้องมีเนื้อหาของวิธีการ
- คลาสสามารถใช้อินเทอร์เฟซได้มากมาย (อย่างที่ฉันบอกไปแล้วว่านี่เป็นทางเลือกแทนการสืบทอดหลายรายการ) ซึ่งเขียนโดยคั่นด้วยเครื่องหมายจุลภาค: คลาส Lion ใช้งาน Animal, Wild
- อินเทอร์เฟซถูกสร้างขึ้นโดยใช้คำหลัก - อินเทอร์เฟซ
- เมื่อนำอินเทอร์เฟซไปใช้โดยคลาส คีย์เวิร์ดจะถูกใช้ - นำไปใช้
- คลาสที่ใช้อินเทอร์เฟซเฉพาะจะต้องใช้วิธีการนามธรรมทั้งหมดหรือต้องประกาศตัวเองว่าเป็นนามธรรม
- วัตถุประสงค์หลักของการใช้อินเทอร์เฟซคือการใช้ความหลากหลาย (ความสามารถของวัตถุที่มีหลายรูปแบบ)
- ตามกฎแล้ว ตัวแก้ไขการเข้าถึงสำหรับวิธีการจะไม่ถูกเขียนในอินเทอร์เฟซ: เป็นสาธารณะ ตามค่าเริ่มต้น และ ไม่สามารถระบุตัวแก้ไขอื่น ๆ นอกเหนือจากสาธารณะ ได้ ตั้งแต่ Java 9 คุณสามารถใช้ ตัวดัดแปลง ส่วนตัวสำหรับวิธีการได้
- ตัวแปรอินเทอร์เฟซ จะเป็นค่าคงที่สุดท้ายตามค่าเริ่มต้นหรืออีกนัยหนึ่งคือค่าคงที่ ซึ่งจำเป็นต้องเริ่มต้นโดยตรงในอินเทอร์เฟซเสมอ
- คุณไม่สามารถสร้างวัตถุอินเทอร์เฟซได้

46. ฉันสามารถเริ่มต้นฟิลด์คงที่ได้ที่ไหน?
ฟิลด์แบบคงที่สามารถเริ่มต้นได้:- โดยตรงเมื่อมีการประกาศผ่านเครื่องหมายเท่ากับ= ;
- ในบล็อกการเริ่มต้นแบบคงที่
- ในบล็อกการเริ่มต้นที่ไม่คงที่ แต่คุณต้องเข้าใจว่าทุกครั้งที่สร้างอ็อบเจ็กต์ ฟิลด์นี้จะถูกเขียนทับโดยบล็อกการเริ่มต้นนี้
- ในตัวสร้างคลาส แต่ละครั้งที่มีการเรียก Constructor นี้ (นั่นคือ เมื่อวัตถุถูกสร้างขึ้นผ่าน Constructor นี้) ฟิลด์นี้จะถูกเขียนทับ
- ในวิธีคงที่
- ในวิธีการไม่คงที่
- ในคลาสคงที่และไม่คงที่ภายใน ภายในและไม่ระบุชื่อ
47. คลาสที่ไม่เปิดเผยตัวตนคืออะไร?
คลาสที่ไม่ระบุชื่อคือคลาสที่ไม่มีประเภทของตัวเอง ฉันกำลังพูดถึงอะไร? เมื่อเราพูดถึงอินเทอร์เฟซ ฉันบอกว่าคุณไม่สามารถสร้างวัตถุอินเทอร์เฟซได้ คุณสามารถสร้างได้เพียงวัตถุของคลาสที่ใช้อินเทอร์เฟซเท่านั้น จะเป็นอย่างไรหากคุณไม่ต้องการใช้อินเทอร์เฟซในคลาส แต่คุณยังต้องการออบเจ็กต์ประเภทอินเทอร์เฟซ และเป็นไปได้มากว่านี่จะเป็นกรณีเดียวของการใช้วัตถุนี้ และคุณไม่จำเป็นต้องสร้างคลาสการใช้งานแบบเต็มรูปแบบ คุณจะทำเช่นนี้ได้อย่างไร? ขวา! ผ่านคลาสนิรนาม!
public final interface Animal {
public void voice();
}
หากเราต้องการสร้างอินสแตนซ์อินเทอร์เฟซนี้ผ่านคลาสที่ไม่ระบุชื่อ:
Animal cat = new Animal() {
@Override
public void voice() {
System.out.println("Meow! Meow! Meow!");
}
};
จากนั้นคุณสามารถใช้วัตถุนี้และวิธีการนำไปใช้ได้อย่างปลอดภัย - เสียง . นั่นคือคลาสที่ไม่ระบุตัวตนใช้อินเทอร์เฟซนี้และวิธีการนามธรรมทั้งหมดที่นี่และเดี๋ยวนี้ มิฉะนั้น เราจะไม่สามารถสร้างอ็อบเจกต์คลาสอินเทอร์เฟซ/นามธรรมได้ เนื่องจากมีวิธีการที่ไม่ได้นำไปใช้/นามธรรม ดังที่ได้กล่าวไปแล้ว คลาสที่ไม่ระบุตัวตนไม่เพียงแต่ใช้วิธีนามธรรมของอินเทอร์เฟซเท่านั้น แต่ยังใช้วิธีนามธรรมของคลาสนามธรรมด้วย วิธีนี้เหมาะสำหรับสถานการณ์เมื่อมีการใช้ออบเจ็กต์เพียงครั้งเดียวหรือจำเป็นต้องใช้วิธีการที่กำหนดเพียงครั้งเดียว และไม่จำเป็นต้องสร้างคลาสแยกต่างหากที่จะใช้คลาส/อินเทอร์เฟซนามธรรมที่จำเป็น แต่ฉันจะทราบด้วยว่าการใช้คลาสที่ไม่ระบุชื่อเป็นเหตุการณ์ที่เกิดขึ้นได้ยากในการทำงาน: ตามกฎแล้วยังคงให้ความสำคัญกับคลาสธรรมดาอยู่ คุณสามารถอ่านเพิ่มเติมเกี่ยวกับคลาสที่ไม่ระบุชื่อได้ในบทความนี้
48. คลาสดั้งเดิมคืออะไร?
สำหรับฉัน นี่เป็นคำถามที่แปลกมากและบางทีนี่อาจเป็นคำถามกับดัก เพราะใน Java ไม่มีคลาสดั้งเดิม ยกเว้นบางทีแนวคิดของประเภทดั้งเดิม ซึ่งเราได้พิจารณาไปแล้วก่อนหน้านี้ อย่างที่เราจำได้ มี 8 ประเภทดั้งเดิมใน Java - byte , short , int , long , float , double , char , boolean
49. คลาส “wrapper” คืออะไร?
ปัญหาหลักของการใช้ประเภทดั้งเดิมใน Java ก็คือพวกมันยังไม่ใช่คลาส และ Java ยังคงเป็นภาษา OOP นั่นคือโปรแกรมที่เขียนในภาษานี้จะลดลงเมื่อมีปฏิสัมพันธ์ระหว่างวัตถุ ดั้งเดิมไม่ใช่วัตถุ พวกเขาไม่มีวิธีการ ไม่มีแม้แต่วิธีมาตรฐานจากคลาสObject จะเป็นอย่างไรถ้าเราจำเป็นต้องใช้คีย์ดั้งเดิมเป็นคีย์ในMap ล่ะ ? จากนั้นคุณ จะต้องเรียก ใช้ เมธอด hashCode คุณยังสามารถเรียก วิธี เท่ากับได้ที่ นั่น แล้วไงล่ะ? อาจมีช่วงเวลาต่างๆ มากมายที่ควรมีคลาส ไม่ใช่คลาสดั้งเดิม ซึ่งทำให้องค์ประกอบดั้งเดิมไม่ได้ใช้และไม่เป็นที่พึงปรารถนาในโปรแกรม เนื่องจากสิ่งนี้ทำลายแนวคิดของ OOP แต่ไม่ใช่ทุกอย่างจะแย่อย่างที่คิด ท้ายที่สุดแล้ว Java มีแนวคิดเกี่ยวกับ wrapper ดั้งเดิม แต่ละประเภทดั้งเดิมมีคลาสอะนาล็อก:- ไบต์ -> Byte.class
- สั้น -> Short.class
- int -> จำนวนเต็ม.class
- ยาว -> Long.class
- ลอย -> Float.class
- สองเท่า -> Double.class
- ถ่าน -> Character.class
- บูลีน -> Boolean.class

50. คลาสที่ซ้อนกันคืออะไร? มันใช้เมื่อไหร่?
คลาสที่ซ้อนกันเป็นคลาสภายในที่เป็นสมาชิกของคลาสอื่น ใน Java มีคลาสภายในอยู่ 4 ประเภท: 1. คลาสภายใน คลาส ประเภทนี้จะถูกประกาศโดยตรงในเนื้อความของคลาสอื่น คลาสภายในที่ซ้อนกันสามารถเข้าถึงฟิลด์ส่วนตัวหรือวิธีการของอินสแตนซ์ของคลาสภายนอกได้ ตัวอย่างเช่น เรามาสร้างสวนสัตว์ที่เราจะมีสัตว์ - ม้าลาย:public class Zoo {
class Zebra {
public void toFeed(String food) {
System.out.println("Дать зебре - " + food);
}
}
}
ไม่มีอะไรซับซ้อนใช่ไหม? ลองมาดูตัวอย่างการสร้างวัตถุคลาสภายใน:
Zoo.Zebra zebra = new Zoo().new Zebra();
zebra.toFeed("яблоко");
ดังที่คุณเห็นแล้ว จำเป็นต้องสร้างอ็อบเจ็กต์ของคลาสเฟรม โดยอิงจากการอ้างอิงที่คุณสามารถสร้างอ็อบเจ็กต์ของคลาสภายในได้ ฉันต้องการทราบด้วยว่าคลาสภายในที่ซ้อนกันไม่สามารถมีวิธีการแบบคงที่หรือฟิลด์แบบคงที่ได้ เป็นเพราะคลาสภายในมีความเกี่ยวข้องโดยปริยายกับอ็อบเจ็กต์ของคลาสภายนอกและไม่สามารถประกาศวิธีการคงที่ภายในตัวมันเองได้ 2. คลาสที่ซ้อนกันแบบสแตติก คลาสนี้คล้ายกับคลาสก่อนหน้า เพียงแต่มี ตัวแก้ไขการเข้าถึง แบบคงที่ใกล้กับการประกาศคลาส เนื่องจากคลาสประเภทนี้ไม่มีสิทธิ์เข้าถึงฟิลด์ที่ไม่คงที่ของคลาสภายนอก มันจึงเหมือนกับส่วนคงที่ของคลาสภายนอกมากกว่าคลาสภายใน ในกรณีนี้ ข้อมูลคลาสจะสามารถเข้าถึงสมาชิกแบบคงที่ทั้งหมดของคลาสภายนอก แม้แต่สมาชิกส่วนตัวก็ตาม ตัวอย่างของคลาสที่ซ้อนกันแบบคงที่:
public class Zoo {
static class Zebra {
public void toFeed(String food) {
System.out.println("Дать зебре - " + food);
}
}
}
วิธีการสร้างแตกต่างจากวิธีก่อนหน้าเล็กน้อย:
Zoo.Zebra zebra = new Zoo.Zebra();
zebra.toFeed("яблоко");
ที่นี่เราไม่ต้องการวัตถุของคลาสภายนอกเพื่อสร้างวัตถุของคลาสสแตติกที่ซ้อนกัน จากคลาสภายนอก เราต้องการเพียงประเภทของคลาสนั้นเพื่อที่เราจะสามารถค้นหาตำแหน่งของคลาสที่ซ้อนกันได้ 3. คลาสท้องถิ่น คลาส ท้องถิ่นคือคลาสที่ประกาศไว้ภายในเนื้อความของวิธีการ และการสร้างและการใช้อ็อบเจ็กต์ของคลาสท้องถิ่นนั้นสามารถทำได้เฉพาะภายในวิธีนี้เท่านั้น ตัวอย่าง:
public class Zoo {
public void toFeed(String animal, String food) {
switch(animal){
case "зебра":
class Zebra {
void toFeedZebra(String food) {
System.out.println("Дать зебре - " + food);
}
}
Zebra zebra = new Zebra();
zebra.toFeedZebra(food);
...
ตัวอย่างการใช้งาน:
Zoo zoo = new Zoo();
zoo.toFeed("зебра", "яблоко");
หากไม่เห็นโค้ดสำหรับ วิธี toFeedคุณจะไม่สงสัยด้วยซ้ำว่ามีคลาสในเครื่องอยู่จริงไหม คลาสโลคัลไม่สามารถเป็นแบบคงที่หรือชั่วคราวแต่สามารถทำเครื่องหมายเป็นนามธรรมหรือขั้นสุดท้ายได้ (เฉพาะ OR เท่านั้น เนื่องจากการใช้ตัวดัดแปลงทั้งสองนี้จะทำให้เกิดข้อขัดแย้ง) 4. คลาสที่ไม่ระบุชื่อ เราได้พูดคุยเกี่ยวกับคลาสที่ไม่ระบุชื่อข้างต้นแล้ว และอย่างที่คุณจำได้ คลาสเหล่านี้สามารถสร้างขึ้นได้จากสองแหล่ง - อินเทอร์เฟซและคลาส เหตุผลในการใช้ คลาสภายในแบบคงที่และแบบไม่คงที่ถูกนำมาใช้ เพราะบางครั้ง การฝังคลาสขนาดเล็กไว้ภายในคลาสที่ใหญ่กว่าและรวมเข้าด้วยกันจะดีกว่า วิธีนี้จะทำให้คลาสเหล่านี้มีการทำงานร่วมกันที่สูงกว่าและมีจุดประสงค์ร่วมกัน จริงๆ แล้ว การใช้คลาสที่ซ้อนกันจะเพิ่มการห่อหุ้มโค้ด เหตุผลในการเลือกคลาสท้องถิ่นอาจเป็นเพราะว่าคลาสที่กำหนดถูกใช้เฉพาะในวิธีเดียว กรณีนี้จำเป็นต้องกระจายโค้ดให้ทั่วทั้งแอปพลิเคชันหรือไม่? เลขที่ แต่ในขณะเดียวกัน ฉันจะเสริมว่าในทางปฏิบัติฉันไม่เคยเห็นการใช้ชั้นเรียนในท้องถิ่นเลยเพราะว่า ความต้องการสิ่งเหล่านี้เป็นเรื่องที่ถกเถียงกันอย่างมาก เหตุผลในการใช้คลาสที่ไม่ระบุชื่ออาจเป็นเพราะว่าจำเป็นต้องมีการใช้งานอินเทอร์เฟซหรือคลาสนามธรรมเฉพาะเพียงครั้งเดียว ดังนั้นจึงไม่จำเป็นต้องสร้างคลาสเต็มรูปแบบแยกต่างหากพร้อมการใช้งานสำหรับสิ่งนี้ ในทางกลับกัน ด้วยวิธีง่ายๆ เราได้นำวิธีการที่เราต้องการผ่านคลาสที่ไม่ระบุตัวตน ใช้วัตถุนี้และลืมมันไป (ก็คนเก็บขยะจำมันได้) บทความ นี้และ บทความ นี้ จะช่วยให้คุณศึกษาชั้นเรียน ภายใน
51. คลาสสามารถมีตัวดัดแปลงการเข้าถึงอะไรได้บ้าง?
ดังที่เราจำได้ว่ามีคลาสหลายประเภทและมีตัวแก้ไขการเข้าถึงที่แตกต่างกัน:- คลาสภายนอกสามารถมีตัวแก้ไขการเข้าถึงแบบสาธารณะหรือไม่มีตัวแก้ไข (ตัวแก้ไขเริ่มต้น)
- คลาสภายในรองรับตัวดัดแปลงการเข้าถึงทั้ง 4 ตัว
- คลาสสแตติกที่ซ้อนกันรองรับตัวดัดแปลงการเข้าถึงทั้งหมดยกเว้นprotectedเพราะ ตัวดัดแปลงนี้แสดงถึงการสืบทอดซึ่งขัดแย้งกับสมาชิกแบบคงที่ของคลาส (องค์ประกอบแบบคงที่ไม่ได้รับการสืบทอด)
- คลาสท้องถิ่นสามารถมีได้เฉพาะตัวแก้ไขเริ่มต้นเท่านั้น (กล่าวคือ ไม่มีตัวแก้ไขเลย)
- คลาสที่ไม่ระบุชื่อ : หากไม่มีการประกาศประเภทคลาส ก็ไม่มีตัวแก้ไขการเข้าถึงเลย

GO TO FULL VERSION