Hoe definieert u wereldwijde variabelen in Java?
1, Autoriteit 100%
Om globale variabele te definiëren, kunt u gebruik maken van het statische trefwoord
public class Example {
public static int a;
public static int b;
}
Nu kunt u overal toegang krijgen tot A en B
door
te bellen
Example.a;
Example.b;
2, Autoriteit 18%
u niet. Dat is per ontwerp. Je zou het niet moeten doen, zelfs als je dat zou kunnen.
Dat gezegd hebbende, zou je een reeks openbare statische leden kunnen creëren in een klasse met de naam Global.
public class Globals {
public static int globalInt = 0;
///
}
Maar je zou echt niet moeten :). Serieus .. Doe het niet.
3, Autoriteit 15%
Een andere manier is om een interface als volgt te maken:
public interface GlobalConstants
{
String name = "Chilly Billy";
String address = "10 Chicken head Lane";
}
Elke klasse die ze moet gebruiken hoeft alleen de interface te implementeren:
public class GlobalImpl implements GlobalConstants
{
public GlobalImpl()
{
System.out.println(name);
}
}
4, Autoriteit 9%
U bent beter af met behulp van de afhankelijkheidsinjectie:
public class Globals {
public int a;
public int b;
}
public class UsesGlobals {
private final Globals globals;
public UsesGlobals(Globals globals) {
this.globals = globals;
}
}
Antwoord 5, autoriteit 5%
Veel goede antwoorden, maar ik wil dit voorbeeld geven omdat het door een andere klasse als de juistere manier wordt beschouwd om variabelen van een klasse te benaderen: met behulp van getters en setters.
De reden waarom je getters en setters op deze manier gebruikt in plaats van alleen de variabele openbaar te maken, is als volgt. Laten we zeggen dat je var een globale parameter zal zijn waarvan je NOOIT wilt dat iemand deze verandert tijdens de uitvoering van je programma (in het geval dat je code ontwikkelt met een team), zoiets als misschien de URL voor een website. In theorie kan dit veranderen en kan het vele malen in je programma worden gebruikt, dus je wilt een globale var gebruiken om alles in één keer te kunnen updaten. Maar je wilt niet dat iemand anders naar binnen gaat en deze var wijzigt (mogelijk zonder te beseffen hoe belangrijk het is). In dat geval neem je gewoon geen setter-methode op, en alleen de getter-methode.
public class Global{
private static int var = 5;
public static int getVar(){
return Global.var;
}
//If you do not want to change the var ever then do not include this
public static void setVar(int var){
Global.var = var;
}
}
6, Autoriteit 4%
Er is geen globale variabele in Java
Niettemin, wat we hebben is een statictrefwoord en dat is alles wat we nodig hebben.
Niets bestaat buiten de klas in Java. De staticTrefwoord vertegenwoordigt een klassenvariabele die, in tegenstelling tot een variabele, slechts één exemplaar heeft en die overstaat in alle gevallen van die klasse gemaakt, wat betekent dat de waarde ervan kan worden gewijzigd en toegankelijk is en in alle gevallen wordt geopend op elk moment.
Als u een globale variabele nodig heeft die toegankelijk is voor de scopes, dan is dit de variabele die u nodig heeft, maar de reikwijdte bestaat alleen waar de klasse is, en dat zal alles zijn.
7, Autoriteit 3%
Niets zou wereldwijd moeten zijn, behalve constanten.
public class MyMainClass {
public final static boolean DEBUGMODE=true;
}
Plaats dit binnen uw hoofdklasse. Gebruik het in andere .java-bestanden via:
if(MyMainClass.DEBUGMODE) System.out.println("Some debugging info");
Zorg ervoor dat wanneer u uw code van de vloer van de snijzaal beweegt en in de release wordt verwijderd of deze functionaliteit opmerkt.
Als u een werkhorre-methode hebt, zoals een randomizer, raad ik aan om een ”toolbox” -pakket te maken! Alle coders moeten er één hebben, wanneer u het in een .java wilt gebruiken, importeer het gewoon!
8, Autoriteit 2%
Er bestaat niet zoiets als een echt globale variabele in Java. Elke statische variabele moet behoren tot sommige klasse (zoals System.out), maar wanneer u hebt besloten welke klasse het zal binnengaan, kunt u naar het toewijzen van overal geladen door dezelfde klasserlader.
Merk op dat statische variabelen altijd moeten worden beschermd bij het bijwerken om racecondities te voorkomen.
9
public class GlobalClass {
public static int x = 37;
public static String s = "aaa";
}
Op deze manier kunt u ze openen met GlobalClass.xen GlobalClass.s
10
public class GlobalImpl {
public static int global = 5;
}
U kunt overal bellen die u wilt:
GlobalImpl.global // 5
11
Het probleem begrijpen
Ik beschouw de kwalificatie van globale variabele als een variabele die toegankelijk is en overal in de code is gewijzigd zonder te zorgen voor statisch / exemplaaroproep of een referentie van de ene klasse naar de andere.
Meestal als u een klasse A
hebt
public class A {
private int myVar;
public A(int myVar) {
this.myVar = myVar;
}
public int getMyVar() {
return myVar;
}
public void setMyVar(int mewVar) {
this.myVar = newVar;
}
}
en toegang wilt tot myvaren deze wilt bijwerken in een klasse B,
public class B{
private A a;
public void passA(A a){
this.a = a;
}
public void changeMyVar(int newVar){
a.setMyvar(newVar);
}
}
u moet een referentie hebben van een instantie van klasse A en de waarde in klasse B als volgt bijwerken:
int initialValue = 2;
int newValue = 3;
A a = new A(initialValue);
B b = new B();
b.passA(a);
b.changeMyVar(newValue);
assertEquals(a.getMyVar(),newValue); // true
Oplossing
Dus mijn oplossing hiervoor (zelfs als ik niet zeker weet of het een goede gewoonte is), is om een singleton te gebruiken:
public class Globals {
private static Globals globalsInstance = new Globals();
public static Globals getInstance() {
return globalsInstance;
}
private int myVar = 2;
private Globals() {
}
public int getMyVar() {
return myVar;
}
public void setMyVar(int myVar) {
this.myVar = myVar;
}
}
Nu kunt u de wereldwijde unieke instantie overal krijgen met:
Globals globals = Globals.getInstance();
// and read and write to myVar with the getter and setter like
int myVar = globals.getMyVar();
global.setMyVar(3);
Antwoord 12
Zoals je waarschijnlijk uit het antwoord afleidt, zijn er geen globale variabelen in Java en het enige wat je kunt doen is een klasse maken met statische leden:
public class Global {
public static int a;
}
U kunt het gebruiken met Global.aelders. Als u echter JAVA 1.5 of beter gebruikt, kunt u de import staticMagic gebruiken om het nog meer te laten zien als een echte wereldwijde variabele:
import static test.Global.*;
public class UseGlobal {
public void foo() {
int i = a;
}
}
en voilà !
Nu is dit verre van een beste praktijken, zodat je kunt zien in de commercials: Doe dit niet thuis
13
Er zijn geen wereldwijde variabelen in Java, maar er zijn wereldwijde klassen met openbare velden. U kunt statische importfunctie van Java 5 gebruiken om het er bijna als globale variabelen uit te zien.
14
Over het algemeen globale variabele (ik neem aan dat u het vergelijkt met C, CPP) definieert als public static final
zoals
class GlobalConstant{
public static final String CODE = "cd";
}
ENUMS zijn ook nuttig in een dergelijk scenario:
Bijvoorbeeld Calendar.JANUARY)
15
Een onafhankelijk bestand maken, bijv. Example.java om de 1e oplossing te gebruiken, is prima. Je kunt dat ook binnen de app doen, als b.v. De wereldwijde variabelen zijn speciaal voor uw huidige app, enz.:
Maak aan het begin een klasse en verklaar uw variabelen daar:
class Globals {
static int month_number;
static String month_name;
}
U kunt dan toegang krijgen tot deze variabelen – die ze gebruiken als ‘globals.month_number’, enz. – Van Averywhere in uw app.
16
Als u Wereldwoning wilt bijwerken, kan een eenvoudige Getter / Setter Wrapper-klasse worden gebruikt als globale variabele. Een typisch voorbeeld wordt hieronder weergegeven.
public class GlobalHolder {
private static final GlobalHolder INSTANCE = new GlobalHolder();
private volatile int globalProperty;
public static GlobalHolder getInstance() {
return INSTANCE;
}
public int getGlobalProperty() {
return globalProperty;
}
public void setGlobalProperty(int globalProperty) {
this.globalProperty = globalProperty;
}
public static void main(String[] args) {
GlobalHolder.getInstance().setGlobalProperty(10);
System.out.println(GlobalHolder.getInstance().getGlobalProperty());
}
}
17
Zeer eenvoudig:
class UseOfGlobal
{
private static int a;
private static int b;
}
Maar het is altijd goed om lokale variabelen in de methode-blokken in de methode te hebben waar het ook mogelijk is.
18
Wennen door het concept, globale variabelen, ook bekend als instantie variabele zijn de variabelen van de klasniveau, d.w.z., ze worden gedefinieerd in een klasse maar buitenmethoden. Om ze volledig beschikbaar te maken en ze direct het statische sleutelwoord te geven.
Dus als ik een programma schrijf voor eenvoudige rekenkundige werking en het vereist een cijferpaar, worden twee exemplaarvariabelen als zodanig gedefinieerd:
public class Add {
static int a;
static int b;
static int c;
public static void main(String arg[]) {
c=sum();
System.out.println("Sum is: "+c);
}
static int sum() {
a=20;
b=30;
return a+b;
}
}
Output: Sum is: 50
Bovendien stelt het gebruik van statische trefwoorden voorafgaand aan de instantievariabelen ons in staat om niet steeds opnieuw datatypes voor dezelfde variabelen op te geven. Schrijf de variabele gewoon rechtstreeks.
Antwoord 19
In het algemeen heeft Java geen globale variabelen. Behalve lokale variabelen, vallen alle variabelen onder het bereik van elke klasse die in het programma is gedefinieerd.
We kunnen statische variabelen hebben om het bereik van globale variabelen te hebben.
Antwoord 20
zonder staticis dit ook mogelijk:
class Main {
String globalVar = "Global Value";
class Class1 {
Class1() {
System.out.println("Class1: "+globalVar);
globalVar += " - changed";
} }
class Class2 {
Class2() {
System.out.println("Class2: "+globalVar);
} }
public static void main(String[] args) {
Main m = new Main();
m.mainCode();
}
void mainCode() {
Class1 o1 = new Class1();
Class2 o2 = new Class2();
}
}
/*
Output:
Class1: Global Value
Class2: Global Value - changed
*/
Antwoord 21
Object-Oriented Programmingis gebouwd met dien verstande dat de reikwijdte van variabelen nauw exclusief is voor het klasse-object dat deze variabelen inkapselt.
Het probleem met het maken van “Global Variables” is dat het geen industriestandaard is voor Java. Het is geen industriestandaard omdat het meerdere klassen mogelijk maakt om gegevens te manipuleren die asynycronized, als u een applicatie met meerdere schroefdraad gebruikt, krijgt dit een beetje ingewikkelder en gevaarlijk in termen van draadveiligheid. Er zijn verschillende andere redenen waarom het gebruik van globale variabelen niet effectief zijn, maar als u dat wilt vermijden, Suggereer je toevlucht tot Aspect-georiënteerde programmering .
ASPECT-georiënteerde programmering Ontkent dit probleem door de ouderklasse de leiding te geven over de reikwijdte door iets “Advices”, dat extra gedrag aan de code toevoegt zonder het daadwerkelijk te wijzigen. Het biedt oplossingen voor cross-snijproblemen of wereldwijde variabele gebruik.
lente is een Java-raamwerk dat gebruik maakt van AOP, en hoewel het traditioneel wordt gebruikt voor webtoepassingen, de kern Toepassing kan universeel worden gebruikt in het Java-raamwerk (13.0 inbegrepen). Dit kan een richting zijn die u meer wilt verkennen.
22
// Get the access of global while retaining priveleges.
// You can access variables in one class from another, with provisions.
// The primitive must be protected or no modifier (seen in example).
// the first class
public class farm{
int eggs; // an integer to be set by constructor
fox afox; // declaration of a fox object
// the constructor inits
farm(){
eggs = 4;
afox = new fox(); // an instance of a fox object
// show count of eggs before the fox arrives
System.out.println("Count of eggs before: " + eggs);
// call class fox, afox method, pass myFarm as a reference
afox.stealEgg(this);
// show the farm class, myFarm, primitive value
System.out.println("Count of eggs after : " + eggs);
} // end constructor
public static void main(String[] args){
// instance of a farm class object
farm myFarm = new farm();
}; // end main
} // end class
// the second class
public class fox{
// theFarm is the myFarm object instance
// any public, protected, or "no modifier" variable is accessible
void stealEgg(farm theFarm){ --theFarm.eggs; }
} // end class
Antwoord 23
Als u ongekwalificeerde toegang wilt verlenen aan statische leden van een andere klas, kunt u ook een statische import uitvoeren:
import static my.package.GlobalConstants;
Nu, in plaats van print(GlobalConstants.MY_PASSWORD);
je kunt de constante direct gebruiken: print(MY_PASSWORD);
Zie Wat betekent de “statische” modifier na “import” ?om over te beslissen.
En denk eens na over het antwoord van Evan Lévesque over interfaces om de constanten te dragen.
Antwoord 24
Om globale variabele te definiëren, kunt u gebruik maken van een statisch trefwoord
public final class Tools {
public static int a;
public static int b;
}
u hebt nu overal toegang tot a en b door te bellen
Tools.a;
Tools.b;
Je hebt gelijk…speciaal in J2ME…
U kunt NullPointerException vermijden door in uw MidLet-constructor te plaatsen
(proggy initialisatie) deze regel code:
new Tools();
Dit zorgt ervoor dat Tools worden toegewezen vóór elke instructie
die het gebruikt.
Dat is het!