Ik heb deze testcode geschreven:
class MyProgram
{
int count = 0;
public static void main(String[] args)
{
System.out.println(count);
}
}
Maar het geeft de volgende foutmelding:
Main.java:6: error: non-static variable count cannot be referenced from a static context
System.out.println(count);
^
Hoe zorg ik ervoor dat mijn methoden mijn klassenvariabelen herkennen?
Antwoord 1, autoriteit 100%
U moet het verschil begrijpen tussen een klasse en een instantie van die klasse. Als je een auto op straat ziet, weet je meteen dat het een auto is, ook al kun je niet zien welk model of type. Dit komt omdat je vergelijkt wat je ziet met de klasse “auto”. De klasse bevat die vergelijkbaar is met alle auto’s. Zie het als een sjabloon of een idee.
Tegelijkertijd is de auto die u ziet een instantie van de klasse “auto”, aangezien deze alle eigenschappen heeft die u verwacht: er is iemand die hem bestuurt, hij heeft een motor, wielen.
Dus de klas zegt “alle auto’s hebben een kleur” en de instantie zegt “deze specifieke auto is rood”.
In de OO-wereld definieert u de klasse en binnen de klasse definieert u een veld van het type Color. Wanneer de klasse wordt geïnstantieerd (wanneer u een specifieke instantie maakt), wordt geheugen gereserveerd voor de kleur en kunt u deze specifieke instantie een kleur geven. Aangezien deze kenmerken specifiek zijn, zijn ze niet statisch.
Statische velden en methoden worden gedeeld met alle instanties. Ze zijn voor waarden die specifiek zijn voor de klasse en niet voor een specifieke instantie. Voor methoden zijn dit meestal globale hulpmethoden (zoals Integer.parseInt()). Voor velden zijn het meestal constanten (zoals autotypes, d.w.z. iets waar je een beperkte set hebt die niet vaak verandert).
Om uw probleem op te lossen, moet u een instantie van uw klasse instantiëren (een object maken), zodat de runtime geheugen voor de instantie kan reserveren (anders zouden verschillende instanties elkaar overschrijven, wat u niet wilt).
p>
Probeer in jouw geval deze code als startblok:
public static void main (String[] args)
{
try
{
MyProgram7 obj = new MyProgram7 ();
obj.run (args);
}
catch (Exception e)
{
e.printStackTrace ();
}
}
// instance variables here
public void run (String[] args) throws Exception
{
// put your code here
}
De nieuwe methode main() maakt een instantie van de klasse die deze bevat (klinkt vreemd, maar aangezien main() wordt gemaakt met de klasse in plaats van met de instantie, het kan dit doen) en roept vervolgens een instantiemethode aan (run()).
Antwoord 2, autoriteit 29%
Statische velden en methoden zijn verbonden met de klasse zelf en niet met de instanties ervan. Als je een klasse A, een ‘normale’ methode b en een statische methode c hebt, en je maakt een instantie A van uw klasse A, zijn de aanroepen naar A.c() en a.b() geldig. Methode c() heeft geen idee welke instantie is verbonden, dus het kan geen niet-statische velden gebruiken.
De oplossing voor u is dat u uw velden statisch of uw methoden niet-statisch maakt. Je zou er dan ongeveer zo uit kunnen zien:
class Programm {
public static void main(String[] args) {
Programm programm = new Programm();
programm.start();
}
public void start() {
// can now access non-static fields
}
}
Antwoord 3, autoriteit 20%
Het sleutelwoord static wijzigt de levenscyclus van een methode of variabele binnen een klasse. Een static methode of variabele wordt aangemaakt op het moment dat een klasse wordt geladen. Een methode of variabele die niet als static is gedeclareerd, wordt alleen gemaakt wanneer de klasse wordt geïnstantieerd als een object, bijvoorbeeld door de operator new te gebruiken.
De levenscyclus van een klasse, in algemene termen, is:
- de broncode voor de klas is geschreven door een sjabloon te maken of
patroon of stempel die vervolgens kan worden gebruikt om - maak een object met de operator
newen gebruik de klasse om een instantie van de klasse als een echt object te maken en als je klaar bent met het object - vernietig het object door de bronnen terug te winnen die het bevat, zoals geheugen tijdens het ophalen van afval.
Om een eerste toegangspunt voor een toepassing te hebben, heeft Java de conventie aangenomen dat het Java-programma een klasse moet hebben die een methode bevat met een overeengekomen of speciale naam. Deze speciale methode heet main(). Aangezien de methode moet bestaan, ongeacht of de klasse die de hoofdmethode bevat is geïnstantieerd of niet, moet de methode main() worden gedeclareerd met de modifier static, zodat zodra de class is geladen, is de methode main() beschikbaar.
Het resultaat is dat wanneer u uw Java-toepassing start via een opdrachtregel zoals java helloworld, er een reeks acties plaatsvindt. Allereerst wordt een Java Virtual Machine opgestart en geïnitialiseerd. Vervolgens wordt het helloworld.class-bestand met de gecompileerde Java-code in de Java Virtual Machine geladen. Vervolgens zoekt de Java Virtual Machine naar een methode in de klasse helloworld die main(String [] args) wordt genoemd. deze methode moet static zijn zodat deze zal bestaan, ook al is de klasse niet echt als object geïnstantieerd. De Java Virtual Machine maakt geen instantie van de klasse door een object van de klasse te maken. Het laadt gewoon de klasse en start de uitvoering op de main() methode.
Dus je moet een instantie van je klasse maken als een object en dan heb je toegang tot de methoden en variabelen van de klasse die niet zijn gedeclareerd met de static modifier. Zodra uw Java-programma is gestart met de functie main(), kunt u alle variabelen of methoden gebruiken die de modifier static hebben, aangezien ze bestaan als onderdeel van de klasse die wordt geladen .
Echter, die variabelen en methoden van de klasse die buiten de main() methode vallen en die niet de static modifier hebben, kunnen niet worden gebruikt totdat een instantie van de klasse is gemaakt als een object binnen de methode main(). Nadat u het object hebt gemaakt, kunt u de variabelen en methoden van het object gebruiken. Een poging om de variabelen en methoden van de klasse te gebruiken die geen static-modifier hebben zonder een object van de klasse te doorlopen, wordt tijdens het compileren door de Java-compiler opgevangen en als een fout gemarkeerd.
import java.io.*;
class HelloWorld {
int myInt; // this is a class variable that is unique to each object
static int myInt2; // this is a class variable shared by all objects of this class
static void main (String [] args) {
// this is the main entry point for this Java application
System.out.println ("Hello, World\n");
myInt2 = 14; // able to access the static int
HelloWorld myWorld = new HelloWorld();
myWorld.myInt = 32; // able to access non-static through an object
}
}
Antwoord 4, autoriteit 4%
Laten we eerst uw programma analyseren..
In je programma is je eerste methode main(), en onthoud dat het de statische methode is… Vervolgens declareer je de lokale variabele voor die methode (compareCount, low, high, etc. .). Het bereik van deze variabele is alleen de gedeclareerde methode, ongeacht of het een statische of niet-statische methode is. Je kunt die variabelen dus niet buiten die methode gebruiken. Dit is de basisfout die je hebt gemaakt.
Dan komen we bij het volgende punt. Je zei dat static je vermoordt. (Het kan je doden, maar het geeft alleen leven aan je programma!!) Eerst moet je de basis begrijpen.
*Statische methode roept alleen de statische methode aan en gebruikt alleen de statische variabele.
*Statische variabele of statische methode is niet afhankelijk van een instantie van die klasse. (d.w.z. als u een status van de statische variabele wijzigt, wordt dit in alle objecten van de klasse weergegeven)
*Hierdoor noem je het een klassevariabele of een klassemethode.
En er is nog veel meer over het “statische” zoekwoord.
Ik hoop dat je het idee nu snapt. Wijzig eerst het bereik van de variabele en declareer deze als een statische (om deze in statische methoden te kunnen gebruiken).
En het advies voor jou is: je hebt het idee van de reikwijdte van de variabelen en statische functionaliteiten verkeerd begrepen. Krijg daar een duidelijk idee van.
Antwoord 5, autoriteit 4%
Om ze te kunnen openen vanuit uw statische methoden, moeten ze statische lidvariabelen zijn, zoals deze:
public class MyProgram7 {
static Scanner scan = new Scanner(System.in);
static int compareCount = 0;
static int low = 0;
static int high = 0;
static int mid = 0;
static int key = 0;
static Scanner temp;
static int[]list;
static String menu, outputString;
static int option = 1;
static boolean found = false;
public static void main (String[]args) throws IOException {
...
Antwoord 6, autoriteit 4%
Het allerbelangrijkste is dat statische variabelen of statische methoden zich op klasseniveau bevinden. Variabelen of methoden op klasseniveau worden geladen voorafgaand aan methoden of variabelen op instantieniveau. En uiteraard kan het ding dat niet is geladen niet worden gebruikt. Dus java-compiler die de dingen die tijdens runtime moeten worden afgehandeld, niet laat oplossen tijdens het compileren. Dat is waarom het je een fout geeft, niet-statische dingen kunnen niet worden doorverwezen vanuit een statische context. U hoeft alleen maar te lezen over het bereik van het klasseniveau, het bereik van het instantieniveau en het lokale bereik.
Antwoord 7, autoriteit 2%
Je kunt nu instanties toevoegen/gebruiken met in de methode
public class Myprogram7 {
Scanner scan;
int compareCount = 0;
int low = 0;
int high = 0;
int mid = 0;
int key = 0;
Scanner temp;
int[]list;
String menu, outputString;
int option = 1;
boolean found = false;
private void readLine() {
}
private void findkey() {
}
private void printCount() {
}
public static void main(String[] args){
Myprogram7 myprg=new Myprogram7();
myprg.readLine();
myprg.findkey();
myprg.printCount();
}
}
Antwoord 8
Ik zal proberen het statische aan je uit te leggen. Ten eerste behoren statische variabelen niet tot een bepaalde instantie van de klasse. Ze worden herkend aan de naam van de klas. Statische methoden horen weer niet bij een bepaalde instantie. Ze hebben alleen toegang tot statische variabelen. Stel je voor dat je MyClass.myMethod() aanroept en myMethod is een statische methode. Als je niet-statische variabelen in de methode gebruikt, hoe zou het dan in godsnaam weten welke variabelen te gebruiken? Daarom kunt u van statische methoden alleen statische variabelen gebruiken. Ik herhaal nogmaals dat ze NIET tot een bepaalde instantie behoren.
Antwoord 9
-
Het eerste wat je moet weten is het verschil tussen een instantie van een klasse en de klasse zelf. Een klasse modelleert bepaalde eigenschappen, en het gedrag van het geheel in de context van die eigenschappen. Een instantie definieert specifieke waarden voor die eigenschappen.
-
Alles wat gebonden is aan het statische sleutelwoord is beschikbaar in de context van de klasse in plaats van in de context van een instantie van de klasse
-
Als uitvloeisel van het bovenstaande
- variabelen binnen een methode mogen niet statisch zijn
- statische velden en methoden moeten worden aangeroepen met de klassenaam, b.v. MijnProgramma7.main(…)
-
De levensduur van een statisch veld/methode is gelijk aan de levensduur van uw toepassing
Bijvoorbeeld
Stel, auto heeft de eigenschapskleur, en vertoont het gedrag ‘beweging’.
Een voorbeeld van de auto zou een Rode Volkswagen Kever zijn die 25 km/u rijdt.
Nu zou een statische eigenschap van de auto het aantal wielen (4) op de weg zijn, en dit zou voor alle auto’s gelden.
HTH
Antwoord 10
Voordat u een instantiemethode of instantievariabele aanroept, heeft deze een object (instantie) nodig. Wanneer de instantievariabele wordt aangeroepen vanuit de statische methode, weet de compiler niet bij welk object deze variabele hoort. Omdat statische methoden geen object hebben (slechts één kopie altijd). Wanneer u een instantievariabele of instantiemethoden aanroept vanuit de instantiemethode, verwijst deze naar het object this. Het betekent dat de variabele bij het gemaakte object hoort en dat elk object zijn eigen kopie van instantiemethoden en variabelen heeft.
Statische variabelen zijn gemarkeerd als static en instantievariabelen hebben geen specifiek trefwoord.
Antwoord 11
Het is ClassLoader die verantwoordelijk is voor het laden van de klassenbestanden. Laten we eens kijken wat er gebeurt als we onze eigen klassen schrijven.
Voorbeeld 1:
class StaticTest {
static int a;
int b;
int c;
}
Nu kunnen we zien dat de klasse “StaticTest” 3 velden heeft. Maar eigenlijk bestaat er geen b,c-lidvariabele. Maar waarom ???. Oké, eens kijken. Hier zijn b, c instantievariabele. Aangezien instantievariabele het geheugen krijgt op het moment dat het object wordt gemaakt. Dus hier krijgen b,c nog geen geheugen. Daarom bestaat er geen b,c. Er is dus alleen het bestaan van een.
Voor ClassLoader heeft het slechts één informatie over a. ClassLoader herkent b,c nog niet omdat het object nog niet is geïnstantieerd.
Laten we nog een voorbeeld bekijken:
Voorbeeld 2:
class StaticTest {
public void display() {
System.out.println("Static Test");
}
public static void main(String []cmd) {
display();
}
}
Als we nu proberen deze code te compileren, geeft de compiler een CE-fout.
CE: niet-statische methode display() kan niet worden verwezen vanuit een statische context.
Voor ClassLoader ziet het er nu als volgt uit:
class StaticTest {
public static void main(String []cmd) {
display();
}
}
In voorbeeld 2 is de CE-fout omdat we een niet-statische methode aanroepen vanuit een statische context. Het is dus niet mogelijk voor ClassLoader om de methode display() te herkennen tijdens het compileren. Er is dus een compileerfout opgetreden.
Antwoord 12
Dit is een beetje moeilijk om uit te leggen over statische trefwoorden voor alle beginners.
Je leert het duidelijk kennen als je meer met klassen en objecten werkt.
|*| Statisch: Statische items kunnen worden aangeroepen met Class Name
Als je in codes observeert, worden sommige functies direct aangeroepen met klassenamen zoals
NamCls.NamFnc();
System.out.println();
Dit komt omdat NamFnc en println worden gedeclareerd met het sleutelwoord static ervoor.
|*| Niet-statisch:Niet-statische items kunnen worden aangeroepen met klassevariabele
Als het niet statisch is, heb je een variabele van de klasse nodig,
zet een punt achter de klassevariabele en
bel dan functie.
NamCls NamObjVar = new NamCls();
NamObjVar.NamFnc();
Onderstaande code legt je netjes uit
|*| Statische en niet-statische functie in de klas:
public class NamCls
{
public static void main(String[] args)
{
PlsPrnFnc("Tst Txt");
NamCls NamObjVar = new NamCls();
NamObjVar.PrnFnc("Tst Txt");
}
static void PlsPrnFnc(String SrgPsgVal)
{
System.out.println(SrgPsgVal);
}
void PrnFnc(String SrgPsgVal)
{
System.out.println(SrgPsgVal);
}
}
|*| Statische en niet-statische klasse binnen een klasse:
public class NamCls
{
public static void main(String[] args)
{
NamTicCls NamTicVaj = new NamTicCls();
NamTicVaj.PrnFnc("Tst Txt");
NamCls NamObjVar = new NamCls();
NamNicCls NamNicVar = NamObjVar.new NamNicCls();
NamNicVar.PrnFnc("Tst Txt");
}
static class NamTicCls
{
void PrnFnc(String SrgPsgVal)
{
System.out.println(SrgPsgVal);
}
}
class NamNicCls
{
void PrnFnc(String SrgPsgVal)
{
System.out.println(SrgPsgVal);
}
}
}