Co robi słowo kluczowe "static" w klasie?

Oznacza to, że istnieje tylko jedna instancja "clock" w Hello, a nie jedna na każdą osobną instancję klasy "Hello", lub więcej-oznacza to więc, że będzie jedno wspólne odniesienie "clock "pomiędzy wszystkimi instancjami klasy" Hello".

Więc jeśli miałbyś zrobić" nowe Halo " gdziekolwiek w swoim kodzie: A - w pierwszym scenariuszu (przed zmianą, bez użycia "static"), będzie to nowy zegar za każdym razem, gdy zostanie wywołane "new Hello", ale B - w drugim scenariuszu (po zmianie, używając "static"), każda instancja" new Hello "nadal będzie współdzielić i używać początkowego i tego samego odniesienia" clock", które zostało wcześniej utworzone.

Jeśli nie potrzebujesz "zegara" gdzieś poza main, to działałoby to równie dobrze:

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

Słowo kluczowe static oznacza, że coś (pole, metoda lub klasa zagnieżdżona) jest związane z typem , a nie z jakąkolwiek konkretną instancją tego typu. Na przykład, wywołujemy Math.sin(...) bez żadnej instancji klasy Mathi rzeczywiście nie możemy utworzyć instancji klasy Math.

Aby uzyskać więcej informacji, zobacz odpowiedni fragment samouczka Java firmy Oracle.

Sidenote

Java niestety pozwala aby uzyskać dostęp do statycznych członków tak, jakby były członkami instancji, np.

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

To sprawia, że wygląda tak, jakby sleep była metodą instancji, ale w rzeczywistości jest to metoda statyczna-to zawsze powoduje uśpienie bieżącego wątku. Lepiej poćwiczyć, aby było to jasne w kodzie wywołującym:

// Clearer
Thread.sleep(5000);

Słowo kluczowe static w języku Java oznacza, że zmienna lub funkcja jest współdzielona pomiędzy wszystkimi instancjami tej klasy, ponieważ należy do typu , a nie do samych obiektów.

Więc jeśli masz zmienną: private static int i = 0; i zwiększysz ją (i++) w jednym wystąpieniu, zmiana będzie odzwierciedlona we wszystkich wystąpieniach. i będzie teraz 1 we wszystkich przypadkach.

Statyczne metody mogą być używane bez tworzenia instancji obiektu.

Podstawowe użycie elementów statycznych...

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
}

W ten sposób możesz mieć wartości współdzielone we wszystkich klasach bez wysyłania instancji klasy Hello do innej klasy. I trochę statyczne nie trzeba tworzyć instancji klasy.

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

Możesz po prostu wywołać wartości statyczne lub metody po nazwie klasy:

Hello.staticValue = "abc";

Statyczne oznacza, że nie musisz tworzyć instancji klasy, aby używać metod lub zmiennych powiązanych z klasą. W twoim przykładzie możesz wywołać:

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

Bezpośrednio, zamiast:

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

Wewnątrz statycznej metody (która należy do klasy) nie możesz uzyskać dostępu do żadnych członków, które nie są statyczne, ponieważ ich wartości zależą od twojej instancji klasy. Niestatyczny obiekt zegara, który jest członkiem instancji, miałby inną wartość / odniesienie dla każdego instancja Twojej klasy Hello, a zatem nie możesz uzyskać do niej dostępu ze statycznej części klasy.

Statyczny w Javie:

Static jest modyfikatorem Nie dostępowym. Słowo kluczowe statyczne należy do instancji klasy than. może być użyty do dołączenia zmiennej lub metody do klasy.

Statyczne słowo kluczowe może być użyte z:

Metoda

Zmienna

Klasa zagnieżdżona w innej klasie

Blok Inicjalizacji

Nie można używać z:

Klasa (Nie Zagnieżdżone)

Konstruktor

Interfejsy

Method Local Inner Class (Difference then nested class)

Metody klasy wewnętrznej

Zmienne Instancji

Zmienne Lokalne

Przykład:

Wyobraź sobie następujący przykład, który ma zmienną instancji o nazwie count , która jest inkrementowana w konstruktorze:

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();

    }
}

Wyjście:

1 1 1

Ponieważ zmienna instancji pobiera pamięć w czas tworzenia obiektu, każdy obiekt będzie miał kopię zmiennej instancji, jeśli zostanie zwiększona, nie będzie odzwierciedlać do innych obiektów.

Teraz jeśli zmienimy liczbę zmiennych instancji na statyczną , to program wygeneruje inne wyjście:

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();

    }
}

Wyjście:

1 2 3

W tym przypadku zmienna statyczna uzyska pamięć tylko raz, jeśli jakikolwiek obiekt zmieni wartość zmiennej statycznej, zachowa swoją wartość.

Static with Final:

Zmienna globalna zadeklarowana jako ostateczna i statyczna pozostaje bez zmian przez cały czas wykonywania. Ponieważ statyczne elementy są przechowywane w pamięci klasy i są ładowane tylko raz w całym wykonaniu. Są one wspólne dla wszystkich obiektów klasy. Jeśli zadeklarujesz statyczne zmienne jako ostateczne, żaden z obiektów nie może zmienić ich wartości, ponieważ jest ostateczny. Dlatego zmienne deklarowane jako końcowe i statyczne są czasami określane do stałych as. Wszystkie pola interfejsów są określane jako stałe, ponieważ domyślnie są ostateczne i statyczne.

Źródło Obrazu: Końcowa Statyczna

Aby dodać do istniejących odpowiedzi, pozwól mi spróbować ze zdjęciem:

Do wszystkich kont oszczędnościowych stosuje się stopę procentową w wysokości 2%. Stąd jest to Statyczne .

