Это три совершенно разные вещи:

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

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

означает, что метод не имеет возвращаемого значения. Если метод возвращает вы должны написать вместо .

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

---

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

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

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

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

---

Это означает три вещи.

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

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

означает, что функция не возвращает значение.

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

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

---

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

---

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

---

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

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

Кроме этого, на статический класс, накладываются как минимум следующие ограничения:

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

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

А сейчас я покажу пример создания статического класса. Но для этого, давайте вспомним пример из предыдущей статьи. В ней был рассмотрен класс «Operations», который выглядел так:

//Класс, реализующий некие операции class Operations { //Статический метод, принимающий два целых числа и возвращающий их сумму public static int Sum(int aFirstArg, int aSecondArg) { return aFirstArg + aSecondArg; } }

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

//Класс, реализующий некие операции static class Operations { //Статический метод, принимающий два целых числа и возвращающий их сумму public static int Sum(int aFirstArg, int aSecondArg) { return aFirstArg + aSecondArg; } }

Обратите внимание, даже не смотря на то что весь класс является статическим, метод «Sum» мы тоже явно сделали статическим! Так требует компилятор…

Вот так вот у меня для Вас информация о статических классах.

Теги: Классы памяти, auto, register, extern, static, объявление переменной, определение переменной, константный инициализатор.

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

Классы памяти переменных

По умолчанию, локальные переменные имеют класс auto. Такие переменные располагаются на стеке а их область видимости ограничена своим блоком. Запись

#include <conio.h> #include <stdio.h> void main() { int x = 10; { int x = 20; { int x = 30; printf(«%d\n», x); } printf(«%d\n», x); } printf(«%d\n», x); getch(); }

идентична

#include <conio.h> #include <stdio.h> void main() { int auto x = 10; { int auto x = 20; { int auto x = 30; printf(«%d\n», x); } printf(«%d\n», x); } printf(«%d\n», x); getch(); }

Очевидно, что глобальные переменные не могут быть объявлены как auto, потому что располагаются в data-сегменте.

Следующий класс памяти – register. Когда мы определяем регистровую переменную, то мы просим компилятор, чтобы переменная располагалась в регистре, а не в оперативной памяти. Компилятор может сделать переменную регистровой, если позволяют условия (регистры не заняты, и по мнению компилятора это не приведёт к увеличению издержек). Регистровые переменные определяются с помощью служебного слово register перед типом

register int x = 20; register int y = 30;

Так как регистровая переменная не имеет адреса, то к ней не применима операция взятия адреса, это вызовет ошибку во время компиляции. Аргументы функции также могут быть заданы как register. Внутри функции они будут вести себя также, как и регистровые переменные.

Следующий класс памяти – статический. Переменные, объявленные как static, хранятся в data или в bss сегменте. Отличительной чертой является то, что время их жизни совпадает с временем жизни приложения, как и у глобальных переменных. Но в отличие от глобальных переменных, область видимости ограничена только блоком, в котором они определены.

#include <conio.h> #include <stdio.h> unsigned long long factorial(unsigned char n) { static unsigned char prevArg = 0; static long long prevAns = 1; if (n == prevArg) { printf(«return previous answer\n»); return prevAns; } else { unsigned i = 0; printf(«count new answer\n»); prevAns = 1; for (i = 1; i <= n; i++) { prevAns *= i; } prevArg = n; return prevAns; } } void main() { printf(«!%d == %llu\n», 10, factorial(10)); printf(«!%d == %llu\n», 10, factorial(10)); printf(«!%d == %llu\n», 11, factorial(11)); printf(«!%d == %llu\n», 11, factorial(11)); getch(); }

В этом примере переменные prevArg и prevAns инициализируются единожды, и не уничтожаются после выхода из функции. Переменная prevArg используется для хранения предыдущего аргумента функции, а prevAns для хранения предыдущего результата. Если аргумента функции совпадает с предыдущим, то возвращается ранее вычисленное значение, иначе оно вычисляется по-новому.

Другой показательный пример – функция-генератор, которая при каждом вызове возвращает новое значение.

#include <conio.h> #include <stdio.h> int next() { static int counter = 0; counter++; return counter; } void main() { printf(«%d\n», next()); printf(«%d\n», next()); printf(«%d\n», next()); printf(«%d\n», next()); printf(«%d\n», next()); _getch(); }

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

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

… static double x = foo(3); //Ошибка …

Переменная, объявленная как static, должна иметь только один экземпляр в данной области видимости и вне этой области видимости не видна. Глобальная переменная, объявленная как static, видна только в своём файле.

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

Объявление и определение переменной.

В глобальном контексте переменная сначала требует объявления. Таким образом, компилятор будет знать её имя и тип. Определение переменной требует выделения под неё памяти и инициализации. Посмотрите следующий код. Он абсолютно легален и должен работать по стандарту

