Scala - คลาสและวัตถุ

บทนี้จะอธิบายวิธีการใช้คลาสและอ็อบเจ็กต์ในการเขียนโปรแกรม Scala คลาสคือพิมพ์เขียวสำหรับออบเจ็กต์ เมื่อคุณกำหนดคลาสแล้วคุณสามารถสร้างอ็อบเจกต์จากพิมพ์เขียวคลาสด้วยคีย์เวิร์ดnew. ผ่านวัตถุคุณสามารถใช้ฟังก์ชันทั้งหมดของคลาสที่กำหนด

แผนภาพต่อไปนี้แสดงให้เห็นถึงคลาสและออบเจ็กต์โดยใช้ตัวอย่างของ class student ซึ่งมีตัวแปรสมาชิก (ชื่อและหมายเลขม้วน) และเมธอดสมาชิก (setName () และ setRollNo ()) ในที่สุดทุกคนก็เป็นสมาชิกของชั้นเรียน คลาสเป็นงานพิมพ์สีน้ำเงินและวัตถุต่างๆมีอยู่จริงที่นี่ ในแผนภาพต่อไปนี้ Student คือชั้นเรียนและ Harini, John และ Maria เป็นวัตถุของชั้นนักเรียนซึ่งมีชื่อและหมายเลขม้วน

คลาสพื้นฐาน

ต่อไปนี้เป็นไวยากรณ์ง่ายๆในการกำหนดคลาสพื้นฐานใน Scala คลาสนี้กำหนดตัวแปรสองตัวx และ y และวิธีการ: moveซึ่งไม่ส่งคืนค่า เรียกตัวแปรคลาสฟิลด์ของคลาสและเมธอดเรียกว่าคลาสเมธอด

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

ไวยากรณ์

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

ดังที่ได้กล่าวไว้ก่อนหน้านี้ในบทนี้คุณสามารถสร้างวัตถุโดยใช้คำสำคัญ new จากนั้นคุณสามารถเข้าถึงฟิลด์คลาสและวิธีการดังที่แสดงด้านล่างในตัวอย่าง -

ตัวอย่าง

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

object Demo {
   def main(args: Array[String]) {
      val pt = new Point(10, 20);

      // Move to a new location
      pt.move(10, 10);
   }
}

บันทึกโปรแกรมข้างต้นใน Demo.scala. คำสั่งต่อไปนี้ใช้เพื่อคอมไพล์และรันโปรแกรมนี้

คำสั่ง

\>scalac Demo.scala
\>scala Demo

เอาต์พุต

Point x location : 20
Point y location : 30

การขยายคลาส

คุณสามารถขยายคลาส Scala พื้นฐานและคุณสามารถออกแบบคลาสที่สืบทอดมาในลักษณะเดียวกับที่คุณทำใน Java (ใช้ extends คำสำคัญ) แต่มีข้อ จำกัด สองประการ: การแทนที่วิธีการต้องใช้ override คีย์เวิร์ดและเฉพาะไฟล์ primaryตัวสร้างสามารถส่งผ่านพารามิเตอร์ไปยังตัวสร้างฐาน ให้เราขยายชั้นเรียนข้างต้นและเพิ่มวิธีการเรียนอีกหนึ่งวิธี

ตัวอย่าง

ให้เรายกตัวอย่างคลาส Point สองคลาส (ดังตัวอย่างข้างบน) และคลาส Location เป็นคลาสที่สืบทอดมาโดยใช้คีย์เวิร์ดขยาย เช่นextends'clause มีผลสองอย่างคือทำให้คลาส Location สืบทอดสมาชิกที่ไม่ใช่ไพรเวตทั้งหมดจากคลาส Point และทำให้ประเภทLocationเป็นประเภทย่อยของประเภทPoint class ดังนั้นที่นี่จึงเรียกคลาส Pointsuperclassและคลาสที่ตั้งถูกเรียกsubclass. การขยายคลาสและการสืบทอดคุณลักษณะทั้งหมดของคลาสพาเรนต์เรียกว่าinheritance แต่ Scala อนุญาตให้สืบทอดจากคลาสเดียวเท่านั้น

Note - วิธีการย้าย () วิธีการในคลาส Point และ move() method in Location class อย่าแทนที่คำจำกัดความที่เกี่ยวข้องของการย้ายเนื่องจากเป็นคำจำกัดความที่แตกต่างกัน (ตัวอย่างเช่นในอดีตใช้อาร์กิวเมนต์สองตัวในขณะที่คำจำกัดความหลังใช้สามอาร์กิวเมนต์)

ลองใช้โปรแกรมตัวอย่างต่อไปนี้เพื่อใช้การสืบทอด

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Point(xc, yc){
   var z: Int = zc

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("Point x location : " + x);
      println ("Point y location : " + y);
      println ("Point z location : " + z);
   }
}

