วัตถุใน Java

1. วัตถุ

ทุกอย่างใน Java เป็นวัตถุ

พูดให้ถูกคือ มีบางสิ่งใน Java น้อยมากที่ไม่ใช่วัตถุ ตัวอย่างเช่น ประเภทดั้งเดิม แต่นี่เป็นข้อยกเว้นที่ค่อนข้างหายากสำหรับกฎ

แล้ววัตถุคืออะไร?

ออบเจกต์คือเอนทิตีที่จัดกลุ่มข้อมูลด้วยวิธีการที่ประมวลผลข้อมูล เมื่อเราพูดว่า "ข้อมูล" เราหมายถึงตัวแปร แน่นอน

ตัวแปรของวัตถุเรียกว่า "ข้อมูล" หรือ "สถานะ"

มีการกล่าวถึงวิธีการของวัตถุว่าเป็น "พฤติกรรม" ของมัน เป็นเรื่องปกติที่จะเปลี่ยนสถานะของวัตถุ (ตัวแปร) โดยใช้เมธอดของวัตถุนั้นเท่านั้น การเปลี่ยนตัวแปรของวัตถุโดยตรง (ไม่ใช้วิธีการของมัน) ถือเป็นรูปแบบที่ไม่ดี

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

แต่ละวัตถุมีสำเนาของตัวแปรอินสแตนซ์ (ฟิลด์) ของตัวเอง หากมีการประกาศตัวแปร int แบบไม่คงที่ในคลาส และโปรแกรมของคุณสร้างออบเจกต์ 10 รายการในคลาสนั้น แต่ละออบเจ็กต์จะมีตัวแปร int ของตัวเอง

การโต้ตอบกับวัตถุ

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

variable.method()

Where variableคือตัวแปรที่เก็บการอ้างอิงไปยังอ็อบเจกต์ และmethodเป็นเมธอดของคลาสนั้น

หากคุณต้องการอ้างถึงฟิลด์ (ตัวแปร) ของวัตถุ คุณต้องใช้ตัวดำเนินการจุด :

variable.field

Where variableคือตัวแปรที่เก็บการอ้างอิงไปยังวัตถุ และfieldเป็นตัวแปรอินสแตนซ์ (ฟิลด์)

2. newตัวดำเนินการ

ในการสร้างวัตถุของบางคลาส คุณต้องใช้newตัวดำเนินการ โดยทั่วไป การสร้างวัตถุมีลักษณะดังนี้:

Class variable = new Class(arguments);

Classชื่อของคลาสของvariableตัวแปรและชื่อของคลาสของอ็อบเจกต์จะสร้างอยู่ที่ไหน และvariable เป็นตัวแปรที่เก็บการอ้างอิงถึงวัตถุที่สร้างขึ้น และargumentsเป็นตัวยึดสำหรับรายการอาร์กิวเมนต์ที่คั่นด้วยเครื่องหมายจุลภาคที่ส่งไปยังตัวสร้าง

รายการอาร์กิวเมนต์เฉพาะที่สามารถส่งผ่านได้จะถูกตัดสินโดยโปรแกรมเมอร์ที่เขียนคลาส

คุณเคยสร้างวัตถุมาก่อนและใช้โครงสร้างเฉพาะนี้ด้วยซ้ำ คุณยังไม่ลืมฉันหวังว่า?

Scanner console = new Scanner(System.in);
int x = console.nextInt();

Scanner console— สิ่งนี้สร้างconsoleตัวแปรที่มีประเภทเป็นScanner. - สิ่งนี้สร้างวัตถุ ใหม่ และตัวดำเนินการกำหนดจะตั้งค่าตัวแปรเท่ากับการอ้างอิงไปยังวัตถุที่สร้างขึ้นใหม่new Scanner(System.in)Scannerconsole

ในบรรทัดที่สอง เราเรียกnextInt()เมธอดบนScannerวัตถุ โดยใช้consoleตัวแปรที่เก็บการอ้างอิงถึงScannerวัตถุ

ตัวอย่างการสร้างวัตถุ:

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

วัตถุที่สร้างขึ้นจะเรียกว่าวัตถุของคลาสหรืออินสแตนซ์ของคลาสในขณะที่คลาสจะเรียกว่าคลาสของวัตถุ ตัวอย่างเช่นsตัวแปรเก็บการอ้างอิงถึงอินสแตนซ์ของStringคลาส

3. แนะนำชั้นเรียน

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

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

โปรแกรมเมอร์มักจะสร้างคลาสของตนเองเมื่อต้องการนำเอนทิตีใหม่เข้ามาในโปรแกรม ฟังดูสับสนไหม? จากนั้นฉันจะพยายามอธิบาย แต่ฉันจะเริ่มจากที่ไกล ๆ

