# Konstanten in Java



## .maik. (15. Sep 2010)

Hi @ all.
Diese Frage quält mich schon länger:
Wieso muss die zum Beispiel vordefinierte Farbe Color.WHITE nicht deklariert werden. Zum Beispiel setzeFarbe(...) Der Parameter erwartet doch ein Objekt. Wieso muss dann Color.WHITE vorher nicht erzeugt und deklariert werden? Oder werden beim Laden der Klasse Color auch schon die vordefinierten Farben mitgeladen und so auch zugänglich gemacht?

Danke für eure Hilfe, bin noch ein Anfänger auf dem Java Gebiet.

Maik


----------



## pl4gu33 (15. Sep 2010)

also du meinst jetzt zum Beispiel hier:


```
this.setForeground(Color.WHITE);
```

dieses Color White ist schon deklariert als Static in :
java.awt.Color;

was dein Eclipse z.b. automatisch importet

siehe auch: Color (Java 2 Platform SE v1.4.2)


----------



## .maik. (15. Sep 2010)

danke für die schnelle antwort.
aber das mit der eclipse verstehe ich nicht. also werden die konstanten in der klasse color schon deklariert?


----------



## pl4gu33 (15. Sep 2010)

.maik. hat gesagt.:


> danke für die schnelle antwort.
> aber das mit der eclipse verstehe ich nicht. also werden die konstanten in der klasse color schon deklariert?



jop,... als static darum kannst du sie ja dann so adden wie Color.White,... das mit Eclipse meinte ich nur nebenbei, dass wenn man Color.White schreibt Eclipse automatisch die Klasse importiert zumindest bei mir so,... dass man das nicht selber schreiben muss also den Import-Befehl,... aber ist auch nur nebenläufig und für deine Frage net wichtig 

hier siehst du wie gesagt alle vorgegebenen Farben und dort gibts auch noch mehr Infos:

Color (Java 2 Platform SE v1.4.2)


----------



## .maik. (15. Sep 2010)

jetzt habe ich es verstanden.danke


----------



## Final_Striker (15. Sep 2010)

Wenn die in den Sourcecode der Klasse Color schaust, dann sieht du da:


```
/**
     * The color white.  In the default sRGB space.
     */
    public final static Color white     = new Color(255, 255, 255);

    /**
     * The color white.  In the default sRGB space.
     * @since 1.4
     */
    public final static Color WHITE = white;

    /**
     * The color light gray.  In the default sRGB space.
     */
    public final static Color lightGray = new Color(192, 192, 192);

    /**
     * The color light gray.  In the default sRGB space.
     * @since 1.4
     */
    public final static Color LIGHT_GRAY = lightGray;

    /**
     * The color gray.  In the default sRGB space.
     */
    public final static Color gray      = new Color(128, 128, 128);

    ...
    ...
    ...
```


----------



## .maik. (17. Sep 2010)

aber das sind doch jeweils Klassenvariablen oder? und die werden dann beim importieren der Klasse mit eingefügt. 
und in deinem code..  was bedeutet das new? das wird doch nur beim erzeugen von objekten verwendet, oder nicht?


----------



## Java-Freak (17. Sep 2010)

> und die werden dann beim importieren der Klasse mit eingefügt.


das importieren erzeugt weder eine instanz von der klasse noch fügt es variablen in die klasse ein
wenn du besipielsweise die klasse java.awt.Color importierst dann sagst du deinem programm lediglich das wenn du in deinem programm Color schreibst damit java.awt.Color meinst. du könntest auch immer java.awt.Color.WHITE schreiben und müsstest gar nichts importieren...

Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 6.3 Statische Methoden und statische Attribute
les dir das mal durch vllt auch das ganze kapitel


----------



## .maik. (17. Sep 2010)

ja. in diesem kapitel verstehe ich vieles nciht weil ich noch ein echter Anfänger bin und momentan ein anderes buch lese. Also wenn ich jetzt zum Beispiel Objekt.setzeFarbe(Color.BLUE); schreibe, dann greift der auf die Klasse Color.awt zu und sucht nach der Definition. Und das static bedeutet, dass die Variable oder Methode objekt unabhängig ist.
ist jetzt alles richtig?


