# Globale Klassenvariablen.



## Decca (4. Nov 2006)

Hallo,

ich steige gerade von C++ zu Java um. In C++ war es möglich globale Objekte zu erzeugen:


```
class CBestand
{

	short sWert;		
	short sAnzahl; 
	
	short sGetWert(){return sWert;} //Methode gibt den Wert aus
	void  vSetWert(short x){sWert=x;}	//Methode speichert neuen Wert
	
	short sGetAnzahl(){return sAnzahl;}	//gibt die Anzahl aus
	void  vSetAnzahl(short x){sAnzahl=x;}	//speichert neu eingegebene Anzahl
	
	void  vIncrAnzahl(){sAnzahl++;}		//inkrementiert die Anzahl
	void  vDecrAnzahl(){sAnzahl--;}		//dekrementiert die Anzahl

}

CBestand WarenBestand[5];     // Datenobjekt Global
```

Ich konnte dann in einer anderen Klasse z.B. WarenBestand[0].vSetWert(5); aufrufen...

Wie löse ich dieses Problem in Java? Das Objektfeld soll in allen Klassen abgefragt und verändert werden. Ich habe schon mit Klassenvariablen hantiert. Aber ich brauche so etwas wie ein Klassenobjekt.

Danke für Hilfe


----------



## The_S (4. Nov 2006)

mit Gettern und Settern. Sprich du musst deine Methoden public machen.


----------



## Leroy42 (4. Nov 2006)

Am elegantesten ist ein Interface:


```
public interface Global {
  static int TheGlobalVariable = 42;
}
```

Und alle interessierten Klassen _implementieren_ dieses Interface:


```
class KlasseClass implements Global {
  int myInitialInt = TheGlobalVariable;
}
```

Aber als gutes Design würde ich das nicht empfehlen;
lerne lieber auf soetwas wie _globale Variablen_
überhaupt zu verzichten.


----------



## Wildcard (4. Nov 2006)

Wegen Variablen implementiert man keine Interfaces.


----------



## Decca (4. Nov 2006)

Hallo nochmal.

Danke für die Antworten.

Aber mir ist noch nicht klar wie ich mir von der Klasse ein Objekt(feld) z.B. CBestand WarenBestand[5]; erstellen kann, welches in allen Klassen verwendet werden kann.
Wenn ich die Methoden public mache brauche ich doch trotzdem ein Objekt welches die Methoden dann aufruft 
(Objekt[0] .sGetWert).  

@Leroy42 
Wenn ich ein Interface benutze muss ich doch alle Methoden aus dem Interface in einer konkreten Klasse wieder überschreiben oder? 
Andere frage wie kriege ich mittels Interface ein Obj. hin womit O[0].Methode aufrufen kann?

Gruß


----------



## Beni (4. Nov 2006)

Ich denke, du suchst das Schlüsselwort "static":

So wird eine statische Methode (Variable, ...) definiert:

```
public class Irgendwas{
  public static int tuwas( String x ){
    return ... // irgendwas was halt aus x berechnet wird
  }
}
```

Und an einer beliebigen Stelle in einer anderen Klasse kannst du schreiben:

```
public class Nirgendwo{
  public void mampf(){
    // Zugriff auf die statische Methode "tuwas", ohne dass
    // ein "Irgendwas"-Objekt benötigt wird.
    int wert = Irgendwas.tuwas( "abc" );
  }
}
```


----------



## Decca (4. Nov 2006)

Ahh mit static habe ich schon gearbeitet, sind ja sogenante Klassenvariablen... Bei mir hat es nicht funktioniert weil ich die Klasse bzw. die Methoden zusätzlich noch mit public bezeichnen muss. Das werde ich mal probieren, danke.


----------



## Decca (4. Nov 2006)

Ok noch eine Sache:


```
public class Irgendwas{

static int irgandwann;
static int irgandwo;
static int irgandwie;


  public static int tuwas( String x ){
    return irgendwie // irgendwas was halt aus x berechnet wird
  }
}
```

wenn ich jetzt die drei Klassenvariablen habe (static int irgendw...), wie kann ich dann ein Feld anlegen wo ich die Sachen bündele:  int wert = Irgendwas.*Feld[0]*.tuwas( "abc" );


