Что делает ключевое слово static в классе?

Чтобы быть конкретным, я пытался использовать этот код:

package hello;

public class Hello {

    Clock clock = new Clock();

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

Но это дало ошибку

Невозможно получить доступ к нестатическому полю в основном статическом методе

Итак, я изменил объявление clock на это:

static Clock clock = new Clock();

И это сработало. Что значит поставить это ключевое слово перед объявлением? Что именно он будет делать и/или ограничивать с точки зрения того, что можно сделать с этим объектом?

ОТВЕТЫ

Ответ 1

static члены принадлежат классу вместо конкретного экземпляра.

Это означает, что существует только один экземпляр поля static [1] даже если вы создаете миллион экземпляров класса или не создаете каких-либо, Он будет использоваться всеми экземплярами.

Так как методы static также не относятся к определенному экземпляру, они не могут ссылаться на члены экземпляра (как вы узнаете, к какому экземпляру класса Hello вы хотите обратиться?). Члены static могут ссылаться только на членов static. Члены экземпляра могут, конечно, получить доступ к static членам.

Боковое примечание: Конечно, члены 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 или thread, но это не относится к точке.

Ответ 2

Это означает, что в Hello есть только один экземпляр "часов", а не один для каждого отдельного экземпляра класса "Hello", или, более того, это означает, что будет одна общедоступная "часовая" ссылка среди все экземпляры класса "Hello".

Итак, если вы хотите сделать "новый Hello" в любом месте своего кода: A- в первом сценарии (до изменения, без использования "статического" ), он будет создавать новые часы каждый раз, когда вызывается "новый Hello", но B- во втором сценарии (после изменения, используя "статический" ), каждый экземпляр "нового Hello" по-прежнему будет совместно использовать и использовать начальную и ту же самую ссылку "часы", которая была создана впервые.

Если вам не нужны "часы" где-то вне основного, это будет работать так же хорошо:

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

Ответ 3

Ключевое слово static означает, что что-то (поле, метод или вложенный класс) связано с типом, а не с каким-либо конкретным экземпляром типа. Например, один вызывает Math.sin(...) без какого-либо экземпляра класса Math, и вы действительно не можете создать экземпляр класса Math.

Для получения дополнительной информации см. соответствующий бит Oracle Java Tutorial.

Sidenote

Java, к сожалению, позволяет вам обращаться к статическим членам, как если бы они были членами экземпляра, например.

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

Это делает его похожим на то, что sleep - это метод экземпляра, но он фактически статический метод - он всегда заставляет текущий поток спать. Лучше всего это сделать в коде вызова:

// Clearer
Thread.sleep(5000);

Ответ 4

Ключевое слово static в Java означает, что переменная или функция разделяются между всеми экземплярами этого класса, принадлежащими типу, а не самими объектами.

Итак, если у вас есть переменная: private static int i = 0; и вы увеличиваете ее (i++) в одном экземпляре, это изменение будет отражено во всех экземплярах. i теперь будет 1 во всех случаях.

Статические методы могут использоваться без создания экземпляра объекта.

Ответ 5

Основное использование статических элементов...

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

Ответ 6

Static означает, что вам не нужно создавать экземпляр класса для использования методов или переменных, связанных с классом. В вашем примере вы можете позвонить:

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

Изнутри статического метода (который принадлежит классу) вы не можете получить доступ к тем членам, которые не являются статическими, поскольку их значения зависят от вашего экземпляра класса. Объект non-static Clock, который является членом экземпляра, будет иметь другое значение/ссылку для каждого экземпляра вашего класса Hello, и поэтому вы не можете получить к нему доступ из статической части класса.

Ответ 7

Статический язык Java:

Статик - это модификатор без доступа. Ключевое слово static принадлежит классу, чем экземпляр класса. может использоваться для присоединения переменной или метода к классу.

Статическое ключевое слово CAN может использоваться с:

Метод

Переменная

Класс, вложенный в другой класс

Блок инициализации

НЕ МОЖЕТ использоваться с:

Класс (не вложен)

Конструктор

Интерфейсы

Метод Локальный Внутренний Класс (Разница, затем вложенный класс)

Методы внутреннего класса

Переменные экземпляра

Локальные переменные

Пример:

Представьте следующий пример, который имеет переменную экземпляра с именем count, которая с добавлением в конструкторе:

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

В этом случае статическая переменная получит память только один раз, если какой-либо объект изменит значение статической переменной, он сохранит свое значение.

Статический с финал:

Глобальная переменная, объявленная как окончательная и статическая, остается неизменной для всего исполнения. Поскольку, статические члены хранятся в памяти классов, и они загружаются только один раз во всем исполнении. Они являются общими для всех объектов класса. Если вы объявляете статические переменные окончательными, любой из объектов не может изменить свое значение, поскольку оно является окончательным. Поэтому переменные, объявленные как final и static, иногда называются константами. Все поля интерфейсов называются константами, поскольку по умолчанию они являются окончательными и статическими.

введите описание изображения здесь

Ресурс изображения: Final Static

Ответ 8

Это обсуждение до сих пор игнорировало соображения загрузчика классов. Строго говоря, статические поля Java разделяются между всеми экземплярами класса для заданного classloader.

Ответ 9

Чтобы добавить к существующим ответам, позвольте мне попробовать:

Процентная ставка 2% применяется ко всем Сберегательным счетам. Следовательно, он является статичным.

Баланс должен быть индивидуальным, поэтому он не является статичным.

enter image description here

Ответ 10

Поле может быть назначено либо классу, либо экземпляру класса. По умолчанию поля являются переменными экземпляра. Используя static, поле становится переменной класса, поэтому существует один и только один clock. Если вы вносите изменения в одно место, это видно повсюду. Переменные экземпляра изменяются независимо друг от друга.

Ответ 11

В Java ключевое слово static можно просто считать следующим:

"без учета или отношения к какому-либо конкретному экземпляру"

Если вы думаете об static таким образом, становится легче понять его использование в различных контекстах, в которых он встречается:

