CodeGym /Java Course /Java Syntax /Statische variabelen en methoden

Statische variabelen en methoden

Java Syntax
Niveau 6 , Les 6
Beschikbaar

'Laten we naar een nieuw onderwerp gaan. Nu wil ik het hebben over statische variabelen en methoden.'

'Ellie, ik heb al iets geleerd over statische variabelen en methoden. Maar ik zou graag meer details willen weten.'

"Wanneer we variabelen in een klasse declareren, definiëren we of deze variabelen slechts één keer worden gemaakt, of dat elke instantie (object) van de klasse zijn eigen kopie krijgt. Standaard wordt voor elk object een nieuwe kopie van een variabele gemaakt Zo ziet het eruit:"

Klasse verklaring
class Cat                        // Class
{
    String name;                 // Variable

    Cat(String name)             // Constructor
    {
        this.name = name;        // Variable initialization
    }
}
Code in de hoofdmethode :
Cat cat1 = new Cat("Oscar"); // Create one object whose name variable contains "Oscar"
Cat cat2 = new Cat("Missy"); // Create one object whose name variable contains "Missy"
System.out.println(cat1.name);
System.out.println(cat2.name);
Schermuitvoer
Oscar
Missy

"Ondanks dat ze in dezelfde klasse (Cat) zijn gedeclareerd, bevatten de variabelen cat1.nameen cat2.nameverschillende waarden omdat ze verwijzen naar verschillende objecten."
"Dat is logisch."
"Er bestaat echter slechts één kopie van een statische variabele voor elke instantie van een klasse en deze moet worden geopend met behulp van de klassenaam."

Klasse verklaring
class Cat                   // Сlass
{
    String name;            // Instance (non-static) variable
    static int catCount;    // Static variable

    Cat(String name)
    {
        this.name = name;
        Cat.catCount++;   // Increment the static variable by 1
    }
}
Code in de hoofdmethode:
System.out.println(Cat.catCount);
Cat cat1 = new Cat("Oscar");

System.out.println(Cat.catCount);
Cat cat2 = new Cat("Missy");

System.out.println(cat1.name);
System.out.println(cat2.name);
System.out.println(Cat.catCount);
Schermuitvoer:
0
1
Oscar
Missy
2

"OK, dat is ook logisch."

"Java-methoden zijn onderverdeeld in twee categorieën. Instantiemethoden worden aangeroepen op een object en hebben toegang tot de gegevens van dat object. Statische methoden hebben die toegang niet, omdat ze eenvoudigweg geen objectreferentie hebben. Ze kunnen echter verwijzen naar de statische variabelen van de klasse en andere statische methoden.

Statische methoden kunnen geen niet-statische methoden of niet-statische variabelen aanspreken!"

"Waarom is dat, Ellie?"

"Elke instantievariabele bevindt zich in een object. Het is alleen toegankelijk als u een verwijzing naar dat object hebt. Een dergelijke verwijzing is niet beschikbaar voor een statische methode."

"Hebben instantiemethoden zo'n referentie?"

"Ja, het wordt indirect doorgegeven aan instantiemethoden. Een verwijzing naar het object waarop een instantiemethode wordt aangeroepen, wordt indirect doorgegeven aan de instantiemethode. De variabele die deze referentie opslaat, wordt dit genoemd . Hierdoor heeft de methode altijd toegang tot de gegevens of roep een andere niet-statische methode op hetzelfde object aan.

In plaats van een objectreferentie wordt null doorgegeven aan statische methoden. Daarom kunnen ze geen niet-statische variabelen en methoden aanspreken. Ze hebben eenvoudigweg geen verwijzing naar een object dat aan deze variabelen en methoden is gekoppeld."

"Ok Ellie, dat begrijp ik."

"Dit is hoe niet-statische methoden werken:

Hoe de code eruit ziet
Cat cat = new Cat();
String name = cat.getName();
cat.setAge(17);
cat.setChildren(cat1, cat2, cat3);
Wat gebeurt er echt
Cat cat = new Cat();
String name = Cat.getName(cat);
Cat.setAge(cat, 17);
Cat.setChildren(cat, cat1, cat2, cat3);
Wanneer je een methode aanroept met <object> punt <methodenaam>, roep je eigenlijk een klassemethode aan en geef je hetzelfde object door als het eerste argument. Binnen de methode heet het object 'this' . Alle bewerkingen in de methode worden uitgevoerd op dit object en zijn gegevens."

"Hier is hoe statische methoden werken:

Hoe de code eruit ziet
Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount();
Wat gebeurt er echt
Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount(null);
Wanneer u een statische methode aanroept, wordt er geen object aan doorgegeven. Met andere woorden, 'dit' is gelijk aan null . Daarom heeft een statische methode geen toegang tot niet-statische variabelen en methoden (aangezien het niets heeft om impliciet door te geven aan niet-statische methoden)."

"Een variabele of methode is statisch als het trefwoord statisch ervoor staat."

"Waarom zijn dergelijke methoden nodig als ze zo ernstig beperkt zijn?"

"Nou, zulke methoden hebben hun voordelen."

"Ten eerste hoeven we geen objectreferentie door te geven om statische methoden en variabelen te gebruiken. "

"Ten tweede is het soms nodig om één en slechts één kopie van een variabele te hebben. Bijvoorbeeld System.out (de statische out-variabele van de System-klasse)."

"Ten derde moet je soms een methode aanroepen voordat je objecten kunt maken."

"Ellie, kun je me hier een voorbeeld van geven?"

"Waarom denk je dat de main() methode statisch is? Het is statisch, dus de programmeur kan het direct aanroepen nadat een klasse in het geheugen is geladen, voordat er objecten zijn gemaakt."

Opmerkingen
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION