การใช้ตัวแปรแบบคงที่ส่วนตัวใน Java คืออะไร?

ถ้าตัวแปรถูกประกาศเป็นแล้วผมสามารถเข้าถึงได้จากทุกที่public static varName; ClassName.varNameฉันยังทราบว่าสมาชิกแบบคงที่จะถูกใช้ร่วมกันโดยอินสแตนซ์ทั้งหมดของคลาสและไม่ได้ถูกจัดสรรใหม่ในแต่ละอินสแตนซ์

การประกาศตัวแปรprivate static varName;แตกต่างจากการประกาศตัวแปรprivate varName;หรือไม่?

ในทั้งสองกรณีมันไม่สามารถเข้าถึงได้เป็นClassName.varNameหรือเป็นClassInstance.varNameจากชั้นอื่น ๆ

การประกาศตัวแปรเป็นแบบสแตติกให้คุณสมบัติพิเศษอื่น ๆ หรือไม่

แน่นอนมันสามารถเข้าถึงได้เป็นClassName.var_nameแต่เพียงจากภายในชั้นเรียนในสิ่งที่มันถูกกำหนด - privateนั่นเป็นเพราะมันถูกกำหนดให้เป็น

public staticหรือprivate staticตัวแปรมักใช้สำหรับค่าคงที่ ตัวอย่างเช่นหลายคนไม่ชอบค่าคงที่ "รหัสยาก" ในรหัสของพวกเขา พวกเขาต้องการสร้างpublic staticหรือprivate staticตัวแปรที่มีชื่อที่มีความหมายและใช้ในโค้ดซึ่งควรทำให้โค้ดอ่านง่ายขึ้น (คุณควรสร้างค่าคงที่เช่นนี้final)

ตัวอย่างเช่น:

public class Example {
    private final static String JDBC_URL = "jdbc:mysql://localhost/shopdb";
    private final static String JDBC_USERNAME = "username";
    private final static String JDBC_PASSWORD = "password";

    public static void main(String[] args) {
        Connection conn = DriverManager.getConnection(JDBC_URL,
                                         JDBC_USERNAME, JDBC_PASSWORD);

        // ...
    }
}

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

ตัวแปรสแตติกมีค่าเดียวสำหรับอินสแตนซ์ทั้งหมดของคลาส

ถ้าคุณทำสิ่งที่ชอบ:

public class Person
{
    private static int numberOfEyes;
    private String name;
}

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

ตัวแปรสแตติกส่วนตัวมีประโยชน์ในลักษณะเดียวกับที่ตัวแปรอินสแตนซ์ส่วนตัวมีประโยชน์: พวกเขาเก็บสถานะซึ่งเข้าถึงได้โดยรหัสภายในคลาสเดียวกันเท่านั้น ความสามารถในการเข้าใช้งาน (ส่วนตัว / สาธารณะ / ฯลฯ ) และอินสแตนซ์ / ธรรมชาติของตัวแปรนั้นเป็นแนวคิดมุมฉากทั้งหมด

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

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

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

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

นี่คือตัวอย่าง:

Class test {
   public static String name = "AA";
   private static String age;

   public static void setAge(String yourAge) {
       //here if the age variable is not static you will get an error that you cannot access non static variables from static procedures so you have to make it static and private to not be accessed from other classes
       age = yourAge;
   }
}

ดีprivate staticตัวแปรสามารถใช้ในการใช้ข้อมูลร่วมกันข้ามกรณีของชั้นเรียนที่ ในขณะที่คุณถูกต้องที่เราไม่สามารถเข้าถึงprivate staticตัวแปรโดยใช้การสร้างเช่นClassName.memberหรือClassInstance.memberแต่สมาชิกจะสามารถมองเห็นได้จากวิธีการของคลาสนั้นหรืออินสแตนซ์ของคลาสนั้น ดังนั้นในกรณีที่มีผลของคลาสนั้นจะสามารถอ้างถึงสมาชิกได้เสมอ

การใช้ตัวแปรคลาสสแตติกส่วนตัวคืออะไร?

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

public class Book {
    private static int numBooks = 0;
    private int id;
    public String name;

    Book(String name) {
        id = numBooks++;
        this.name = name;
    }
}

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

ส่อเสียดมาก!

การประกาศตัวแปรprivate static varName;แตกต่างจากการประกาศตัวแปรprivate varName;หรือไม่?

