Классы и объекты java / skillbox media

Наследование

Наследование — это процедура, при которой один класс приобретает свойства другого. Например, потомок наследует признаки своего родителя.

class Developer{  public void writeCode(){  // writeCode method}class BackendDeveloper extends Developer{  public void writeCode(){  // writeCode method  }}Class run{  public static void main (String args[]){    Developer developerObject = new Developer() // writeCode method in class Developer will be executed    developerObject.writeCode();    BackendDeveloper backendDeveloperObj = new BackendDeveloper();    // writeCodemethod in class BackendDeveloper will be executed    backendDeveloperObj.writeCode();  }}

Перегрузка методов, overload

Совокупность имени метода и набора формальных параметров называется сигнатурой метода. Java позволяет создавать несколько методов
с одинаковыми именами, но разными сигнатурами. Создание метода с тем же именем, но с другим набором параметров называется перегрузкой.
Какой из перегруженных методов должен выполняться при вызове, Java определяет на основе фактических параметров, передаваемых методу.

Пример класса Test с тремя перегруженными методами test :

public class Test
{
     void test()
     {
         System.out.println("параметр отсутствует");
     }
     void test(int a)
     {
         System.out.println("a = " + String.valueOf(a));
     }
     void test (int a, int b)
     {
         System.out.println("a + b = " + String.valueOf(a + b));
     }
     void test(double d)
     {
         System.out.println("d = " + String.valueOf(d));
     }
}

Пример использования класса Test:

public class Testing
{
    public static void main(String args[])
    {
        Test of = new Test();
        double result = 30.25;
        of.test();
        of.test(10);
        of.test(20, 10);
        of.test(result);
    }
}

Java рекурсия

Рекурсией называется метод (функция), которая внутри своего тела вызывает сама себя.

Рассмотрим пример рекурсивного метода вычисления факториала. Для того чтобы вычислить n!, достаточно знать и перемножить между
собой (n-1)! и n. Создадим метод, реализующий описанный способ.

static int fact (int n)
{
    if (n == 1) {
        return 1;
    } else if (n == 2) {
        return 2;
    } else {
        return fact(n-1) * n;
   }
}

Указанный рекурсивный метод вычисляет факториал натурального числа.

Рассмотрим пример, вычисляющий через рекурсию n-ое число Фибоначчи. Напомним, как выглядят первые элементы этого ряда:
1 1 2 3 5 8 13 …

static int fib (int n)
{
    if (index <= 0) {
        return 0;
    } else if (n == 1)
        return 1; 
    else if (n == 2))
        return 1;

    return fib (n-2) + fib (n-1);
}

Статические переменные

В Java, когда мы создаем объекты класса, каждый объект будет иметь свою собственную копию всех переменных класса. Например,

Здесь оба объекта test1 и test2 будут иметь отдельные копии переменной age. И они отличаются друг от друга.

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

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

Пример 2: статические и нестатические переменные Java

Выход :