#include <conio.h> #include <stdio.h> int Global; //Объявили переменную int Global = 20; //Определили переменную void main() { printf(«%d», Global); getch(); }

Теперь, что будет, если одновременно объявить переменную и инициализировать её. Это определение переменной, которое требует её объявления

int Global = 20;

Следующая программа не скомпилируется

#include <conio.h> #include <stdio.h> extern int Global; void main() { Global = 30; printf(«%d», Global); getch(); }

Это связано с тем, что отсутствует определение переменной. Если определить переменную внутри main, то это будет уже другой экземпляр переменной, которая будет расположена на стеке. Вообще, при работе с одним файлом использование extern переменных не оправдано. Рассмотрим ситуацию, когда у нас имеются ещё два файла – заголовочный File1.h и File1.c. В заголовочном файле объявим extern переменную Global

#ifndef _FILE1_H_ #define _FILE1_H_ extern int Global; #endif

в файле исходного кода определим её

#include «File1.h» int Global = 100;

После подключения файла File1.h можно использовать эту переменную в файле main.c, при этом гарантировано, что существует только один экземпляр этой переменной для всех файлов проекта

#include <conio.h> #include <stdio.h> #include «File1.h» void main() { printf(«%d\n», Global); getch(); }

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

#ifndef _FILE1_H_ #define _FILE1_H_ #include <stdio.h> extern int Global; void changeAndPrint(); #endif #include «File1.h» int Global = 100; void changeAndPrint() { printf(«from File1: Global = %d\n», Global); Global = 1234; printf(«changed to %d\n», Global); } #include <conio.h> #include <stdio.h> #include «File1.h» void main() { Global = 567; printf(«From main: Global = %d\n», Global); changeAndPrint(); printf(«From main: Global = %d\n», Global); getch(); }

Вывод

Класс памяти для функций

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

void foo() { … }

эквивалентна

extern void foo() { …

Методы Java — как вызывать и использовать

}

Другой класс — static, делает функцию видимой только внутри своего модуля.

Рассмотрим пример – у нас будет, как обычно 2 файла, File1.h и File1.c. В первом определим две функции, одну extern, а вторую static

#ifndef _FILE1_H_ #define _FILE1_H_ #include <stdio.h> void visible(); static void hidden(); #endif #include «File1.h» void visible() { printf(«Everyone can use me!\n»); hidden(); } void hidden() { printf(«No one can use me, except my friends from File1.c\n»); }

Заметьте: мы не сможем вызвать функцию hidden вне файла File1.c, но внутри файла эта функция доступна.

#include <conio.h> #include <stdio.h> #include «File1.h» void main() { visible(); //hidden(); её теперь не вызвать getch(); }

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

ru-Cyrl18-tutorialSypachev S.S.1989-04-14sypachev_s_s@mail.ruStepanSypachevstudents

Q&A

Что такое static

В некоторых случаях желательно определить член класса, который будет использоваться независимо от любого объекта этого класса. Обычно обращение к члену класса должно выполняться только в сочетании с объектом его класса. Однако можно создать член класса, который может использоваться самостоятельно, без ссылки на конкретный экземпляр. Чтобы создать такой член, в начало его объявления нужно поместить ключевое слово static. Когда член класса объявлен как static (статический), он доступен до создания каких-либо объектов его класса и без ссылки на какой-либо объект. Статическими могут быть объявлены как методы, так и переменные. Наиболее распространенный пример статического члена — метод main (). Этот метод объявляют как static, поскольку он должен быть объявлен до создания любых объектов.

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

На методы, объявленные как static, накладывается ряд ограничений.

• Они могут вызывать только другие статические методы.
• Они должны осуществлять доступ только к статическим переменным.
• Они ни коим образом не могут ссылаться на члены типа this или super. (Ключевое слово super связано с наследованием и описывается в следующей главе.)

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

Сразу после загрузки класса UseStatic программа выполняет все операторы static. Вначале значение а устанавливается равным 3, затем программа выполняет блок static, который выводит сообщение, а затем инициализирует переменную b значением а*4, или 12. Затем программа вызывает метод main (), который обращается к методу meth (), передавая параметру х значение 42.

Три оператора println () ссылаются на две статических переменные а и b на локальную переменную х.

Вывод этой программы имеет такой вид:

За пределами класса, в котором они определены, статические методы и переменные могут использоваться независимо от какого-либо объекта. Для этого достаточно указать имя их класса, за которым должна следовать операция точки. Например, если метод типа static нужно вызвать извне его класса, это можно выполнить, используя следующую общую форму:

Здесь имя_класса — имя класса, в котором объявлен метод тип static. Как видите, этот формат аналогичен применяемому для вызова нестатических методов через переменные объектных ссылок. Статическая переменная доступна аналогичным образом — посредством операции точки, следующей за именем класса.

Что означает «public static void» в Java?

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

Приведем пример. Внутри метода main () обращение к статическому методу callme () и статической переменной b осуществляется посредством имени их класса StaticDemo.

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