ใช่ทั้งสองแตกต่างกัน และเป็นครั้งแรกหนึ่งเรียกว่าclass variableเพราะมันเก็บค่าเดียวสำหรับการว่าclassในขณะที่คนอื่น ๆ จะเรียกว่าเพราะมันสามารถเก็บค่าที่แตกต่างกันสำหรับการที่แตกต่างกันinstance variable instances(Objects)อันแรกถูกสร้างเพียงครั้งเดียวใน jvm และอีกอันหนึ่งถูกสร้างขึ้นหนึ่งครั้งต่อหนึ่งอินสแตนซ์นั่นคือถ้าคุณมี 10 อินสแตนซ์คุณจะมี 10 private varName;ใน jvm ที่แตกต่างกัน

ไม่ประกาศตัวแปรstaticให้คุณสมบัติพิเศษอื่น ๆ ?

ใช่ตัวแปรแบบสแตติกได้รับคุณสมบัติที่แตกต่างจากตัวแปรอินสแตนซ์ทั่วไป ฉันได้กล่าวเพียงไม่กี่แล้วและขอให้เห็นบางส่วนที่นี่: class variables(เช่นตัวแปรซึ่งได้รับการประกาศให้เป็นคงที่) ClassName.varNameสามารถเข้าถึงได้โดยตรงโดยใช้ชื่อชั้นเช่น และวัตถุใด ๆ ของคลาสนั้นสามารถเข้าถึงและแก้ไขค่าของมันซึ่งแตกต่างจากตัวแปรอินสแตนซ์ที่เข้าถึงได้โดยวัตถุที่เกี่ยวข้องเท่านั้น ตัวแปรคลาสสามารถใช้ในวิธีการคงที่

อะไรคือการใช้ private static variableใน Java คืออะไร?

เหตุผลprivate static variableไม่แตกต่างจากpublic static variableคนแรกให้คุณควบคุมได้มากขึ้น IMO คุณสามารถแทนที่ได้อย่างแท้จริงpublic static variableด้วยโดยprivate static variableใช้public staticวิธี getter และ setter

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

public class Singleton {
    private static Singleton singletonInstance = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return Singleton.singletonInstance;
    }
}

คำหลักที่เอกชนจะใช้สำหรับการเข้าถึงตัวแปรภายในชั้นเรียนและการรักษาแบบคงที่ในแง่ที่เราสามารถเข้าถึงตัวแปรในวิธีการที่คงยัง แต่ตัวแปรอ้างอิงไม่สามารถเข้าถึงในวิธีการคง

มุมมองอื่น:

1. คลาสและอินสแตนซ์ของมันเป็นสองสิ่งที่แตกต่างกันที่รันไทม์ ข้อมูลระดับคือ "ร่วมกัน" โดยทุกกรณีของการเรียนว่า
2. ตัวแปรคลาสที่ไม่คงที่เป็นของอินสแตนซ์และตัวแปรสแตติกเป็นของคลาส
3. เช่นเดียวกับตัวแปรอินสแตนซ์สามารถเป็นส่วนตัวหรือสาธารณะตัวแปรสแตติกสามารถเป็นส่วนตัวหรือสาธารณะได้

เมื่ออยู่ในวิธีการคงที่คุณใช้ตัวแปรตัวแปรจะต้องคงที่เช่นกัน:

private static int a=0;  
public static void testMethod() {  
        a=1;  
}

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

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

คุณควรดูตัวอย่างของฉันถ้ามันไม่สมเหตุสมผล ไปที่นี่http://www.siteconsortium.com/h/D0000D.php

บรรทัดล่างคือว่ามันค่อนข้างตรงตามที่บอกไว้ มันเป็นตัวแปรสมาชิกแบบคงที่ที่เป็นส่วนตัว ตัวอย่างเช่นถ้าคุณต้องการสร้างวัตถุ Singleton ทำไมคุณต้องการทำให้ตัวแปร SingletonExample.instance เป็นแบบสาธารณะ หากคุณเป็นคนที่ใช้คลาสสามารถเขียนทับค่าได้อย่างง่ายดาย

