В терминах laymans, что означает "статический" в Java?

Ответ 1

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

public class Foo {
    public static void doStuff(){
        // does stuff
    }
}

Итак, вместо создания экземпляра Foo и вызова doStuff следующим образом:

Foo f = new Foo();
f.doStuff();

Вы просто вызываете метод непосредственно против класса, например:

Foo.doStuff();

Ответ 2

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

Ответ 3

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

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

public class SomeObject {
    public int someField;
    public void someMethod() { };
    public Class SomeInnerClass { };
}

Чтобы использовать someField, someMethod или SomeInnerClass, я должен сначала создать экземпляр SomeObject.

public class SomeOtherObject {
    public void doSomeStuff() {
        SomeObject anInstance = new SomeObject();
        anInstance.someField = 7;
        anInstance.someMethod();
        //Non-static inner classes are usually not created outside of the
        //class instance so you don't normally see this syntax
        SomeInnerClass blah = anInstance.new SomeInnerClass();
    }
}

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

public class SomeObjectWithStaticStuff {
    public static int someField;
    public static void someMethod() { };
    public static Class SomeInnerClass { };
}

public class SomeOtherObject {
    public void doSomeStuff() {
        SomeObjectWithStaticStuff.someField = 7;
        SomeObjectWithStaticStuff.someMethod();
        SomeObjectWithStaticStuff.SomeInnerClass blah = new SomeObjectWithStaticStuff.SomeInnerClass();
        //Or you can also do this if your imports are correct
        SomeInnerClass blah2 = new SomeInnerClass();
    }
}

Объявление чего-то статического имеет несколько последствий.

Во-первых, во всем вашем приложении может быть только одно значение статического поля.

public class SomeOtherObject {
    public void doSomeStuff() {
        //Two objects, two different values
        SomeObject instanceOne = new SomeObject();
        SomeObject instanceTwo = new SomeObject();
        instanceOne.someField = 7;
        instanceTwo.someField = 10;
        //Static object, only ever one value
        SomeObjectWithStaticStuff.someField = 7;
        SomeObjectWithStaticStuff.someField = 10; //Redefines the above set
    }
}

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

public class SomeObjectWithStaticStuff {
    private int nonStaticField;
    private void nonStaticMethod() { };

    public static void someStaticMethod() {
        nonStaticField = 7; //Not allowed
        this.nonStaticField = 7; //Not allowed, can never use *this* in static
        nonStaticMethod(); //Not allowed
        super.someSuperMethod(); //Not allowed, can never use *super* in static
    }

    public static class SomeStaticInnerClass {

        public void doStuff() {
            someStaticField = 7; //Not allowed
            nonStaticMethod(); //Not allowed
            someStaticMethod(); //This is ok
        }

    }
}

Статическое ключевое слово также может быть применено к внутренним интерфейсам, аннотациям и перечислениям.

public class SomeObject {   открытый статический интерфейс SomeInterface {};   public static @interface SomeAnnotation {};   public static enum SomeEnum {}; }

Во всех этих случаях ключевое слово является избыточным и не имеет никакого эффекта. Интерфейсы, аннотации и перечисления по умолчанию статичны, потому что они никогда не имеют отношения к внутреннему классу.

Это просто описывает, что делает ключевое слово. Он не описывает, является ли использование ключевого слова плохая идея или нет. Это может быть рассмотрено более подробно в других вопросах, таких как Использует ли множество статических методов плохую вещь?

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

//SomeStaticThing.java
public class SomeStaticThing {
    public static int StaticCounterOne = 0;
}

//SomeOtherStaticThing.java
public class SomeOtherStaticThing {
    public static int StaticCounterTwo = 0;
}

//SomeOtherClass.java
import static some.package.SomeStaticThing.*;
import some.package.SomeOtherStaticThing.*;

public class SomeOtherClass {
    public void doStuff() {
        StaticCounterOne++; //Ok
        StaticCounterTwo++; //Not ok
        SomeOtherStaticThing.StaticCounterTwo++; //Ok
    }
}

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

public class SomeObject {

    private static int x;

    static {
        x = 7;
    }
}

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

Ответ 4

Еще один отличный пример использования статических атрибутов и операций, когда вы хотите применить шаблон дизайна Singleton. В двух словах шаблон дизайна Singleton гарантирует, что один и только один объект определенного класса будет когда-либо создаваться в течение всего срока службы вашей системы. чтобы обеспечить создание только одного объекта, типичные реализации шаблона Singleton сохраняют внутреннюю статическую ссылку на единственный экземпляр разрешенного объекта, а доступ к этому экземпляру управляется с помощью операции static

Ответ 5

В дополнение к тому, что указал @inkedmn, статический член находится на уровне класса. Следовательно, указанный член загружается в память JVM один раз для этого класса (когда класс загружен). То есть не существует n экземпляров статического члена, загруженного для n экземпляров класса, к которому он принадлежит.

Ответ 6

Вышеуказанные точки верны, и я хочу добавить еще несколько важных моментов в отношении ключевого слова Static.

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

поэтому у вас возникнет сомнение в том, что использование этого права???

пример: static int a = 10; (1 программа)

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

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

пример: static int a = 20; (2 программы)

переменная 'a' хранится в памяти кучи программой 1. Та же статическая переменная 'a' находится в программе 2, тогда она выиграл `т еще раз "переменную" в памяти кучи вместо того, чтобы просто заменить значение от 10 до 20.

В общем случае он снова создаст переменную 'a' в стеке памяти (временную память), если вы не объявите 'a' как статическую переменную.

В целом я могу сказать, что если мы используем статическое ключевое слово
  1.we может сохранить память
  2.we может избежать дубликатов
  3. Не нужно создавать объект для доступа к статической переменной с помощью имени класса, к которому вы можете получить доступ.