```
public class Nirgendwo{
  public void mampf(){
    // Zugriff auf die statische Methode "tuwas", ohne dass
    // ein "Irgendwas"-Objekt benötigt wird.
    int wert = Irgendwas.Feld[0].tuwas( "abc" );
  }
}
```

Ich brauche dieses Feld weil ich z.B. 10 Waren brauche die alle unterschiedliche Eigenschaften haben, halt irgendwann, irgendwo... 
[/b]


----------



## Wildcard (4. Nov 2006)

Ich bin mir nicht ganz sicher ob ich dir folgen kann...
Meinst du vielleicht etwas in Richtung enum?

Es würde allerdings helfen wenn du den größeren Kontext das Problems erläutern könnte, dann können wir dir sicherlich eine OOP Lösung anbieten.


----------



## Decca (4. Nov 2006)

Ok dann muss ich noch einmal den Code vom C++ Programm zeigen, anders kann ich das sonst nicht erklären, sorry.


```
class CBestand
{

   short sWert;      
   short sAnzahl;
   
   short sGetWert(){return sWert;} //Methode gibt den Wert aus
   void  vSetWert(short x){sWert=x;}   //Methode speichert neuen Wert
   
   short sGetAnzahl(){return sAnzahl;}   //gibt die Anzahl aus
   void  vSetAnzahl(short x){sAnzahl=x;}   //speichert neu eingegebene Anzahl
   
   void  vIncrAnzahl(){sAnzahl++;}      //inkrementiert die Anzahl
   void  vDecrAnzahl(){sAnzahl--;}      //dekrementiert die Anzahl

}

CBestand WarenBestand[5];     // Datenobjekt Global
```

jetzt habe ich doch mehrere Objekte der Klasse CBestand (CBestand WarenBestand[5]; )
so jetzt möchte ich in anderen Klassen z.B.:



```
class Ctuwas
{

int x=WarenBestand[0].sGetWert();
int y=WarenBestand[1].sGetWert();
int z=WarenBestand[2].sGetWert();
...

}
```

nun z.B. in einer ganz anderen Klasse


```
class Cganzanders
{

int x=WarenBestand[0].sGetAnzahl();
int y=WarenBestand[1].sGetAnzahl();
int z=WarenBestand[2].sGetAnzahl();
...

}
```

so letztes Bsp. eine Klasse wo ich was ändern...


```
class Cganzanders
{

int x=WarenBestand[0].vSetAnzahl(1)
int y=WarenBestand[1].vSetAnzahl(2)
int z=WarenBestand[2].vSetAnzahl(3)
...

}
```

so ich hoffe ich habe mich verständlicher ausdrücken können.[/code]


----------



## Wildcard (4. Nov 2006)

Mach dir doch einfach eine Klasse die deine Werte kapselt.
Dann erzeugst du ein Array vom Typ dieser Klasse und greifst darauf zu.
Ist doch im prinzip genau das gleiche wie bei C++...
Veilleicht versteh ich's aber auch immer noch nicht


----------



## Beni (4. Nov 2006)

Das kannst du mit einem statischen Array lösen:

```
public class Irgendwas{
  public static Irgendwas feld[];

  // statischer "Konstruktor", wird aufgerufen wenn 
  // die Klasse geladen wird
  static{
    feld = new Irgendwas[5];
    for( int i = 0; i < feld.length; i++ ){
      // in Java das initialisieren der Elemente nicht vergessen!
      feld[i] = new Irgendwas( i, "abc", 123 );
    }
  }

  // ab hier sind keine Klassenvariablen oder
  // -Methoden mehr notwendig (im Gegenteil, es
  // hätte ziemlich böse Nebeneffekte...)
  private int x;
  public void setX( int x ){
    this.x = x;
  }
}
```

Und an einer anderen Stelle:

```
public class Nirgendwo{
  private void mampf(){
    Irgendwas.feld[4].setX( 456 );
  }
}
```


----------



## Decca (4. Nov 2006)

Ok das sieht gut aus. Probleme kommen ja beim Programmieren  . Ich werde das jetzt mal testen.


----------