นั่นคือทั้งหมดที่มันเป็น

    สาธารณะชั้น SingletonExample {
      อินสแตนซ์ SingletonExample ส่วนตัวคง = null;
      ค่า int คงที่ส่วนตัว = 0;
      SingletonExample ส่วนตัว () {
        ++ this.value;
      }
      สาธารณะคง SingletonExample getInstance () {
        ถ้า (อินสแตนซ์! = null)
        ตัวอย่างการส่งคืน
        ทำข้อมูลให้ตรงกัน (SingletonExample.class) {
        อินสแตนซ์ใหม่ SingletonExample ();
        ตัวอย่างการส่งคืน
        }
      }
      โมฆะสาธารณะ printValue () {
        System.out.print (this.value);
      }

      โมฆะคงที่สาธารณะหลัก (String [] args) {
        ตัวอย่าง SingletonExample = getInstance ();
        instance.printValue ();
        อินสแตนซ์ = getInstance ();
        instance.printValue ();
         }
    }

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

หากตัวแปรถูกกำหนดเป็นสแตติกสาธารณะก็สามารถเข้าถึงได้ผ่านชื่อคลาสจากคลาสใด ๆ

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

ตัวอย่างที่ดีมากของมันคือsleep()เมธอดในคลาสของเธรด

Thread.sleep(2500);

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

ตัวอย่างที่ดีมากของมันคือการกำหนดการเชื่อมต่อฐานข้อมูลหรือค่าคงที่ซึ่งต้องการการประกาศตัวแปรเป็นสแตติกส่วนตัว

อีกตัวอย่างทั่วไปคือ

private static int numberOfCars=10;

public static int returnNumber(){

return numberOfCars;

}

ฉันใหม่กับ Java แต่วิธีหนึ่งที่ฉันใช้ตัวแปรแบบคงที่อย่างที่ฉันคิดว่าหลายคนทำคือการนับจำนวนอินสแตนซ์ของคลาส เช่น:

public Class Company {
    private static int numCompanies;

    public static int getNumCompanies(){
        return numCompanies;
    }
}

จากนั้นคุณสามารถ sysout:

Company.getNumCompanies();

คุณยังสามารถเข้าถึง numCompanies จากแต่ละอินสแตนซ์ของชั้นเรียน (ซึ่งฉันไม่เข้าใจอย่างสมบูรณ์) แต่มันจะไม่เป็นแบบ "คงที่" ฉันไม่รู้ว่านี่เป็นการปฏิบัติที่ดีที่สุดหรือไม่ แต่มันสมเหตุสมผลสำหรับฉัน

*) หากตัวแปรถูกประกาศเป็นแบบส่วนตัวมันจะไม่สามารถมองเห็นได้นอก class.this จะถูกเรียกว่า datahiding

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

classname.variablename;

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

public class PrivateStatic {

private static int var = 10;
public void setVar(int newVal) {
    var = newVal;
}

public int getVar() {
    return var;
}

public static void main(String... args) {
    PrivateStatic p1 = new Sub1();
    System.out.println(PrivateStatic.var);
    p1.setVar(200);

    PrivateStatic p2 = new Sub2();
    System.out.println(p2.getVar());
}
}


class Sub1 extends PrivateStatic {

}

class Sub2 extends PrivateStatic {
}

ThreadLocalprivate staticตัวแปรที่จะดำเนินการมักจะเป็น ด้วยวิธีนี้พวกเขาจะไม่ถูกผูกไว้กับชั้นเรียนและแต่ละหัวข้อมีการอ้างอิงของตัวเองไปยังวัตถุ "ThreadLocal" ของตัวเอง

ในตัวอย่างต่อไปนี้eyeถูกเปลี่ยนโดย PersonB ในขณะที่legยังคงเหมือนเดิม นี่เป็นเพราะตัวแปรส่วนตัวสร้างสำเนาของตัวเองไปยังวิธีการเพื่อให้ค่าเดิมยังคงเหมือนเดิม ในขณะที่ค่าคงที่ส่วนตัวมีเพียงหนึ่งสำเนาสำหรับวิธีการทั้งหมดเพื่อแบ่งปันดังนั้นการแก้ไขค่าจะเปลี่ยนค่าเดิม

public class test {
private static int eye=2;
private int leg=3;

public test (int eyes, int legs){
    eye = eyes;
    leg=leg;
}

public test (){
}

public void print(){
    System.out.println(eye);
    System.out.println(leg);
}

public static void main(String[] args){
    test PersonA = new test();      
    test PersonB = new test(14,8);
    PersonA.print();    
}

}

> 14 3