0Pricing
Scala for Backend Engineering & Functional Programming · บทเรียน

คลาส ออบเจ็กต์ และการจัดแพ็กเกจ

ทำความเข้าใจวิธีกำหนดคลาส สร้างออบเจ็กต์ และจัดระเบียบโค้ดด้วยแพ็กเกจใน Scala

คลาส ออบเจ็กต์ และการจัดแพ็กเกจ เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 2 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 2 บทเรียน

ยินดีต้อนรับสู่การเขียนโปรแกรมเชิงวัตถุในสกาลา

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

มาเริ่มสร้างแอปพลิเคชันที่แข็งแกร่งและแยกส่วนได้กัน!

คลาส: พิมพ์เขียว

ลองนึกภาพว่า คลาส เป็นพิมพ์เขียวสำหรับสร้างอ็อบเจกต์ คลาสจะกำหนดคุณสมบัติ (ข้อมูล) และพฤติกรรม (เมธอด) ที่อ็อบเจกต์ของคลาสนั้นจะมี คลาสไม่ได้เก็บข้อมูลไว้ด้วยตัวเอง แต่จะอธิบายว่าอ็อบเจกต์สามารถเก็บข้อมูลใดได้บ้าง

ต่อไปนี้คือตัวอย่างการประกาศคลาสพื้นฐาน:

class Car {
  // Properties and methods go here
}

การกำหนดคลาสอย่างง่าย

ใน Scala คุณกำหนดคลาสโดยใช้คีย์เวิร์ด class ตามด้วยชื่อคลาส มาสร้างคลาส Dog อย่างง่ายกัน คลาสนี้ยังทำอะไรได้ไม่มาก แต่ถือเป็นจุดเริ่มต้นที่ดี!

ลองเรียกใช้การประกาศคลาสว่างนี้:

class Dog {
  // This dog has no properties or behaviors yet
}

object Main {
  def main(args: Array[String]): Unit = {
    println("Dog class defined!")
  }
}

การสร้างอ็อบเจกต์ (อินสแตนซ์)

อ็อบเจกต์ คืออินสแตนซ์ของคลาส หรือก็คือ “สิ่ง” จริงที่สร้างขึ้นจากพิมพ์เขียว หากต้องการสร้างอ็อบเจกต์ ให้ใช้คีย์เวิร์ด new ตามด้วยชื่อคลาส

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

class Dog {
  // Still an empty dog blueprint
}

object Main {
  def main(args: Array[String]): Unit = {
    val myDog = new Dog()
    val yourDog = new Dog()
    println("Two dog objects created!")
  }
}

การเพิ่มคุณสมบัติให้คลาส

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

มาเพิ่ม name และ breed ให้กับ Dog กัน:

class Dog(val name: String, val breed: String) {
  // 'val' makes name and breed immutable properties
}

object Main {
  def main(args: Array[String]): Unit = {
    val myDog = new Dog("Buddy", "Golden Retriever")
    println(s"My dog's name is ${myDog.name} and breed is ${myDog.breed}.")
  }
}

การเพิ่มพฤติกรรม (เมธอด)

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

ตอนนี้ Dog ของเราสามารถ bark() ได้แล้ว:

class Dog(val name: String, val breed: String) {
  def bark(): String = {
    s"${name} says Woof!"
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val myDog = new Dog("Max", "Labrador")
    println(myDog.bark())
  }
}

Scala `object` (ซิงเกิลตัน)

ใน Scala คีย์เวิร์ด object ใช้กำหนด ซิงเกิลตัน ซึ่งหมายความว่าจะมีอินสแตนซ์ของสิ่งนี้ได้เพียงหนึ่งรายการเท่านั้น คุณไม่ต้องใช้ new เพื่อสร้าง แต่สามารถอ้างอิงด้วยชื่อของมันได้โดยตรง

มักใช้สำหรับเมธอดอรรถประโยชน์หรือเป็นจุดเริ่มต้นเพียงจุดเดียว

object MathUtils {
  def add(a: Int, b: Int): Int = a + b
  def subtract(a: Int, b: Int): Int = a - b
}

object Main {
  def main(args: Array[String]): Unit = {
    val sum = MathUtils.add(5, 3)
    println(s"5 + 3 = ${sum}")
  }
}