----------



## klein-odd (17. Sep 2010)

Lieber maik,
du kannst Dir beliebige Farbe selbst definieren.
Ob zum Einstellen des Vordergrundes (setForeground) oder Hintergrundes (setBackgroud),
sind es immer Instanzen der Klasse Color (java.awt.Color).

Eclipse schlägt beim Codeschreiben nur vor,  was schon vordefiniert ist.

Jede Farbe ist doch klarerweise aus 3 Anteilen zusammengesetzt : 
- aus rot
- aus grün
- aus blau,

jeweils als eine ganze Zahl zwischen 0 und 255 einzugeben.

Du kannst Dir eine Farbe selbst erstellen ( mischen ), 
wenn Du die 3 Anteile bestimmst, beispeilsweise 

```
int myRed  = 10;
int myGreen = 45;
int myBlue = 99;
//dann kannst Du eine Farbe aus den 3 Anteilen zusammenmischen
//in dem Du eine Instanz der Klasse Color zuammenbaust :

Color myColor = new Color(myRed,myGreen,myBlue);

//was soviel bedeutet und bewirkt, wie

Color myColor = new Color(10,45,99);

//dies kannst Du so ablesen : dass Du eine Instanz der Klasse Color erstellst
//und myColor nennst. Als Eingangsparameter übergibst Du die 3 Anteile.
//Du kannst Dir es sehr erleichtern,  
//wenn Du "fertig gebackene" Hilfsliteratur benutzt :
//z.B.API, die Du als gezipptes html. Dokument
//von der Java- Download Siete herunterlädst
```

das new steht für "neue Instanz".
Die neue Instanz heisst myColor und soll aus 
den 3 Eingangsparametern konstruiert werden :
myRed, myGreen, myBlue;

Damit Du Instanz konstruieren kannst, reicht folgende ImportZeile aus:


```
import java.awt.*;
```

Die neu konstruierte Farbe kannst Du beispielsweise so verwenden :


```
//konstruietre einen Schaltknopf als Instanz der Klasse JButton

JButton button = new JButton("START");

//als Eingangsparameter gib hier die Knopfbeschriftung ein  : START;

//ertelle eine VordergrúndFarbe

int r = 10;
int g = 30;
int b = 99;

Color schriftfarbe = new Color(r,g,b);

//ertelle eine HinterergrundFarbe

int R = 210;
int G = 10;
int B = 19;

Color schaltflaechenfarbe = new Color(R,G,B);

//vergib dem Knopf eine Vordergrundbarbe

button.setForeground(schriftfarbe);

//vergib dem Knopf eine Hintergrundfarbe

button.setForeground(schaltflaechenfarbe);

//setzt den Konpf dorthon, wo Du ihn brauchst mit .add(button);
```
Die Vorschäge von Eclipse kannst Du mit solchen selbst erstellten Werten ersetzen.

Color.red,Color.green,Color.blue,Color.black,Color.white u.s.w sind schon vorkonstruierte Farben,
die jeweils aus den 3 Anteilen zusammengesetzt sind. 

Viel Spaß !


----------



## .maik. (17. Sep 2010)

das selbstmischen verstehe ich auch, aber jetzt sind wir wieder bei meinem anfangsproblem und zwar erzeugt man ja objekte in das klasse color.awt und manche sind schon vordefiniert. wenn ich jetzt die klasse importiere und eine vordefinierte farbe benutze, dann muss ich die farbe vorher nicht deklarieren und erzeugen. Das wundert mich so , weil es ja eig eine Instanz ist. Ist jetzt meine Frage klar ?
 DANKE


----------



## klein-odd (17. Sep 2010)

ich vermute, dass ich weiss, wonach Du Fragst.

die Vorschläge von Eclipse kannst Du immer überscheriben.


```
//z.B. als Vordergrund eines Konpfes 

JButton button = new JButton("KNOPF");

//hier wird die Beschriftung rot von der fertzigen Packung verwendet : 

button.setForeground(Color.red); 

//statt der roten Farbe (Color.red),
//kannst Du Dir eine sonst-noch rote Farbe zusammenmischen :

Color myRed = new Color((250,20,20);

//die Vorschläge von Eclipse mit Deiner Farbe ersetzen :

button.setForeground(myRed);
```

