Statische variabelen en methoden

'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:"

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

    Cat(String name)             // Constructor
    {
        this.name = name;        // Variable initialization
    }
}

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);

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."

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
    }
}

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);

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:

Cat cat = new Cat();
String name = cat.getName();
cat.setAge(17);
cat.setChildren(cat1, cat2, cat3);

Cat cat = new Cat();
String name = Cat.getName(cat);
Cat.setAge(cat, 17);
Cat.setChildren(cat, cat1, cat2, cat3);

"Hier is hoe statische methoden werken:

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount();

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount(null);

"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."