# Abstraction ใน OOP ภาษา Java คืออะไร พร้อมทั้งยกตัวอย่างวิธีการใช้งาน
การเขียนโปรแกรมเป็นกระบวนการสร้างผลงานที่ต้องอาศัยความคิดสร้างสรรค์และหลักการทางวิทยาการเพื่อให้ได้ผลลัพธ์ที่สอดคล้องกับความต้องการของผู้ใช้งาน ในภาษาการเขียนโปรแกรม Java หนึ่งในหลักการที่สำคัญทางวิชาการคือ Abstraction หรือการทำให้เป็นนามธรรม ซึ่งเป็นหัวใจสำคัญของ Object-Oriented Programming (OOP) ที่ช่วยในการจัดการความซับซ้อนของโปรแกรมได้อย่างมีประสิทธิภาพ
Abstraction เป็นกระบวนการที่เราซ่อนรายละเอียดที่ยุ่งยากหรือไม่จำเป็นออกไป โดยเน้นที่การโฟกัสไปที่ประวัติศาสตร์การนำไปใช้งาน การทำ Abstraction ทำให้โปรแกรมเมอร์สามารถจัดการกับงานได้อย่างง่ายดายมากขึ้น โดยไม่ต้องกังวลกับรายละเอียดที่ไม่เกี่ยวข้องกับปัญหาที่พวกเขาต้องการแก้ไข
ในภาษา Java, abstraction สามารถดำเนินการได้ในสองระดับหลัก:
1. Abstract Classes
2. Interfaces
Abstract Classes
Abstract class ใน Java เป็นคลาสที่ไม่สามารถนำมาสร้างเป็น object โดยตรงได้ คลาสเหล่านี้ได้ถูกออกแบบมาเพื่อเป็นคลาสพื้นฐานที่อื่น ๆ จะต้องมาสืบทอด (inherit) คุณสมบัติและพฤติกรรม ภายใน abstract class, เราสามารถกำหนด abstract methods, ซึ่งเป็นวิธีการไม่มีการประกาศร่างกายเช่นเดียวกันซึ่งคลาสลูกจะต้องใช้เวลาในการใช้งาน (implement)
#### ตัวอย่างของ Abstract Class
abstract class Vehicle {
abstract void startEngine();
public void stopEngine() {
System.out.println("Engine stopped.");
}
}
class Car extends Vehicle {
@Override
void startEngine() {
System.out.println("Car engine started.");
}
}
ในตัวอย่างนี้, `Vehicle` คือ abstract class ที่มี abstract method `startEngine()` และคลาส `Car` ที่สืบทอดจาก `Vehicle` จะต้อง implement method `startEngine()` เพื่อระบุวิธีการ start engine สำหรับรถยนต์
Interfaces
Interface ใน Java เป็นชนิดข้อมูลนามธรรมที่ 100% abstraction ซึ่งใช้เพื่อกำหนดรายการของ methods ที่คลาสต้อง implement โดยไม่ให้ผลลัพธ์ใด ๆ เกี่ยวกับการทำงานของ methods เหล่านั้น
#### ตัวอย่างของ Interface
interface Drivable {
void accelerate();
void brake();
}
class Motorcycle implements Drivable {
@Override
public void accelerate() {
System.out.println("Motorcycle accelerating.");
}
@Override
public void brake() {
System.out.println("Motorcycle braking.");
}
}
`Drivable` นั้นเป็น interface ที่ประกาศว่ารถหรือยานพาหนะที่สามารถขับเคลื่อนได้ต้องมี methods อะไรบ้าง และ `Motorcycle` นั้นเป็นคลาสที่จะต้องมีการ implement method `accelerate` และ `brake` ตามที่ `Drivable` ได้กำหนดไว้
Abstraction ช่วยให้สามารถจัดการกับความซับซ้อนของโปรแกรมได้ดีขึ้น เพราะเราสามารถคิดในภาพใหญ่โดยไม่ต้องจมปลักไปกับรายละเอียดที่ไม่เกี่ยวข้องและยากต่อการจัดการ นอกจากนี้ การใช้ abstraction ยังช่วยให้โค้ดของเรามี flexibity และต่อยอดได้ในอนาคต นอกเหนือจากนั้น ยังทำให้โค้ดของเราสามารถนำไปใช้ reuse กับโครงการใหม่ ๆ ได้ง่ายขึ้น
Abstraction เป็นแนวทางมาตรฐานในการออกแบบและสร้างโปรแกรมในภาษา Java ซึ่งไม่เพียงแค่ปรับปรุงความอ่านง่ายและการจัดการโค้ดเท่านั้น แต่ยังเป็นการลดความรับผิดชอบของโปรแกรมเมอร์ในการจัดการกับความซับซ้อนของรายละเอียดภายในโค้ด นอกจากนี้ ยังช่วยให้การพัฒนา software เป็นไปได้ด้วยความสูงส่ง ส่งเสริมให้มีการแบ่งแยกความรับผิดชอบของโมดูลต่าง ๆ และง่ายต่อการดำเนินการอัพเดทหรือการบำรุงรักษา
ถึงแม้ในบทความนี้เราจะไม่ได้ชวนคุณเข้ามาเรียนรู้การเขียนโปรแกรมที่ EPT โดยตรง แต่ก็หวังว่าการแบ่งปันความรู้เกี่ยวกับ Abstraction นี้จะทำให้คุณตระหนักถึงความสำคัญและคุณค่าที่โปรแกรมมิ่งมีอยู่ กระตุ้นให้คุณหาความรู้และเพิ่มทักษะในด้านนี้ต่อไป หากคุณมีความสนใจที่จะลึกซึ้งและพัฒนาฝีมือการเขียนโปรแกรมของคุณให้ยิ่งขึ้น การเรียนรู้จากสถาบันที่มีคุณภาพก็เป็นทางเลือกที่คุณอาจพิจารณาได้เช่นกัน.
หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง
หากเจอข้อผิดพลาด หรือต้องการพูดคุย ติดต่อได้ที่ https://m.me/expert.Programming.Tutor/
หากมีข้อผิดพลาด/ต้องการพูดคุยเพิ่มเติมเกี่ยวกับบทความนี้ กรุณาแจ้งที่ http://m.me/Expert.Programming.Tutor
085-350-7540 (DTAC)
084-88-00-255 (AIS)
026-111-618
หรือทาง EMAIL: NTPRINTF@GMAIL.COM