object Demo {
   def main(args: Array[String]) {
      val loc = new Location(10, 20, 15);

      // Move to a new location
      loc.move(10, 10, 5);
   }
}

บันทึกโปรแกรมข้างต้นใน Demo.scala. คำสั่งต่อไปนี้ใช้เพื่อคอมไพล์และรันโปรแกรมนี้

คำสั่ง

\>scalac Demo.scala
\>scala Demo

เอาต์พุต

Point x location : 20
Point y location : 30
Point z location : 20

ชั้นเรียนโดยปริยาย

คลาสโดยนัยอนุญาตให้มีการสนทนาโดยนัยกับตัวสร้างหลักของคลาสเมื่อคลาสอยู่ในขอบเขต Implicit class คือคลาสที่มีคีย์เวิร์ด 'implicit' ฟีเจอร์นี้ถูกนำมาใช้ใน Scala 2.10

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

ไวยากรณ์

object <object name> {
   implicit class <class name>(<Variable>: Data type) {
      def <method>(): Unit =
   }
}

ตัวอย่าง

ให้เรายกตัวอย่างของคลาสโดยนัยที่ชื่อ IntTimesด้วยวิธีการครั้ง () หมายความว่า times () มีธุรกรรมแบบวนซ้ำที่จะดำเนินการคำสั่งที่กำหนดในจำนวนครั้งที่เราให้ สมมติว่าคำสั่งที่กำหนดคือ“ 4 times println (“ Hello”)” หมายถึงคำสั่ง println (“” Hello”) จะดำเนินการ 4 ครั้ง

ต่อไปนี้เป็นโปรแกรมสำหรับตัวอย่างที่กำหนด ในตัวอย่างนี้มีการใช้คลาสอ็อบเจ็กต์สองคลาส (Run และ Demo) เพื่อให้เราต้องบันทึกทั้งสองคลาสในไฟล์ต่างกันโดยมีชื่อตามลำดับดังนี้

Run.scala - บันทึกโปรแกรมต่อไปนี้ใน Run.scala

object Run {
   implicit class IntTimes(x: Int) {
      def times [A](f: =>A): Unit = {
         def loop(current: Int): Unit =
         
         if(current > 0){
            f
            loop(current - 1)
         }
         loop(x)
      }
   }
}

Demo.scala - บันทึกโปรแกรมต่อไปนี้ใน Demo.scala

import Run._

object Demo {
   def main(args: Array[String]) {
      4 times println("hello")
   }
}

คำสั่งต่อไปนี้ใช้เพื่อคอมไพล์และรันโปรแกรมทั้งสองนี้

คำสั่ง

\>scalac Run.scala
\>scalac Demo.scala
\>scala Demo

เอาต์พุต

Hello
Hello
Hello
Hello

Note -

• ต้องกำหนดคลาสโดยนัยภายในคลาส / อ็อบเจ็กต์ / ลักษณะอื่น (ไม่ใช่ในระดับบนสุด)

• ชั้นเรียนโดยนัยอาจใช้อาร์กิวเมนต์ที่ไม่ใช่ข้อโต้แย้งเพียงหนึ่งข้อในตัวสร้าง

• คลาสโดยนัยต้องไม่ใช่เมธอดสมาชิกหรืออ็อบเจ็กต์ใด ๆ ในขอบเขตที่มีชื่อเดียวกับคลาสโดยนัย

Singleton Objects

Scala เป็นเชิงวัตถุมากกว่า Java เนื่องจากใน Scala เราไม่สามารถมีสมาชิกแบบคงที่ได้ แต่ Scala มีsingleton objects. Singleton เป็นคลาสที่สามารถมีได้เพียงอินสแตนซ์เดียวคือ Object คุณสร้างซิงเกิลตันโดยใช้คีย์เวิร์ดobjectแทนคำหลักของคลาส เนื่องจากคุณไม่สามารถสร้างอินสแตนซ์อ็อบเจ็กต์ซิงเกิลตันคุณจึงไม่สามารถส่งผ่านพารามิเตอร์ไปยังตัวสร้างหลักได้ คุณได้เห็นตัวอย่างทั้งหมดแล้วโดยใช้วัตถุเดี่ยวที่คุณเรียกว่าวิธีการหลักของ Scala

ต่อไปนี้เป็นโปรแกรมตัวอย่างเดียวกับการใช้งานซิงเกิลตัน

ตัวอย่าง

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
   }
}

object Demo {
   def main(args: Array[String]) {
      val point = new Point(10, 20)
      printPoint

      def printPoint{
         println ("Point x location : " + point.x);
         println ("Point y location : " + point.y);
      }
   }
}

บันทึกโปรแกรมข้างต้นใน Demo.scala. คำสั่งต่อไปนี้ใช้เพื่อคอมไพล์และรันโปรแกรมนี้

คำสั่ง

\>scalac Demo.scala
\>scala Demo

เอาต์พุต

Point x location : 10
Point y location : 20