ติวสอบสัมภาษณ์งาน Java เบื้องต้น ฉบับ มือใหม่ [1]

Object-Oriented Programming (การเขียนโปรแกรมเชิงวัตถุ) คือ แนวคิดในการเขียนโปรแกรมที่เน้นการแบ่งระบบออกเป็น "วัตถุ" (Objects) โดยวัตถุแต่ละชิ้นจะเป็นตัวแทนของสิ่งของหรือแนวคิดในโลกจริง และมี "ข้อมูล" (Attributes) กับ "พฤติกรรม" (Methods) ของตัวเอง

สั้นๆ
"OOP คือแนวทางเขียนโปรแกรมโดยมอง "ปัญหา" เป็นกลุ่มของวัตถุที่สื่อสารกัน"

4 เสาหลักของ OOP ที่ต้องจำให้แม่น

🔢	ชื่อหลักการ	คำอธิบายแบบเข้าใจง่าย
1️⃣	Encapsulation (การห่อหุ้มข้อมูล)	ซ่อนข้อมูลภายใน object ไม่ให้เข้าถึงโดยตรง ใช้ private + getter/setter เพื่อควบคุมการเข้าถึง
2️⃣	Abstraction (การย่อรายละเอียด)	ซ่อนรายละเอียดการทำงานที่ซับซ้อนไว้เบื้องหลัง เผยเฉพาะสิ่งที่จำเป็น เช่น ผ่าน abstract class หรือ interface
3️⃣	Inheritance (การสืบทอดคุณสมบัติ)	ให้ class ใหม่สามารถ “รับมรดก” จาก class เดิมได้ ช่วยลดการเขียนโค้ดซ้ำ เช่น ใช้ extends
4️⃣	Polymorphism (ความหลากหลายของพฤติกรรม)	object สามารถตอบสนองต่อ method เดียวกันได้หลายแบบ เช่น overloading และ overriding

"ห่อ ย่อ สืบ หลาย"
ห่อหุ้ม (Encapsulation) → ย่อรายละเอียด (Abstraction) → สืบทอด (Inheritance) → หลากหลายพฤติกรรม (Polymorphism)

องค์ประกอบของ OOP

• Class (แม่แบบของวัตถุ) "พิมพ์เขียว" หรือ "สูตรการสร้างวัตถุ"
• Object (วัตถุจริงที่สร้างจาก class)

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

Object-Oriented Programming (OOP)

• Class & Object: พิมพ์เขียวและอินสแตนซ์
• Encapsulation: ซ่อนข้อมูล (ใช้ private + getter/setter)
• Inheritance: สืบทอดคุณสมบัติ (ใช้ extends)
• Polymorphism: เมธอดเดียว ใช้ได้หลายแบบ (Overloading / Overriding)
• Abstraction: ซ่อนรายละเอียดการทำงาน (ใช้ abstract class หรือ interface)

องค์ประกอบหลักของ Class มีอะไรบ้าง?

องค์ประกอบ	คำอธิบาย
Fields (Attributes / Properties)	ตัวแปรที่เก็บ "ข้อมูล" ของ object เช่น ชื่อ อายุ
Constructors	เมธอดพิเศษที่ใช้สร้าง object จาก class นั้น
Methods (พฤติกรรม)	เมธอดที่อธิบาย "สิ่งที่ object ทำได้"
Access Modifiers	เช่น public, private, protected – กำหนดการเข้าถึงองค์ประกอบใน class
Static Members	ฟิลด์หรือเมธอดที่เป็นของ class ทั้งหมด ไม่ใช่เฉพาะ object ใด object หนึ่ง
Nested Classes (ถ้ามี)	class ที่ประกาศซ้อนอยู่ภายใน class อื่น
Annotations (ถ้ามี)	เช่น @Override, @Getter ฯลฯ เพื่อกำหนดพฤติกรรมพิเศษ

Class = ข้อมูล + พฤติกรรม + วิธีสร้าง + การควบคุมการเข้าถึง
Class = Field + Constructor + Method (+ Access Control)

Data Types (ชนิดข้อมูล) หลัก ๆ อยู่ 2 กลุ่มใหญ่

• Primitive Data Types (ชนิดข้อมูลพื้นฐาน)

Java มี 8 ชนิดที่เป็นข้อมูลดิบแบบเบา ไม่ใช่ object ใช้บ่อยมาก!