 мин + 1 = 6 макс + 1 = 11

В приведенной выше программе мы объявили нестатическую переменную с именем min и статическую переменную с именем max внутри класса Test.

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

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

What is this keyword in Java?

this is another Java keyword which as a reference to the current object within an instance method or a constructor — the object whose method or constructor is being called. By the use of this keyword, programmers can refer to any member of the current object within an instance method or a constructor. This keyword can be used to refer to the current object, and it always acts as a reference to an object in which method was invoked. There are the various uses of this keyword in Java. These are:

For referring current class instance variable, this keyword can be used
To invoke current class constructor, this() is used
this can be passed as message argument in a method call
In a constructor call, this can be passed as argument
For returning current class instance, this keyword is used

1 Статические методы

Кроме статических переменных, в классах могут быть и статические методы.

Обычные методы привязаны к объектам (экземплярам) класса и могут обращаться к обычным-переменным класса (а также к статическим переменным и методам). Статические же методы привязаны к статическому объекту класса и могут обращаться только к статическим переменным и/или другим статическим методам класса.

Чтобы вызвать обычный метод у класса, сначала нужно создать объект этого класса, а только потом вызвать метод у объекта. Вызвать обычный метод не у объекта, а у класса нельзя.

Пример:

Вызвать нестатический метод у класса нельзя!

А чтобы вызвать статический метод, достаточно чтобы просто существовал статический объект класса (который всегда существует после загрузки класса в память). Именно поэтому метод main() — статический. Он привязан к статистическому объекту класса, для его вызова не нужно создавать никакие объекты.

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

Примеры:

Код	Примечание
	Метод вызывается Java-машиной командой вида: ; Статический метод вызывается в статическом методе .

Чтобы вызвать статический метод из другого класса, нужно указать имя класса перед именем статического метода. Общий вид этой конструкции такой:

Примеры:

Код	Статический метод

Статический класс

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

Архитектура вложенных классов делится на две части:

вложенные классы, объявленные статическими , называются статическими вложенными классами, тогда как
вложенные классы, которые не являются статическими , называются внутренними классами

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

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

6.1. Пример статического класса

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

6.2. Compelling Reasons to Use a static Inner Class

Grouping classes that will be used only in one place increases encapsulation
The code is brought closer to the place that will be only one to use it; this increases readability and code is more maintainable
If nested class doesn’t require any access to it’s enclosing class instance members, then it’s better to declare it as static because this way, it won’t be coupled to the outer class and hence will be more optimal as they won’t require any heap or stack memory

6.3. Key Points to Remember

static nested classes do not have access to any instance members of the enclosing outer class; it can only access them through an object’s reference
статические вложенные классы могут получить доступ ко всем статическим членам включающего класса, включая частные
Спецификация программирования Java не позволяет нам объявить класс верхнего уровня статическим ; только классы внутри классов (вложенные классы) могут быть статическими

Полиморфизм

Полиморфизм — это концепция ООП, при которой одно имя принимает множество форм, (другое название — перегрузка). Динамический полиморфизм — это механизм, с помощью которого несколько методов определяются одним именем и сигнатурой подкласса или суперкласса (другое название — переопределение).

Перегрузка — это несколько методов одного класса с одним именем, но разной сигнатурой.
Переопределение — два метода (один в родительском классе, другой — в дочернем) с одним именем и сигнатурой.
Метод подкласса переопределяет метод суперкласса.
При переопределении подклассов модификатор доступа должен быть больше родительского класса. Например, если использовать public abc() в родительском классе и private abc() в подклассе — это вызовет исключение.

Методы класса

Метод класса в объектно-ориентированном программировании — это функция или процедура, принадлежащая какому-либо классу или объекту.

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

Различают простые методы и статические методы :

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

Методы предоставляют интерфейс, при помощи которого осуществляется доступ к данным объекта некоторого класса, тем самым, обеспечивая
инкапсуляцию данных.

Кроме имени и тела (кода) у метода есть ряд других характеристик:

набор модификаторов;
тип возвращаемого значения;
набор аргументов (параметров).

Модификаторы метода — public, protected, private

Модификаторы метода определяют уровень доступа. В зависимости от того, какой уровень доступа предоставляет тот или иной метод,
выделяют:

public : открытый — общий интерфейс для всех пользователей данного класса;
protected : защищённый — внутренний интерфейс для всех наследников данного класса;
private : закрытый — интерфейс, доступный только изнутри данного класса.

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

Для того чтобы создать статический метод, перед его именем надо указать модификатор static. Если этого не сделать, то метод можно
будет вызывать только в приложении к конкретному объекту данного класса (будет нестатическим).

Класс может включать метод main, который должен иметь уровень доступа public; к нему обращается виртуальная машина Java,
не являющаяся частью какого-либо пакета.

Абстрактный класс, abstract class

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

public abstract class Price
{
    public abstract int getPriceCode();

    public abstract double summPrice(int days);

    public int bonusPrice(int days)
    {
        return 1;
    }
}

Статические переменные Java

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

Если программа содержит как статические блоки, так и переменные, то она выполняет их в том же порядке, в котором они присутствуют.

Синтаксис:

static datatype variable_name;

//Example
static int i;

Пример статической переменной с несколькими объектами

Рассмотрим приведенный ниже пример, где у нас есть класс с именем Студент. Мы также объявили 1 статическую переменную колледж и 2 нестатические переменные name и dept. Внутри статического блока мы инициализировали статическую переменную. Теперь во время выполнения, когда класс загружается, он сначала инициализирует эту статическую переменную, а затем вызывает основной метод, в котором он вызывает конструктор. У нас есть 2 отдельных объекта Student s1 и s2 с разными именами и отделами. Но если вы заметили на выходе колледж значение одинаково для обоих объектов. Это связано с тем, что статическая переменная имеет одно и то же значение для всех экземпляров класса, а память выделяется только один раз.

public class Student{

