คลาสแบบคงที่ใน Java

มีอะไรstatic classในจาวาหรือเปล่า?

ความหมายของคลาสนั้นคืออะไร ทุกวิธีของคลาสสแตติกจำเป็นต้องมีstaticด้วยหรือไม่

มันจำเป็นต้องใช้วิธีอื่นในการปัดเศษหรือไม่ถ้าชั้นมีวิธีคงที่ทั้งหมดชั้นจะคงที่ด้วยหรือไม่

คลาสแบบคงที่ดีสำหรับอะไร?

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

• ประกาศคลาสของคุณfinal- ป้องกันการขยายชั้นเรียนเนื่องจากการขยายคลาสแบบคงที่ไม่มีเหตุผล
• สร้างตัวสร้างprivate- ป้องกันการสร้างอินสแตนซ์ด้วยรหัสไคลเอนต์เนื่องจากไม่มีเหตุผลในการสร้างอินสแตนซ์คลาสแบบคงที่
• ทำให้ทุกสมาชิกและฟังก์ชั่นของการเรียนstatic- ตั้งแต่ระดับที่ไม่สามารถ instantiated ไม่มีวิธีการเช่นสามารถเรียกได้หรือสาขาเช่นการเข้าถึง
• โปรดทราบว่าคอมไพเลอร์จะไม่ป้องกันคุณจากการประกาศสมาชิก (ไม่คงที่) สมาชิก ปัญหาจะปรากฏขึ้นเฉพาะเมื่อคุณพยายามโทรหาสมาชิกอินสแตนซ์

ตัวอย่างง่ายๆต่อข้อเสนอแนะจากด้านบน:

public class TestMyStaticClass {
     public static void main(String []args){
        MyStaticClass.setMyStaticMember(5);
        System.out.println("Static value: " + MyStaticClass.getMyStaticMember());
        System.out.println("Value squared: " + MyStaticClass.squareMyStaticMember());
        // MyStaticClass x = new MyStaticClass(); // results in compile time error
     }
}

// A top-level Java class mimicking static class behavior
public final class MyStaticClass {
    private MyStaticClass () { // private constructor
        myStaticMember = 1;
    }
    private static int myStaticMember;
    public static void setMyStaticMember(int val) {
        myStaticMember = val;
    }
    public static int getMyStaticMember() {
        return myStaticMember;
    }
    public static int squareMyStaticMember() {
        return myStaticMember * myStaticMember;
    }
}

คลาสแบบคงที่ที่ดีคืออะไร? การใช้คลาสสแตติกที่ดีคือการกำหนดคลาสแบบใช้ครั้งเดียวยูทิลิตี้และ / หรือไลบรารีที่การสร้างอินสแตนซ์ไม่เหมาะสม ตัวอย่างที่ดีคือคลาสคณิตศาสตร์ที่มีค่าคงที่ทางคณิตศาสตร์เช่น PI และ E และให้การคำนวณทางคณิตศาสตร์ การใช้อินสแตนซ์ในกรณีเช่นนี้จะไม่จำเป็นและทำให้สับสน ดูMathการเรียนและรหัสแหล่งที่มา แจ้งให้ทราบว่ามันและของสมาชิกทุกคนมีfinal staticถ้า Java อนุญาตให้คลาสระดับบนสุดถูกประกาศstaticคลาส Math จะคงที่แน่นอน

Java มี "คลาสที่ซ้อนกันแบบคงที่" แต่พวกเขาไม่ได้เหมือนกับคลาสแบบคงที่ของ C # ทุกครั้งถ้านั่นคือที่ที่คุณมา คลาสที่ซ้อนแบบคงที่เป็นเพียงคลาสที่ไม่มีการอ้างอิงถึงอินสแตนซ์ของคลาสภายนอก

คลาสที่ซ้อนกันแบบคงที่สามารถมีวิธีการอินสแตนซ์และวิธีการแบบคงที่

ไม่มีสิ่งเช่นคลาสคงที่ระดับสูงสุดใน Java

