# Globale Variablen



## Destiny1985 (30. Mai 2005)

Hi !

Gibt es globale Variablen wie in C++ auch in Java ? Wenn ich die Variablen vor den Main-Funktion deklariere, kommt er damit nicht zurecht und spuckt Fehler, in C++ geht das so aber einwandfrei. Was muss ich tun, um auch in Java das zu erreichen ?

mfg

[-edit-]

So soll es funktionieren


```
import java.io.*;

public class Schuldentilgung
{
  double kreditbetrag = 10000, zinssatz = 5, annuitaet = 1200, zinsen,
         restschuld, zinssumme = 0, abtrag, rueckzahlsumme;

  public static void main (String[] args)
  {
    zinssatz = 10;
  }
}
```

Aber beim Zugriff auf Zinssatz meckert er mir dann


```
non-static variable zinssatz cannot be referenced from a static context
```

[/-edit-]


----------



## Sky (30. Mai 2005)

Ich würde Dir empfehlen pack die Variablen, die 'überall' verfügbar sein sollen entweder in die System-Properties oder in ein Interface (m.E. die bessere Alternative)


----------



## Destiny1985 (30. Mai 2005)

sky80 hat gesagt.:
			
		

> ...oder in ein Interface (m.E. die bessere Alternative)



Und wie soll das funktionieren ? Kann damit momentan nichts anfangen...


----------



## Sky (30. Mai 2005)

Zuerst definierst Du das Interface:

```
interface myConst {
 public String string = "string";
 public int i = -1;
}
```

und nun kannst darauf zugreifen, wenn das Interface importiert wird mittels:

```
String s = myConst.string;
int i = myConst.i;
```

Wenn Du Java 5.0 benutzt, dann guck Dir zusätzlich mal das Konzept der 'static imports' an.


----------



## Destiny1985 (30. Mai 2005)

Danke schön, werd das gleich mal probieren.

mfg


----------



## Sky (30. Mai 2005)

Ok, nachdem Du deinen Code oben eingefügt hast, ist das Problem klar! So sollte es gehen:


```
import java.io.*; 

public class Schuldentilgung { 
  double kreditbetrag = 10000, zinssatz = 5, annuitaet = 1200, zinsen, 
         restschuld, zinssumme = 0, abtrag, rueckzahlsumme; 

  public Schuldentilgung {
    zinssatz = 10; 
  }

  public static void main (String[] args) { 
    new Schuldentilgung();
  } 
}
```


----------



## Destiny1985 (30. Mai 2005)

Ok, mein Code sieht aus wie folgt


```
import java.io.*;

interface myConst
{
   public int i = -1;
}

public class Schuldentilgung
{
    int i = myConst.i;

  public static void main (String[] args)
  {
     System.out.println(i);
  }

}
```

was mache ich falsch ? Fehlermeldung bleibt dieselbe wie oben bereits gepostet...

mfg


----------



## Sky (30. Mai 2005)

Siehe mein Post oben! Das hat nichts mit global oder nicht global zu tun! Du versucht in einer statischen Methode (main) auf nicht-statische Eigenschaften der Klasse Schuldentilgung zuzugreifen. Das geht aber nicht!


----------



## Destiny1985 (30. Mai 2005)

sky80 hat gesagt.:
			
		

