คำหลัก 'คงที่' ทำอะไรในชั้นเรียน

เพื่อเป็นการเฉพาะฉันได้ลองใช้รหัสนี้:

package hello;

public class Hello {

    Clock clock = new Clock();

    public static void main(String args[]) {
        clock.sayTime();
    }
}

แต่มันทำให้เกิดข้อผิดพลาด

ไม่สามารถเข้าถึงฟิลด์ที่ไม่คงที่ในวิธีหลักคงที่

ดังนั้นฉันจึงเปลี่ยนการประกาศของclockนี้:

static Clock clock = new Clock();

และมันก็ใช้งานได้ การใส่คำหลักนั้นไว้ข้างหน้าหมายถึงอะไร? มันจะทำอะไรและ / หรือ จำกัด ในแง่ของสิ่งที่สามารถทำได้กับวัตถุนั้น?

static สมาชิกอยู่ในชั้นเรียนแทนอินสแตนซ์ที่เฉพาะเจาะจง

หมายความว่ามีเพียงหนึ่งอินสแตนซ์ของstaticเขตข้อมูลที่มีอยู่^[1]แม้ว่าคุณจะสร้างอินสแตนซ์ของคลาสเป็นล้านรายการหรือคุณไม่ได้สร้างก็ตาม มันจะถูกใช้ร่วมกันโดยทุกกรณี