Oder brauchst Du einen Beispielcode fürs Spielen mit Farben an einem Knopf oder Label ?

Das kann ich erst in der nächsten Woche liefern

Es gibt auch ein deutsches Meisterwewerk 
zur JAVA Programmierung, geschrieben von GUIDO KRÜGER
man kann es online betrachten, 
man kann es auch frei herunterladen. 
Den Titel merke ich nicht mehr.
Versuch' dann nach GUIDO KRÜGER JAVA zu googeln

Gruss

PS. Jedenfalls bin ich offen für Deine Worte


----------



## .maik. (17. Sep 2010)

ja trifft meine Frage nicht wirklich.
ich bin wie gesagt noch ein echter Anfänger und habe noch keine Klassen selbst geschrieben. ich zeige euch mal meinen code:

[JAVA=42]
import sum.kern.*;
import sum.werkzeuge.*;
/**
 * @author Maik Aßhoff
 * @version 17.09.10
 */
public class himmel
{
    // Objekte
    Bildschirm derBildschirm;
    Buntstift meinBuntstift;
    Rechner meinRechner;
    Maus dieMaus;

    // Konstruktor
    public himmel()
    {
        derBildschirm = new Bildschirm(0, 0, 1800, 700);
        meinBuntstift = new Buntstift();
        meinRechner = new Rechner();
        dieMaus = new Maus();
    }

    // Dienste
    public void fuehreAus()
    {
        // Aktionsteil


        while(!dieMaus.doppelKlick())
        {
            meinBuntstift.hoch();
            meinBuntstift.bewegeBis(meinRechner.ganzeZufallszahl(0, derBildschirm.breite()),
                                meinRechner.ganzeZufallszahl(0, derBildschirm.hoehe()));
            switch(meinRechner.ganzeZufallszahl(0, 4))
            {
                case 0: meinBuntstift.setzeFarbe(Farbe.BLAU); break;
                case 1: meinBuntstift.setzeFarbe(Farbe.SCHWARZ); break;
                case 2: meinBuntstift.setzeFarbe(Farbe.GELB); break;
                case 3: meinBuntstift.setzeFarbe(Farbe.ROT); break;
                case 4: meinBuntstift.setzeFarbe(Farbe.HELLGRAU); break;
            }
            meinBuntstift.runter();
            meinBuntstift.zeichneKreis(2);
        }

        // Aufraeumen
        dieMaus.gibFrei();
        meinRechner.gibFrei();
        meinBuntstift.gibFrei();
        derBildschirm.gibFrei();
    }
}
[/code]

Dieses Programm erstellt verschieden farbige Kreise an verschiedenen Orten. Das ist ja eig egal. Meine Frage ist jetzt: Warum muss ich zum Beispiel bei  meinBuntstift.setzeFarbe(Farbe.GELB); nicht Farbe.Gelb vorher in dieser Klasse deklarieren und erzeugen, so habe ich es doch bei jedem anderen Objekt auch gemacht. Das mit dem Mischen habe cih verstanden. Nur das eine verstehe ich nicht. Kann mir da jetzt bitte einer die entgültige Erklärung geben. 

Danke


----------



## Atze (17. Sep 2010)

final_striker hat dir doch einen auszug aus den Color-sourcen geposted!
da steht zb.:

```
/**
     * The color white.  In the default sRGB space.
     */
    public final static Color white     = new Color(255, 255, 255);
 
    /**
     * The color white.  In the default sRGB space.
     * @since 1.4
     */
    public final static Color WHITE = white;
```

also ist die variable "white" eine referenz auf ein objekt "new Color(255, 255, 255);"

das uppercase "WHITE" (eine statische konstante (final static), und konstanten werden nach java-konvention im uppercase geschrieben) verweist auf dieses "white"

da das statische konstanten sind, kannst du sie mit über Color.WHITE direkt verwenden!


----------



## Java-Freak (17. Sep 2010)

.maik. hat gesagt.:


