0Pricing
TypeScript Academy · บทเรียน

การใช้อินเทอร์เฟซกับคลาส

บังคับใช้โครงสร้างคลาสด้วยคีย์เวิร์ด implements

การใช้อินเทอร์เฟซกับคลาส เป็นบทเรียน TypeScript Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน TypeScript Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน

เริ่มต้นใช้งาน

คีย์เวิร์ด `implements` ทำให้แน่ใจว่าคลาสทำตามข้อกำหนดของอินเทอร์เฟซ TypeScript จะตรวจสอบว่าคลาสมีพร็อพเพอร์ตีและเมธอดที่จำเป็นทั้งหมด

implements พื้นฐาน

ใช้ `implements InterfaceName` ต่อท้ายชื่อคลาส หากสมาชิกที่จำเป็นขาดหายไป TypeScript จะแจ้งข้อผิดพลาด
interface Printable {
  print(): void;
}
class Document implements Printable {
  print() { console.log('Printing...'); }
}

สมาชิกที่ขาดหายไปทำให้เกิดข้อผิดพลาด

หากคลาสไม่ได้ใช้งานสมาชิกที่จำเป็นทั้งหมด TypeScript จะแจ้งข้อผิดพลาดที่การประกาศคลาส
interface Serializable { serialize(): string; }
// Error: Class 'Broken' incorrectly implements interface 'Serializable'
// class Broken implements Serializable {}

การใช้งานหลายอินเทอร์เฟซ

คลาสสามารถใช้งานอินเทอร์เฟซหลายรายการพร้อมกันได้ โดยคั่นชื่อแต่ละรายการด้วยเครื่องหมายจุลภาค
interface Flyable { fly(): void; }
interface Swimmable { swim(): void; }
class Duck implements Flyable, Swimmable {
  fly() { console.log('Flying'); }
  swim() { console.log('Swimming'); }
}

interface ไม่ได้จัดเตรียมการใช้งาน

อินเทอร์เฟซอธิบายเฉพาะโครงสร้างเท่านั้น คลาสเป็นผู้จัดเตรียมการใช้งานจริง

implements กับสมาชิกที่ไม่บังคับ

ไม่จำเป็นต้องใช้งานสมาชิกอินเทอร์เฟซที่ไม่บังคับ คลาสอาจจัดเตรียมสมาชิกเหล่านั้นได้ แต่ไม่จำเป็นต้องทำ
interface Logger {
  log(msg: string): void;
  warn?(msg: string): void; // optional
}
class SimpleLogger implements Logger {
  log(msg: string) { console.log(msg); }
  // warn is not required
}

อินเทอร์เฟซสำหรับการแทรกการพึ่งพา

การใช้อินเทอร์เฟซเป็นชนิดข้อมูลของพารามิเตอร์ตัวสร้างช่วยให้แทรกการพึ่งพาได้ คุณสามารถส่งคลาสใดก็ได้ที่ใช้งานอินเทอร์เฟซนั้น
interface Storage { save(data: string): void; }
class Service {
  constructor(private storage: Storage) {}
  run() { this.storage.save('data'); }
}
class LocalStorage implements Storage {
  save(data: string) { localStorage.setItem('key', data); }
}

extends กับ implements

`extends` สืบทอดจากคลาสอื่นและใช้การใช้งานร่วมกัน ส่วน `implements` ตรวจสอบเฉพาะโครงสร้างเท่านั้น ไม่มีการสืบทอดโค้ด

คลาสที่ใช้งานอินเทอร์เฟซและขยายคลาส

คลาสสามารถขยายจากคลาสฐานและใช้งานอินเทอร์เฟซหลายรายการได้พร้อมกัน
class Animal { breathe() { return 'breathing'; } }
interface Trainable { train(): void; }
class Dog extends Animal implements Trainable {
  train() { console.log('Sit!'); }
}

การใช้งานอินเทอร์เฟซแบบเจเนอริก

คลาสสามารถใช้งานอินเทอร์เฟซแบบเจเนอริกได้โดยระบุอาร์กิวเมนต์ชนิดข้อมูล
interface Repository<T> {
  findById(id: number): T | null;
}
class UserRepo implements Repository<User> {
  findById(id: number): User | null {
    return null; // stub
  }
}

ความปลอดภัยด้านชนิดข้อมูลของ implements

`implements` ไม่เพิ่มพฤติกรรมขณะทำงาน เมื่อทำงานจริง คลาสจะไม่รับรู้ถึงอินเทอร์เฟซ เป็นเพียงข้อกำหนดที่ใช้ขณะคอมไพล์เท่านั้น

ตรวจสอบอย่างรวดเร็ว

เมื่อคลาสใช้คีย์เวิร์ด `implements` TypeScript จะตรวจสอบอะไร

สรุปทบทวน

`implements` บังคับให้คลาสทำตามข้อกำหนดของอินเทอร์เฟซขณะคอมไพล์ คลาสหนึ่งสามารถใช้งานอินเทอร์เฟซหลายรายการได้ ใช้อินเทอร์เฟซสำหรับการแทรกการพึ่งพา ความสามารถในการทดสอบ และการแยกพฤติกรรมออกจากการใช้งาน

คำถามที่พบบ่อย

บทเรียน “การใช้อินเทอร์เฟซกับคลาส” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การใช้อินเทอร์เฟซกับคลาส” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส TypeScript Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การใช้อินเทอร์เฟซกับคลาส”

บังคับใช้โครงสร้างคลาสด้วยคีย์เวิร์ด implements คุณปฏิบัติ TypeScript Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน TypeScript Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน TypeScript Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การใช้อินเทอร์เฟซกับคลาส” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน TypeScript Academy นี้ได้ไหม

ได้ บทเรียน TypeScript Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. คลาสและคอนสตรักเตอร์ของ TypeScript
  2. ตัวปรับแต่ง public, private และ protected
  3. พร็อพเพอร์ตี readonly และพร็อพเพอร์ตีของพารามิเตอร์
  4. การใช้อินเทอร์เฟซกับคลาส
← กลับไปที่ TypeScript Academy