ජාවා හි ස්ථිතික පන්ති

static classජාවා වල වගේ දෙයක් තියෙනවද?

එවැනි පංතියක තේරුම කුමක්ද? ස්ථිතික පන්තියේ සියලුම ක්‍රම ද අවශ්‍ය විය staticයුතුද?

පංතියක සියලු ස්ථිතික ක්‍රම තිබේ නම්, පන්තියද ස්ථිතික විය යුතුද?

ස්ථිතික පන්ති මොනවාද?

ජාවාහි ස්ථිතික කැදැලි පන්ති ඇති නමුත් ඔබ ඉහළ මට්ටමේ ස්ථිතික පන්තියක් සොයන බවක් පෙනේ. ඉහළ මට්ටමේ පන්ති ස්ථිතිකයක් සෑදීමට ජාවාට ක්‍රමයක් නැත, නමුත් ඔබට මේ වගේ ස්ථිතික පන්තියක් අනුකරණය කළ හැකිය:

• ඔබේ පංතිය ප්‍රකාශ කරන්න final- ස්ථිතික පන්තියක් දීර් ing කිරීම තේරුමක් නැති බැවින් පන්තියේ දිගුව වළක්වයි
• ඉදිකිරීම්කරු සාදන්න private- ස්ථිතික පංතියක් ක්ෂණික කිරීම තේරුමක් නැති බැවින් ග්‍රාහක කේතය මඟින් ක්ෂණිකව වැළැක්වීම
• පංතියේ සියලුම සාමාජිකයන් හා කාර්යයන් සාදන්න static- පංතිය ක්ෂණිකව කළ නොහැකි බැවින් නිදර්ශන ක්‍රම ඇමතීමට හෝ නිදර්ශන ක්ෂේත්‍රවලට ප්‍රවේශ විය නොහැක
• නිදසුනක් (ස්ථිතික නොවන) සාමාජිකයෙකු ප්‍රකාශ කිරීමෙන් සම්පාදකයා ඔබව වළක්වන්නේ නැති බව සලකන්න. ගැටළුව පෙන්වන්නේ ඔබ උදාහරණ සාමාජිකයා ඇමතීමට උත්සාහ කළහොත් පමණි

ඉහත යෝජනා සඳහා සරල උදාහරණයක්:

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. ඉහළ මට්ටමේ පන්ති ප්‍රකාශයට පත් කිරීමට ජාවා ඉඩ දුන්නේ නම් staticගණිත පන්තිය ස්ථිතික වනු ඇත.

හොඳයි, ජාවා සතුව “ස්ථිතික කැදැලි පන්ති” ඇත, නමුත් ඒවා ඔබ සී # හි ස්ථිතික පන්ති වලට සමාන නොවේ. ස්ථිතික කැදැලි පන්තියක් යනු බාහිර පන්තියේ නිදසුනක් ගැන ව්‍යංගයෙන් සඳහනක් නැති එකකි.

ස්ථිතික කැදැලි පන්තිවලට නිදර්ශන ක්‍රම සහ ස්ථිතික ක්‍රම තිබිය හැකිය.

ජාවා හි ඉහළ මට්ටමේ ස්ථිතික පන්තියක් වැනි දෙයක් නොමැත.

ස්ථිතික කැදැලි පංතියක් ඇත , මෙම [ස්ථිතික කැදැලි] පන්තියට ක්ෂණිකව ක්‍රියාත්මක වීම සඳහා සංවෘත පන්තියේ උදාහරණයක් අවශ්‍ය නොවේ.

මෙම පංති [ස්ථිතික කැදැල්ලට] ප්‍රවේශ විය හැක්කේ සංවෘත පන්තියේ ස්ථිතික සාමාජිකයින්ට පමණි [එයට සංවෘත පන්තියේ අවස්ථා පිළිබඳ සඳහනක් නොමැති බැවින් ...]

කේත නියැදිය:

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..? ක්ෂණිකව තොරව සාමාජිකයින්ට ප්‍රවේශ විය හැකි බව class. එබැවින් බාහිර පන්තිය (ඉහළ මට්ටමේ පන්තිය) සෑදීම staticඅර්ථයක් නැත. එබැවින් එයට අවසර නැත.

