Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
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.
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:
Wenn die in den Sourcecode der Klasse Color schaust, dann sieht du da:
Java:
/**
* 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);
...
...
...
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?
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...
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?
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
Java:
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:
Java:
import java.awt.*;
Die neu konstruierte Farbe kannst Du beispielsweise so verwenden :
Java:
//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.
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
die Vorschläge von Eclipse kannst Du immer überscheriben.
Java:
//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
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:
// 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);
}
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.
final_striker hat dir doch einen auszug aus den Color-sourcen geposted!
da steht zb.:
Java:
/**
* 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!
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
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
Java:
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 :
Java:
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
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:
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
Java:
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!
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 ?
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?
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:
Java:
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"