  static String college;
  public String name;
  public String dept;
  
  static {
    System.out.println("Static Block");
    college = "BITS";
  }
  
  Student(String name, String dept){
    this.name = name;
    this.dept = dept;
  }
  
  public static void main(String[] args) {
    Student s1 = new Student("Harsh", "IT");
    Student s2 = new Student("Kiran", "CSE");
    System.out.println(s1.name + " " + s1.dept + " " + college);
    System.out.println(s2.name + " " + s2.dept + " " + college);

  }

}

Static Block
Harsh IT BITS
Kiran CSE BITS

Пример статической переменной с использованием счетчика

Теперь мы увидим разницу между статическими и нестатическими переменными, которые помогут вам лучше понять концепцию. Мы создали статическую переменную противодействие и нестатическая переменная считать оба инициализируются значением 0. В конструкторе мы увеличиваем оба значения и печатаем их. Сейчас. когда мы создаем первый объект, он печатает оба значения как 1. Когда мы создаем второй объект, нестатическая переменная инициализируется снова, и, следовательно, значение будет по-прежнему равно 1, но статическая переменная хранит ту же память и, следовательно, значение будет увеличивается до 2. Это связано с тем, что статические переменные инициализируются только один раз во время загрузки класса и являются общими для всех объектов. Надеюсь, теперь мы ясно поняли ключевое слово static в java в отношении переменных.

public class StaticCounter {
  static int counter = 0;
  public int count = 0;
  
  StaticCounter(){
    counter ++;
    count ++;
    System.out.println("Static Counter: " + counter);
    System.out.println("Non static Count: " + count);
  }
  public static void main(String[] args) {
    StaticCounter sc1 = new StaticCounter();
    StaticCounter sc2 = new StaticCounter();
    
  }

}

Static Counter: 1
Non static Count: 1
Static Counter: 2
Non static Count: 1

Далее мы перейдем к статическим методам.

Пример всех статических членов Java

Подводя итог, ниже приведен пример, который охватывает все статические элементы ключевого слова java, такие как блок, переменная, метод и класс.

public class StaticExample {

  static int number;
  public String value;
  
  static {
    number = 5;
    System.out.println("Value of number inside static block: " + number);
  }
  
  public void displayString() {
    value = "Hello";
    System.out.println("Value of string: " + value);
    number =20;
    System.out.println("Value of number inside Outer class method: " + number);
  }
  
  
  static class Inner {
    static void display() {
      number = 10;
      System.out.println("Value of number inside static class method: " + number);
    }
  }
  
  public static void main(String[] args) {
    StaticExample s = new StaticExample();
    StaticExample.Inner.display();
    s.displayString();

  }

}

Value of number inside static block: 5
Value of number inside static class method: 10
Value of string: Hello
Value of number inside Outer class method: 20

Преимущества статической переменной

Java static переменная не загружает память.

Пример, в котором не используется статическая переменная

Предположим, что в колледже 500 студентов. Класс Student будут задействовать память каждый раз при создании объекта. У всех студентов есть уникальное rollno и name . А college — это общее свойство для всех объектов. Если сделать его статическим, то поле будет задействовать память только один раз.

Статическое свойство Java является общим для всех объектов.

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

Программа подсчета без статической переменной

В этом примере мы создаем Java static переменную count , которая увеличивается в конструкторе. Поскольку переменная экземпляра задействует память только во время создания объекта, то каждый объект ее копию. Поэтому при увеличении переменной он не будет влиять на другие объекты. Каждый объект получит значение 1 в переменной count .

Программа подсчета со статической переменной

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

2) Статический метод Java

Если ключевое слово static применяется в объявлении метода, то это static method Java .

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

Пример статического метода

Другой пример Java static метода, выполняющего обычный расчет

Ограничения для статического метода

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

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

Вопрос: почему основной main метод Java является статическим?

Ответ : поскольку объект не является обязательным для вызова статического метода, если он был нестатическим. Виртуальная машина сначала вызывает Java public static void main() , что приводит к выделению дополнительной памяти.