  • Поле A static - это поле, которое принадлежит классу, а не любому конкретному экземпляру

  • A static метод - это метод, который не имеет понятия this; он определен в классе и не знает о каком-либо конкретном экземпляре этого класса, если ему не передается ссылка

  • A static класс-член представляет собой вложенный класс без какого-либо представления или знания экземпляра его вмещающего класса (если только ссылка на экземпляр закрывающего класса не передана ему)

Ответ 12

Статичность делает член часов членом класса вместо члена экземпляра. Без ключевого слова static вам нужно будет создать экземпляр класса Hello (который имеет переменную элемента синхронизации) - например,

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

Ответ 13

статические методы не используют никаких переменных экземпляра класса, в котором они определены. Очень хорошее объяснение разницы можно найти на этой странице

Ответ 14

Я разработал симпатию к статическим методам (только, если это возможно) в классах "помощника".

Вызывающему классу не нужно создавать другую переменную-член (экземпляр) класса-помощника. Вы просто вызываете методы вспомогательного класса. Также класс помощника улучшен, потому что вам больше не нужен конструктор, и вам не нужны переменные-члены (экземпляры).

Вероятно, есть и другие преимущества.

Ответ 15

Ключевое слово static используется для обозначения поля или метода как принадлежащего самому классу, а не экземпляру. Используя ваш код, если объект Clock является статическим, все экземпляры класса Hello будут совместно использовать этот элемент данных Clock (поле). Если вы сделаете его нестатичным, каждый отдельный экземпляр Hello может иметь уникальное поле Clock.

Проблема заключается в том, что вы добавили основной метод в свой класс Hello, чтобы вы могли запускать код. Проблема здесь в том, что основной метод статичен и как таковой он не может ссылаться на нестатические поля или методы внутри него. Вы можете решить это двумя способами:

  • Сделать все поля и методы класса Hello статическими, чтобы они могли ссылаться внутри основного метода. Это действительно нехорошо (или неправильная причина делает поле и/или метод статичным)
  • Создайте экземпляр класса 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();
    }
}

Ответ 16

Можно также думать о статических членах, не имеющих указателя "this". Они распределяются между всеми экземплярами.

Ответ 17

Понимание статических понятий

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

Ответ 18

Еще раз помните, что для класса CLASSLOADER существует один экземпляр статического класса.

Ответ 19

main() - статический метод, который имеет два фундаментальных ограничения:

  1. Статический метод не может использовать нестатический элемент данных или напрямую вызывать нестатический метод.

  2. this() и super() не могут использоваться в статическом контексте.

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

Выход: ошибка времени компиляции

Ответ 20

Статические переменные Доступ возможен только в статических методах, поэтому, когда мы объявляем статические переменные, методы getter и setter будут статическими методами

статические методы - это уровень класса, к которому мы можем получить доступ, используя имя класса

Ниже приведен пример для статических переменных: Getters and Setters:

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

}

Ответ 21

Ключевое слово static modifier при использовании в сочетании с переменной создаст переменную, которая будет существовать независимо от любых экземпляров объектов, созданных с использованием этого класса. Статические переменные будут инициализироваться только один раз, в начале выполнения приложения, иногда называемого запуском приложения. Переменные, которые используют ключевое слово static modifier, будут инициализированы сначала, прежде чем инициализировать любые переменные экземпляра. Только одна копия статической переменной будет существовать в системной памяти независимо от количества экземпляров класса, который содержит эту переменную. Таким образом, статический код Java означает, что переменная принадлежит классу, а не экземплярам объекта, созданным этим классом.

Ключевое слово static modifier работает одинаково для методов, объявленных как static, поэтому статический модификатор будет использоваться для создания методов, которые должны существовать независимо от любых экземпляров объектов, созданных с использованием класса. Это снова фиксирует метод на месте, поэтому это единственная копия этого метода, которая будет использоваться вашим классом и объектами из этого класса.

Статические методы не могут использовать любые переменные экземпляра любых экземпляров объектов, созданных с использованием класса, в котором они определены, до тех пор, пока не будет создан один из этих экземпляров объектов. Статические методы должны принимать все свои значения данных из списка входящих параметров, а затем вычислять что-то из этих параметров без ссылки на переменные, которые по своей сути не являются статическими, поскольку переменная theyre!

Ответ 22

Существует два основных ограничения для статического метода. Это:

1. Статический метод не может использовать нестатический элемент данных или напрямую обращаться к нестационарному методу.

2.Эта и супер не могут использоваться в статическом контексте.

первая причина вызвана вашей ошибкой компиляции

Ответ 23

При запуске какого-то проекта сначала загружаются статические вещи (переменные, методы, блоки...).

При первом запуске этого основного метода загрузки проекта. Потому что его static method. Затем он выглядит объект "a" object. Но объект a еще не определен. Потому что он не статичен. Затем введите эту ошибку.

Ответ 24

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