> ja. in diesem kapitel verstehe ich vieles nciht weil ich noch ein echter Anfänger bin und momentan ein anderes buch lese. Also wenn ich jetzt zum Beispiel Objekt.setzeFarbe(Color.BLUE); schreibe, dann greift der auf die Klasse Color.awt zu und sucht nach der Definition. Und das static bedeutet, dass die Variable oder Methode objekt unabhängig ist.
> ist jetzt alles richtig?


nein, weil es die klasse java.awt.Color ist und nicht Color.awt
static bedeutet das die methode/variable objekt(instanz) unabhängig ist das ist richtig


----------



## klein-odd (18. Sep 2010)

Hallo maik,
jetzt bin ich etwa in der Eile

aber ich werde Dir spätestens am Dienstag eine ausführiche Antwort schreiben.

Kurz erläutert:
damit Du in Eclipse irgendetwas importierst,
müssen es statische Variablen oder Methoden sein.
Wären die vordefinierten Farben der Klasse Color nicht als
static modifiziert, hätte die Eclipse sie nicht vorgeschlagen und Du hättest sie nicht gesehen.

Man könnte neben den bekannten Variablen, 
oder besser ausgedrückt : Instanzen der Klasse Color auch viele sonst deklarieren.

Zb neben red, blue, green, black, white 
auch redPink, treeBrown, skyBlue und sonstige Farben definieren.

So hätte es auszusehen

```
public class Color
{
     static Color red = new Color(anteilRotImRoten, anteilGrünImRoten, anteilBlauImRoten);
     static Color blue = new Color(anteilRotImBlauen, anteilGrünImBlauen, anteilBlauImBlauen);
     static Color green = new Color(anteilRotImGruenen, anteilGrünImGruenen, anteilBlauImGruenen);
     static Color black = new Color(anteilRotImSchwarzen, anteilGrünImSchwarzen, anteilBlauImSchwarzen);
     static Color white = new Color(anteilRotImWeissen, anteilGrünImWeissen, anteilBlauImWeissen);

     public Color(int anteilRot, anteilGruen, anteilBlau)
     {}

//Methoden

      static int getRed(Color color)
      { 
          return anteilRot;
      }
      static int getGreen(Color color)
      { 
          return anteilGruen;
      }
      static int getBlue(Color color)
      { 
          return anteilBlau;
      }
}
```

alle hier gezeigten Variablen und Methoden wind für einen Eclipse-Benútzer sichtbar. Sie sind durch den Modifikator static gekennzeichnet.

Aber schau mal hierunter, da sind einige Zeilen mehr geschrieben :


```
public class Color
{
     static Color red = new Color(anteilRotImRoten, anteilGrünImRoten, anteilBlauImRoten);
     static Color blue = new Color(anteilRotImBlauen, anteilGrünImBlauen, anteilBlauImBlauen);
     static Color green = new Color(anteilRotImGruenen, anteilGrünImGruenen, anteilBlauImGruenen);
     static Color black = new Color(anteilRotImSchwarzen, anteilGrünImSchwarzen, anteilBlauImSchwarzen);
     static Color white = new Color(anteilRotImWeissen, anteilGrünImWeissen, anteilBlauImWeissen);
      
     Color redPink= new Color(anteilRot, anteilGruen, anteilBlau);
     Color treeBrown  = new Color(anteilRot, anteilGruen, anteilBlau);
     Color skyBlue  = new Color(anteilRot, anteilGruen, anteilBlau);


     public Color(int anteilRot, anteilGruen, anteilBlau)
     {}

//Methoden

      static int getRed(Color color)
      { 
          return anteilRot;
      }
      static int getGreen(Color color)
      { 
          return anteilGruen;
      }
      static int getBlue(Color color)
      { 
          return anteilBlau;
      }
      String getFeeling(Color color)
      {
           return "no feeling"
      }

}
```

Die Farben :
     redPink, treeBrown, skyBlue

werden zwar erzeugt aber Du kannst sie nicht in eine andere Klasse importieren. 
Sie sind nicht static und werden auch durch eclipse nicht vorgeschlagen, 
ebenso auch kannst Du auch die Methode getFeeling (die eine Zeichenkette liefert) nicht importieren.

ist das mehr oder weniger verständlkich ?
Am Montag lese ich, was Du noch wissen wolltest, 
ich wünsche Dir ein schönes Wochenende, 
klein-odd