Równowaga powinna być indywidualna , więc jest a nie statyczna.

Ta dyskusja do tej pory ignorowała względy classloadera. Ściśle mówiąc, statyczne pola Javy są współdzielone pomiędzy wszystkimi instancjami klasy dla danego classloader .

Pole może być przypisane do klasy lub instancji klasy. Domyślnie pola są zmiennymi instancji. Używając static pole staje się zmienną klasy, więc istnieje jedna i tylko jedna clock. Jeśli dokonasz zmiany w jednym miejscu, jest ona widoczna wszędzie. Zmienne instancji są zmieniane niezależnie od siebie.

W języku Java słowo kluczowe static może być po prostu uznane za wskazujące:

"bez względu lub związku z jakąkolwiek konkretną instancją"

Jeśli pomyślisz o static w ten sposób, łatwiej będzie zrozumieć jego użycie w różnych kontekstach, w których jest spotykany:

• Pole static jest polem, które należy do klasy, a nie do konkretnej instancji

• Metoda static jest metodą, która nie ma pojęcia o this; jest zdefiniowana na klasie i nie wie o żadnej konkretnej instancji tej klasy, chyba że zostanie do niej przekazane odniesienie

• Klasa member jest klasą zagnieżdżoną bez żadnego pojęcia ani wiedzy o instancji jej klasy enklawowej (chyba że zostanie do niej przekazane odniesienie do instancji klasy enklawowej)

Słowo kluczowe static jest używane do oznaczenia pola lub metody jako należące do samej klasy, a nie do instancji. Używając Twojego kodu, jeśli obiekt Clock jest statyczny, wszystkie instancje klasy Hello będą współdzielić ten element (pole) danych Clock. Jeśli uczynisz go niestatycznym, każda pojedyncza instancja {[3] } może mieć unikalne pole Clock.

Dodałeś metodę main do swojej klasy Hello, abyś mógł uruchomić kod. Problem w tym, że główna metoda jest statyczna i jako taka nie może odnosić się do niestatycznych pól lub metod wewnątrz niej. Można to rozwiązać na dwa sposoby:

1. aby wszystkie pola i metody klasy Hello stały się statyczne, tak aby można było się do nich odwoływać wewnątrz metody main. To naprawdę nie jest dobra rzecz do zrobienia (lub zły powód, aby pole i/lub metoda stały)
2. Utwórz instancję swojej klasy Hello wewnątrz głównej metody i uzyskaj dostęp do wszystkich jej pól i metody w sposób, w jaki były one przeznaczone w pierwszej kolejności.

Dla Ciebie oznacza to następującą zmianę kodu:

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();
    }
}

Static sprawia, że członek zegara jest członkiem klasy zamiast członkiem instancji. Bez statycznego słowa kluczowego trzeba by utworzyć instancję klasy Hello (która ma zmienną clock member) - np.

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

Metody statyczne nie używają żadnych zmiennych instancji klasy, w której są zdefiniowane. Bardzo dobre wyjaśnienie różnicy można znaleźć na tej stronie

Rozwinąłem upodobanie do metod statycznych (tylko, jeśli to możliwe) w klasach "helper".

Klasa wywołująca nie musi tworzyć innej zmiennej członkowskiej (instancji) klasy pomocniczej. Wystarczy wywołać metody klasy pomocniczej. Również Klasa pomocnicza jest ulepszona, ponieważ nie potrzebujesz już konstruktora i nie potrzebujesz zmiennych członkowskich (instancji).

Są prawdopodobnie inne zalety.

//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
    }
}

Może również myśleć o statycznych członach, które nie mają "tego" wskaźnika. Są one wspólne dla wszystkich instancji.

Zrozumienie pojęć statycznych

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 */

    }
}

Druga Klasa

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

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

main() jest metodą statyczną, która ma dwa podstawowe ograniczenia:

1. metoda statyczna nie może używać niestatycznego elementu danych ani bezpośrednio wywoływać niestatycznej metody.

2. this() i super() nie mogą być używane w kontekście statycznym.

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

Wyjście: Błąd Czasu Kompilacji

Statyczne zmienne mogą być dostępne tylko w metodach statycznych, więc kiedy zadeklarujemy statyczne zmienne, te metody getter i setter będą metodami statycznymi

Metody statyczne to poziom klasy, do którego możemy uzyskać dostęp używając nazwy klasy

Oto przykład dla Getterów i Setterów zmiennych statycznych:

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;
    }

}

Zadano pytanie tutaj o wybór słowa "statyczny" dla tego pojęcia. Było dup ' d do tego pytania, ale nie sądzę, etymologia została wyraźnie skierowana. Więc...

Rozważmy deklaracje danych w C (wewnątrz ciała funkcji):

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

Zmienna foo jest tworzona na stosie po wprowadzeniu funkcji (i niszczona po jej zakończeniu). Natomiast bar jest zawsze, więc jest "statyczny" w znaczeniu potocznego angielskiego - nigdzie się nie wybiera.

Java i podobne języki mają tę samą koncepcję dla danych. Dane mogą być przydzielane na instancję klasy (na obiekt) lub raz dla całej klasy. Ponieważ Java ma mieć znaną składnię dla programistów C / c++, odpowiednie jest tutaj słowo kluczowe 'static'.

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

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

Istnieje, mówiąc koncepcyjnie, instancja foo () dla każdej instancji klasy C. Istnieje tylko jedna instancja bar () dla całej klasy C. Jest to równoległe do omawianego przypadku dla danych, dlatego używanie 'static' jest ponownie rozsądnym wyborem, szczególnie jeśli nie chcesz dodawać więcej zarezerwowanych słów kluczowych do swojego języka.