อ็อบเจกต์คู่หู

อ็อบเจกต์คู่หู คือ object ที่มีชื่อเดียวกับ class และกำหนดไว้ในไฟล์ต้นฉบับเดียวกัน ทั้งสองมีสิทธิ์เข้าถึงสมาชิกส่วนตัวของกันและกันเป็นกรณีพิเศษ

  • คลาสเก็บข้อมูลและเมธอดเฉพาะของแต่ละอินสแตนซ์
  • อ็อบเจกต์คู่หูเก็บเมธอดที่มีลักษณะคล้ายเมธอดสแตติก หรือเมธอดโรงงาน
class Circle(val radius: Double) {
  def area: Double = Circle.PI * radius * radius
}

object Circle {
  // This is the companion object for the Circle class
  val PI: Double = 3.14159
  def apply(r: Double): Circle = new Circle(r) // Factory method
}

object Main {
  def main(args: Array[String]): Unit = {
    val c = Circle(5.0) // Using the apply method from companion object
    println(s"Circle area: ${c.area}")
  }
}

การจัดระเบียบโค้ดด้วยแพ็กเกจ

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

ลองนึกภาพแพ็กเกจเป็นโฟลเดอร์สำหรับโค้ดของคุณ คีย์เวิร์ด package ใช้ประกาศแพ็กเกจไว้ด้านบนของไฟล์ Scala

package com.coddykit.animals

class Cat(val name: String) {
  def meow(): String = s"${name} says Meow!"
}

// This class is now inside com.coddykit.animals package

การนำเข้าสมาชิกจากแพ็กเกจ

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

มานำเข้าคลาส Cat กัน:

package com.coddykit.app

// Define a class in a package first for import example
package com.coddykit.animals {
  class Cat(val name: String) {
    def meow(): String = s"${name} says Meow!"
  }
}

import com.coddykit.animals.Cat

object Main {
  def main(args: Array[String]): Unit = {
    val myCat = new Cat("Whiskers")
    println(myCat.meow())
  }
}

ตรวจสอบความเข้าใจ: คลาสหรืออ็อบเจกต์

คุณได้เรียนรู้เกี่ยวกับคลาส อ็อบเจกต์ และแพ็กเกจแล้ว มาทดสอบความเข้าใจกัน!

ทบทวน: คลาส อ็อบเจกต์ และแพ็กเกจ

ทำได้ยอดเยี่ยมมาก! คุณได้เรียนรู้พื้นฐานการเขียนโปรแกรมเชิงวัตถุใน Scala แล้ว:

  • คลาส คือพิมพ์เขียวที่กำหนดคุณสมบัติและพฤติกรรม
  • อ็อบเจกต์ คืออินสแตนซ์ที่สร้างจากคลาสโดยใช้ new
  • คีย์เวิร์ด object ของ Scala ใช้สร้างซิงเกิลตัน ซึ่งมีประโยชน์สำหรับอรรถประโยชน์หรือโรงงาน
  • อ็อบเจกต์คู่หู ใช้คู่กับคลาสเพื่อสร้างสมาชิกที่มีลักษณะคล้ายสแตติก
  • แพ็กเกจ ใช้จัดระเบียบโค้ด ป้องกันชื่อซ้ำ และช่วยให้โครงสร้างโค้ดดีขึ้น

ต่อไป เราจะต่อยอดพื้นฐานนี้ด้วยการเรียนรู้เรื่องการสืบทอดและพหุรูปแบบ!

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

บทเรียน “คลาส ออบเจ็กต์ และการจัดแพ็กเกจ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “คลาส ออบเจ็กต์ และการจัดแพ็กเกจ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 2 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “คลาส ออบเจ็กต์ และการจัดแพ็กเกจ”

ทำความเข้าใจวิธีกำหนดคลาส สร้างออบเจ็กต์ และจัดระเบียบโค้ดด้วยแพ็กเกจใน Scala คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 2 บทเรียน

บทเรียน “คลาส ออบเจ็กต์ และการจัดแพ็กเกจ” ใช้เวลานานแค่ไหน

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

ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม

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

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

  1. คลาส ออบเจ็กต์ และการจัดแพ็กเกจ
  2. การสืบทอดและพหุสัณฐาน
← กลับไปที่ Scala for Backend Engineering & Functional Programming