නමුත් ඔබට අභ්‍යන්තර පන්ති ස්ථිතික ලෙස සැකසිය හැකිය (එය ඉහළ මට්ටමේ පන්තියේ සාමාජිකයෙකු බැවින්). එවිට ඉහළ පෙළ පන්තිය ක්ෂණිකව නොගෙන එම පන්තියට ප්‍රවේශ විය හැකිය. පහත උදාහරණය සලකා බලන්න.

public class A {
    public static class B {

    }
}

දැන්, වෙනත් පංතියක් තුළ C, පන්තියේ Bනිදසුනක් නොකර පන්තියට ප්‍රවේශ විය හැකිය A.

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

staticපන්තිවලට non-staticසාමාජිකයන් ද සිටිය හැකිය . ස්ථිතික වන්නේ පන්තියට පමණි.

නමුත් staticමූලික පදය පන්තියෙන් ඉවත් කළ හොත්, Bනිදසුනක් නොමැතිව එය කෙලින්ම ප්‍රවේශ කළ නොහැක A.

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

නමුත් අපට අභ්‍යන්තර පන්තියක් staticතුළ සාමාජිකයන් සිටිය නොහැක non-static.

ජාවාහි පන්තියක් ස්ථිතික විය හැකිද?

පිළිතුර ඔව් , අපට ජාවාහි ස්ථිතික පන්තියක් තිබිය හැකිය. ජාවා හි, අපට ස්ථිතික නිදර්ශන විචල්‍යයන් මෙන්ම ස්ථිතික ක්‍රම සහ ස්ථිතික වාරණ ද ඇත . පංති ද ජාවාහි ස්ථිතික කළ හැකිය.

ජාවා වලදී අපට ඉහළ මට්ටමේ (පිටත) පන්තිය ස්ථිතික කළ නොහැක. ස්ථිතික විය හැක්කේ කැදැලි පන්ති පමණි.

ස්ථිතික කැදැලි පන්තිය එදිරිව ස්ථිතික නොවන කැදැලි පන්තිය

1) නෙස්ටඩ් ස්ථිතික පන්තියට පිටත පන්තිය පිළිබඳ සඳහනක් අවශ්‍ය නොවේ, නමුත් ස්ථිතික නොවන කැදැලි පන්තියට හෝ අභ්‍යන්තර පන්තියට පිටත පන්ති යොමු කිරීම අවශ්‍ය වේ.

2) අභ්‍යන්තර පන්තියට (හෝ ස්ථිතික නොවන කැදැලි පන්තියට) පිටත පන්තියේ ස්ථිතික හා ස්ථිතික නොවන සාමාජිකයන්ට ප්‍රවේශ විය හැකිය. ස්ථිතික පන්තියකට පිටත පන්තියේ ස්ථිතික නොවන සාමාජිකයින්ට ප්‍රවේශ විය නොහැක. එයට ප්‍රවේශ විය හැක්කේ පිටත පන්තියේ ස්ථිතික සාමාජිකයින්ට පමණි.

මෙතැනින් බලන්න: https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

මෙය "ස්ථිතික පංතියේ ජාවා" සඳහා ගූගල්හි ඉහළම ප්‍රති result ලය වන අතර හොඳම පිළිතුර මෙහි නොමැති නිසා මම එය එකතු කරමි යැයි සිතුවෙමි. මම OP හි ප්‍රශ්නය අර්ථ නිරූපණය කරන්නේ C # හි ස්ථිතික පංති සම්බන්ධයෙන් වන අතර ඒවා ජාවා ලෝකයේ තනි බොත්තම් ලෙස හැඳින්වේ. නොදන්නා අය සඳහා, C # හි "ස්ථිතික" මූල පදය පන්ති ප්‍රකාශනයකට යෙදිය හැකි අතර එයින් අදහස් කරන්නේ එහි ප්‍රති ing ලයක් ලෙස ඇති පන්තිය කිසි විටෙකත් ක්ෂණිකව කළ නොහැකි බවයි.

ජොෂුවා බ්ලොච් විසින් රචිත "ective ලදායී ජාවා - දෙවන සංස්කරණය" වෙතින් උපුටා ගැනීමකි (ලබා ගත හැකි හොඳම ජාවා විලාසිතාවේ මාර්ගෝපදේශයක් ලෙස පුළුල් ලෙස සැලකේ):

