what is static keyword java
Tento výukový program vysvětluje statické klíčové slovo v Javě a jeho použití v proměnných, metodách, blocích a třídách. Uvádí také rozdíl mezi statickými a nestatickými členy:
Java podporuje různé typy deklarací k označení rozsahu a chování jejích proměnných, metod, tříd atd. Například, klíčové slovo final, zapečetěné, statické atd. Všechna tato prohlášení mají určitý specifický význam, pokud jsou použita v programu Java.
Jak budeme pokračovat v tomto tutoriálu, prozkoumáme všechna tato klíčová slova. Zde probereme podrobnosti o jednom z nejdůležitějších klíčových slov v Javě, tj. „Statické“.
Co se naučíte:
Statické klíčové slovo v Javě
Člen programu Java může být deklarován jako statický pomocí klíčového slova „static“ předcházejícího jeho deklaraci / definici. Když je člen prohlášen za statický, pak to v podstatě znamená, že je člen sdílen všemi instancemi třídy, aniž by vytvářel kopie jednotlivých instancí.
Statický je tedy modifikátor netřídy používaný v Javě a lze jej použít na následující členy:
- Proměnné
- Metody
- Bloky
- Třídy (konkrétněji vnořené třídy)
Když je člen prohlášen za statický, lze k němu přistupovat bez použití objektu. To znamená, že před vytvořením instance třídy je statický člen aktivní a přístupný. Na rozdíl od ostatních členů nestatické třídy, kteří přestanou existovat, když objekt třídy zmizí z rozsahu, je statický člen stále zjevně aktivní.
Statická proměnná v Javě
Členská proměnná třídy, která je deklarována jako statická, se nazývá statická proměnná. Nazývá se také jako „proměnná třídy“. Jakmile je proměnná deklarována jako statická, je paměť přidělena pouze jednou a ne pokaždé, když je vytvořena instance třídy. Proto můžete přistupovat ke statické proměnné bez odkazu na objekt.
Následující program Java popisuje použití statických proměnných:
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); } } Výstup:
Ve výše uvedeném programu máme dvě statické proměnné, tj. A a b. Tyto proměnné upravujeme ve funkci „printStatic“ i „main“. Všimněte si, že hodnoty těchto statických proměnných jsou zachovány napříč funkcemi, i když rozsah funkce končí. Výstup zobrazuje hodnoty proměnných ve dvou funkcích.
Proč potřebujeme statické proměnné a kde jsou užitečné?
Statické proměnné jsou nejužitečnější v aplikacích, které potřebují čítače. Jak víte, čítače dávají nesprávné hodnoty, pokud jsou deklarovány jako normální proměnné.
Například pokud máte normální proměnnou nastavenou jako čítač v aplikaci, která má třídu řekněme auto. Poté, kdykoli vytvoříme objekt automobilu, bude proměnná normálního čítače inicializována s každou instancí. Ale pokud máme proměnnou čítače jako statickou proměnnou nebo proměnnou třídy, bude se inicializovat pouze jednou, když je vytvořena třída.
Později se u každé instance třídy tento čítač zvýší o jednu. To je na rozdíl od normální proměnné, kde s každou instancí bude čítač zvýšen, ale hodnota čítače bude vždy 1.
Proto i když vytvoříte stovku objektů třídního vozu, pak čítač jako normální proměnná bude mít vždy hodnotu 1, zatímco se statickou proměnnou bude zobrazovat správný počet 100.
Níže je uveden další příklad statických čítačů v Javě:
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(); } } Výstup:
Fungování statické proměnné je patrné ve výše uvedeném programu. Deklarovali jsme počet statických proměnných s počáteční hodnotou = 0. Potom v konstruktoru třídy zvýšíme statickou proměnnou.
V hlavní funkci vytvoříme tři objekty počitadla tříd. Výstup ukazuje hodnotu statické proměnné pokaždé, když je vytvořen objekt čítače. Vidíme, že s každým vytvořeným objektem se stávající hodnota statické proměnné zvyšuje a neinicializuje.
Statická metoda Java
Metoda v Javě je statická, pokud jí předchází klíčové slovo „static“.
Některé body, které si musíte pamatovat na statickou metodu, zahrnují:
mp3 ke stažení zdarma pro telefony Android
- Statická metoda patří do třídy oproti jiným nestatickým metodám, které jsou vyvolány pomocí instance třídy.
- K vyvolání statické metody nepotřebujete objekt třídy.
- Členové statických dat třídy jsou přístupní statické metodě. Statická metoda může dokonce změnit hodnoty statického datového člena.
- Statická metoda nemůže mít odkaz na členy „this“ nebo „super“. I když se je statická metoda pokusí odkázat, bude to chyba kompilátoru.
- Stejně jako statická data může statická metoda volat i jiné statické metody.
- Statická metoda nemůže odkazovat na nestatické datové členy nebo proměnné a nemůže volat také nestatické metody.
Následující program ukazuje implementaci statické metody v Javě:
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(); } } Výstup:
Toto je jednoduchá ilustrace. Definujeme statickou metodu, která jednoduše vytiskne zprávu. Pak se v hlavní funkci volá statická metoda bez jakéhokoli objektu nebo instance třídy.
Další příklad implementace statického klíčového slova v Javě.
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(); } } Jak vidíte ve výše uvedeném programu, máme dvě metody. Metoda printStatic je statická metoda, zatímco inst_print je metoda instance. Máme také dvě proměnné, static_count je statická proměnná ab je proměnná instance.
Ve statické metodě - printStatic nejprve zobrazíme zprávu a poté se pokusíme změnit hodnotu instanční proměnné b a zavoláme také nestatickou metodu.
Dále zkusíme použít klíčové slovo „super“.
b = 20;
inst_print ();
System.out.println (super.count_static);
Když spustíme program s výše uvedenými řádky, dostaneme chyby kompilace pro použití proměnných instance, volání nestatických metod a odkazování super ve statickém kontextu. Toto jsou omezení statické metody.
Když komentujeme výše uvedené tři řádky, výše uvedený program funguje dobře a vytvoří následující výstup.
Výstup:
Přetížení a přepsání statické metody
Jak všichni víte, Overloading a Overriding jsou vlastnosti OOPS a pomáhají v polymorfismu. Přetížení lze klasifikovat jako polymorfismus v době kompilace, přičemž můžete mít metody se stejným názvem, ale s různými seznamy parametrů.
Přepsání je funkce polymorfismu za běhu a v tomto je metoda základní třídy přepsána v odvozené třídě, takže podpis metody nebo prototyp je stejný, ale definice se liší.
bezplatný software pro správu verzí pro Windows
Pojďme diskutovat o tom, jak přetížení a přepsání ovlivňují statickou třídu v Javě.
Přetížení
Statickou metodu v Javě můžete přetížit různými seznamy parametrů, ale se stejným názvem.
Následující program zobrazuje přetížení:
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!!'); } } Výstup:
Tento program má dvě statické metody se stejným názvem „static_method“, ale s jiným seznamem argumentů. První metoda nebere žádný argument a druhá metoda přijímá řetězcový argument.
Je třeba poznamenat, že metodu nelze přetížit pouze v závislosti na klíčovém slově „static“. Například, pokud máte instanční metodu „sum“ a pokud definujete jinou metodu „sum“ a deklarujete ji jako statickou, pak to nebude fungovat. Tento pokus o přetížení na základě „statického“ klíčového slova bude mít za následek selhání kompilace.
Převažující
Protože jsou vyvolány statické metody bez jakéhokoli objektu třídy, i když máte v odvozené třídě statickou metodu se stejným podpisem, nebude to přepsání. Je to proto, že bez instance neexistuje žádný běhový polymorfismus.
Proto nemůžete přepsat statickou metodu. Pokud ale v odvozené třídě vůbec existuje statická metoda se stejným podpisem, pak metoda volání nezávisí na objektech za běhu, ale záleží na kompilátoru.
Musíte si uvědomit, že i když statické metody nelze přepsat, jazyk Java nedává žádné chyby kompilátoru, pokud máte metodu v odvozené třídě se stejným podpisem jako metoda základní třídy.
Následující implementace to dokazuje.
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(); } } Výstup:
Ve výše uvedeném programu vidíte, že volaná statická metoda nezávisí na tom, na který objekt ukazuje ukazatel. Je to proto, že statické metody objekty vůbec nepoužívají.
Statický blok v Javě
Stejně jako máte funkční bloky v programovacích jazycích jako C ++, C # atd., Také v Javě existuje speciální blok zvaný „statický“ blok, který obvykle obsahuje blok kódu související se statickými daty.
Tento statický blok je proveden v okamžiku, kdy je vytvořen první objekt třídy (přesně v době načítání třídy) nebo když je použit statický člen uvnitř bloku.
Následující program ukazuje použití statického bloku.
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); } } Výstup:
Všimněte si pořadí provádění příkazů ve výše uvedeném programu. Nejprve se provede obsah statického bloku a poté hlavní program. Statické proměnné sum a val1 mají počáteční hodnoty, zatímco val2 není inicializován (výchozí hodnota je 0). Pak ve statickém bloku val2 stále není přiřazena hodnota, a proto se jeho hodnota zobrazí jako 0.
Proměnné val2 je po vytištění ve statickém bloku přiřazena hodnota a součet je přepočítán. Proto v hlavní funkci získáme různé hodnoty součtu a val2.
Pokud zadáte konstruktor, pak se obsah statického bloku provede ještě před konstruktorem. Statické bloky se většinou používají k inicializaci statických členů třídy a další inicializaci související se statickými členy.
Statická třída Java
V Javě máte statické bloky, statické metody a dokonce i statické proměnné. Je tedy zřejmé, že můžete mít i statické třídy. V Javě je možné mít třídu uvnitř jiné třídy, která se nazývá vnořená třída. Třída, která obklopuje vnořenou třídu, se nazývá vnější třída.
I když v Javě můžete deklarovat vnořenou třídu jako statickou, není možné mít vnější třídu jako statickou.
Podívejme se nyní na statické vnořené třídy v Javě.
Statická vnořená třída v Javě
Jak již bylo zmíněno, můžete mít vnořenou třídu v Javě deklarovanou jako statickou. Statická vnořená třída se liší od nestatické vnořené třídy (vnitřní třídy) v určitých aspektech, jak je uvedeno níže.
Na rozdíl od nestatické vnořené třídy vnořená statická třída nepotřebuje odkaz na vnější třídu.
Statická vnořená třída může přistupovat pouze ke statickým členům vnější třídy oproti nestatickým třídám, které mají přístup ke statickým i nestatickým členům vnější třídy.
Níže je uveden příklad statické vnořené třídy.
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(); } } Výstup:
Ve výše uvedeném programu vidíte, že statická vnořená třída může přistupovat ke statické proměnné (řetězci) z vnější třídy.
Statický import v Javě
Jak víte, do programu Java obvykle zahrnujeme různé balíčky a předdefinované funkce pomocí direktivy „import“. Použití slova static s direktivou importu vám umožňuje používat funkce třídy bez použití názvu třídy.
Příklad:
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'); } } Výstup:
V tomto programu používáme statický import pro třídu java.lang.System.
Poznámka: V hlavní funkci jsme právě použili out.println k zobrazení zprávy.
Přestože funkce statického importu činí kód stručnějším a čitelnějším, někdy vytváří nejednoznačnost, zejména když některé balíčky mají stejné funkce. Statický import by proto měl být použit pouze v případě, že je to extrémně nutné.
Statické vs. nestatické
Pojďme diskutovat o hlavních rozdílech mezi statickými a nestatickými členy Javy.
Níže jsou uvedeny rozdíly mezi Statické a nestatické proměnné .
| Statické proměnné | Nestatické proměnné |
|---|---|
| Je přístupný pouze pomocí názvu třídy. | Vyžaduje přístup k objektům třídy. |
| Jsou přístupné jak statickým, tak i nestatickým metodám. | Jsou přístupné pouze pro nestatické metody. |
| Paměť pro statickou proměnnou je pro každou třídu přidělena pouze jednou. | Paměť pro nestatické proměnné je přidělena každému objektu. |
| Sdíleno všemi objekty třídy. | Je vytvořena kopie proměnné na objekt. |
| Má globální rozsah a je k dispozici všem metodám a blokům. | Má místní rozsah a je viditelný pro objekty třídy. |
Níže je uveden rozdíl mezi statickými a nestatickými metodami .
| Statické metody | Nestatické metody |
|---|---|
| Metoda, které předchází statické klíčové slovo a je k dispozici na úrovni třídy. | Metoda, které nepředchází statické klíčové slovo a je k dispozici pro každou z instancí třídy. |
| Podporuje kompilaci nebo časnou vazbu. | Podporuje běhovou nebo dynamickou vazbu. |
| Může přistupovat pouze ke statickým datovým členům své třídy a jakékoli jiné třídy. | Může přistupovat ke statickým i nestatickým členům třídy a dalších tříd. |
| Statické metody nelze přepsat. | Lze přepsat. |
| Paměť je přidělena pouze jednou. Použitá paměť je tedy menší. | Spotřeba paměti je větší, protože paměť je přidělena při každém vyvolání metody. |
Statické vs. konečné
Static a Final jsou dvě klíčová slova v Javě, která mohou dát zvláštní význam entitě, se kterou se používá. Například, když je proměnná deklarována jako statická, stane se proměnnou třídy, ke které lze přistupovat bez odkazu na objekt.
Podobně, když je proměnná deklarována jako konečná, stává se neměnnou, tj. Konstantou.
Uveďme tabulku některých hlavních rozdílů mezi statickými a finálními klíčovými slovy v Javě.
| Statický | Finále |
|---|---|
| Statický datový člen (vnořená třída, proměnná nebo metoda) je datový člen, kterému předchází statické klíčové slovo a lze k němu přistupovat bez objektu. | Konečné klíčové slovo lze použít na proměnnou, metodu, třídu atd. a ukládá entitám omezení. |
| Není povinné inicializovat statickou proměnnou s hodnotou během deklarace. | Je nutné, aby byla finální proměnná inicializována na hodnotu v době deklarace |
| Můžete znovu inicializovat statické proměnné. | Není možné znovu inicializovat konečné proměnné. |
| Statické metody jsou ty, které mají přístup pouze ke statickým členům. | Konečné metody jsou metody, které nelze zdědit / přepsat. |
| Statické třídy jsou třídy, jejichž objekty nelze vytvořit. | Konečné třídy jsou třídy, které nelze zdědit. |
Často kladené otázky
Otázka č. 1) Může být třída Java statická?
nejlepší aplikace pro snímky obrazovky pro Windows 10
Odpovědět: Ano, třída v Javě může být statická, pokud nejde o vnější třídu. To znamená, že statické mohou být pouze vnořené třídy v Javě.
Otázka 2) Kdy bych měl použít statický v Javě?
Odpovědět: Kdykoli chcete ve svém programu datový člen, který by měl zachovat svoji hodnotu napříč objekty, měli byste použít static. Například, počítadlo. Metodu lze deklarovat jako statickou, když ji nechcete vyvolat pomocí objektu.
Otázka č. 3) Může mít statická třída konstruktor?
Odpovědět: Ano, statická třída může mít konstruktor a jejím účelem je pouze inicializovat statické datové členy. Bude vyvolána pouze poprvé při přístupu k datovým členům. Při dalším přístupu nebude vyvolána.
Otázka č. 4) Jaké je použití statického konstruktoru?
Odpovědět: Obecně se konstruktor používá k inicializaci členů statických dat. Používá se také k provádění operací / akcí, které je třeba provést pouze jednou.
Otázka č. 5) Jsou statické metody zděděny v Javě?
Odpovědět: Ano, statické metody v Javě se dědí, ale nejsou přepsány.
Závěr
V tomto kurzu jsme podrobně probrali statické klíčové slovo Java spolu s jeho použitím v datových členech, metodách, blocích a třídách. Statické klíčové slovo je klíčové slovo, které se používá k označení úrovně třídy nebo globálního rozsahu.
Ke statickým členům nemusíte přistupovat pomocí instancí kurzu. Ke statickým datovým členům můžete přistupovat přímo pomocí názvu třídy. Také jsme diskutovali o hlavních rozdílech mezi statickými a nestatickými členy a také o statických a konečných klíčových slovech.
V našich následujících tématech prozkoumáme více klíčových slov a jejich význam v jazyce Java.
Doporučené čtení
- Statické v C ++
- Výukový program pro rozhraní Java a abstraktní třídu s příklady
- Implementace Java: Vytvoření a spuštění souboru Java JAR
- Virtuální stroj Java: Jak JVM pomáhá při spouštění aplikace Java
- Koncepty C #: konstruktor, destruktor, statická třída, struktura a výčet
- Modifikátory přístupu v Javě - výuka s příklady
- Výukový program Java Reflection s příklady
- Úvod do programovacího jazyka Java - výukový program