X
xN1ghtw0lfx
Hey also ich hab so als halb hausaufgabe bekommen das ich mich infomieren soll wie ich die sonne zum bewegen bekomm!
Als erstes haben wir ein haus mit sonne programmieren sollen aus Dreiecken, Quadraten und Kreisen!
Das war ganz einfach jetzt sollen wir die sonne über das haus laufen lassen!
Ich hab auch shcon eine lösung davor blos is diese lösung viel zu lang^^ so ungefär 300 befehle oder so
jetzt wollt ich fragen wie ich des hinbekommen kann! Vll könnt ihr mir ja die methode sagen un erklären die ich benutzen sol! der lehrer hatte shc irgendwas davon gesagt! ich wies nur das es was mit x und y wert zu tun hat^^
Hier mal die Quellcodes! Wir arbeiten in der schule mit BlueJ
Kreis:
Dreieck:
Quadrat:
Leinwand! Also des wo das haus abgebildet wird^^
Un jetzt des was wir programmieren sollten! des bewirkt das sich des haus automatisch aus den einzelnen klassen zusammen baut!
wie gesagt viel zu lange^^ wenn jemand hier bluej hat oder so kann ich euch auch mein projekt schicken oder so! ich muss wissen wie ich die sonne ohne 300 commands bewegen kann!
Danke schonmal für ne Antwort^^
Als erstes haben wir ein haus mit sonne programmieren sollen aus Dreiecken, Quadraten und Kreisen!
Das war ganz einfach jetzt sollen wir die sonne über das haus laufen lassen!
Ich hab auch shcon eine lösung davor blos is diese lösung viel zu lang^^ so ungefär 300 befehle oder so
jetzt wollt ich fragen wie ich des hinbekommen kann! Vll könnt ihr mir ja die methode sagen un erklären die ich benutzen sol! der lehrer hatte shc irgendwas davon gesagt! ich wies nur das es was mit x und y wert zu tun hat^^
Hier mal die Quellcodes! Wir arbeiten in der schule mit BlueJ
Kreis:
Code:
import java.awt.geom.Ellipse2D;
/**
* Ein Kreis, der manipuliert werden kann und sich selbst auf einer Leinwand
* zeichnet.
*
* @author Michael Kölling und David J. Barnes
* @version 2006.03.30
*/
public class Kreis {
private int durchmesser;
private int xPosition;
private int yPosition;
private String farbe;
private boolean istSichtbar;
/**
* Erzeuge einen neuen Kreis an einer Standardposition mit einer
* Standardfarbe.
*/
public Kreis() {
durchmesser = 30;
xPosition = 20;
yPosition = 60;
farbe = "blau";
istSichtbar = false;
}
/**
* Mache diesen Kreis sichtbar. Wenn es bereits sichtbar ist, tue nichts.
*/
public void sichtbarMachen() {
istSichtbar = true;
zeichnen();
}
/**
* Mache diesen Kreis unsichtbar. Wenn es bereits unsichtbar ist, tue
* nichts.
*/
public void unsichtbarMachen() {
loeschen();
istSichtbar = false;
}
/**
* Bewege diesen Kreis einige Bildschirmpunkte nach rechts.
*/
public void nachRechtsBewegen() {
horizontalBewegen(20);
}
/**
* Bewege diesen Kreis einige Bildschirmpunkte nach links.
*/
public void nachLinksBewegen() {
horizontalBewegen(-20);
}
/**
* Bewege diesen Kreis einige Bildschirmpunkte nach oben.
*/
public void nachObenBewegen() {
vertikalBewegen(-20);
}
/**
* Bewege diesen Kreis einige Bildschirmpunkte nach unten.
*/
public void nachUntenBewegen() {
vertikalBewegen(20);
}
/**
* Bewege diesen Kreis horizontal um 'entfernung' Bildschirmpunkte.
*/
public void horizontalBewegen(int entfernung) {
loeschen();
xPosition += entfernung;
zeichnen();
}
/**
* Bewege diesen Kreis vertikal um 'entfernung' Bildschirmpunkte.
*/
public void vertikalBewegen(int entfernung) {
loeschen();
yPosition += entfernung;
zeichnen();
}
/**
* Bewege diesen Kreis langsam horizontal um 'entfernung' Bildschirmpunkte.
*/
public void langsamHorizontalBewegen(int entfernung) {
int delta;
if (entfernung < 0) {
delta = -1;
entfernung = -entfernung;
} else {
delta = 1;
}
for (int i = 0; i < entfernung; i++) {
xPosition += delta;
zeichnen();
}
}
/**
* Bewege diesen Kreis langsam vertikal um 'entfernung' Bildschirmpunkte.
*/
public void langsamVertikalBewegen(int entfernung) {
int delta;
if (entfernung < 0) {
delta = -1;
entfernung = -entfernung;
} else {
delta = 1;
}
for (int i = 0; i < entfernung; i++) {
yPosition += delta;
zeichnen();
}
}
/**
* Ändere den Durchmesser dieses Kreises in 'neuerDurchmesser' (Angabe in
* Bildschirmpunkten). 'neuerDurchmesser' muss größer gleich Null sein.
*/
public void groesseAendern(int neuerDurchmesser) {
loeschen();
durchmesser = neuerDurchmesser;
zeichnen();
}
/**
* Ändere die Farbe dieses Kreises in 'neueFarbe'. Gültige Angaben sind
* "rot", "gelb", "blau", "gruen", "lila" und "schwarz".
*/
public void farbeAendern(String neueFarbe) {
farbe = neueFarbe;
zeichnen();
}
/**
* Zeichne diesen Kreis mit seinen aktuellen Werten auf den Bildschirm.
*/
private void zeichnen() {
if (istSichtbar) {
Leinwand leinwand = Leinwand.gibLeinwand();
leinwand.zeichne(this, farbe, new Ellipse2D.Double(xPosition,
yPosition, durchmesser, durchmesser));
leinwand.warte(10);
}
}
/**
* Lösche diesen Kreis vom Bildschirm.
*/
private void loeschen() {
if (istSichtbar) {
Leinwand leinwand = Leinwand.gibLeinwand();
leinwand.entferne(this);
}
}
}Dreieck:
Code:
import java.awt.Polygon;
/**
* Ein Dreieck, das manipuliert werden kann und sich selbst auf einer Leinwand
* zeichnet.
*
* @author Michael Kölling und David J. Barnes
* @version 2006.03.30
*/
public class Dreieck {
private int hoehe;
private int breite;
private int xPosition;
private int yPosition;
private String farbe;
private boolean istSichtbar;
/**
* Erzeuge ein Dreieck mit einer Standardfarbe an einer Standardposition.
*/
public Dreieck() {
hoehe = 30;
breite = 40;
xPosition = 50;
yPosition = 15;
farbe = "gruen";
istSichtbar = false;
}
/**
* Mache dieses Dreieck sichtbar. Wenn es bereits sichtbar ist, tue nichts.
*/
public void sichtbarMachen() {
istSichtbar = true;
zeichnen();
}
/**
* Mache dieses Dreieck unsichtbar. Wenn es bereits unsichtbar ist, tue
* nichts.
*/
public void unsichtbarMachen() {
loeschen();
istSichtbar = false;
}
/**
* Bewege dieses Dreieck einige Bildschirmpunkte nach rechts.
*/
public void nachRechtsBewegen() {
horizontalBewegen(20);
}
/**
* Bewege dieses Dreieck einige Bildschirmpunkte nach links.
*/
public void nachLinksBewegen() {
horizontalBewegen(-20);
}
/**
* Bewege dieses Dreieck einige Bildschirmpunkte nach oben.
*/
public void nachObenBewegen() {
vertikalBewegen(-20);
}
/**
* Bewege dieses Dreieck einige Bildschirmpunkte nach unten.
*/
public void nachUntenBewegen() {
vertikalBewegen(20);
}
/**
* Bewege dieses Dreieck horizontal um 'entfernung' Bildschirmpunkte.
*/
public void horizontalBewegen(int entfernung) {
loeschen();
xPosition += entfernung;
zeichnen();
}
/**
* Bewege dieses Dreieck vertikal um 'entfernung' Bildschirmpunkte.
*/
public void vertikalBewegen(int entfernung) {
loeschen();
yPosition += entfernung;
zeichnen();
}
/**
* Bewege dieses Dreieck langsam horizontal um 'entfernung'
* Bildschirmpunkte.
*/
public void langsamHorizontalBewegen(int entfernung) {
int delta;
if (entfernung < 0) {
delta = -1;
entfernung = -entfernung;
} else {
delta = 1;
}
for (int i = 0; i < entfernung; i++) {
xPosition += delta;
zeichnen();
}
}
/**
* Bewege dieses Dreieck langsam vertikal um 'entfernung' Bildschirmpunkte.
*/
public void langsamVertikalBewegen(int entfernung) {
int delta;
if (entfernung < 0) {
delta = -1;
entfernung = -entfernung;
} else {
delta = 1;
}
for (int i = 0; i < entfernung; i++) {
yPosition += delta;
zeichnen();
}
}
/**
* Ändere die Höhe in 'neueHoehe' und die Breite in 'neueBreite'. Beide
* Angaben müssen größer gleich Null sein.
*/
public void groesseAendern(int neueHoehe, int neueBreite) {
loeschen();
hoehe = neueHoehe;
breite = neueBreite;
zeichnen();
}
/**
* Ändere die Farbe dieses Dreiecks in 'neueFarbe'. Gültige Angaben sind
* "rot", "gelb", "blau", "gruen", "lila" und "schwarz".
*/
public void farbeAendern(String neueFarbe) {
farbe = neueFarbe;
zeichnen();
}
/**
* Zeichne dieses Dreieck mit seinen aktuellen Werten auf den Bildschirm.
*/
private void zeichnen() {
if (istSichtbar) {
Leinwand leinwand = Leinwand.gibLeinwand();
int[] xpoints = { xPosition, xPosition + (breite / 2),
xPosition - (breite / 2) };
int[] ypoints = { yPosition, yPosition + hoehe, yPosition + hoehe };
leinwand.zeichne(this, farbe, new Polygon(xpoints, ypoints, 3));
leinwand.warte(10);
}
}
/**
* Lösche dieses Dreieck vom Bildschirm.
*/
private void loeschen() {
if (istSichtbar) {
Leinwand leinwand = Leinwand.gibLeinwand();
leinwand.entferne(this);
}
}
}
Code:
import java.awt.Rectangle;
/**
* Ein Quadrat, das manipuliert werden kann und sich selbst auf einer Leinwand
* zeichnet.
*
* @author Michael Kölling und David J. Barnes
* @version 2006.03.30
*/
public class Quadrat {
private int groesse;
private int xPosition;
private int yPosition;
private String farbe;
private boolean istSichtbar;
/**
* Erzeuge ein neues Quadrat mit einer Standardfarbe an einer
* Standardposition.
*/
public Quadrat() {
groesse = 30;
xPosition = 60;
yPosition = 50;
farbe = "rot";
istSichtbar = false;
}
/**
* Mache dieses Quadrat sichtbar. Wenn es bereits sichtbar ist, tue nichts.
*/
public void sichtbarMachen() {
istSichtbar = true;
zeichnen();
}
/**
* Mache dieses Quadrat unsichtbar. Wenn es bereits unsichtbar ist, tue
* nichts.
*/
public void unsichtbarMachen() {
loeschen();
istSichtbar = false;
}
/**
* Bewege dieses Quadrat einige Bildschirmpunkte nach rechts.
*/
public void nachRechtsBewegen() {
horizontalBewegen(20);
}
/**
* Bewege dieses Quadrat einige Bildschirmpunkte nach links.
*/
public void nachLinksBewegen() {
horizontalBewegen(-20);
}
/**
* Bewege dieses Quadrat einige Bildschirmpunkte nach oben.
*/
public void nachObenBewegen() {
vertikalBewegen(-20);
}
/**
* Bewege dieses Quadrat einige Bildschirmpunkte nach unten.
*/
public void nachUntenBewegen() {
vertikalBewegen(20);
}
/**
* Bewege dieses Quadrat horizontal um 'entfernung' Bildschirmpunkte.
*/
public void horizontalBewegen(int distance) {
loeschen();
xPosition += distance;
zeichnen();
}
/**
* Bewege dieses Quadrat vertikal um 'entfernung' Bildschirmpunkte.
*/
public void vertikalBewegen(int entfernung) {
loeschen();
yPosition += entfernung;
zeichnen();
}
/**
* Bewege dieses Quadrat langsam horizontal um 'entfernung'
* Bildschirmpunkte.
*/
public void langsamHorizontalBewegen(int entfernung) {
int delta;
if (entfernung < 0) {
delta = -1;
entfernung = -entfernung;
} else {
delta = 1;
}
for (int i = 0; i < entfernung; i++) {
xPosition += delta;
zeichnen();
}
}
/**
* Bewege dieses Quadrat langsam vertikal um 'entfernung' Bildschirmpunkte.
*/
public void langsamVertikalBewegen(int entfernung) {
int delta;
if (entfernung < 0) {
delta = -1;
entfernung = -entfernung;
} else {
delta = 1;
}
for (int i = 0; i < entfernung; i++) {
yPosition += delta;
zeichnen();
}
}
/**
* Ändere die Größe dieses Quadrates in 'neueGroesse'. 'neueGroesse' muss
* groesser gleich Null sein.
*/
public void groesseAendern(int neueGroesse) {
loeschen();
groesse = neueGroesse;
zeichnen();
}
/**
* Ändere die Farbe dieses Quadrates in 'neueFarbe'. Gültige Angaben sind
* "rot", "gelb", "blau", "gruen", "lila" und "schwarz".
*/
public void farbeAendern(String neueFarbe) {
farbe = neueFarbe;
zeichnen();
}
/**
* Zeichne dieses Quadrat mit seinen aktuellen Werten auf den Bildschirm.
*/
private void zeichnen() {
if (istSichtbar) {
Leinwand leinwand = Leinwand.gibLeinwand();
leinwand.zeichne(this, farbe, new Rectangle(xPosition, yPosition,
groesse, groesse));
leinwand.warte(10);
}
}
/**
* Lösche dieses Quadrat vom Bildschirm.
*/
private void loeschen() {
if (istSichtbar) {
Leinwand leinwand = Leinwand.gibLeinwand();
leinwand.entferne(this);
}
}
}
Code:
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Shape;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.swing.JFrame;
import javax.swing.JPanel;
/**
* Leinwand ist eine Klasse, die einfache Zeichenoperationen auf einer
* leinwandartigen Zeichenfläche ermöglicht. Sie ist eine vereinfachte Version
* der Klasse Canvas (englisch für Leinwand) des JDK und wurde speziell für das
* Projekt "Figuren" geschrieben.
*
*
* @author: Bruce Quig
* @author: Michael Kölling (mik)
* @author: Axel Schmolitzky
*
* @version: 2006.03.30
*/
public class Leinwand {
// Hinweis: Die Implementierung dieser Klasse (insbesondere die
// Verwaltung der Farben und Identitäten der Figuren) ist etwas
// komplizierter als notwendig. Dies ist absichtlich so, weil damit
// die Schnittstellen und Exemplarvariablen der Figuren-Klassen
// für den Lernanspruch dieses Projekts einfacher und klarer
// sein können.
private static Leinwand leinwandSingleton;
/**
* Fabrikmethode, die eine Referenz auf das einzige Exemplar dieser Klasse
* zurückliefert. Wenn es von einer Klasse nur genau ein Exemplar gibt, wird
* dieses als 'Singleton' bezeichnet.
*/
public static Leinwand gibLeinwand() {
if (leinwandSingleton == null) {
leinwandSingleton = new Leinwand("BlueJ Figuren Demo", 300, 300,
Color.white);
}
leinwandSingleton.setzeSichtbarkeit(true);
return leinwandSingleton;
}
// ----- Exemplarvariablen -----
private JFrame fenster;
private Zeichenflaeche zeichenflaeche;
private Graphics2D graphic;
private Color hintergrundfarbe;
private Image leinwandImage;
private List<Object> figuren;
private Map<Object, ShapeMitFarbe> figurZuShape;
/**
* Erzeuge eine Leinwand.
*
* @param titel
* Titel, der im Rahmen der Leinwand angezeigt wird
* @param breite
* die gewünschte Breite der Leinwand
* @param hoehe
* die gewünschte Höhe der Leinwand
* @param grundfarbe
* die Hintergrundfarbe der Leinwand
*/
private Leinwand(String titel, int breite, int hoehe, Color grundfarbe) {
fenster = new JFrame();
zeichenflaeche = new Zeichenflaeche();
fenster.setContentPane(zeichenflaeche);
fenster.setTitle(titel);
zeichenflaeche.setPreferredSize(new Dimension(breite, hoehe));
hintergrundfarbe = grundfarbe;
fenster.pack();
figuren = new ArrayList<Object>();
figurZuShape = new HashMap<Object, ShapeMitFarbe>();
}
/**
* Setze, ob diese Leinwand sichtbar sein soll oder nicht. Wenn die Leinwand
* sichtbar gemacht wird, wird ihr Fenster in den Vordergrund geholt. Diese
* Operation kann auch benutzt werden, um ein bereits sichtbares
* Leinwandfenster in den Vordergrund (vor andere Fenster) zu holen.
*
* @param sichtbar
* boolean für die gewünschte Sichtbarkeit: true für sichtbar,
* false für nicht sichtbar.
*/
public void setzeSichtbarkeit(boolean sichtbar) {
if (graphic == null) {
// erstmaliger Aufruf: erzeuge das Bildschirm-Image und fülle
// es mit der Hintergrundfarbe
Dimension size = zeichenflaeche.getSize();
leinwandImage = zeichenflaeche.createImage(size.width, size.height);
graphic = (Graphics2D) leinwandImage.getGraphics();
graphic.setColor(hintergrundfarbe);
graphic.fillRect(0, 0, size.width, size.height);
graphic.setColor(Color.black);
}
fenster.setVisible(sichtbar);
}
/**
* Zeichne für das gegebene Figur-Objekt eine Java-Figur (einen Shape) auf
* die Leinwand.
*
* @param figur
* das Figur-Objekt, für das ein Shape gezeichnet werden soll
* @param farbe
* die Farbe der Figur
* @param shape
* ein Objekt der Klasse Shape, das tatsächlich gezeichnet wird
*/
public void zeichne(Object figur, String farbe, Shape shape) {
figuren.remove(figur); // entfernen, falls schon eingetragen
figuren.add(figur); // am Ende hinzufügen
figurZuShape.put(figur, new ShapeMitFarbe(shape, farbe));
erneutZeichnen();
}
/**
* Entferne die gegebene Figur von der Leinwand.
*
* @param figur
* die Figur, deren Shape entfernt werden soll
*/
public void entferne(Object figur) {
figuren.remove(figur); // entfernen,falls schon eingetragen
figurZuShape.remove(figur);
erneutZeichnen();
}
/**
* Setze die Zeichenfarbe der Leinwand.
*
* @param farbname
* der Name der neuen Zeichenfarbe.
*/
public void setzeZeichenfarbe(String farbname) {
if (farbname.equals("rot")) {
graphic.setColor(Color.red);
} else if (farbname.equals("schwarz")) {
graphic.setColor(Color.black);
} else if (farbname.equals("blau")) {
graphic.setColor(Color.blue);
} else if (farbname.equals("gelb")) {
graphic.setColor(Color.yellow);
} else if (farbname.equals("gruen")) {
graphic.setColor(Color.green);
} else if (farbname.equals("lila")) {
graphic.setColor(Color.magenta);
} else if (farbname.equals("weiss")) {
graphic.setColor(Color.white);
} else {
graphic.setColor(Color.black);
}
}
/**
* Warte für die angegebenen Millisekunden. Mit dieser Operation wird eine
* Verzögerung definiert, die für animierte Zeichnungen benutzt werden kann.
*
* @param millisekunden
* die zu wartenden Millisekunden
*/
public void warte(int millisekunden) {
try {
Thread.sleep(millisekunden);
} catch (Exception e) {
// Exception ignorieren
}
}
/**
* Zeichne erneut alle Figuren auf der Leinwand.
*/
private void erneutZeichnen() {
loeschen();
for (Object figur : figuren) {
figurZuShape.get(figur).draw(graphic);
}
zeichenflaeche.repaint();
}
/**
* Lösche die gesamte Leinwand.
*/
private void loeschen() {
Color original = graphic.getColor();
graphic.setColor(hintergrundfarbe);
Dimension size = zeichenflaeche.getSize();
graphic.fill(new Rectangle(0, 0, size.width, size.height));
graphic.setColor(original);
}
/***************************************************************************
* Interne Klasse Zeichenflaeche - die Klasse für die GUI-Komponente, die
* tatsächlich im Leinwand-Fenster angezeigt wird. Diese Klasse definiert
* ein JPanel mit der zusätzlichen Möglichkeit, das auf ihm gezeichnet Image
* aufzufrischen (erneut zu zeichnen).
*/
private class Zeichenflaeche extends JPanel {
private static final long serialVersionUID = 20060330L;
public void paint(Graphics g) {
g.drawImage(leinwandImage, 0, 0, null);
}
}
/***************************************************************************
* Interne Klasse ShapeMitFarbe - Da die Klasse Shape des JDK nicht auch
* eine Farbe mitverwalten kann, muss mit dieser Klasse die Verknüpfung
* modelliert werden.
*/
private class ShapeMitFarbe {
private Shape shape;
private String farbe;
public ShapeMitFarbe(Shape shape, String farbe) {
this.shape = shape;
this.farbe = farbe;
}
public void draw(Graphics2D graphic) {
setzeZeichenfarbe(farbe);
graphic.fill(shape);
}
}
}Un jetzt des was wir programmieren sollten! des bewirkt das sich des haus automatisch aus den einzelnen klassen zusammen baut!
Code:
public class Zeichnung
{
private Kreis sonne;
private Quadrat haus;
private Dreieck dach;
private Quadrat fenster;
private Quadrat tuer;
public Zeichnung()
{
haus = new Quadrat();
sonne = new Kreis();
dach = new Dreieck();
fenster = new Quadrat();
tuer = new Quadrat();
}
public void sichtbarMachen()
{
sonne.sichtbarMachen();
haus.sichtbarMachen();
dach.sichtbarMachen();
fenster.sichtbarMachen();
tuer.sichtbarMachen();
sonne.farbeAendern("gelb");
haus.farbeAendern("gruen");
dach.farbeAendern("rot");
fenster.farbeAendern("blau");
tuer.farbeAendern("schwarz");
sonne.horizontalBewegen(190);
dach.horizontalBewegen(85);
fenster.horizontalBewegen(85);
tuer.horizontalBewegen(40);
haus.horizontalBewegen(40);
haus.vertikalBewegen(180);
dach.vertikalBewegen(165);
fenster.vertikalBewegen(190);
tuer.vertikalBewegen(220);
sonne.vertikalBewegen(70);
sonne.groesseAendern(80);
haus.groesseAendern(70);
dach.groesseAendern(60,100);
fenster.groesseAendern(25);
tuer.groesseAendern(35);
un hier halt des 300 zeichen lange teil zum bewegen der sonne
(is zu lang zum posten!)
}
}wie gesagt viel zu lange^^ wenn jemand hier bluej hat oder so kann ich euch auch mein projekt schicken oder so! ich muss wissen wie ich die sonne ohne 300 commands bewegen kann!
Danke schonmal für ne Antwort^^