มีคลาสที่ซ้อนกันแบบสแตติกคลาส [สแตติกที่ซ้อนกัน] นี้ไม่ต้องการอินสแตนซ์ของคลาสที่ล้อมรอบเพื่อที่จะอินสแตนซ์ของตัวเอง

คลาสเหล่านี้ [สแตติกอ็อบเจ็กต์แบบซ้อน] สามารถเข้าถึงเฉพาะสมาชิกแบบสแตติกของคลาสที่ปิดล้อม [เนื่องจากไม่มีการอ้างอิงใด ๆ กับอินสแตนซ์ของคลาสที่ปิดล้อม ... ]

ตัวอย่างโค้ด:

public class Test { 
  class A { } 
  static class B { }
  public static void main(String[] args) { 
    /*will fail - compilation error, you need an instance of Test to instantiate A*/
    A a = new A(); 
    /*will compile successfully, not instance of Test is needed to instantiate B */
    B b = new B(); 
  }
}

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

ตัวอย่าง:

public class A
{

 public static class B
 {
 }
}

เนื่องจากclass Bมีการประกาศแบบคงที่คุณสามารถสร้างอินสแตนซ์เป็น:

B b = new B();

หมายเหตุหากclass Bไม่ได้ประกาศว่าเป็นแบบสแตติกเพื่อให้ทำงานแบบสแตนด์อะโลนการเรียกอ็อบเจ็กต์อินสแตนซ์จะเป็นดังนี้:

A a= new A();
B b = a.new B();

จะเกิดอะไรขึ้นเมื่อสมาชิกภายในclassประกาศเป็นstatic.. ? ว่าสมาชิกสามารถเข้าถึงได้โดยไม่ต้อง instantiating classดังนั้นการสร้างคลาสภายนอก (คลาสระดับบนสุด) staticจึงไม่มีความหมาย ดังนั้นจึงไม่ได้รับอนุญาต

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

public class A {
    public static class B {

    }
}

ตอนนี้อยู่ในระดับที่แตกต่างกันCในชั้นเรียนสามารถเข้าถึงได้โดยไม่ต้องทำตัวอย่างของคลาสBA

public class C {
    A.B ab = new A.B();
}

staticคลาสสามารถมีnon-staticสมาชิกได้เช่นกัน เฉพาะคลาสที่รับค่าคงที่เท่านั้น

แต่ถ้าstaticคำหลักจะถูกลบออกจากชั้นเรียนจะไม่สามารถเข้าถึงได้โดยตรงโดยไม่ต้องทำตัวอย่างของBA

public class C {
    A a = new A();
    A.B ab = a. new B();
}

แต่เราไม่สามารถมีstaticสมาชิกในnon-staticชั้นในได้

การเห็นว่านี่เป็นผลลัพธ์อันดับต้น ๆ ของ Google สำหรับ "static class java" และคำตอบที่ดีที่สุดไม่ได้อยู่ที่นี่ฉันคิดว่าฉันจะเพิ่มมัน ฉันตีความคำถามของ OP เกี่ยวกับคลาสสแตติกใน C # ซึ่งรู้จักกันในชื่อ singletons ในโลก Java สำหรับผู้ที่ไม่รู้ใน C # คำสำคัญ "คงที่" สามารถนำไปใช้กับการประกาศคลาสซึ่งหมายความว่าชั้นที่เกิดขึ้นไม่สามารถยกตัวอย่าง

ข้อความที่ตัดตอนมาจาก "Effective Java - Second Edition" โดย Joshua Bloch (พิจารณาอย่างกว้างขวางว่าเป็นหนึ่งในคู่มือสไตล์ Java ที่ดีที่สุด):

ตั้งแต่รีลีส 1.5 มีวิธีที่สามในการติดตั้งซิงเกิล เพียงทำประเภท enum ด้วยองค์ประกอบเดียว:

// Enum singleton - the preferred approach
public enum Elvis {
    INSTANCE;
    public void leaveTheBuilding() { ... }
}

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

โบลชโจชัว (2008-05-08) Java ที่มีประสิทธิภาพ (Java Series) (หน้า 18) การศึกษาของเพียร์สัน

ฉันคิดว่าการนำไปปฏิบัติและการให้เหตุผลนั้นค่อนข้างอธิบายตนเอง