ชนิด	ขนาด	ตัวอย่าง	คำอธิบาย
byte	8-bit	byte b = 127;	เลขจำนวนเต็มขนาดเล็ก (-128 ถึง 127)
short	16-bit	short s = 1000;	ตัวเลขขนาดกลาง
int	32-bit	int age = 30;	จำนวนเต็มทั่วไป
long	64-bit	long population = 8000000000L;	ตัวเลขใหญ่
float	32-bit	float pi = 3.14f;	ทศนิยมเบา ต้องลงท้ายด้วย f
double	64-bit	double d = 3.14159;	ทศนิยมละเอียด ใช้บ่อยกว่า float
char	16-bit	char c = 'A';	ตัวอักษร 1 ตัว (ใช้ single quote ')
boolean	1-bit	boolean flag = true;	มีแค่ true หรือ false

• Reference Data Types (ชนิดข้อมูลอ้างอิง) คือข้อมูลที่ อ้างถึง object หรือคลาส เช่น:

ชนิด	ตัวอย่าง	คำอธิบาย
String	"Hello"	ตัวอักษรหลายตัว (เป็น object)
Array	int[] numbers = {1, 2, 3};	เก็บข้อมูลหลายค่าในตัวแปรเดียว
Class	Person p = new Person();	เก็บวัตถุที่เราสร้างจาก class
Interface	Runnable r = () -> {}	ตัวแปรที่อ้างถึง interface
List, Map, Set	จาก Java Collections	เก็บข้อมูลหลายแบบในรูปโครงสร้างที่ยืดหยุ่น

Primitive Types (8 แบบ):

• byte, short, int, long
• float, double
• char, boolean

Reference Types:

• String, Array, Object, Class, List, Map ฯลฯ

การสร้างคลาส

public class Person { // Class Declaration

    // Fields
    private String name;
    private int age;

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Methods
    public void sayHello() {
        System.out.println("Hi, I'm " + name + " and I'm " + age + " years old.");
    }

    // Getter & Setter (Encapsulation)
    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // Static Method
    public static void describeClass() {
        System.out.println("This is a Person class.");
    }
}

สร้างวัตถุจากคลาส

ชื่อคลาส ชื่อตัวแปร = new ชื่อคลาส(พารามิเตอร์);

Collections Framework
Java Collections Framework คืออะไร?
Collections Framework คือชุดของ class และ interface ที่ Java เตรียมไว้ให้สำหรับจัดการ กลุ่มข้อมูล (Group of Objects) อย่างมีประสิทธิภาพ เช่น การเก็บข้อมูล, ค้นหา, เพิ่ม, ลบ, เรียงลำดับ ฯลฯ

หมวดหมู่หลักของ Collection (แบ่งตามโครงสร้าง)

• Java แบ่ง Collection ออกเป็น 3 กลุ่มหลักใหญ่ ๆ:

กลุ่มหลัก	Interface	ตัวอย่างคลาสยอดนิยม
List (ลำดับ)	List<E>	ArrayList, LinkedList, Vector
Set (ไม่ซ้ำ)	Set<E>	HashSet, LinkedHashSet, TreeSet
Map (คีย์-ค่า)	Map<K, V>	HashMap, LinkedHashMap, TreeMap
Queue / Deque (คิว)	Queue<E>, Deque<E>	PriorityQueue, ArrayDeque, LinkedList

List (ลำดับข้อมูล, มี index)

• เก็บข้อมูลแบบเรียงลำดับ
• มี index (เริ่มที่ 0)
• ซ้ำกันได้

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
System.out.println(names.get(0)); // Alice

คลาสที่ใช้บ่อย:

• ArrayList – โครงสร้าง array, เข้าถึงเร็ว
• LinkedList – เพิ่ม/ลบไว (โดยเฉพาะกลางรายการ)

Set (ไม่มีข้อมูลซ้ำ)

• ❌ ไม่มี index
• ❌ ไม่เก็บข้อมูลซ้ำ

Set<String> ids = new HashSet<>();
ids.add("A001");
ids.add("A001"); // ซ้ำ → ไม่เก็บ

สรุป Collections Framework แบบภาพรวม

        Collection
           |
   ------------------
   |       |        |
 List     Set     Queue
           |
         SortedSet (TreeSet)

        Map
         |
     SortedMap (TreeMap)

• List → มีลำดับ ซ้ำได้
• Set → ไม่มีซ้ำ ไม่มี index
• Map → เก็บคู่ Key-Value
• Queue → เข้าก่อนออกก่อน (FIFO)

สำหรับมือใหม่จะมีความสับสนระหว่าง Array กับ List

Array กับ List ต่างกันชัดเจนทั้งในเรื่องโครงสร้าง ความยืดหยุ่น และวิธีใช้

• Array กับ List ต่างกันชัดเจนทั้งในเรื่องโครงสร้าง ความยืดหยุ่น และวิธีใช้

🔸 Array = โครงสร้างพื้นฐาน, ขนาดคงที่, ทำงานเร็ว
🔹 List = เป็น interface ใน Collections Framework, ขยายได้, ใช้งานยืดหยุ่น

❓ Array กับ List ต่างกันอย่างไร?

จุดเปรียบเทียบ	Array	List (เช่น ArrayList)
ประเภท	โครงสร้างข้อมูลแบบพื้นฐาน (built-in)	Interface + Class จาก Collections Framework
ขนาด	คงที่ กำหนดตอนสร้างแล้วเปลี่ยนไม่ได้	ยืดหยุ่น เพิ่ม/ลบได้ตามต้องการ
การเข้าถึง	เร็วมาก (index โดยตรง)	เร็ว (แต่มี overhead จาก object management)
การเพิ่ม/ลบข้อมูล	เพิ่ม/ลบไม่ได้ ต้องสร้าง array ใหม่	ทำได้สะดวก (add, remove)
ประเภทข้อมูล	เก็บ primitive ได้ (เช่น int[]) หรือ object	เก็บ object (เช่น List<Integer>)
การใช้ memory	ใช้ memory น้อยกว่า	ใช้ memory มากกว่า เพราะเก็บ metadata
ฟังก์ชันเสริม	ไม่มี method นอกจาก length	มี method เช่น add, remove, contains, size ฯลฯ

📊 เปรียบเทียบ Array กับ List แบบละเอียด

หัวข้อ	Array	List (ArrayList, LinkedList)
คืออะไร?	โครงสร้างข้อมูลพื้นฐาน	Interface ใน Java Collections
ขนาด	คงที่	ยืดหยุ่น (เพิ่ม/ลบได้)
Index	มี	มี
รองรับ Generic	⛔ ไม่รองรับแบบสมบูรณ์	✅ รองรับเต็มที่
เพิ่ม/ลบข้อมูล	ยุ่งยาก (ต้องสร้างใหม่)	ง่าย (add(), remove())
ใช้งานจริง	เบา เร็ว เหมาะกับข้อมูลไม่เปลี่ยน	เหมาะกับโปรเจกต์จริง ใช้งานร่วมกับ Spring
ประสิทธิภาพ	เร็วกว่าเล็กน้อย	ช้ากว่าเล็กน้อย แต่ยืดหยุ่นกว่า
ตัวอย่าง	int[] arr = new int[3];	List<Integer> list = new ArrayList<>();

📌 Array

int[] numbers = new int[3];
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

// ขนาดคงที่ เพิ่มใหม่ไม่ได้

📌 List (ArrayList)

List<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
numbers.add(40); // เพิ่มได้ไม่จำกัด

✅ เมื่อไรควรใช้?

ใช้ Array	ใช้ List
ข้อมูลคงที่ ไม่เพิ่ม/ลบบ่อย	ต้องเพิ่ม ลบ ค้นหา บ่อย
ต้องการประสิทธิภาพสูงสุด (speed/memory)	ต้องการความสะดวกในการจัดการข้อมูล
เก็บ primitive โดยตรง (เช่น int[])	เก็บ object และใช้ method ที่ Collections Framework ให้มา

✅ สรุปจำง่าย

• 📌 Array = เร็ว คงที่
• 📌 List = ยืดหยุ่น ใช้ง่าย ใช้บ่อยใน Java สมัยใหม่

🔁 ถ้าเขียนโค้ด Java ยุคใหม่ หรือใช้ Spring Boot → ใช้ List เป็นหลัก

** วิธีแปลง Array ↔ List ใน Java**

แปลง Array → List
✅ แบบง่าย (ใช้ Arrays.asList)

String[] arr = {"A", "B", "C"};
List<String> list = Arrays.asList(arr);

⚠️ หมายเหตุ: Arrays.asList() คืนค่าเป็น fixed-size list → เพิ่ม/ลบไม่ได้ (add() จะ error)

✅ แบบยืดหยุ่น (แนะนำ)

List<String> list = new ArrayList<>(Arrays.asList(arr)); // สามารถ add/remove ได้
list.add("D"); // ✅ ทำได้

Spring Bean คือ อ็อบเจ็กต์ (Object) ที่ถูกจัดการโดย Spring IoC Container (Inversion of Control) ในเฟรมเวิร์ก Spring. พูดง่ายๆ คือ Spring Bean คือ Java Object ที่ Spring Framework สร้าง, จัดการ, และกำหนดค่าให้. คอนเทนเนอร์ Spring IoC จะรับผิดชอบในการสร้าง, จัดการ, และทำลาย Bean เหล่านี้

Inversion of control เป็น concept รูปแบบนึงที่ช่วยลดความผูกมัดกันระหว่าง module หรือ object เพื่อช่วยให้ code ของเรา clean, maintain ง่าย และ test ง่าย ซึ่งตัว IoC นั้นมีวิธีการ implement หลายแบบ แต่วันนี้เราจะมาพูดถึง Dependency Injection

Dependency Injection เป็นรูปแบบการ implement แบบนึงของ IoC โดยการ inject object ผ่าน constructor