3) Статический блок Java

Применяется для инициализации статического члена;
Выполняется перед методом main во время загрузки класса.

Пример статического блока

Вопрос: можно ли выполнить программу без метода main()?

Ответ : да, один из способов — применение модификатора static в Java , но в предыдущей версии JDK , а не в JDK 1.7 .

В JDK7 и выше вывод будет следующим:

Данная публикация представляет собой перевод статьи « Java static keyword » , подготовленной дружной командой проекта Интернет-технологии.ру

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

Static — это ключевое слово в Java. Мы не можем создать имя класса или пакета с ключом static. В Java static может быть использовано в четырех случаях:

1. Статические переменные

В Java мы можем использовать ключевое слово static в переменной уровня класса. Статическая переменная класса и не принадлежит к объекту/экземпляру класса. Так, статические переменные являются общими для всех экземпляров объекта, они не потоко-безопасные. Обычно статические переменные используются с ключевым словом final для общих ресурсов или констант, которые могут быть использованы всеми объектами. Если статическая переменная не является private, то мы сможем получить к ней доступ следующим способом: ClassName.VARIABLENAME

Общие письменные тестовые вопросы интервью

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

1. Каков вывод следующего кода?

base static
test static
base constructor
test constructor

Что касается того, почему это результат, давайте сначала не будем его обсуждать. Давайте подумаем о конкретном процессе выполнения этого кода. В начале выполнения мы должны найти метод main, потому что метод main является точкой входа в программу, но перед выполнением метода main он должен быть Сначала загружается класс Test, и когда загружается класс Test, обнаруживается, что класс Test наследуется от базового класса, поэтому сначала он будет загружать базовый класс. Когда загружается базовый класс, обнаруживается, что существует статический блок и выполняется статический блок. После загрузки базового класса он продолжает загружать класс Test, а затем обнаруживает, что в классе Test также есть статический блок, и затем выполняет статический блок. После загрузки необходимых классов основной метод начинает выполняться. Когда новый метод Test () выполняется в методе main, сначала вызывается конструктор родительского класса, а затем вызывается его собственный конструктор. Таким образом, вышеупомянутый вывод появляется.

2. Каков вывод этого кода?

test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor

Точно так же давайте подумаем о конкретном процессе выполнения этого кода. Класс Test загружается первым, поэтому выполняется статический блок в классе Test. Затем выполните новый MyClass (), и класс MyClass еще не был загружен, поэтому необходимо загрузить класс MyClass. При загрузке класса MyClass я обнаружил, что класс MyClass наследуется от класса Test, но поскольку класс Test уже загружен, вам нужно только загрузить класс MyClass, и тогда будет выполнен статический блок в классе MyClass. После загрузки объект генерируется конструктором. При создании объекта вы должны сначала инициализировать переменные-члены родительского класса, чтобы Person person = new Person () в Test был выполнен, а класс Person не был загружен, поэтому класс Person будет загружен первым и выполнен в классе Person. Статический блок, затем выполните конструктор родительского класса, завершите инициализацию родительского класса, а затем инициализируйте себя, чтобы он затем выполнил Person person = new Person () в MyClass и, наконец, выполнил конструктор MyClass.

3. Какой вывод этого кода?

test static 1
test static 2

Хотя в методе main нет оператора, он все равно будет выводиться, причина была описана выше. Кроме того, статический блок может появляться в любом месте класса (если он не внутри метода, помните, что внутри нет метода), и выполнение выполняется в порядке статического блока.

Ссылки:

　　http://lavasoft.blog.51cto.com/62575/18771/

　　http://www.51cto.com/specbook/24/35011.htm

　　http://blog.csdn.net/zhu_apollo/article/details/1888219

　　http://blog.sina.com.cn/s/blog_70b845780100n9zz.html

　　http://hi.baidu.com/yuiezt/item/b71ff5fbfe9c385cc8f3370d

　　http://bbs.csdn.net/topics/330251070

　　http://yezixingchen.iteye.com/blog/1597186

Java «идеи программирования Java»

Типы переменных

В Java есть три типа переменных: локальные переменные, переменные экземпляра и переменные класса. Посмотрим подробно, что это такое.

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

Мы говорим о локальных переменных, когда объявление происходит внутри метода.