คลาสสามารถเป็นแบบสแตติกใน Java หรือไม่?

คำตอบคือใช่เราสามารถมีคลาสแบบคงที่ใน java ใน java เรามีตัวแปรคงที่เช่นเช่นเดียวกับวิธีการคงและยังบล็อกแบบคงที่ คลาสสามารถสร้างได้คงที่ใน Java

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

คลาสที่ซ้อนแบบคงที่เทียบกับชั้นที่ไม่อยู่ในรูปแบบคงที่

1) คลาสแบบคงที่ซ้อนกันไม่ต้องการการอ้างอิงของคลาสภายนอก แต่คลาสที่ซ้อนแบบไม่คงที่หรือคลาสภายในต้องการการอ้างอิงคลาสภายนอก

2) Inner class (หรือคลาสที่ซ้อนกันไม่คงที่) สามารถเข้าถึงสมาชิกทั้งแบบคงที่และไม่คงที่ของคลาสภายนอก คลาสแบบสแตติกไม่สามารถเข้าถึงสมาชิกที่ไม่คงที่ของคลาสภายนอก สามารถเข้าถึงได้เฉพาะสมาชิกแบบคงที่ของคลาสภายนอก

ดูที่นี่: https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

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

ในแง่ง่าย ๆ จาวาสนับสนุนการประกาศคลาสให้เป็นแบบสแตติกสำหรับคลาสภายในเท่านั้น แต่ไม่ใช่สำหรับคลาสระดับบนสุด

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

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

ดังนั้น Java รองรับคลาสแบบคงที่ที่ระดับชั้นใน (ในชั้นเรียนที่ซ้อนกัน)

และ Java ไม่รองรับคลาสสแตติกที่ระดับบนสุด

ฉันหวังว่านี่เป็นวิธีแก้ปัญหาที่ง่ายกว่าสำหรับคำถามเพื่อความเข้าใจพื้นฐานของคลาสแบบคงที่ใน Java

Java มีวิธีการคงที่ที่เกี่ยวข้องกับการเรียน (เช่น java.lang.Math มีวิธีการคงที่เท่านั้น) แต่ชั้นเรียนไม่ได้คงที่

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

public class Outer {
   static class Nested_Demo {
      public void my_method() {
          System.out.println("This is my nested class");
      }
   }
public static void main(String args[]) {
      Outer.Nested_Demo nested = new Outer.Nested_Demo();
      nested.my_method();
   }
}

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

public class MyClass {
   // Static method
   static void myStaticMethod() {
      System.out.println("Static methods can be called without creating objects");
   }

  // Public method
  public void myPublicMethod() {
      System.out.println("Public methods must be called by creating objects");
   }

  // Main method
  public static void main(String[ ] args) {
      myStaticMethod(); // Call the static method
    // myPublicMethod(); This would output an error

    MyClass myObj = new MyClass(); // Create an object of MyClass
    myObj.myPublicMethod(); // Call the public method
  }
}

ทุกคำตอบที่ดี แต่ฉันไม่เห็นการอ้างอิงถึง java.util.Collections ซึ่งใช้คลาสภายในแบบคงที่จำนวนตันสำหรับวิธีการปัจจัยแบบคงที่ ดังนั้นการเพิ่มเดียวกัน

การเพิ่มตัวอย่างจาก java.util.Collections ซึ่งมีหลายคลาสภายในคงที่ คลาสภายในมีประโยชน์กับรหัสกลุ่มซึ่งจำเป็นต้องเข้าถึงผ่านคลาสภายนอก

/**
 * @serial include
 */
static class UnmodifiableSet<E> extends UnmodifiableCollection<E>
                             implements Set<E>, Serializable {
    private static final long serialVersionUID = -9215047833775013803L;

    UnmodifiableSet(Set<? extends E> s)     {super(s);}
    public boolean equals(Object o) {return o == this || c.equals(o);}
    public int hashCode()           {return c.hashCode();}
}

นี่คือวิธีปัจจัยแบบคงที่ในคลาส java.util.Collections

public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
    return new UnmodifiableSet<>(s);
}