1.5 නිකුතුව වන විට, තනි බොත්තම් ක්‍රියාත්මක කිරීම සඳහා තුන්වන ප්‍රවේශයක් ඇත. එක් මූලද්‍රව්‍යයක් සමඟ එනමම් වර්ගයක් සාදන්න:

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

මෙම ප්‍රවේශය වඩාත් සංක්ෂිප්ත, අනුක්‍රමිකකරණ යන්ත්‍රෝපකරණ නොමිලයේ ලබා දීම සහ නවීන අනුක්‍රමිකකරණය හෝ පරාවර්තන ප්‍රහාර හමුවේ පවා බහු වාරිකකරණයට එරෙහිව යකඩ ආවරණ සහතිකයක් ලබා දීම හැර, පොදු ක්ෂේත්‍ර ප්‍රවේශයට ක්‍රියාකාරීව සමාන වේ. මෙම ප්‍රවේශය තවමත් පුළුල් ලෙස අනුගමනය කර නොමැති අතර, තනි මූලද්‍රව්‍යයක් වන එනුම් වර්ගය තනි ඒකකය ක්‍රියාත්මක කිරීමට හොඳම ක්‍රමයයි. (අවධාරණය කර්තෘගේ)

බ්ලොච්, ජෝෂුවා (2008-05-08). Java ලදායී ජාවා (ජාවා ශ්‍රේණි) (පි. 18). පියර්සන් අධ්‍යාපනය.

මම හිතන්නේ ක්‍රියාත්මක කිරීම සහ සාධාරණීකරණය කිරීම ස්වයං පැහැදිලි කිරීමක්.

පිටත පන්ති ස්ථිතික විය නොහැක, නමුත් කැදැලි / අභ්‍යන්තර පන්ති විය හැකිය. බාහිර පංතියේ නිදසුනක් නිර්මාණය නොකර කූඩු / අභ්‍යන්තර පන්තිය භාවිතා කිරීමට එය මූලික වශයෙන් උපකාරී වේ.

සරළව කිවහොත්, ජාවා විසින් පංතියක් ස්ථිතික යැයි ප්‍රකාශ කිරීම අභ්‍යන්තර පංති සඳහා පමණක් නොව ඉහළ මට්ටමේ පන්ති සඳහා නොවේ.

ඉහළ මට්ටමේ පන්ති: ජාවා ව්‍යාපෘතියකට සෑම ජාවා ප්‍රභව ගොනුවකම ඉහළ මට්ටමේ පන්ති එකකට වඩා අඩංගු විය හැකිය, එක් පන්තියක් ගොනු නාමයෙන් නම් කර ඇත. ඉහළ මට්ටමේ පන්ති ඉදිරිපිට පොදු, වියුක්ත හා අවසාන වශයෙන් අවසර දී ඇත්තේ විකල්ප තුනක් හෝ වචන තුනක් පමණි.

අභ්‍යන්තර පංති: ඉහළ පෙළේ පන්තියක ඇති පන්ති අභ්‍යන්තර පන්ති ලෙස හැඳින්වේ. අභ්‍යන්තර පන්ති ස්ථිතික විය හැකිය . අභ්‍යන්තර පංති ස්ථිතික බවට පත් කිරීමේ අදහස නම්, ඉහළ පෙළේ පන්තියේ වස්තුව ක්ෂණිකව නොගෙන අභ්‍යන්තර පංතිවල වස්තූන් ක්ෂණිකව ස්ථාපනය කිරීමේ වාසිය ලබා ගැනීමයි. ඉහළ මට්ටමේ පන්තියක ස්ථිතික ක්‍රම සහ විචල්‍යයන් ක්‍රියා කරන ආකාරයට මෙය හරියටම සමාන වේ.

එබැවින් ජාවා අභ්‍යන්තර පන්ති මට්ටමින් (කැදැලි පන්තිවල) ස්ථිතික පන්ති සඳහා සහය දක්වයි

ඉහළ මට්ටමේ පන්තිවල ස්ථිතික පන්ති සඳහා ජාවා සහාය නොදක්වයි.

ජාවා හි ස්ථිතික පංති පිළිබඳ මූලික අවබෝධය සඳහා වන ප්‍රශ්නයට මෙය සරල විසඳුමක් ලබා දෙනු ඇතැයි මම බලාපොරොත්තු වෙමි.

පංති හා සම්බන්ධ ස්ථිතික ක්‍රම ජාවා සතුව ඇත (උදා: 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);
}