Hallo,
ich habe ein Problem
Ich habe ein Programm,welches die Stabilität von Türmen berechnet und eine grafische Oberfläche welche ein Raster anzeigt …..
Nun möchte ich das die grafische Oberfläche nur stabile Bautürme abbildet(bündig angeordnet links unten )
Ich weiß leider nicht wie ich meiner Anwendung sage :,,Teste die Bausteintürme und gebe mir die stabilen Türme wieder und zeichne sie im Raster “
Stabilitätprogramm
Grafische Oberfläche
ich habe ein Problem
Ich habe ein Programm,welches die Stabilität von Türmen berechnet und eine grafische Oberfläche welche ein Raster anzeigt …..
Nun möchte ich das die grafische Oberfläche nur stabile Bautürme abbildet(bündig angeordnet links unten )
Ich weiß leider nicht wie ich meiner Anwendung sage :,,Teste die Bausteintürme und gebe mir die stabilen Türme wieder und zeichne sie im Raster “
Stabilitätprogramm
Java:
package anwendung;
import modell.BausteinBox;
import modell.BausteinTurm;
import schnittstellen.IBaustein2D;
import schnittstellen.IBausteinTurm;
import util.Punkt2D;
import ausnahmen.Listenfehler;
import ausnahmen.TurmInstabilException;
/**
* Anwendungsfall 1: Bausteinturm bestehend aus Bausteinen der Größe 2,3,5,4,1
* und 3 werden nacheinander versucht auf den Turm zu legen
*/
public class Anwendungsfall1 {
/**
* Einsprungpunkt für Programm
*
* @param args
*/
public static void main(String[] args) {
IBausteinTurm turm = new BausteinTurm();
try {
IBaustein2D b1 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 0.0), 2);
turm.legeBausteinAb(b1);
IBaustein2D b2 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 1.0), 3);
turm.legeBausteinAb(b2);
IBaustein2D b3 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 2.0), 5);
turm.legeBausteinAb(b3);
IBaustein2D b4 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 3.0), 4);
turm.legeBausteinAb(b4);
IBaustein2D b5 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 4.0), 1);
turm.legeBausteinAb(b5);
IBaustein2D b6 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 5.0), 3);
turm.legeBausteinAb(b6);
} catch (Listenfehler e) {
System.out.println(e.getMessage());
} catch (TurmInstabilException e) {
System.out.println(e.getMessage());
}
turm.ausgebenAufShell();
}
}
Java:
package anwendung;
import modell.BausteinBox;
import modell.BausteinTurm;
import schnittstellen.IBaustein2D;
import schnittstellen.IBausteinTurm;
import util.Punkt2D;
import ausnahmen.Listenfehler;
import ausnahmen.TurmInstabilException;
/**
* Anwendungsfall 1: Bausteinturm bestehend aus Bausteinen der Größe 5,4,3,4,5
* und 5 werden nacheinander versucht auf den Turm zu legen
*/
public class Anwendungsfall2 {
/**
* Einsprungpunkt für Programm
*
* @param args
*/
public static void main(String[] args) {
IBausteinTurm turm = new BausteinTurm();
try {
IBaustein2D b1 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 0.0), 5);
turm.legeBausteinAb(b1);
IBaustein2D b2 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 0.0), 4);
turm.legeBausteinAb(b2);
IBaustein2D b3 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 0.0), 3);
turm.legeBausteinAb(b3);
IBaustein2D b4 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 0.0), 4);
turm.legeBausteinAb(b4);
IBaustein2D b5 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 0.0), 5);
turm.legeBausteinAb(b5);
IBaustein2D b6 = BausteinBox.erzeugeBaustein(new Punkt2D(0.0, 0.0), 5);
turm.legeBausteinAb(b6);
} catch (Listenfehler e) {
System.out.println(e.getMessage());
} catch (TurmInstabilException e) {
System.out.println(e.getMessage());
}
turm.ausgebenAufShell();
}
}
Java:
package ausnahmen;
@SuppressWarnings("serial")
/**
* Ausnahme die beim Fehler innerhalb der Einfach verketteten Liste ausgelöst wird
*
*/
public class Listenfehler extends Exception {
/**
* Konstruktor für die Ausnahme übergibt Parameter an Vaterklasse weiter
*
* @param message
*/
public Listenfehler(String message) {
super(message);
}
}
Java:
package ausnahmen;
@SuppressWarnings("serial")
/**
* Ausnahme die bei Turminstabilität ausgelöst wird
*
*/
public class TurmInstabilException extends Exception {
/**
* Konstruktor für die Ausnahme übergibt Parameter an Vaterklasse weiter
*
* @param message
*/
public TurmInstabilException(String message) {
super(message);
}
}
Java:
package modell;
import schnittstellen.IBaustein2D;
import schnittstellen.IPunkt2D;
import util.Punkt2D;
/**
* Ein Baustein mit beliebiger Länge, Höhe gleich 1 und Tiefe gleich 1;
*/
public class Baustein2D implements IBaustein2D {
//rechte obere und linke untere Ecke des Bausteins als Punkte
private IPunkt2D rechteObereEcke;
private IPunkt2D linkeUntereEcke;
/**
* Konstruktor für einen Baustein mithilfe zweier Eckkoordinaten
*
* @param linkeUntereEcke: Punktkoordinate der linken unteren Ecke
* @param rechteObereEcke: Punktkoordinate der rechten oberen Ecke
*/
public Baustein2D(IPunkt2D linkeUntereEcke, IPunkt2D rechteObereEcke) {
this.linkeUntereEcke = linkeUntereEcke;
this.rechteObereEcke = rechteObereEcke;
}
/**
* holt die Länge des Bausteines
*/
public double getLaenge() {
return rechteObereEcke.getX() - linkeUntereEcke.getX();
}
/**
* holt Schwerpunkt des Bausteines
*/
public IPunkt2D getSchwerpunkt() {
double xKoord = (rechteObereEcke.getX() - linkeUntereEcke.getX()) / 2.0;
double yKoord = (rechteObereEcke.getY() - linkeUntereEcke.getY()) / 2.0;
return new Punkt2D(xKoord, yKoord);
}
/**
* holt rechten oberen Eckpunkt
*/
public IPunkt2D getRechteObereEcke() {
return rechteObereEcke;
}
/**
* setzt rechten oberen Eckpunkt
*
* @param rechteObereEcke
*/
public void setRechteObereEcke(IPunkt2D rechteObereEcke) {
this.rechteObereEcke = rechteObereEcke;
}
/**
* holt linken unteren Eckpunkt
*/
public IPunkt2D getLinkeUntereEcke() {
return linkeUntereEcke;
}
/**
* setzt linken unteren Eckpunkt
*
* @param linkeUntereEcke
*/
public void setLinkeUntereEcke(IPunkt2D linkeUntereEcke) {
this.linkeUntereEcke = linkeUntereEcke;
}
/**
* gibt die String-Repräsentation eines Bausteines zurück
*/
public String toString() {
String s = "Baustein Größe " + (int) getLaenge();
return s;
}
}
Java:
package modell;
import schnittstellen.IBaustein2D;
import util.Punkt2D;
/**
* Eine Bausteinbox mit dessen Hilfe Bausteine verschiedenen Länge erzeugt
* werden können
*/
public class BausteinBox {
/**
* statische Methode zum Erzeugen von Baustein-Instanzen
*
* @param linkeUntereEcke: Punktkoordinaten der linken unteren Ecke des
* Bausteines
* @param bausteinGroesse: Bausteinlänge als Ganzzahl
* @return
*/
public static IBaustein2D erzeugeBaustein(Punkt2D linkeUntereEcke, int bausteinGroesse) {
Punkt2D rechteObereEcke = new Punkt2D((double) bausteinGroesse, linkeUntereEcke.getY() + 1.0);
IBaustein2D neuerBaustein = new Baustein2D(linkeUntereEcke, rechteObereEcke);
return neuerBaustein;
}
}
Java:
package modell;
import schnittstellen.IBaustein2D;
import schnittstellen.IBausteinTurm;
import schnittstellen.IIterator;
import util.EinfachVerketteteListe;
import ausnahmen.Listenfehler;
import ausnahmen.TurmInstabilException;
/**
* Ein Bausteinturm bestehend aus n Bausteinen, abgelegt in der Reihenfolge in
* der sie auf den Turm gelegt wurden
*/
public class BausteinTurm implements IBausteinTurm {
//Einfach verkettete Liste zum Speichern der Bausteine
private EinfachVerketteteListe bausteine;
/**
* Leerkonstruktor für einen Bausteinturm. Initialisiert die Einfach
* verkettete Liste
*/
public BausteinTurm() {
this.bausteine = new EinfachVerketteteListe();
}
/**
* legt einen Baustein auf den vorhandenen Turm, wenn alle statischen
* Anforderungen erfüllt sind. Bringt der Aufzulegende Stein den Turm zum
* Einstürzen wird der Baustein nicht abgelegt.
*/
public void legeBausteinAb(IBaustein2D abzulegenderStein) throws Listenfehler, TurmInstabilException {
// bei leerer Liste wird erster Stein immer abgelegt
if (bausteine.istLeer()) {
bausteine.fuegeAmAnfangEin(abzulegenderStein);
System.out.println("Erster Stein: " + abzulegenderStein.toString() + " abgelegt!");
} else {
//globaler Iterator für Bezugsstein
IIterator itGlobal = bausteine.iterator();
//Überprüfung der gesamten Turmstabilität
while (itGlobal.hatNaechsten()) {
//Bezugstein um den das Gesamtmoment geprüft wird
IBaustein2D bezugsStein = (IBaustein2D) itGlobal.naechster();
IBaustein2D aktStein = abzulegenderStein;
double resMoment = 0.0;
//lokaler Iterator für den zu überprüfenden Teilturm
IIterator itLokal = bausteine.iterator();
//Errechnung des Gesamtmomentes des Teilturmes
while (aktStein != bezugsStein && itLokal.hatNaechsten()) {
double diffSchwerpktZuBezugsPkt = aktStein.getSchwerpunkt().getX() - bezugsStein.getRechteObereEcke().getX();
resMoment = resMoment + diffSchwerpktZuBezugsPkt * aktStein.getLaenge() * 1 * 1;
aktStein = (IBaustein2D) itLokal.naechster();
}
// wenn das Moment um den Bezugspunkt >= 0 wird der Baustein NICHT abgelegt
if (resMoment >= 0.0) {
throw new TurmInstabilException(abzulegenderStein.toString() + " würde den Turm zum Einstürzen bringen!");
}
}
bausteine.fuegeAmAnfangEin(abzulegenderStein);
System.out.println(abzulegenderStein.toString() + " abgelegt!");
}
}
/**
* gibt die String-Repräsentation eines Bausteinturmes zurück
*/
public String toString() {
String s = "";
IIterator iterator = bausteine.iterator();
while (iterator.hatNaechsten()) {
s = s + iterator.naechster().toString() + '\n';
}
s = s + "Bodenplatte";
return s;
}
/**
* Ausgabe der Bausteine eines Bausteinturmes auf der Shell
*/
public void ausgebenAufShell() {
System.out.println();
System.out.println("Liegengebliebene Bausteine des Turms:");
System.out.println(toString());
}
}
Java:
package schnittstellen;
/**
* Schnittstelle für Baustein2D
*/
public interface IBaustein2D {
double getLaenge();
IPunkt2D getSchwerpunkt();
IPunkt2D getRechteObereEcke();
IPunkt2D getLinkeUntereEcke();
String toString();
}
Java:
package schnittstellen;
import ausnahmen.Listenfehler;
import ausnahmen.TurmInstabilException;
/**
* Schnittstelle für Bausteinturm
*/
public interface IBausteinTurm {
void legeBausteinAb(IBaustein2D b1) throws Listenfehler, TurmInstabilException;
void ausgebenAufShell();
}
Java:
package schnittstellen;
/**
* Schnittstelle für Iterator
*/
public interface IIterator {
boolean hatNaechsten();
Object naechster();
}
Java:
package schnittstellen;
/**
* Schnittstelle für 2-dimensionalen Punkt
*/
public interface IPunkt2D {
double getX();
double getY();
String toString();
}
Java:
package util;
import schnittstellen.IIterator;
import ausnahmen.Listenfehler;
/**
* Eine einfach verkettete liste
*/
public class EinfachVerketteteListe {
// Referenz auf das erste Listenelement, wenn die Liste leer ist verweist es
// auf null
private EinfachVerkettetesListenElement erster;
/**
* Konstruktor erstellt eine leere Liste
*/
public EinfachVerketteteListe() {
setErster(null);
}
/**
* gibt an, ob die Liste leer ist
*
* @return true wenn Liste leer, false sonst
*/
public boolean istLeer() {
return erster == null;
}
public IIterator iterator() {
return new ListenIterator(erster);
}
/**
* fuegt ein Objekt am Anfang ein
*
* @param o : einzufuegendes Objekt
* @throws Listenfehler
*/
public void fuegeAmAnfangEin(Object o) throws Listenfehler {
// wenn kein Objekt uebergeben, wird Ausnahme geworfen
if (o == null) {
throw new Listenfehler("Fehlerhaftes oder kein Element übergeben!");
}
// erzeuge neues Listenelement
EinfachVerkettetesListenElement neu = new EinfachVerkettetesListenElement();
neu.setzeObjekt(o);
neu.setzeNachfolger(erster);
erster = neu;
}
/**
* entfernt das Objekt am Anfang und gibt das entfernte Objekt zurück
*
* @return : entferntes Objekt
* @throws Listenfehler
*/
public Object trageAmAnfangAus() throws Listenfehler {
if (istLeer()) {
throw new Listenfehler("Kein Element vorhanden!");
}
EinfachVerkettetesListenElement merke = erster;
erster = erster.holeNachfolger();
return merke;
}
/**
* getter für erstes Listenelement in der Liste
*
* @return
*/
public EinfachVerkettetesListenElement getErster() {
return erster;
}
/**
* setter für erstes Listenelement in Liste
*
* @param erster
*/
public void setErster(EinfachVerkettetesListenElement erster) {
this.erster = erster;
}
/**
* Rückgabe der Liste als String
*/
public String toString() {
return "Listeninhalt: " + erster;
}
}
Java:
package util;
/**
* Ein Listenelement fuer eine einfach verkettete Liste
*/
public class EinfachVerkettetesListenElement {
private Object o;
private EinfachVerkettetesListenElement nachfolger;
/**
* leerer Konstruktor fuer eine ListenElement
*/
public EinfachVerkettetesListenElement() {
setzeObjekt(null);
setzeNachfolger(null);
}
/**
* Konstruktor mit Übergabeparametern
*
* @param o eigentlich zu speicherndes Objekt
* @param nachfolger Nachfolgerelement in der Liste
*/
public EinfachVerkettetesListenElement(Object o, EinfachVerkettetesListenElement nachfolger) {
super();
this.o = o;
this.nachfolger = nachfolger;
}
/**
* hole Objekt o
*
* @return
*/
public Object holeObjekt() {
return o;
}
/**
* setze Objekt o
*
* @param Baustein
*/
public void setzeObjekt(Object o) {
this.o = o;
}
/**
* hole den Nachfolger des Listenelementes
*
* @return
*/
public EinfachVerkettetesListenElement holeNachfolger() {
return nachfolger;
}
/**
* setze den Nachfolger des Listenelementes
*
* @param nachfolger
*/
public void setzeNachfolger(EinfachVerkettetesListenElement nachfolger) {
this.nachfolger = nachfolger;
}
/**
* Ruekgabe des Listeelementes als String
*/
@Override
public String toString() {
return "EinfachVerkettetesListenElement [o=" + o + "]";
}
}
Java:
package util;
import schnittstellen.IIterator;
/**
* Iterator für eine Einfach verkettete Liste. Implementiert die Schnittstelle
* schnittstellen.IIterator
*/
public class ListenIterator implements IIterator {
//Referenz auf das aktuelle Element, auf welches der Iterator verweist
private EinfachVerkettetesListenElement aktueller;
/**
* Konstruktor für einen Listeniterator
*
* @param aktueller Referenz auf die der Iterator beim Erzeugen verweist
*/
public ListenIterator(EinfachVerkettetesListenElement aktueller) {
this.aktueller = aktueller;
}
/**
* prüft ob es ein nächstes Listenelement in der Liste gibt
*/
public boolean hatNaechsten() {
if (aktueller == null) {
return false;
}
return true;
}
/**
* gibt das aktuelle Listenelement zurück und setzt die Referenz für aktueller
* auf den Nachfolger des zurückgegebenen Listenelementes
*/
public Object naechster() {
Object merke = this.aktueller.holeObjekt();
this.aktueller = this.aktueller.holeNachfolger();
return merke;
}
}
Java:
package util;
import schnittstellen.IPunkt2D;
/**
* ein Punkt für ein 2-dimensionales Koordinatensystem mit x- und y-Koordinate
*/
public class Punkt2D implements IPunkt2D {
//Koordinaten als Gleitkommazahlen
private double xKoord;
private double yKoord;
/**
* Konstruktor für einen Punkt2D mit Übergabe der beiden Koordinaten
*
* @param xKoord
* @param yKoord
*/
public Punkt2D(double xKoord, double yKoord) {
setX(xKoord);
setY(yKoord);
}
/**
* hole x-Koordinate
*/
public double getX() {
return this.xKoord;
}
/**
* setze x-Koordinate
*
* @param xKoord
*/
public void setX(double xKoord) {
this.xKoord = xKoord;
}
/**
* hole y-Koordinate
*/
public double getY() {
return this.yKoord;
}
/**
* setze y-Koordinate
*/
public void setY(double yKoord) {
this.yKoord = yKoord;
}
/**
* gibt die String-Representation eines Punktes zurück
*/
public String toString() {
return "Punkt [x=" + xKoord + ", y=" + yKoord + "]";
}
}Grafische Oberfläche
Java:
package anwendung;
import modell.Raster;
import oberflaeche.RasterOberflaeche;
/*
* "Baupln" fuer das Programm zur Bearbeitung eines Objektes vom Typ Vektor3D
*/
public class Rasterprogramm {
/*
* Main-Methode
*/
public static void main(String[] args) {
// Anlegen des Objektes
Raster raster = new Raster();
// Anlegen der Oberflaeche fuer diese Objekt
RasterOberflaeche oberflaeche = new RasterOberflaeche(raster);
// Darstellen der Oberflaeche
oberflaeche.stelleDar();
}
}
Java:
package modell;
/*
* "Bauplan" fuer ein Raster
*/
public class Raster {
// Rasterabstand in Pixeln
private int abstand;
/*
* Konstruktor
*/
public Raster() {
abstand = 40;
}
/*
* Setzen des Abstands
*/
public void setAbstand(int wert) {
abstand = wert;
}
/*
* Holen des Abstands
*/
public int getAbstand() {
return abstand;
}
}
Java:
package oberflaeche;
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JComponent;
import modell.Raster;
/*
* "Bauplan" zur Darstellung eines Rasters
*/
public class RasterDarstellungGraphisch extends JComponent {
/**
*
*/
private static final long serialVersionUID = -8028992788842073219L;
// das darzustellende Raster
private Raster raster;
/*
* Konstruktor, vermerkt das Raster
*/
public RasterDarstellungGraphisch(Raster r) {
raster = r;
}
/*
* Ueberschrieben wird die Methode zum Darstellen
*/
public void paintComponent(Graphics g) {
// hole die Breite
int breite = this.getWidth();
// hole die Hoehe
int hoehe = this.getHeight();
// zeichnen des Rasters: Urspung ist linke untere Ecke
// Koordinaten einer Rasterlinie
int x1, x2, y1, y2;
// Horizontal
// Koordinaten der linken unteren Ecke
x1 = 0;
y1 = hoehe - 1;
// Koordinaten der rechtern unteren Ecke
x2 = breite - 1;
y2 = hoehe - 1;
// Schleife
for (int i = 0; i <= hoehe / raster.getAbstand(); i++) {
g.drawLine(x1, y1, x2, y2);
y1 -= raster.getAbstand();
y2 -= raster.getAbstand();
}
// Vertikal
// Koordinaten der linken unteren Ecke
x1 = 0;
y1 = hoehe;
// Koordinaten der linken oberen Ecke
x2 = 0;
y2 = 0;
// Schleife
for (int i = 0; i <= breite / raster.getAbstand(); i++) {
g.drawLine(x1, y1, x2, y2);
x1 += raster.getAbstand();
x2 += raster.getAbstand();
}
// stelle das zweite Rasterkästchen unten links gelb dar
Color aktuelleFarbe = g.getColor();
g.setColor(Color.YELLOW);
g.fillRect(raster.getAbstand() + 1, hoehe - raster.getAbstand(),
raster.getAbstand() - 1, raster.getAbstand() - 1);
// stelle das darüber liegende Rasterkästchen rot dar
g.setColor(Color.RED);
g.fillRect(raster.getAbstand() + 1, hoehe - 2 * raster.getAbstand(),
raster.getAbstand() - 1, raster.getAbstand() - 1);
g.setColor(aktuelleFarbe);
}
}
Java:
package oberflaeche;
import java.awt.BorderLayout;
import java.awt.GridLayout;
import javax.swing.JLabel;
import javax.swing.JPanel;
import modell.Raster;
/*
* "Bauplan" fuer die Eingabe eines Rasters
*/
public class RasterEingabe {
// das Objekt
private Raster raster;
// das Panel, auf dem alles dargestellt wird
private JPanel panel;
// die Objekte, die auf dem Panel plaziert werden
private JLabel label;
/*
* Konstruktor
*/
public RasterEingabe(Raster r, RasterDarstellungGraphisch d) {
// Speichern der Objektreferenzen
raster = r;
// Anlegen des Panel
panel = new JPanel();
panel.setLayout(new BorderLayout());
// Anlegen und Platzieren der Objekte fur die Koordinaten
label = new JLabel(" Bausteinturm ");
JPanel internesPanelOben = new JPanel();
internesPanelOben.setLayout(new GridLayout(1, 2));
internesPanelOben.add(label);
panel.add(internesPanelOben, BorderLayout.NORTH);
}
/*
* Holen des Panels, auf dem alles angeordnet ist
*/
public JPanel getPanel() {
return panel;
}
public Raster getRaster() {
return raster;
}
}
Java:
package oberflaeche;
import java.awt.BorderLayout;
import javax.swing.JFrame;
import modell.Raster;
public class RasterOberflaeche {
// Die Oberflaeche verwaltet eine Eingabe und eine Darstellung
private RasterEingabe rasterEingabe;
private RasterDarstellungGraphisch rasterDarstellung;
// Die Oberflaeche wird in einem Fenster dargestellt
private JFrame fenster;
// Konstruktor
public RasterOberflaeche(Raster r) {
// Alles wird auf einem Fenster dargestellt
fenster = new JFrame(" Raster ");
fenster.setSize(700, 500);
fenster.setLayout(new BorderLayout());
// Erzeugen der Darstellung
rasterDarstellung = new RasterDarstellungGraphisch(r);
// Erzeugen der Eingabe
rasterEingabe = new RasterEingabe(r,rasterDarstellung);
// Plazieren der Eingabe
fenster.add(rasterEingabe.getPanel(), BorderLayout.NORTH);
// Plazieren der Darstellung
fenster.add(rasterDarstellung, BorderLayout.CENTER);
// Das Programm endet, wenn das Fenster geschlossen wird.
fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
/*
* Methode zum Darstellen des Fensters
*/
public void stelleDar() {
// Das Fenster wird sichtbar.
fenster.setVisible(true);
}
}