----------



## Java-Freak (18. Sep 2010)

auch nicht-statische methoden werden von eclipse vorgeschlagen und müssen importiert werden


----------



## Atze (18. Sep 2010)

ich glaube ihr verwirrt ihn mit dem wort "importieren" total!!!! 

importe sind NUR da, um schreibarbeit zu sparen! wenn die klasse sichtbar ist, würde beim aufruf auch der volle qualifizierer reichen! ohne "import java.awt.Color" vor der klassendeklaration
bspw:

```
java.awt.Color myColor = new java.awt.Color(...);
```

durch den import sparst du dir das nur, und kannst (falls du nur eine klasse verwendest, die Color heißt) den packagepfad (namespace) weglassen

```
Color myColor = new Color(...);
```
wenn du mehrere klasse verwendest, dei den gleichen klassennamen tragen, musst du den vollen qualifizierer nutzen, weil sonst nicht klar ist, welche klasse Color du im code verwenden willst

was ihn verwundert ist imho, dass er die konstanten verwenden kann, ohne objekte der klasse Color zu instanzieren, also ohne "new Color(...)". das ist so, weil sie STATISCH sind, das heißt der classloader erzeugt beim benutzen der klasse die objekte, die sich hinter den statischen variablen "Color.WHITE" etc. verstecken. diese objekte gibt es beim laden der klasse also schon, diese brauchst du nicht mehr selbst zu instanzieren!


----------



## Java-Freak (18. Sep 2010)

genau das hab ich auch gesagt... 
eclipse verwirrt ihn weil es automatisch sachen macht die er nicht versteht
Beitrag


----------



## .maik. (19. Sep 2010)

danke für die vielen erläuterungen.. Atze hat meine Frage verstanden. Also ist es jetzt so, wenn ich die Klasse lade erzeugt der schon die Objekte mit dem Attribut static und dann muss ich sie nicht nochmal selbst instanzieren ?


hoffentlich stimmt das jetzt 
danke


----------



## Atze (19. Sep 2010)

ja, genau! statische variablen gehören zur klasse und sind immer da, sie benötigen keine objekte!


----------



## .maik. (21. Sep 2010)

ok. bevor ich dieses thema wirklich entgültig schließe, habe ich noch eine Frage:
Ich kann das mit den klassenvariablen nachvollziehen, aber die vordefinierten Farben sind doch objekte oder? und objekte muessen immer insantziert werden. ich habe auch schon eine wenig gegoogelt und überall werden auch nur klassenvariablen und methoden erläutert, aber keine objekte.
Kann mir da bitte jemand noch helfen?

Danke


----------



## Landei (21. Sep 2010)

Klassenvariablen dürfen sowohl Primitve (int, double...) wie auch Objekte enthalten. Sie dürfen sogar (was dich in diesem Fall zu verwirren scheint) Objekte der eigenen Klasse enthalten:


```
class AmpelFarbe {
   //diese Klassenvariablen werden automatisch instantiiert
   static public AmpelFarbe ROT = new AmpelFarbe("Rot");
   static public AmpelFarbe GELB = new AmpelFarbe("Gelb");
   static public AmpelFarbe GRÜN = new AmpelFarbe("Grün");

   //eine Instanzvariable
   private String name;
   //zur Instantiierung wird ganz normal der Konstruktor aufgerufen
   private AmpelFarbe(String farbName) {
      name = farbName;
   }
}

//anderswo im Code
ampel.set(AmpelFarbe.ROT);
```

Wenn du in den Konstruktor noch ein System.out.println("Farbe: " + farbName); schreiben würdest, könntest du sehen, dass er dreimal ausgeführt wird (für Rot, Grün, Gelb), sobald dein Programm die Klasse AmpelFarbe irgendwo das erste Mal "anfaßt"


----------



## Bierhumpen (21. Sep 2010)

.maik. hat gesagt.:


> aber die vordefinierten Farben sind doch objekte oder?


Ja hast du richtig verstanden.


> und objekte muessen immer insantziert werden.


Ja auch richtig.

Was ist jetzt deine Frage dazu?


----------