เนื่องจากstaticเมธอดไม่ได้เป็นของอินสแตนซ์ที่เฉพาะเจาะจงจึงไม่สามารถอ้างถึงสมาชิกอินสแตนซ์ได้ ในตัวอย่างที่ให้มาmainไม่ทราบว่าอินสแตนซ์ของHelloชั้นเรียนใด (และดังนั้นจึงClockควรอ้างอิงถึงตัวอย่างของชั้นเรียน staticสมาชิกสามารถอ้างถึงstaticสมาชิกเท่านั้น สมาชิกอินสแตนซ์สามารถของstaticสมาชิกเข้าถึงแน่นอน

บันทึก Side:แน่นอนstaticสมาชิกสามารถเข้าถึงสมาชิกเช่นผ่านการอ้างอิงวัตถุ

ตัวอย่าง:

public class Example {
    private static boolean staticField;
    private boolean instanceField;
    public static void main(String[] args) {
        // a static method can access static fields
        staticField = true;

        // a static method can access instance fields through an object reference
        Example instance = new Example();
        instance.instanceField = true;
    }

[1]: ขึ้นอยู่กับลักษณะของรันไทม์สามารถมีได้หนึ่งรายการต่อ ClassLoader หรือ AppDomain หรือเธรด แต่อยู่ด้านข้างจุด

หมายความว่ามี "นาฬิกา" เพียงหนึ่งอินสแตนซ์ใน Hello ไม่ใช่หนึ่งต่อแต่ละอินสแตนซ์ที่แยกต่างหากของคลาส "Hello" หรือมากกว่านั้นหมายความว่าจะมีการอ้างอิง "นาฬิกา" ที่ใช้ร่วมกันทั่วไปหนึ่งรายการในทุกกรณีของ ชั้น "Hello"

ดังนั้นหากคุณต้องทำ "สวัสดีใหม่" ที่ใดก็ได้ในรหัสของคุณ: A- ในสถานการณ์แรก (ก่อนการเปลี่ยนแปลงโดยไม่ใช้ "คงที่") มันจะทำให้นาฬิกาใหม่ทุกครั้งที่มีการเรียก "สวัสดีใหม่" แต่ B- ในสถานการณ์ที่สอง (หลังจากการเปลี่ยนแปลงโดยใช้ "คงที่") อินสแตนซ์ "สวัสดีใหม่" ทุกคนจะยังคงแบ่งปันและใช้การอ้างอิง "นาฬิกา" เริ่มต้นและเหมือนกันครั้งแรกที่สร้างขึ้น

นอกเสียจากว่าคุณต้องการ "นาฬิกา" ที่ใดที่หนึ่งนอกเหนือจากหลักสิ่งนี้ก็ใช้ได้เช่นกัน:

package hello;
public class Hello
{
    public static void main(String args[])
    {
      Clock clock=new Clock();
      clock.sayTime();    
    }
}

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

สำหรับข้อมูลเพิ่มเติมโปรดดูที่บิตที่เกี่ยวข้องของออราเคิล Java กวดวิชา

sidenote

Java น่าเสียดายที่อนุญาตให้คุณเข้าถึงสมาชิกแบบคงที่ราวกับว่าพวกเขาเป็นสมาชิกอินสแตนซ์เช่น

// Bad code!
Thread.currentThread().sleep(5000);
someOtherThread.sleep(5000);

ที่ทำให้มันดูราวกับว่าsleepเป็นวิธีการเช่น แต่จริงๆแล้ววิธีสถิต - มันมักจะทำให้นอนหลับเธรดปัจจุบัน เป็นการปฏิบัติที่ดีกว่าเพื่อให้ชัดเจนในรหัสการโทร:

// Clearer
Thread.sleep(5000);

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

ดังนั้นหากคุณมีตัวแปร: private static int i = 0;และคุณเพิ่ม ( i++) ในหนึ่งอินสแตนซ์การเปลี่ยนแปลงจะปรากฏในทุกกรณี iจะเป็น 1 ในทุกกรณี

วิธีการคงที่สามารถใช้งานได้โดยไม่ต้องยกวัตถุ

การใช้งานพื้นฐานของสมาชิกแบบคงที่ ...

public class Hello
{
    // value / method
    public static String staticValue;
    public String nonStaticValue;
}

class A
{
    Hello hello = new Hello();
    hello.staticValue = "abc";
    hello.nonStaticValue = "xyz";
}

class B
{
    Hello hello2 = new Hello(); // here staticValue = "abc"
    hello2.staticValue; // will have value of "abc"
    hello2.nonStaticValue; // will have value of null
}

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

Hello hello = new Hello();
hello.staticValue = "abc";

คุณสามารถเรียกค่าคงที่หรือวิธีการตามชื่อคลาส:

Hello.staticValue = "abc";

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

Hello.main(new String[]()) //main(...) is declared as a static function in the Hello class

โดยตรงแทน:

Hello h = new Hello();
h.main(new String[]()); //main(...) is a non-static function linked with the "h" variable

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

คงที่ใน Java:

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

คำหลักคงที่สามารถใช้กับ:

วิธี

ตัวแปร

คลาสที่ซ้อนภายในคลาสอื่น

บล็อกการเริ่มต้น

ไม่สามารถใช้กับ:

ชั้น (ไม่ซ้อน)

นวกรรมิก

อินเตอร์เฟซ

วิธีการชั้นในท้องถิ่น (ความแตกต่างแล้วชั้นซ้อนกัน)

วิธีการชั้นใน

ตัวแปรอินสแตนซ์

ตัวแปรท้องถิ่น

ตัวอย่าง:

ลองนึกภาพตัวอย่างต่อไปนี้ซึ่งมีตัวแปรอินสแตนซ์ชื่อนับซึ่งเพิ่มขึ้นในตัวสร้าง:

package pkg;

class StaticExample {
    int count = 0;// will get memory when instance is created

    StaticExample() {
        count++;
        System.out.println(count);
    }

    public static void main(String args[]) {

        StaticExample c1 = new StaticExample();
        StaticExample c2 = new StaticExample();
        StaticExample c3 = new StaticExample();

    }
}

เอาท์พุท:

1 1 1

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

ตอนนี้ถ้าเราเปลี่ยนตัวแปรอินสแตนซ์นับเป็นสแตติกโปรแกรมจะสร้างเอาต์พุตที่แตกต่างกัน:

package pkg;

class StaticExample {
    static int count = 0;// will get memory when instance is created

    StaticExample() {
        count++;
        System.out.println(count);
    }

    public static void main(String args[]) {

        StaticExample c1 = new StaticExample();
        StaticExample c2 = new StaticExample();
        StaticExample c3 = new StaticExample();

    }
}

เอาท์พุท:

1 2 3

ในกรณีนี้ตัวแปรแบบคงที่จะได้รับหน่วยความจำเพียงครั้งเดียวหากวัตถุใด ๆ เปลี่ยนค่าของตัวแปรแบบคงที่มันจะเก็บค่าของมัน

คงที่กับรอบชิงชนะเลิศ:

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

ทรัพยากรรูปภาพ: สุดท้ายคงที่

หากต้องการเพิ่มคำตอบที่มีอยู่ให้ฉันลองกับรูปภาพ:

อัตราดอกเบี้ย 2% จะถูกนำไปใช้กับบัญชีออมทรัพย์ทั้งหมด ดังนั้นมันเป็นแบบคงที่

ยอดคงเหลือควรเป็นรายบุคคลดังนั้นจึงไม่คงที่

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

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

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

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

1. ทำฟิลด์และเมธอดทั้งหมดของHelloคลาสสแตติกเพื่อให้สามารถอ้างถึงได้ภายในเมธอดหลัก นี่ไม่ใช่สิ่งที่ดีที่จะทำจริงๆ (หรือเหตุผลที่ผิดที่ทำให้ฟิลด์และ / หรือวิธีการคงที่)
2. สร้างอินสแตนซ์ของHelloคลาสของคุณภายในวิธีหลักและเข้าถึงฟิลด์และวิธีทั้งหมดตามที่ตั้งใจไว้ตั้งแต่แรก

สำหรับคุณนี่หมายถึงการเปลี่ยนแปลงรหัสของคุณดังต่อไปนี้:

package hello;

public class Hello {

    private Clock clock = new Clock();

    public Clock getClock() {
        return clock;
    }

    public static void main(String args[]) {
        Hello hello = new Hello();
        hello.getClock().sayTime();
    }
}

ใน Java staticคำสำคัญนั้นสามารถถือได้ว่าเป็นการระบุสิ่งต่อไปนี้:

"โดยไม่คำนึงถึงหรือความสัมพันธ์กับอินสแตนซ์เฉพาะ"

หากคุณคิดstaticในลักษณะนี้มันจะง่ายต่อการเข้าใจการใช้งานในบริบทต่างๆที่พบ:

• staticฟิลด์เป็นเขตที่อยู่ในชั้นเรียนมากกว่าโดยเฉพาะกรณีใด ๆ

• staticวิธีเป็นวิธีการที่มีความคิดของการไม่มีthis; มันถูกกำหนดไว้ในชั้นเรียนและไม่ทราบเกี่ยวกับอินสแตนซ์เฉพาะของชั้นเรียนนั้นจนกว่าจะมีการอ้างอิงถึง

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

สแตติกทำให้สมาชิกนาฬิกาเป็นสมาชิกคลาสแทนสมาชิกอินสแตนซ์ หากไม่มีคีย์เวิร์ดแบบคงที่คุณจะต้องสร้างอินสแตนซ์ของคลาส Hello (ซึ่งมีตัวแปรสมาชิกนาฬิกา) - เช่น

Hello hello = new Hello();
hello.clock.sayTime();

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

ฉันได้พัฒนาความชื่นชอบสำหรับวิธีการคงที่ (เท่านั้นถ้าเป็นไปได้) ในชั้นเรียน "ผู้ช่วย"

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

อาจมีข้อดีอื่น ๆ

//Here is an example 

public class StaticClass 
{
    static int version;
    public void printVersion() {
         System.out.println(version);
    }
}

public class MainClass 
{
    public static void main(String args[]) {  
        StaticClass staticVar1 = new StaticClass();
        staticVar1.version = 10;
        staticVar1.printVersion() // Output 10

        StaticClass staticVar2 = new StaticClass();
        staticVar2.printVersion() // Output 10
        staticVar2.version = 20;
        staticVar2.printVersion() // Output 20
        staticVar1.printVersion() // Output 20
    }
}

ยังสามารถคิดว่าสมาชิกแบบคงที่ไม่มีตัวชี้ "นี้" พวกเขาแบ่งปันในทุกกรณี

การทำความเข้าใจแนวคิดแบบคงที่

public class StaticPractise1 {
    public static void main(String[] args) {
        StaticPractise2 staticPractise2 = new StaticPractise2();
        staticPractise2.printUddhav(); //true
        StaticPractise2.printUddhav(); /* false, because printUddhav() is although inside StaticPractise2, but it is where exactly depends on PC program counter on runtime. */

        StaticPractise2.printUddhavsStatic1(); //true
        staticPractise2.printUddhavsStatic1(); /*false, because, when staticPractise2 is blueprinted, it tracks everything other than static  things and it organizes in its own heap. So, class static methods, object can't reference */

    }
}

ชั้นสอง

public class StaticPractise2 {
    public static void printUddhavsStatic1() {
        System.out.println("Uddhav");
    }

    public void printUddhav() {
        System.out.println("Uddhav");
    }
}

main() เป็นวิธีการคงที่ซึ่งมีข้อ จำกัด พื้นฐานที่สอง:

1. วิธีการคงที่ไม่สามารถใช้ข้อมูลสมาชิกไม่คงที่หรือเรียกวิธีการไม่คงที่โดยตรง

2. this()และsuper()ไม่สามารถใช้ในบริบทแบบคงที่ได้

   class A {  
       int a = 40; //non static
       public static void main(String args[]) {  
           System.out.println(a);  
       }  
   }

ผลลัพธ์: ข้อผิดพลาดในการรวบรวมเวลา

ตัวแปรแบบคงที่สามารถเข้าถึงได้เฉพาะในวิธีการแบบคงที่ดังนั้นเมื่อเราประกาศตัวแปรแบบคงที่วิธีการ getter และ setter จะเป็นวิธีการแบบคงที่

วิธีการคงที่เป็นระดับชั้นเรียนที่เราสามารถเข้าถึงได้โดยใช้ชื่อชั้นเรียน

ตัวอย่างต่อไปนี้เป็นตัวอย่างของตัวรับและตัวตั้งค่าตัวแปรแบบคงที่:

public class Static 
{

    private static String owner;
    private static int rent;
    private String car;
    public String getCar() {
        return car;
    }
    public void setCar(String car) {
        this.car = car;
    }
    public static int getRent() {
        return rent;
    }
    public static void setRent(int rent) {
        Static.rent = rent;
    }
    public static String getOwner() {
        return owner;
    }

    public static void setOwner(String owner) {
        Static.owner = owner;
    }

}

คำถามถูกถามที่นี่เกี่ยวกับการเลือกคำว่า 'คงที่' สำหรับแนวคิดนี้ มันซ้ำซ้อนกับคำถามนี้ แต่ฉันไม่คิดว่านิรุกติศาสตร์ได้รับการแก้ไขอย่างชัดเจน ดังนั้น...

เนื่องจากการใช้คำหลักซ้ำเริ่มต้นด้วย C

พิจารณาการประกาศข้อมูลใน C (ภายในตัวฟังก์ชัน):

    void f() {
        int foo = 1;
        static int bar = 2;
         :
    }

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

Java และภาษาที่คล้ายกันมีแนวคิดเดียวกันสำหรับข้อมูล ข้อมูลสามารถถูกจัดสรรต่ออินสแตนซ์ของคลาส (ต่อวัตถุ) หรือหนึ่งครั้งสำหรับคลาสทั้งหมด เนื่องจาก Java ตั้งเป้าหมายว่าจะมีไวยากรณ์ที่คุ้นเคยสำหรับโปรแกรมเมอร์ C / C ++ คำหลัก 'static' จึงเหมาะสมที่นี่

    class C {
        int foo = 1;
        static int bar = 2;
         :
    }

สุดท้ายเรามาถึงวิธีการ

    class C {
        int foo() { ... }
        static int bar() { ... }
         :
    }

นั่นคือการพูดในเชิงแนวคิดตัวอย่างของ foo () สำหรับทุก ๆ คลาสของ C มีเพียงหนึ่งอินสแตนซ์ของ bar () สำหรับทั้งคลาส C นี่ขนานกับกรณีที่เราพูดถึงข้อมูลและใช้ 'static 'เป็นตัวเลือกที่สมเหตุสมผลอีกครั้งโดยเฉพาะอย่างยิ่งหากคุณไม่ต้องการเพิ่มคำหลักที่สงวนไว้ในภาษาของคุณ