คลาสสแตติก

1. ชั้นเรียนภายใน

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

ใน Java คุณได้รับอนุญาตให้ประกาศคลาสภายในคลาสได้ทั้งหมด และแม้แต่ชั้นเรียนภายในชั้นเรียนที่อยู่ภายในชั้นเรียนภายในชั้นเรียน ทุกอย่างดูเรียบง่ายมาก:

class OuterClass
{
   variables of the class
   methods of the class

   class NestedClass
   {
      variables of the class
      methods of the class
   }
}

เราเพิ่งประกาศคลาสหนึ่งภายในอีกคลาสหนึ่ง ง่ายๆอย่างนั้น

ตัวอย่าง:

public class Solution
{
   static ArrayList<Point> points = new ArrayList<Point>();

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;
      points.add(point);
   }

   static class Point
   {
      int x;
      int y;
   }
}

คลาสที่ซ้อนกันอาจเป็นแบบคงที่หรือไม่คงที่ก็ได้ คลาสที่ซ้อนกันแบบคงที่เรียกง่ายๆ ว่าคลาสที่ซ้อนกันแบบคงที่ คลาสที่ซ้อนกันแบบไม่คงที่เรียกว่าคลาสภายใน ( คลาสภายใน )

2. คลาสคงที่

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

ชื่อชั้น

หากคุณต้องการอ้างถึงคลาสที่ซ้อนกันแบบสแตติกจากที่อื่นที่ไม่ใช่คลาสภายนอก คุณต้องระบุชื่อคลาส ซึ่งประกอบด้วยชื่อของคลาสภายนอกและชื่อของคลาสที่ซ้อนกัน นี่คือลักษณะทั่วไปของชื่อนี้:

OuterClass.InnerClass

ตัวอย่าง:

com.codegym.Solution

Point

com.codegym.Solution.Point

java.util.Map

Entry

java.util.Map.Entry

java.util.Files

DirectoryStream

java.util.Files.DirectoryStream

java.nio.WindowsPath

Closeable

java.nio.WindowsPath.Closeable

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

ตัวอย่างทั่วไปของคลาสซ้อนใน JDK คือEntryคลาสภายในMapคลาส หากคุณต้องการรับชุดของคู่คีย์-ค่าที่จัดเก็บไว้ในHashMapออบเจกต์ ให้ใช้entrySet()เมธอด ซึ่งจะคืนค่าaSet<Map.Entry>

โปรดทราบว่าเป็นตัวอย่างของคลาสภายนอกและคลาสที่ซ้อนกันMap.Entry

การสร้างวัตถุ

มันง่ายมากที่จะสร้างวัตถุของคลาสที่ซ้อนกันแบบคงที่ นี่คือลักษณะ:

OuterClass.NestedClass name = new OuterClass.NestedClass();

ทุกอย่างเหมือนกับคลาสทั่วไป แต่ชื่อประกอบด้วยสองส่วน

การเรียกเมธอดแบบสแตติก

หากคลาสสแตติกมีเมธอดสแตติก คุณสามารถเข้าถึงได้ด้วยวิธีเดียวกับเมธอดสแตติกของคลาสทั่วไป (แต่ชื่อคลาสจะประกอบด้วยสองส่วน)

OuterClass.NestedClass.staticMethod();

การเข้าถึงตัวแปรคงที่

การเข้าถึงตัวแปรสแตติกสาธารณะของคลาสที่ซ้อนกันก็ง่ายเช่นกัน:

OuterParent.NestedClass.nameOfStaticVariable

3. คุณสมบัติของคลาสสแตติก

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

หากคุณกำลังทำงานกับคลาสที่ซ้อนกันแบบสแตติกภายในคลาสภายนอก คุณจะไม่สังเกตเห็นความแตกต่างใดๆ จากคลาสธรรมดาที่สุด (ไม่ซ้อนและไม่สแตติก)

ตัวอย่าง:

public class Solution
{
   static ArrayList<Point> points;

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;
      points = new ArrayList<Point>();
      points.add(point);
   }

   static class Point
   {
      int x;
      int y;
   }
}

public class Solution
{
   static ArrayList<Point> points;

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;
      points = new ArrayList<Point>();
      points.add(point);
   }
}

class Point
{
   int x;
   int y;
}

หากคุณนำคลาสที่ซ้อนกันแบบคงที่และย้ายออกจากคลาสภายนอก สิ่งเดียวที่จะเปลี่ยนแปลงคือคลาสใหม่จะไม่สามารถเข้าถึงprivate staticตัวแปรและเมธอดของคลาสภายนอกเดิม ได้อีกต่อไป

ตัวอย่าง:

public class Solution
{
   private static ArrayList<Point> points;

   static class Point
   {
      int x;
      int y;

      public static void main(String[] args)
      {
         Point point = new Point();
         point.x = 100;
         point.y = 200;

         // This will work
         points = new ArrayList<Point>();
         points.add(point);
      }
   }
}

public class Solution
{
   private static ArrayList<Point> points;
}

class Point
{
   int x;
   int y;

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;

      // This will generate an error
      points = new ArrayList<Point>();
      points.add(point);
   }
}

เมธอด ใน คลาสmainธรรมดาไม่สามารถเข้าถึงตัวแปรของคลาสได้!Pointprivate static pointsSolution

นี่คือข้อแตกต่างที่สำคัญระหว่างคลาสซ้อนแบบสแตติกและคลาสธรรมดา privateเมธอดของคลาส ที่ซ้อนกันแบบสแตติกสามารถเข้าถึงตัวแปรสแตติกทั้งหมดและเมธอดของคลาสภายนอก แม้ว่าจะถูกประกาศ

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