> ```
> import java.io.*;
> 
> public class Schuldentilgung {
> ...



Wenn ich den Code compiliere sagt er mir bei


```
public Schuldentilgung -> <identifier> expected
```

Und in Zeile 26 sagt er mir das ihm ein ; fehlt (lol wo denn da, in Zeile 26 steht nämlich nur ein })


----------



## Sky (30. Mai 2005)

Hatte den Code nicht getestet... und im Eifer des Gefechtes die Klammern beim Konstruktor vergessen!

Es muss heißen:

```
public Schuldentilgung() {
```


----------



## stev.glasow (30. Mai 2005)

"""public Schuldentilgung { """
zu """public Schuldentilgung() { "" ändern.

Und schau dir mal an was static bedeutet.


----------



## Destiny1985 (30. Mai 2005)

Naja ok funktioniert jetzt, aber wenn ich mir jetzt ein Programm baue mit 10 Variablen, die sich während der Laufzeit mehrmals ändern, dann kann man das doch so nicht realisieren oder ? Wäre ja dann ein riesiger Umfang ? oder steige ich immer noch nicht durch


----------



## Sky (30. Mai 2005)

Ich verstehe dein Problem nicht! Warum kannst du nicht 10 Variablen zur Laufzeit ändern??


```
Var1 = xxx;
Var2 = xyz;
```

Wo ist denn da der riesige Umfang????? Wenn Du 10 Werte ändern willst so mußt Du dafür 10 Anweisugen schreiben!


----------



## Destiny1985 (30. Mai 2005)

Ich gehe erstmal was essen, dann schau ich mir das nochmal an  Bin gerade etwas angeschlagen 

danke für die hilfe

mfg


----------



## bygones (30. Mai 2005)

Ein Interface als Konstanten - Bank... AUTSCH !!!

Ist nicht der Sinn und Zweck eines Interfaces.... Big NO NO


----------



## Destiny1985 (30. Mai 2005)

deathbyaclown hat gesagt.:
			
		

> Ein Interface als Konstanten - Bank... AUTSCH !!!
> 
> Ist nicht der Sinn und Zweck eines Interfaces.... Big NO NO



hm...wie denn dann death ?


----------



## Sky (30. Mai 2005)

deathbyaclown hat gesagt.:
			
		

> Ein Interface als Konstanten - Bank... AUTSCH !!!
> 
> Ist nicht der Sinn und Zweck eines Interfaces.... Big NO NO


Was ist daran "NO NO". Das ist gängige Praxis... guck Dir doch mal die Klasse (oder besser das Interface!) SwingConstants an.


----------



## stev.glasow (30. Mai 2005)

Bei Konstanten ist es ja auch ok, aber hier nicht.
Im Normalfal sind doch nicht konstante, globale Variable schied - und wenn sie nicht private sind so wieso. Meine Meinung.
[edit]



			
				deathbyaclown hat gesagt.:
			
		

> Ein Interface als Konstanten - Bank... AUTSCH !!!
> Ist nicht der Sinn und Zweck eines Interfaces.... Big NO NO


Achso - ops, es ging ja um Konstanten   :autsch: *verpeiltGuck

Also Konstanten im Interface finde ich auch ok. 

[edit]
Ich bins noch mal - bin etwas verpeilt heute früh. Das muss ich aber noch los werden  



> ```
> interface myConst {
> public String string = "string";
> public int i = -1;
> ...


Konstanten macht man final und unter globale Variable verstehe ich eine öffentlich statische.


----------



## Sky (30. Mai 2005)

stevg hat gesagt.:
			
		

> Konstanten macht man final und unter globale Variable verstehe ich eine öffentlich statische.


Hast recht, ich hab da ein final (bzw. zwei) vergessen.


----------



## stev.glasow (30. Mai 2005)

und 'static'  :meld:


----------



## Sky (30. Mai 2005)

stevg hat gesagt.:
			
		

> und 'static'  :meld:


Warum müssen die auch static sein??

Der Zugriff ist doch bei beiden möglich:
	
	
	
	





```
interface myConst {
  public final        String string1 = "string1";
  public final static String string2 = "string2";
}
```
 egal, ob ich in einer statischen oder nicht-statischen Methode bin...


----------



## AlArenal (30. Mai 2005)

static weil:
Wenn du das Interface mal implementierst sparste Ressourcen, weil die Instanzen der Klasse nicht jeder ihre eigenen Konstanten mitschleppen, obwohl diese für jede Instanz gleich sind..


----------



## Sky (30. Mai 2005)

AlArenal hat gesagt.:
			
		

> static weil:
> Wenn du das Interface mal implementierst sparste Ressourcen, weil die Instanzen der Klasse nicht jeder ihre eigenen Konstanten mitschleppen, obwohl diese für jede Instanz gleich sind..


Ok... ich hatte bisher immer auf ein 'implements' verzichtet und per INTERFACE.VAR darauf zugegriffen... klingt aber so äußerst logisch.


----------



## stev.glasow (30. Mai 2005)

sky80 hat gesagt.:
			
		

> stevg hat gesagt.:
> 
> 
> 
> ...



Das wusse ich nicht, bisschen ihh sieht es aber aus.


----------



## Destiny1985 (30. Mai 2005)

Ich komm mit Interfaces mal gar nicht klar...verstehe den ganzen Ansatz irgendwie nicht...habe jetzt den Code


```
import java.io.*;

public class Schuldentilgung
{
  double kreditbetrag = 10000, zinssatz = 5, annuitaet = 1200, zinsen,
         restschuld, zinssumme = 0, abtrag, rueckzahlsumme;

  public Schuldentilgung()
  {
    zinssatz = 10;
  }

  public static void main (String[] args)
  {
    new Schuldentilgung();
  }
}
```

Die zuweisung zinssatz = 10; scheint zu klappen, aber sobald ich in main eine Zeile einfüge


```
System.out.println(zinssatz);
```

meckert er sofort wieder "non-static variable zinssatz cannot be referenced from a static context"

Ist das schon OO oder wieso kenne ich das alles noch nicht ? Sowas kam bisher nirgends dran, daher bin ich auch relativ ratlos !

Was bringt mir der Aufruf von new Schuldentilgung(); (und wieso new). und wieso muss ich das aufrufen, das ding ändert doch nur den wert von zinssatz...wie mache ich es, wenn der benutzer den wert eingeben soll ? Und wieso komme ich im main nicht an den wert ran ?`muss ich da immer alles hin und her übergeben ? und was zum teufel hat es mit dem static auf sich :/

fragen über fragen....


----------



## stev.glasow (30. Mai 2005)

stevg hat gesagt.:
			
		

> Und schau dir mal an was static bedeutet.


----------



## bygones (30. Mai 2005)

Interface sind Schnittstellen. Sie definieren ein Verhalten einer Klasse sodass unabhängig von ihrer Implementierungen andere Klassen die Schnittstelle nutzen können.

Eine reine Konstantenbank als Interface widerspricht dem Sinn und Zweck eines Interfaces ! Klar hat Sun die SwingConstants als Interface definiert, aber Falsches macht das noch nicht Richtig.

Aus meiner Sicht ist das einfach "Missbrauch". Und dann noch per implements - da sträuben sich mir alle Java Haare am Körper.

Nein - für mich ist das Pfui und ich will auch sowas in Programmen nicht sehen.

Für Konstanten
1. Properties datei
2. final class von mir aus auch


----------



## AlArenal (30. Mai 2005)

Wo er Recht hat, hat er Recht. Stilistisch ist es natürlich schweres Pfui ein Interface alleine für Konstanten zu verwenden.


----------



## stev.glasow (30. Mai 2005)

Und was sagt ihr zu sachen wie javax.swing.Action.
Ich bin auch der Meinung, dass man sich auch welche in nicht final Klassen halten kann. Ist doch auch Gang und Gebe.
Oder reden wir an einander vorbei? Ich reden von static Konstanten allgemein nicht nur von irgendwelchem Propertyzeugs.


----------



## Destiny1985 (30. Mai 2005)

back 2 topic plz


----------



## Sky (30. Mai 2005)

stevg hat gesagt.:
			
		

> Und was sagt ihr zu sachen wie javax.swing.Action.
> Ich bin auch der Meinung, dass man sich auch welche in nicht final Klassen halten kann. Ist doch auch Gang und Gebe.
> Oder reden wir an einander vorbei? Ich reden von static Konstanten allgemein nicht nur von irgendwelchem Propertyzeugs.


 Action ist doch auch ein Interface, wenn ich nicht irre!?

Außerdem: Hier wird das Wort 'interface' immer als 'Schnittstelle' übersetzt. Das ist aber eine unvollständige Übersetzung. Ein 'interface' kapselt nämlich die Gemeinsamkeiten zwischen Klassen, die keine Beziehungen zu einander haben. Und somit gehören dazu IMHO auch Konstanten.


----------



## stev.glasow (30. Mai 2005)

eben, bin ganz deiner Meinung.


----------