กลุ่มข้อมูล

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

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

class Solution
{
   public static void printPoints(int[] x, int[] y, int[] color)
   {
     for (int i = 0; i < x.length; i++)
       System.out.println("Color of (" + x[i] + ", " + y[i] + ") = " + color[i]);
   }

   public static void main(String[] args)
   {
     int[] x = new int[100];
     int[] y = new int[100];
     int[] color = new int[100];
     printPoints(x, y, color);
   }
}

มันจะสะดวกกว่ามากถ้าเรามีประเภทเดียว สำหรับจัดเก็บข้อมูลทั้งหมดเกี่ยวกับจุด: x, y, colorหากไม่มีประเภทดังกล่าวใน Java คุณสามารถสร้างได้เอง

ในการทำเช่นนี้ เราจะเขียนโค้ดสำหรับPointชั้นเรียน:

public class Point
{
   public int x;
   public int y;
   public int color;
}

ตอนนี้โค้ดด้านบนสามารถเขียนใหม่เป็น:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       System.out.println("Color of (" + points[i].x + ", " + point[i].y + ") = " + points[i].color);
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

ตอนนี้ให้เพิ่มวิธีการในPointชั้นเรียนที่จะแสดงข้อมูลเกี่ยวกับวัตถุ:

public class Point
{
   public int x;
   public int y;
   public int color;
   public void print()
   {
     System.out.println("Color of (" + x + ", " + y + ") = " + color);
   }
}

ตอนนี้Solutionคลาสมีลักษณะดังนี้:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       points[i].print();
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

เราซ่อนพิกัดและข้อมูลสีของจุดอย่างชำนาญภายในPointชั้นเรียนพร้อมกับวิธีการที่แสดงสถานะของจุด

คลาสเป็นวิธีจัดการความซับซ้อนของโปรแกรม โปรแกรมขนาดใหญ่จะซับซ้อนน้อยลงเมื่อแบ่งออกเป็นคลาสย่อยๆ

4. วัตถุที่ไม่เปลี่ยนรูป vs วัตถุที่ไม่เปลี่ยนรูป

กาลครั้งหนึ่งนานมาแล้ว เราศึกษาค่าคงที่ใน Java และได้ข้อสรุปที่ไม่สบายใจนัก ค่าคงที่ทำให้คุณสามารถป้องกันตัวแปรจากการเปลี่ยนแปลงได้ แต่ไม่สามารถป้องกันการเปลี่ยนแปลงของออบเจกต์ที่อ้างถึงได้

เพื่อแก้ปัญหานี้ Java จึงสร้างวัตถุคงที่ขึ้นมา หรือที่มักเรียกกันว่าวัตถุที่ไม่เปลี่ยนรูป

อย่างไรก็ตาม คุณทราบคลาสดังกล่าวแล้ว ซึ่งวัตถุไม่สามารถเปลี่ยนแปลงได้: String. วัตถุStringจะคงอยู่ตลอดไปไม่เปลี่ยนแปลงหลังจากที่มันถูกสร้างขึ้น และผู้สร้างของ Java บรรลุสิ่งนี้ได้อย่างไร

ขั้น แรกตัวแปรทั้งหมดของStringคลาสจะถูกซ่อนไว้ เช่น ประกาศprivate

ประการที่สอง คุณไม่สามารถสืบทอดStringคลาสได้: การประกาศคลาสรวมถึงfinalตัวดัดแปลง

ประการที่สามและน่าสนใจที่สุดคือเมธอดทั้งหมดของStringคลาส ซึ่งตามทฤษฎีแล้ว คุณคาดหวังที่จะเปลี่ยนแปลงอ็อบเจกต์ที่มีอยู่จริง ๆ แล้วไม่เปลี่ยนแปลง แต่จะส่งคืนออบเจกต์ใหม่แทน

ตัวอย่างเช่นtoUpperCase()เมธอดทำให้ตัวอักษรทั้งหมดในสตริงเป็นตัวพิมพ์ใหญ่ แต่แทนที่จะเปลี่ยนวัตถุที่เรียกใช้เมธอด จะส่งคืนStringวัตถุใหม่ที่ประกอบด้วยตัวพิมพ์ใหญ่:

String text = "This is a very important message";
String message = text.toUpperCase();

นี่คือสิ่งที่จะอยู่ในหน่วยความจำหลังจากรันโค้ดนี้:

ดังนั้นอย่าลังเลที่จะส่งสตริงของคุณไปยังวิธีใดก็ได้: จะไม่มีใครเปลี่ยนได้