what is static keyword java
Този урок обяснява статичната ключова дума в Java и нейното използване в променливи, методи, блокове и класове. Също така посочва разликата между статичните и нестатичните членове:
Java поддържа различни видове декларации, за да посочи обхвата и поведението на своите променливи, методи, класове и т.н. Например, ключовата дума final, запечатана, статична и т.н. Всички тези декларации имат някакво специфично значение, когато се използват в програмата Java.
Ще проучим всички тези ключови думи, докато продължаваме с този урок. Тук ще обсъдим подробностите за една от най-важните ключови думи в Java, т.е. „статична“.
Какво ще научите:
- Статична ключова дума в Java
- Заключение
Статична ключова дума в Java
Член в програма на Java може да бъде деклариран като статичен, използвайки ключовата дума „static“, предшестващ декларацията / дефиницията. Когато член е обявен за статичен, това по същество означава, че членът се споделя от всички екземпляри на клас, без да се правят копия на всеки екземпляр.
По този начин static е некласов модификатор, използван в Java и може да бъде приложен към следните членове:
- Променливи
- Методи
- Блокове
- Класове (по-конкретно, вложени класове)
Когато даден член е обявен за статичен, той може да бъде достъпен без да се използва обект. Това означава, че преди даден клас е създаден, статичният член е активен и достъпен. За разлика от други нестатични членове на класа, които престават да съществуват, когато обектът на класа излезе извън обхвата, статичният член все още е очевидно активен.
Статична променлива в Java
Променлива член на клас, който е деклариран като статичен, се нарича статична променлива. Нарича се още „променливата на класа“. След като променливата бъде декларирана като статична, паметта се разпределя само веднъж, а не всеки път, когато е създаден екземпляр на клас. Следователно можете да получите достъп до статичната променлива без препратка към обект.
Следващата програма на Java изобразява използването на статични променливи:
class Main { // static variables a and b static int a = 10; static int b; static void printStatic() { a = a /2; b = a; System.out.println('printStatic::Value of a : '+a + ' Value of b : '+b); } public static void main(String() args) { printStatic(); b = a*5; a++; System.out.println('main::Value of a : '+a + ' Value of b : '+b); } }
Изход:
В горната програма имаме две статични променливи, т.е.а и b. Ние променяме тези променливи във функция „printStatic“, както и в „main“. Обърнете внимание, че стойностите на тези статични променливи се запазват във функциите, дори когато обхватът на функцията завършва. Резултатът показва стойностите на променливите в две функции.
Защо се нуждаем от статични променливи и къде са полезни?
Статичните променливи са най-полезни в приложения, които се нуждаят от броячи. Както знаете, броячите ще дадат грешни стойности, ако бъдат декларирани като нормални променливи.
Например, ако имате нормална променлива, зададена като брояч в приложение, което има клас, кажете car. След това, всеки път, когато създадем автомобилен обект, нормалната променлива на брояча ще се инициализира с всеки екземпляр. Но ако имаме броячна променлива като статична променлива или клас, тя ще се инициализира само веднъж, когато класът е създаден.
По-късно, с всеки екземпляр на класа, този брояч ще бъде увеличен с един. Това е за разлика от нормалната променлива, при която с всеки екземпляр броячът ще бъде увеличен, но стойността на брояча винаги ще бъде 1.
Следователно, дори ако създадете сто обекта от автомобила на класа, тогава броячът като нормална променлива винаги ще има стойността 1, докато със статична променлива той ще показва правилния брой 100.
По-долу е даден друг пример за статични броячи в Java:
class Counter { static int count=0;//will get memory only once and retain its value Counter() { count++;//incrementing the value of static variable System.out.println(count); } } class Main { public static void main(String args()) { System.out.println('Values of static counter:'); Counter c1=new Counter(); Counter c2=new Counter(); Counter c3=new Counter(); } }
Изход:
Работата на статичната променлива е очевидна в горната програма. Декларирахме броя на статичната променлива с начална стойност = 0. След това в конструктора на класа увеличаваме статичната променлива.
В основната функция създаваме три обекта от брояча на класове. Резултатът показва стойността на статичната променлива всеки път, когато се създава броячът. Виждаме, че с всеки създаден обект стойността на статичната променлива се увеличава и не се инициализира повторно.
Статичен метод на Java
Методът в Java е статичен, когато е предшестван от ключовата дума „static“.
Някои точки, които трябва да запомните за статичния метод, включват:
какво е планиране на тестове и тестова стратегия
- Статичният метод принадлежи на класа за разлика от други нестатични методи, които се извикват с помощта на екземпляра на клас.
- За да извикате статичен метод, нямате нужда от обект на клас.
- Статичните членове на данните от класа са достъпни за статичния метод. Статичният метод може дори да променя стойностите на статичния член с данни.
- Статичният метод не може да има препратка към „този“ или „супер“ членове. Дори ако статичен метод се опита да ги препрати, това ще бъде грешка на компилатора.
- Подобно на статичните данни, статичният метод може да извиква и други статични методи.
- Статичният метод не може да се отнася до нестатични членове на данни или променливи и не може да извиква и нестатични методи.
Следващата програма показва изпълнението на статичния метод в Java:
class Main { // static method static void static_method() { System.out.println('Static method in Java...called without any object'); } public static void main(String() args) { static_method(); } }
Изход:
Това е проста илюстрация. Определяме статичен метод, който просто отпечатва съобщение. Тогава в основната функция статичният метод се извиква без никакъв обект или екземпляр на клас.
Друг пример за внедряване на статична ключова дума в Java.
class Main { // static variable static int count_static = 5; // instance variable int b = 10; // static method static void printStatic() { count_static = 20; System.out.println('static method printStatic'); // b = 20; // compilation error 'error: non-static variable b cannot be referenced from a static context' //inst_print(); // compilation error 'non-static method inst_print() cannot be referenced from a static //context' //System.out.println(super.count_static); // compiler error 'non-static variable super cannot be //referenced from a static context' } // instance method void inst_print() { System.out.println('instance method inst_print'); } public static void main(String() args) { printStatic(); } }
В горната програма, както виждате, имаме два метода. Методът printStatic представлява статичен метод, докато inst_print е метод на екземпляр. Имаме и две променливи, static_count е статична променлива и b е променлива на екземпляр.
В статичния метод - printStatic първо показваме съобщение и след това се опитваме да променим стойността на променливата на екземпляра b и също така извикваме нестатичния метод.
След това се опитваме да използваме ключовата дума „super“.
b = 20;
inst_print ();
System.out.println (super.count_static);
Когато изпълняваме програмата с горните редове, получаваме грешки при компилация за използване на променливи на инстанции, извикване на нестатични методи и препращане към супер в статичен контекст. Това са ограниченията на статичния метод.
Когато коментираме горните три реда, само тогава горната програма работи добре и дава следния изход.
Изход:
Претоварване и заменяне на статичен метод
Както всички знаете, както претоварването, така и заместването са характеристиките на OOPS и помагат в полиморфизма. Претоварването може да се класифицира като полиморфизъм по време на компилация, при което можете да имате методи със същото име, но различни списъци с параметри.
Заменянето е характеристика на полиморфизма по време на изпълнение и при това методът на базовия клас е заменен в производния клас, така че подписът на метода или прототипът е еднакъв, но дефиницията се различава.
Нека обсъдим как претоварването и заместването влияят на статичния клас в Java.
Претоварване
Можете да претоварите статичен метод в Java с различни списъци с параметри, но със същото име.
Следващата програма показва претоварване:
кое е най-доброто приложение за изтегляне на mp3 за android
public class Main { public static void static_method() { System.out.println('static_method called '); } public static void static_method(String msg) { System.out.println('static_method(string) called with ' + msg); } public static void main(String args()) { static_method(); static_method('Hello, World!!'); } }
Изход:
Тази програма има два статични метода със същото име ‘static_method’, но различен списък с аргументи. Първият метод не приема никакъв аргумент, а вторият метод взема аргумент низ.
Един момент, който трябва да се отбележи е, че не можете да претоварвате метода само в зависимост от ключовата дума 'static'. Например, ако имате метод на екземпляр ‘sum’ и ако дефинирате друг метод „sum“ и го декларирате като статичен, тогава той няма да работи. Този опит за претоварване въз основа на „статична“ ключова дума ще доведе до неуспех на компилацията.
Замяна
Тъй като статичните методи се извикват без никакъв обект от класа, дори и да имате статичен метод със същия подпис в извлечения клас, той няма да бъде заместващ. Това е така, защото няма полиморфизъм по време на изпълнение без екземпляр.
Следователно не можете да замените статичен метод. Но ако изобщо има статичен метод със същия подпис в производния клас, тогава методът за извикване не зависи от обектите по време на изпълнение, а от компилатора.
Трябва да отбележите, че въпреки че статичните методи не могат да бъдат заменени, езикът Java не дава никакви грешки на компилатора, когато имате метод в производния клас със същия подпис като метода на базовия клас.
Следващото изпълнение доказва това.
classBase_Class { // Static method in base class which will be hidden in substatic_displayclass public static void static_display() { System.out.println('Base_Class::static_display'); } } classDerived_Class extends Base_Class { public static void static_display() { System.out.println('Derived_Class::static_display'); } } public class Main { public static void main(String args( )) { Base_Class obj1 = new Base_Class(); Base_Class obj2 = new Derived_Class(); Derived_Class obj3 = new Derived_Class(); obj1.static_display(); obj2.static_display(); obj3.static_display(); } }
Изход:
В горната програма можете да видите, че извиканият статичен метод не зависи от това към кой обект сочи указателят. Това е така, защото обектите изобщо не се използват със статични методи.
Статичен блок в Java
Точно както имате функционални блокове в програмни езици като C ++, C # и т.н., също и в Java, има специален блок, наречен 'статичен' блок, който обикновено включва блок от код, свързан със статични данни.
Този статичен блок се изпълнява в момента, когато е създаден първият обект от класа (точно по време на зареждането на класа) или когато се използва статичният член вътре в блока.
Следващата програма показва използването на статичен блок.
class Main { static int sum = 0; static int val1 = 5; static int val2; // static block static { sum = val1 + val2; System.out.println('In static block, val1: ' + val1 + ' val2: '+ val2 + ' sum:' + sum); val2 = val1 * 3; sum = val1 + val2; } public static void main(String() args) { System.out.println('In main function, val1: ' + val1 + ' val2: '+ val2 + ' sum:' + sum); } }
Изход:
Обърнете внимание на реда на изпълнение на изявленията в горната програма. Съдържанието на статичния блок се изпълнява първо, последвано от основната програма. Статичните променливи sum и val1 имат начални стойности, докато val2 не се инициализира (по подразбиране е 0). Тогава в статичния блок val2 все още не е присвоена стойност и следователно стойността му се показва като 0.
На променливата val2 се присвоява стойност след отпечатване в статичния блок и сумата се преизчислява. Следователно в основната функция получаваме различни стойности на sum и val2.
Ако посочите конструктор, тогава съдържанието на статичния блок се изпълнява дори преди конструктора. Статичните блокове се използват предимно за инициализиране на статични членове на класа и друга инициализация, свързани със статични членове.
Статичен клас на Java
В Java имате статични блокове, статични методи и дори статични променливи. Следователно е очевидно, че можете да имате и статични класове. В Java е възможно да има клас в друг клас и това се нарича вложен клас. Класът, който затваря вложения клас, се нарича Външен клас.
В Java, въпреки че можете да декларирате вложен клас като статичен, не е възможно външният клас да бъде статичен.
Нека сега изследваме статичните вложени класове в Java.
Статичен вложен клас в Java
Както вече споменахме, можете да имате вложен клас в Java, деклариран като статичен. Статичният вложен клас се различава от нестатичния вложен клас (вътрешен клас) в някои аспекти, изброени по-долу.
За разлика от нестатичния вложен клас, вложеният статичен клас не се нуждае от външна препратка към клас.
Статичният вложен клас може да има достъп само до статични членове на външния клас срещу нестатичните класове, които имат достъп до статични, както и нестатични членове на външния клас.
Пример за статичен вложен клас е даден по-долу.
class Main{ private static String str = 'SoftwareTestingHelp'; //Static nested class static class NestedClass{ //non-static method public void display() { System.out.println('Static string in OuterClass: ' + str); } } public static void main(String args()) { Main.NestedClassobj = new Main.NestedClass(); obj.display(); } }
Изход:
В горната програма виждате, че статичният вложен клас може да има достъп до статичната променлива (низ) от външния клас.
Статичен импорт в Java
Както знаете, обикновено включваме различни пакети и предварително дефинирана функционалност в програмата Java, като използваме директивата “import”. Използването на думата static с директивата за импортиране ви позволява да използвате функционалността на класа, без да използвате името на класа.
Пример:
import static java.lang.System.*; class Main { public static void main(String() args) { //here we import System class using static, hence we can directly use functionality out.println('demonstrating static import'); } }
Изход:
В тази програма използваме статичен импорт за клас java.lang.System.
Забележка: В основната функция току-що използвахме out.println, за да покажем съобщението.
Въпреки че функцията за статично импортиране прави кода по-кратък и четим, понякога създава неяснота, особено когато някои пакети имат същите функции. Следователно статичното импортиране трябва да се използва само когато е крайно необходимо.
Статично срещу нестатично
Нека обсъдим основните разлики между статичните и нестатичните членове на Java.
По-долу са посочени разликите между Статични и нестатични променливи .
Статични променливи | Нестатични променливи |
---|---|
Достъпът до него може да се използва само с името на класа. | Изисква обекти от клас за достъп. |
Достъпни са както за статични, така и за нестатични методи. | Достъпни са само за нестатични методи. |
Памет за статична променлива се разпределя само веднъж за клас. | За всеки обект се разпределя памет за нестатични променливи. |
Споделено от всички обекти на класа. | Прави се копие на променлива на обект. |
Има глобален обхват и е достъпен за всички методи и блокове. | Има локален обхват и е видим за обекти от класа. |
По-долу е дадена разликата между статични и нестатични методи .
Статични методи | Нестатични методи |
---|---|
Метод, който е предшестван от статична ключова дума и е достъпен на ниво клас. | Метод, който не е предшестван от статична ключова дума и е достъпен за всеки от екземплярите на класа. |
Поддържа време на компилация или ранно свързване. | Поддържа време на изпълнение или динамично свързване. |
Може да има достъп само до статични членове на данните от своя клас и всеки друг клас. | Може да има достъп до статични, както и до нестатични членове на класа и други класове. |
Статичните методи не могат да бъдат заменени. | Може да бъде заменено. |
Паметта се разпределя само веднъж. Следователно използваната памет е по-малка. | Потреблението на памет е повече, тъй като паметта се разпределя всеки път, когато методът бъде извикан. |
Статично срещу финал
Static и Final са две ключови думи в Java, които могат да придадат специално значение на обекта, с който се използва. Например, когато променлива е декларирана като статична, тя се превръща в променлива на клас, която може да бъде достъпна без препратка към обекта.
По същия начин, когато променлива е декларирана като окончателна, тя става неизменна, т.е.константа.
Нека да обобщим някои от основните разлики между Static и Final ключови думи в Java.
Статично | Финал |
---|---|
Статичен член на данни (вложен клас, променлива или метод) е член на данни, предшестван от статична ключова дума и може да бъде достъпен без обект. | Крайната ключова дума може да се приложи към променлива, метод, клас и т.н. и налага ограничения на субектите. |
Не е задължително да се инициализира статичната променлива със стойност по време на декларацията. | Изисква се крайната променлива да бъде инициализирана до стойност по време на декларацията |
Можете да инициализирате статичните променливи. | Не е възможно да се инициализират окончателните променливи. |
Статичните методи са тези, които имат достъп само до статични членове. | Крайните методи са методите, които не могат да бъдат наследени / заменени. |
Статичните класове са класове, чиито обекти не могат да бъдат създадени. | Финалните класове са класове, които не могат да бъдат наследени. |
често задавани въпроси
В # 1) Може ли Java Class да бъде статичен?
Отговор: Да, клас в Java може да бъде статичен, при условие че не е външният клас. Това означава, че само вложени класове в Java могат да бъдат статични.
В # 2) Кога трябва да използвам Static в Java?
Отговор: Винаги, когато искате член на данните във вашата програма, който трябва да запази стойността си в обектите, тогава трябва да използвате статичен. Например, брояч. Методът може да бъде деклариран като статичен, когато не искате да го извиквате с помощта на обект.
В # 3) Може ли статичен клас да има конструктор?
като цяло, през кои два периода на тестване се откриват повечето грешки (дефекти)?
Отговор: Да, статичният клас може да има конструктор и неговата цел е единствено да инициализира статични членове на данни. Той ще бъде извикан само за първи път при достъп до членовете на данните. Той няма да бъде извикан за последващ достъп.
В # 4) Каква е ползата от Static Constructor?
Отговор: По принцип конструкторът се използва за инициализиране на статични членове на данни. Използва се и за извършване на операции / действия, които трябва да бъдат извършени само веднъж.
В # 5) Наследяват ли се статични методи в Java?
Отговор: Да, статичните методи в Java се наследяват, но не се заменят.
Заключение
В този урок обсъдихме подробно статичната ключова дума на Java заедно с използването й в членове на данни, методи, блокове и класове. Ключовата дума static е ключова дума, която се използва за обозначаване на ниво клас или глобален обхват.
Не е необходимо да имате достъп до статични членове, като използвате екземпляри на класа. Можете директно да получите достъп до статичните членове на данни, като използвате името на класа. Също така обсъдихме основните разлики между статичните и нестатичните членове, както и статичните и крайните ключови думи.
В следващите ни теми ще изследваме повече ключови думи и тяхното значение в езика Java.
Препоръчително четене
- Статично в C ++
- Урок за интерфейс на Java и абстрактен клас с примери
- Разполагане на Java: Създаване и изпълнение на Java JAR файл
- Java виртуална машина: Как JVM помага при стартирането на Java приложение
- Концепции на C #: конструктор, деструктор, статичен клас, структура и преброяване
- Модификатори на достъп в Java - Урок с примери
- Урок за отражение на Java с примери
- Въведение в езика за програмиране на Java - видео урок