Локальные переменные создаются при вызове метода и исчезают (стираются из памяти) при выходе из метода.

Каждая переменная, объявленная в методе, может использоваться только внутри самого метода, а в Java локальные переменные не могут использоваться до их инициализации.

Например, если мы попытались скомпилировать следующий метод:

void add(long i) {
	long j;
	j = j + i;
}

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

Вместо этого следующий код будет компилироваться без ошибок:

void add(long i) {
	long j = 1;
	j = j + i;
}

При выполнении этого фрагмента кода виртуальная машина Java создает пространство в памяти для записи локальных переменных, и затем удаляет их (освобождая пространство памяти) в конце выполнения метода .

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

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

Поля имеют в качестве своей области все тело класса, в котором они объявлены, включая методы самого класса. Таким образом, они видны во всех методах класса.

Может случиться так, что локальная переменная в методе (или параметр метода) имеет то же имя (идентификатор), что и переменная экземпляра. В этом случае более конкретная переменная, то есть локальная переменная или параметр, имеет приоритет.

Посмотрим на пример:

public class Scope {
	int var = 6;
	public void metod1(int var) {
		int i = var;		
		// в этом случае параметр var имеет приоритет
		// принимая значение, которое будет передано в качестве параметра методу
	}
	public void metod2() {
		int var = 7;
		int i = var;
		//здесь локальная переменная имеет приоритет над методом, поэтому
		// i имеет значение 7	
	}
	public void metod3() {
		int i = var;		
		// здесь мы просто присваиваем i значение
		// переменной экземпляра и i принимает значение 6
	}
	public void metod4(int var) {
		int i = this.var;
		
// в этом случае i принимает значение 6
// из значения параметра, поскольку мы использовали
// ключевое слово 'this' указывает на использование переменной 'var'
// которое мы определили, как поле и которое принадлежит
// текущему экземпляру класса.
	}
}

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

Переменные класса (статические)

Переменные класса, также обычно называемые статическими полями, являются переменными экземпляра, но в их определении используется ключевое слово ‘static’.

static int var = 6;

Переменная класса — это переменная, видимая из всех экземпляров этого объекта, и ее значение не меняется от экземпляра к экземпляру, поэтому оно принадлежит всему классу.

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

Статическая переменная класса живет (то есть сохраняет занятость памяти и продолжает сохранять свое значение) до конца программы.

Ключевое слово static

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

Пример:

Goblin.java

Java

class Goblin {
static int idCounter = 0;
int id;

Goblin() {
idCounter++;
id = idCounter;
}
}

1
2
3
4
5
6
7
8
9

classGoblin{

staticintidCounter=;

intid;

Goblin(){

idCounter++;

id=idCounter;

}

В таком классе
Goblin переменная
idCounter одна, общая для всех экземпляров. Для всех экземпляров этого класса значение этой переменной будет всегда одно и то же, благодаря чему каждый экземпляр класса будет получать в поле
id уникальное значение, большее значения поля
id предыдущего экземпляра. Переменная
idCounter называется статическим свойством/полем или переменной класса и относится к классу, а не к его экземплярам.

Обратиться к статическому свойству можно либо через имя класса, либо через имя экземпляра, однако рекомендуется всегда обращаться к статическим свойствам через имя класса, чтобы подчеркнуть, что оно относится именно к классу:

Java

System.out.println(«idCounter=» + Goblin.idCounter); // предпочтительно
Goblin goblin = new Goblin();
System.out.println(«idCounter=» + Goblin.idCounter); // предпочтительно
System.out.println(«idCounter=» + goblin.idCounter);

1
2
3
4

System.out.println(«idCounter=»+Goblin.idCounter);// предпочтительно

Goblin goblin=newGoblin();

System.out.println(«idCounter=»+Goblin.idCounter);// предпочтительно

System.out.println(«idCounter=»+goblin.idCounter);

Статическое свойство может тоже иметь модификаторы
private ,
protected или
public.

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

Java

static int getIdCounter() {
return idCounter;
}

1
2
3

staticintgetIdCounter(){

returnidCounter;

}

Пример вызова:

Java

int x = Goblin.getIdCounter();

1	intx=Goblin.getIdCounter();

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

К статическим методам и свойствам можно обратиться даже тогда, когда ещё нет ни одного экземпляра класса.

Запомните:

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