# Wieso funktioniert das nicht?



## Tombery (15. Nov 2009)

hi,

ich schlage mich mal wieder mit der nächsten aufgabe rum ^^

in der müssen wir ein rauten-punkt muster ausgeben...genauer genommen 4 anscheinend. 

doch es kommt einfach nix raus, wenn ich es durchlaufen lasse XD""" ich finde das komisch...

mein quelltext:


```
public class Quadrat {

	//Datenelemente
	
	private int ecke;
	private int seite;
	
	//Konstanten zur Darstellung des Musters
	
	public static final String SIGN1 = "#";
	public static final String SIGN2 = ".";
	
	//Costum-Konstruktor
	
	public Quadrat (int seite, int ecke)
	{
		//Wertzuweisungen der Datenelemente
	}
	
	//Methode für neue Werte
	
	public void update(int seite, int ecke)
	{
		//Wertzuweisungen der neuen Datenelemente
	}
	
	//Methode zur Ausgabe des Musters
	
	public void draw()
	{
		//Muster
		for(int i = 0; i < seite; i++) {
			if (ecke == 0)
			{
				//Rauten
				for(int j = 0; j < seite; j++)
				{
					System.out.println(SIGN1);
				}
				//Punkte
				for(int j = seite-1; j > 0; j--)
				{
					System.out.println(SIGN2);
				}
			}
			else if (ecke == 1)
			{
				//Rauten
				for(int k = seite; k < seite; k--)
				{
					System.out.println(SIGN1);
				}
				//Punkte
				for(int k = 1; k < seite; k++)
				{
					System.out.println(SIGN2);
				}
			}
			else if (ecke == 2)
			{
				//Punkte
				for(int l = 1; l < seite; l++)
				{
					System.out.println(SIGN2);
				}
				//Rauten
				for(int l = seite; l > 0; l--)
				{
					System.out.println(SIGN1);
				}
			}
			else if (ecke == 3)
			{
				//Punkte
				for(int m = seite-1; m < seite; m--)
				{
					System.out.println(SIGN2);
				}
				//Rauten
				for(int m = 0; m < seite; m++)
				{
					System.out.println(SIGN1);
				}
			}
			else
			{
				System.out.println();
			}
		
		}
	}
	
	//main-Methode
	
	public static void main (String[] args){
		
		//erstes Quadrat
		Quadrat quadrat1 = new Quadrat(10,0);
		quadrat1.draw();
		
		//zweites Quadrat
		quadrat1.update(10,1);
		quadrat1.draw();
		
		//drittes Quadrat
		quadrat1.update(10,2);
		quadrat1.draw();
		
		//viertes Quadrat
		quadrat1.update(10,3);
		quadrat1.draw();
	}
}
```


----------



## ARadauer (15. Nov 2009)

du hast das


```
//Costum-Konstruktor
    
    public Quadrat (int seite, int ecke)
    {
        //Wertzuweisungen der Datenelemente
    }
    
    //Methode für neue Werte
    
    public void update(int seite, int ecke)
    {
        //Wertzuweisungen der neuen Datenelemente
    }
```
nicht implementiert...


```
public Quadrat (int seite, int ecke)
    {
       this.seite = seite;
       this.ecke = ecke;
    }
    
    //Methode für neue Werte
    
    public void update(int seite, int ecke)
    {
    	this.seite = seite;
        this.ecke = ecke;
```
woebei da kommt auch nix sinnvolles raus...

btw vewendets ihr keinen debugger? ich vesteh eigentlich die frage nícht.. draw macht nix richtiges.. breakpoint in die methode...     for(int i = 0; i < seite; i++) { seite ist 0.. ok warum ist seite 0, wird nirgends gesetzt... ah da ist der fehler...


was soll eigentlich raus kommen?


----------



## Tombery (15. Nov 2009)

debugger nehmen wir erst irgendwann im dezember durch ^^"

die Ausgabe sollte so aussehen (quadrate untereinander):

#. . . . . . . . .
##. . . . . . . .
###. . . . . . .
####. . . . . .
#####. . . . .
######. . . .
#######. . .
########. .
######### .
##########
(für ecke = 0, seite = 10)

##########
######### .
########. .
#######. . .
######. . . .
#####. . . . .
####. . . . . .
###. . . . . . .
##. . . . . . . .
#. . . . . . . . .
(ecke = 1, seite = 10)

##########
.#########
. .########
. . .#######
. . . .######
. . . . .#####
. . . . . .####
. . . . . . .###
. . . . . . . .##
. . . . . . . . .#
(ecke = 2, seite = 10)

. . . . . . . . .#
. . . . . . . .##
. . . . . . .###
. . . . . .####
. . . . .#####
. . . .######
. . .#######
. .########
.#########
##########
(ecke = 3, seite = 10)


----------



## Tombery (15. Nov 2009)

ich habe etwas rumprobiert und nun das hier bekommen:

aber jetzt kommt wieder garnichts raus


```
public class Quadrat {

	//Datenelemente
	
	private int ecke;
	private int seite;
	
	//Konstanten zur Darstellung des Musters
	
	public static final String SIGN1 = "#";
	public static final String SIGN2 = ".";
	
	//Costum-Konstruktor
	
	public Quadrat (int seite, int ecke)
	{
		this.seite = seite;
	    this.ecke = ecke;
	}
	
	//Methode für neue Werte
	
	public void update(int seite, int ecke)
	{
		this.seite = seite;
        this.ecke = ecke;
	}
	
	//Methode zur Ausgabe des Musters
	
	public void draw()
	{
		int zeile;
		int spalte;
		
		//Muster
			if (ecke == 0)
			{
				//Rauten
				
				//Zeilen für Rauten
				for(zeile = 1; zeile < seite; zeile++)
				{
					//Spalten für Rauten
					for(spalte = zeile; spalte <= zeile; spalte--)
					{
					System.out.print(SIGN1);
				}
					System.out.println();
				}
				
				//Punkte
				
				//Zeilen für Punkte
				for(zeile = seite; zeile <= seite-1; zeile--)
				{
					//Spalten für Punkte
					for(spalte = 2; spalte <= zeile; spalte++)
					{
					System.out.print(SIGN2);
				}
					System.out.println();
			    }
			}
			if (ecke == 1)
			{
                //Rauten
				
				//Zeilen für Rauten
				for(zeile = seite; zeile < seite; zeile--)
				{
					//Spalten für Rauten
					for(spalte = seite; spalte <= zeile; spalte--)
					{
					System.out.print(SIGN1);
				}
					System.out.println();
				}
				
				//Punkte
				
				//Zeilen für Punkte
				for(zeile = 2; zeile <= seite-1; zeile++)
				{
					//Spalten für Punkte
					for(spalte = 2; spalte <= zeile; spalte++)
					{
					System.out.print(SIGN2);
				}
					System.out.println();
			    }
			}
			if (ecke == 2)
			{
				//Punkte
				
				//Zeilen für Punkte
				for(zeile = 2; zeile < seite; zeile++)
				{
					//Spalten für Punkte
					for(spalte = 1; spalte <= zeile; spalte--)
					{
					System.out.print(SIGN2);
				}
					System.out.println();
			    }
                //Rauten
				
				//Zeilen für Rauten
				for(zeile = seite; zeile < seite; zeile--)
				{
					//Spalten für Rauten
					for(spalte = 1; spalte <= zeile; spalte++)
					{
					System.out.print(SIGN1);
				}
					System.out.println();
				}
			}
			if (ecke == 3)
			{
				//Punkte
				
				//Zeilen für Punkte
				for(zeile = seite-1; zeile <= seite-1; zeile--)
				{
					//Spalten für Punkte
					for(spalte = seite-1; spalte <= zeile; spalte--)
					{
					System.out.print(SIGN2);
				}
					System.out.println();
			    }
                //Rauten
				
				//Zeilen für Rauten
				for(zeile = seite; zeile < seite; zeile++)
				{
					//Spalten für Rauten
					for(spalte = 1; spalte <= zeile; spalte++)
					{
					System.out.print(SIGN1);
				}
					System.out.println();
				}
			}
		
	}
	
	//main-Methode
	
	public static void main (String[] args){
		
		//erstes Quadrat
		Quadrat quadrat1 = new Quadrat(10,0);
		quadrat1.draw();
		
		//zweites Quadrat
		quadrat1.update(10,1);
		quadrat1.draw();
		
		//drittes Quadrat
		quadrat1.update(10,2);
		quadrat1.draw();
		
		//viertes Quadrat
		quadrat1.update(10,3);
		quadrat1.draw();
	}
}
```


----------



## Tombery (16. Nov 2009)

hm......also die muster sind bestimmt nicht richtig....aber ich wäre ungemein erleichtert, wenn sich wenigstens die fehlerhaften muster ZEIGEN lassen würden ???:L aber es wird ja wirklich rein garnichts ausgegeben...

gibt es eigentlich nachhilfe für softwareentwicklung?? ich scheine dafür ein echtes handicap zu besitzen *lol*


----------



## Sonecc (17. Nov 2009)

Du hast eine Endlosschleife produziert...


```
//Zeilen für Rauten
                for(zeile = 1; zeile < seite; zeile++)
                {
                	System.out.println("zeile " + zeile);
                    //Spalten für Rauten
                    for(spalte = zeile; spalte <= zeile; spalte--)
                    {
                    	System.out.print(SIGN1);
                    }
                    System.out.println();
                }
```

In diesem Code Bereich ist sie gut zu sehen.


```
for(spalte = zeile; spalte <= zeile; spalte--)
```
Dort ist die Endlosschleife.
Beispiel:
zeile = 5;
spalte = zeile = 5;
spalte <= zeile  -> true
spalte-- -> spalte = 4
spalte (4) <= zeile (5)   -> true
...

so setzt sich das fort und damit terminiert deine Schleife nicht.
Dass nichts angezeigt wird, liegt daran, dass irgendwann zuviel angezeigt wird^^


----------



## Tombery (17. Nov 2009)

ah danke! 

könnte hier mir jemand noch bitte erklären, wie man genau das 1. quadrat darstellt? ich möchte gerne das prinzip verstehen. 

ich habe ja:
(wobei das bestimmt falsch ist und wieder ne endlosschleife irgendwo versteckt ist)


```
if (ecke == 0) 
                        { 
                                //Rauten 
                                
                                //Zeilen für Rauten 
                                for(zeile = 1; zeile <= seite; zeile++) 
                                { 
                                        //Spalten für Rauten 
                                        for(spalte = zeile; spalte < zeile; spalte--) 
                                        { 
                                        System.out.print(SIGN1); 
                                } 
                                        System.out.println(); 
                                } 
                                
                                //Punkte 
                                
                                //Zeilen für Punkte 
                                for(zeile = seite-1; zeile <= seite-1; zeile--) 
                                { 
                                        //Spalten für Punkte 
                                        for(spalte = 2; spalte < zeile; spalte++) 
                                        { 
                                        System.out.print(SIGN2); 
                                } 
                                        System.out.println(); 
                            } 
                        }
```

wie ich auf diese schleifen komme?
ich habe erst 2 schleifen für das rautenmuster definiert und dann 2 schleifen für das punkte-muster. 

rautenmuster-zeilen: 

for(zeile = 1; zeile <= seite; zeile++) 

zeile = 1, da der anfangswert 1 ist, da die erste zeile benutzt wird und es mit einer einzigen raute anfängt... 
zeile <= seite, da die rauten immer um eins weniger werden BIS die zeilen die anzahl der seitenzeichen gleicht (letzte zeile hat ja 10 zeichen) 
zeile++, da die zeichen/rauten-anzahl immer größer wird 

rautenmuster-spalten: 

for(spalte = zeile; spalte < zeile; spalte--) 

spalte = zeile, da es mit der 1.spalte beginnt, die dieselbe anzahl rauten hat wie die seitenzahl 
spalte < zeile, da ähm...tja....eigentlich...10x10....spalte = zeile...aber das geht ja nicht... 
spalte--, da die spalten immer um eine raute weniger wird


----------



## Tombery (18. Nov 2009)

habe nun die quadrate! ^^ *freuuuu* 

nur noch ne kurze frage:


```
if (ecke == 0){
				
				//Zeilen und Spalten, in diesem Fall sind sie gleich (da Quadrat), deswegen nur eine Schleife
				
				for(int zeile_spalte = 1; zeile_spalte <= seite; zeile_spalte++){
```

hier wird in der for-schleife das "zeile_spalte++" in eclipse als unnötig markiert (gelbes ausrufezeichen)

weshalb?


----------

