# Mittels For Schleife Klasse erzeugen



## Neuer001 (23. Jan 2012)

Hallo,

ich möchte mit einer for-Schleife Klassen erzeugen nach folgenden Muster:


```
char c = 'a';
  for(int i = 1; i<5, i++){
    Oberklasse c = new Unterklasse();
    c++;
  }
```
Ich möchte also 4 Unterklassen erzeugen, das Problem ist dabei nur, dass der Compiler logischerweise denkt, er soll eine Unterklasse mit Namen c erzeugen. Derweil soll c ja die Variable sein, welche pro Schleifendurchgang erhöht wird (a,b,c,...)

Wie kann ich das Problem beheben?


----------



## Schandro (23. Jan 2012)

dynamische Variablennamen gibts nicht in Java... Du kannst es bspw. mit ner HashMap lösen:

```
HashMap<Character, Oberklasse> objects = new HashMap<Character, Oberklasse>();
		for(char c = 'a'; c<='e'; ++c){
			objects.put(c, new Unterklasse());
		}

		objects.get('b').doSomething();
```


----------



## Gast2 (23. Jan 2012)

So geht das nicht. Wenn du beliebig viele Instanzen erzeugen willst, dann musst du Arrays oder listen verwenden.


----------



## Neuer001 (23. Jan 2012)

HashMap sagt mir leider überhaupt ncihts und mit einem char-Array schaffe ich es auch nicht. 

```
char[] c = new char[5];
char buchstabe = 'a';
  for(int i = 0; i<5, i++){
    char[i] = buchstabe;
    Oberklasse c[i] = new Unterklasse();
    buchstabe++;
  }
```


----------



## Schandro (23. Jan 2012)

ich hab doch nen kompletten Beispielcode für HashMap gepostet...


----------



## Neuer001 (23. Jan 2012)

Könntest du mir den vielleicht erklären? Ich verwende nämlich ungern etwas, was ich nicht verstanden habe und außerdem war das ja nur ein Beispiel für mein Problem.


----------



## Attila (23. Jan 2012)

z.B.:

```
//...
Oberklasse o = objects.get('b');
// o --> eine Instanz von Unterklasse
```


----------



## jgh (23. Jan 2012)

warum gleich die Collections benutzen, wenn der TO -wie man unschwer erkennen kann- Anfänger ist?


```
Oberklasse[] oberKlassenArray = new Oberklasse[4];
for (int i = 0; i < 4; i++) {
			oberKlassenArray[i] = new UnterKlasse();
		}
```


----------



## JanHH (23. Jan 2012)

Was hast Du denn bloss vor? Das macht irgendwie keinen guten Eindruck..


----------



## jgh (23. Jan 2012)

JanHH hat gesagt.:


> Was hast Du denn bloss vor? Das macht irgendwie keinen guten Eindruck..



meinst du mich, oder den TO?


----------



## ARadauer (23. Jan 2012)

Neuer001 hat gesagt.:


> Könntest du mir den vielleicht erklären? Ich verwende nämlich ungern etwas, was ich nicht verstanden habe und außerdem war das ja nur ein Beispiel für mein Problem.



Hier wird das gut erklärt Java ist auch eine Insel – 11 Datenstrukturen und Algorithmen

Also im Grunde musst du deine Objekte wo rein packen.... Liste, Array, Map. Eine Map ist einfach ein Container wo du Objekte anhand eines Schlüssels rein packen kannst und anhand dieses Schlüssesl wieder raus lesen kanns... Dort könnte man Artikel anhand ihrer Artikel Nummer ablegen, oder ben deine Oberklasse anahnd eines characters


----------



## Neuer001 (23. Jan 2012)

Das geht wohl zu weit und kann nicht die Lösung für mein Aufgabenblatt sein.
Folgende Aufgabe:
Ich soll ein Spiel mit verschiedenen Spielertypen (offensiv, defensiv,...) programmieren und ihnen gleichzeitig einen Namen geben.

Ich habe eine normale Hauptklasse nach dem Schema:

```
class Hauptklasse{
  public static void main(String[] args){
  ...
  }
}
```
Eine abstrakte Oberklasse in der das Spiel gespielt wird:

```
class Spieler{
  
}
```
Und zwei Unterklassen für die Spielertypen:

```
class Spielertyp1{
  
}

class Spielertyp2{
}
```
In der Hauptklasse soll nun abgefragt werden, wieviele Spieler teilnehmen und anschließend entsprechend die Spielernahmen A,B,C,... zugeordnet werden. Zusätzlich immer abwechselnd den Spielertyp1, Spielerty2, Spielertyp1 ...

Mir erschien es eben sinnvoll hier eine for-Schleife zu verwenden.


----------



## timbeau (23. Jan 2012)

Das ist nicht komplex sondern sehr basic. 

Du musst deine Spielernamen irgendwo speichern. Das kannst du in einem sehr simplen Array machen

z.B. 


```
for(char a = 'a', z = 'z'; a <= z; a++) {
	         System.out.println("spieler-" + a+" ");
	    }
```

was dann "spieler-a, spieler-b....." ergibt.

Aber ich würde eher die Instanzen der Spielerklassen in einer Liste o.ä. speichern. Die Namen könnten dann mit der obigen Schleife vergeben werden und in den einzelnen Objekten gespeichert.


----------



## Neuer001 (23. Jan 2012)

jgh's Lösung scheint funktionieren zu können:

Oberklasse[] oberKlassenArray = new Oberklasse[4];

Damit wird ja ein Array erzeugt. in der for-Schleife werden dann die Klassen erzeugt. Das funktioniert auch wunderbar. Nur wie kann ich den Klassen den Namen A, B, C ... geben?


----------



## Michael... (23. Jan 2012)

Neuer001 hat gesagt.:


> Nur wie kann ich den Klassen den Namen A, B, C ... geben?


Du erzeugst keine Klassen sondern Objekte bzw. Instanzen einer Klasse.
Warum sollte man diesen den Namen A, B oder C geben wollen? Man kann diese ja über das Array und den entsprechenden Index ansprechen.
[EDIT]Wenn mit Name der Spieler Name gemeint ist, dann benötigt die Klasse Spieler zunächst ein Attribut 
	
	
	
	





```
name
```
. Die Namen könnte man am Anfang in einem String-Array festlegen und in der Schleife den Spieler Objekten zuweisen.[/EDIT]


----------



## timbeau (23. Jan 2012)

```
for (.......){
Array[i] = new Klasse();
}
int x = 0;
for(j = a -> z) {
Array[x++].setName(j);
if(x=Array.length) break;
}
```

PseudoCode


----------



## Neuer001 (23. Jan 2012)

```
class Hauptklasse{
  public static void main(String[] args){
    Spieler susi = new Spieler("Susi");//das hier wäre eine variante für eine feste anzahl an spielern
    Spieler fritz = new Spieler("Fritz");//es soll aber die Anzahl  der Spieler abgefragt werden
    Spieler egon = new Spieler("Egon");// und anschließend statt susi 'A' stehen usw. 
      Oberklasse[] oberKlassenArray = new Oberklasse[4];
         for (int i = 0; i < 4; i++) {
            oberKlassenArray[i] = new UnterKlasse();
        } */ 
  }
}
```

Eine abstrakte Oberklasse in der das Spiel gespielt wird:

```
class Spieler{
    Spieler(String name) {
    this.name = name;
    Out.println("Spieler " + name + " nimmt teil");
  }
}
```

Und zwei Unterklassen für die Spielertypen:
class Spielertyp1{

}

```
class Spielertyp2{
}
```

In der Hauptklasse funktioniert das mit dem Array schon, dass ich also eine bestimmte Anzahl an Spieler erstelle. Nur möchte ich den Spielern ja einen Namen geben.


----------



## timbeau (23. Jan 2012)

Überleg dir mal den Sinn von Setter-Methoden und dein Problem sollte sich ziemlich schnell auflösen.


----------



## Neuer001 (23. Jan 2012)

Setter Methoden?


----------



## timbeau (23. Jan 2012)

Setter Methoden! :rtfm:


----------



## Neuer001 (23. Jan 2012)

Könntest du das vielleicht genauer erklären wie du das meinst? In meinem LEhrbuch finde ich jetzt nichts passendes dazu.

Meinst du vielleicht so etwas?

class Hauptklasse{
  Hauptklasse Spieler;
  void setSpieler (Hauptklasse Spieler){
    this.Spieler = Spieler;
  }
}

Aber wozu soll mir das Helfen? Und ob das eine Setter-Methode ist weiß ich auch nicht.


----------



## timbeau (23. Jan 2012)

```
public class SpielerNamen {

	public static void main(String[] args) {
		
		//Spieler in einer Datenstruktur speichern 
		Spieler [] alleSpieler = new Spieler[10];
		for (int i = 0; i < alleSpieler.length; i++) {
			alleSpieler[i] = new Spieler(); // neue Spieler anlegen
		}
		
		int x = 0;
		for(char a = 'a', z = 'z'; a <= z; a++) {
	         alleSpieler[x++].setName("spieler-" + a); //namen vergeben
	         if(x == alleSpieler.length) break;
	    }
		
		/* Ausgabe */
		for (int i = 0; i < alleSpieler.length; i++) {
			System.out.println(alleSpieler[i].getName());
		}
		
	}
	
	
}

class Spieler {
	
	private String name;
	
	public void setName(String name){
		this.name = name;
	}
	
	public String getName(){
		return name;
	}
}
```

Ausgabe: 
spieler-a
spieler-b
spieler-c
spieler-d
spieler-e
spieler-f
spieler-g
spieler-h
spieler-i
spieler-j



Setter-Methoden dienen für Zugriffe auf Attribute (hier name) von einzelnen Instanzen (hier einzelne Spieler in dem Array) von Klassen (hier die "class" Spieler)


----------



## Neuer001 (23. Jan 2012)

Warum kann man denn in Zeile 13 nicht anstatt von "Spieler-" +a nur a schreiben?

Ist es korrekt, dass mittels dieses setName der erzeugten Instanz der Buchstabe A,... zugeordnet wird?


----------



## Schandro (23. Jan 2012)

NEIN, es gibt keine dynamischen Variablennamen!


----------



## timbeau (23. Jan 2012)

Zu 1: Klar, den String "spieler-" kannst du natürlich weglassen. Einfach ausprobieren hätte dir hier aber Klarheit geschafft. 

Zu 2: Mittels der set-Methode wird dem Attribut "name" der aktuellen Spielerinstanz, der übergebene String name zugeordnet. Der übergebene String wird in der Schleife erzeugt & übergeben

@Schandro: Das passt schon so...Zeile 13 nicht darüber


----------



## rom4o (17. Dez 2012)

*Hallo Leute ich habe ebenfalls das Problem, dass ich beliebig viele Objekte von Punkten erzeugen möchte.*

Ich befinde mich in der Oberklasse AquaApplet
Ein Punkt hat folgende Klassendefinition:

```
private static class Dot{
   private Vector3D p,v;
   private double r;
   private double m;
   private Color color;
   .....
}
```
*So initialisiere ich ein Array vom Typ Dot mit 3Elementen:*

```
Dot dots [] = new Dot[]{new Dot(new Vector3D(10,10,0),new Vector3D(0.1,0.2,0),r,mass(r),Color.BLUE),
				new Dot(new Vector3D(20,20,0),new Vector3D(3.0,2.0,0),r,mass(r),Color.BLUE),
			  new Dot(new Vector3D(30,30,0),new Vector3D(2.0,2.0,0),r,mass(r),Color.BLUE)};
```
*Das funktioniert perfekt
Ich habe wie im Forum beschrieben versucht mehrere Objekte wie folgt zu definieren.*

```
Dot dots[] = new Dot[3];
		   for (int n=0;n<dots.length;n++) {
			   dots[n] = new Dot(new Vector3D(3*n,10,0),new Vector3D(0.1,0.2,0),r,mass(r),Color.BLUE);
		   }
```
*Leider funktioniert das nicht. Ich arbeite unter Eclipse

hinter 
	
	
	
	






		Java:In die Zwischenablage kopieren


Dot dots[] = new Dot[3];

 kommt folgende Fehlermeldung 'Syntax error on token";",{expected after this token '. Aber das macht keinen Sinn, wenn ich die for-Schleife entferne ist der Fehler weg.

Woran liegt das, wie initialisiert man mit einer for-Schleife komplexere Objekte??*


----------



## Phash (17. Dez 2012)

Hallo rom4o

poste bitte den ganzen Code.

Wie du aber an der Fehlermeldung siehst, scheint ein Zeichen zu fehlen (eine Klammer nach einem Strichpunkt)

die Plugins PMD und Findbugs sollten dir sowas anzeigen - waere aber mit Spatzen auf Code geschossen oder so aehnlich...

geh deinen Code zeilenweise durch, und schau, wo ein solches Zeichen fehlen koennte.
Wenn du mit dem Cursor nach bzw vor einer Klammer stehst, zeigt dir Eclipse, wie weit die Klammer geht.
Siehst du, dass deine Klammer keinen Bereicht umschliesst, weisst du dass was fehlt.


was hiergegen hilft ist CleanCode - lagere deine Prozessschritte in Methoden aus;


```
Dot dots[] = new Dot[3];
           for (int n=0;n<dots.length;n++) {
               dots[n] = new Dot(new Vector3D(3*n,10,0),new Vector3D(0.1,0.2,0),r,mass(r),Color.BLUE);
           }
```
koennte zum Beispiel in eine Methode ausgelagert werden, die ein Dot[] zurueckliefert...
das macht alles viel einfacher


----------



## rom4o (17. Dez 2012)

*Hallo Phash,
das mit dem in eine Methode auslagern habe ich schon probiert geht nicht.
hier die beiden Codes:
"Vector3D.java"*

```
public class Vector3D {
   
   //xyz
   double x,y,z;
   
   //constructors
   public Vector3D(){
      x=y=z=0.0;
   }
   
   public Vector3D(double _x,double _y,double _z){
      x=_x; y=_y; z=_z;
   }
   
   public Vector3D(Vector3D v){
      x=v.x; y=v.y; z=v.z;
   }
   
   //getLength, getSqrLength
   public double getLength(){
      return Math.sqrt(x*x+y*y+z*z);
   }
   
   public double getSqLength(){
      return x*x+y*y+z*z;
   }
   
   // v+v v-v
   public Vector3D add(Vector3D v){
      return new Vector3D(x+v.x, y+v.y, z+v.z);
   }
   
   public Vector3D sub(Vector3D v){
      return new Vector3D(x-v.x, y-v.y, z-v.z);
   }
   
   //v*d v/d
   public Vector3D mul(double d){
      return new Vector3D(x*d, y*d, z*d);
   }
   
   public Vector3D div(double d){
      return new Vector3D(x/d, y/d, z/d);
   }
   
   //scalar and cross products
   public double dot(Vector3D v){
      return x*v.x+y*v.y+z*v.z;
   }
   
   public Vector3D cross(Vector3D v){
      return new Vector3D(y*v.z-z*v.y,
                     z*v.x-x*v.z,
                     x*v.y-y*v.x);
   }
   
   //normalize
   public Vector3D normalize(){
      return this.div(getLength());
   }
   
   //getCos getSin getAngle
   public double getCos(Vector3D v){
      return this.dot(v)/Math.sqrt(this.getSqLength()*v.getSqLength());
   }
   
   public double getSin(Vector3D v){
      return Math.sqrt(this.cross(v).getSqLength()/(this.getSqLength()*v.getSqLength()));
   }
   
   public double getAngle(Vector3D v){
      return Math.acos(this.getCos(v));
   }
   
   //some useful static constants and functions
   public static final Vector3D NULL=new Vector3D(0,0,0);
   public static final Vector3D eX=new Vector3D(1,0,0);
   public static final Vector3D eY=new Vector3D(0,1,0);
   public static final Vector3D eZ=new Vector3D(0,0,1);
}
```

*"AquaApplet.java"*

```
import java.awt.*;//Graphics;
import javax.swing.*;//JFrame
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.util.Date;

public class AquaApplet extends JPanel {

	   // VARIABLEN
		static int fweite = 600;
		static int fhoehe = 600;
		static int fposx = 300;
		static int fposy = 100;
	    private long timer;
        private long elapsedTime;
			    
		private Thread t;
		double mass(double radius){
			double volumen;
			volumen = (4/3)*Math.PI*Math.pow(radius, 3);
			return volumen;
		}
		static double r = 2;
		Color c9 = new Color(200,100,100);
		Rectangle rec = new Rectangle(0,0,fweite-3,fhoehe-32); //Ersten beiden Einträge Startposition im Fenster

/*
//Variante 2 - funktioniert nicht !!! ??????????????????
		Dot dots[] = new Dot[3];
		   for (int n=0;n<dots.length;n++) {
			   dots[n] = new Dot(new Vector3D(3*n,10,0),new Vector3D(0.1,0.2,0),r,mass(r),Color.BLUE);
		   }
*/
		
///*
//Variante 1 - funktioniert aber bei vielen Objekten umständlich!!!
		Dot dots [] = new Dot[]{new Dot(new Vector3D(10,10,0),new Vector3D(0.1,0.2,0),r,mass(r),Color.BLUE),
					  new Dot(new Vector3D(20,20,0),new Vector3D(3.0,2.0,0),r,mass(r),Color.BLUE),
					  new Dot(new Vector3D(30,30,0),new Vector3D(2.0,2.0,0),r,mass(r),Color.BLUE),  
		};
//*/
	   
	   // Interne Klasse Dot
	   private static class Dot{
		      private Vector3D p,v;
		      private double r;
		      private double m;
		   	  private Color color;
		      
		      public Dot(Vector3D p, Vector3D v, double r, double m, Color color){
		         this.p=p;	//Position
		         this.v=v;	//Geschwindigkeit
		         this.r=r;	//Radius
		         this.m=m;	//Masse
		         this.color=color;	//Farbe
		      }
		      
		      public void move(double dt, Rectangle rect){
		         //check collision with bound-rectangle
		         if(p.x<rect.x+r){
		            p.x=rect.x+r; v.x=-v.x;
		         }else if(p.x>rect.x+rect.width-r){
		            p.x=rect.x+rect.width-r; v.x=-v.x;
		         }else if(p.y<rect.y+r){
		            p.y=rect.y+r; v.y=-v.y;
		         }else if(p.y>rect.y+rect.height-r){
		            p.y=rect.y+rect.height-r; v.y=-v.y;
		         }
		      }
	   }
	   // ------------
	   
	   public AquaApplet(String newTitel) { // Konstruktormethode
	      //super.setTitle(newTitel);
	   }

	   public void start() {   //Hauptmethode hat nichts mit Thread zu tun
	       timer=System.currentTimeMillis();
	       t = new Thread(new Runnable(){
	          public void run(){
	                while(true){
	                	//Laufzeit
	                	elapsedTime=-timer+(timer=System.currentTimeMillis());
	                	//Punkte
	                   try{
	                      Thread.sleep(1);	//default = 5
	                      repaint();
	                   } catch(InterruptedException e){;}
	                }
	               }
	            }
	          );

	       t.start();
	   }

	//----------------------------------------------------------------------
	//MAIN-METHODE
	    public static void main(String str[]) {   //MAIN
	       JFrame fenster = new JFrame("AquaApplet"); //JFrame-Hauptobjekt
	       fenster.setSize(fweite, fhoehe);
	       fenster.setLocation(fposx,fposy);
	       fenster.setResizable( false );
	       fenster.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); //beendet das Programm beim schließen des Fensters
	     //Hinzufügen eines Labels
	       UIDefaults uiDefaults = UIManager.getDefaults();
	       uiDefaults.put( "Label.font",((Font)uiDefaults.get("Label.font")).deriveFont(15f) );
	       AquaApplet kb = new AquaApplet("");
	     kb.setBackground(Color.WHITE); //setzt die Hintergrundfarbe
	     fenster.getContentPane().add(kb); //Inhalt von kb wird in den fenster-Container übergeben
	       
	     //setze Fenster sichtbar
	       fenster.setVisible(true);
	       kb.start();   //Hauptmethode wird ausgeführt
	    }
	//----------------------------------------------------------------------
	//PAINTMETHODE
	    public void paintComponent(Graphics g) {   //Paintmethode
	    	super.paintComponent(g);
            for(int i=0; i<dots.length; i++){
    	    	g.setColor(dots[i].color);
    	    	g.drawLine((int)(dots[i].p.x),(int)(dots[i].p.y),(int)(dots[i].p.x),(int)(dots[i].p.y));
            }
	    }
}
```

*Hoffentlich kann mir einer helfen???*


----------



## Phash (17. Dez 2012)

ich schaus mir gleich mal an - installier nur fix das JDK auf dem PC hier


----------



## Phash (18. Dez 2012)

so habs refactored... und da es spaet ist hab ich den Fehler erst spaet gefunden...

du initialisierst dein Array einmal (Variante 2) inline
und einmal in einer for schleife - diese liegt im Deklarationsbereich und nicht innerhalb einer Methode. Das kann nicht funktionieren.


```
package de.mroedig.vector;

import javax.swing.JPanel;
import java.awt.*;//Graphics;
import javax.swing.*;//JFrame
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.util.Date;

public class AquaApplet extends JPanel {
	// VARIABLEN
    static int fweite = 600;
    static int fhoehe = 600;
    static int fposx = 300;
    static int fposy = 100;
    private long timer;
    private long elapsedTime;
            
    private Thread t;
   
    static double r = 2;
    Color c9 = new Color(200,100,100);
    Rectangle rec = new Rectangle(0,0,fweite-3,fhoehe-32); //Ersten beiden Einträge Startposition im Fenster

   public AquaApplet(String newTitel) { // Konstruktormethode
	  
       JFrame fenster = initialisiereFenster();
     //Hinzufügen eines Labels
       UIDefaults uiDefaults = UIManager.getDefaults();
       uiDefaults.put( "Label.font",((Font)uiDefaults.get("Label.font")).deriveFont(15f) );
       
       this.setBackground(Color.WHITE); //setzt die Hintergrundfarbe
       fenster.getContentPane().add(this); //Inhalt von kb wird in den fenster-Container übergeben
       
       //setze Fenster sichtbar
       fenster.setVisible(true);
       this.start();   //Hauptmethode wird ausgeführt
   }

   public void start() {   //Hauptmethode hat nichts mit Thread zu tun
       timer=System.currentTimeMillis();
       t = new Thread(new Runnable(){
          public void run(){
                while(true){
                    //Laufzeit
                    elapsedTime=-timer+(timer=System.currentTimeMillis());
                    //Punkte
                   try{
                      Thread.sleep(1);  //default = 5
                      repaint();
                   } catch(InterruptedException e){;}
                }
               }
            }
          );

       t.start();
   }

	private JFrame initialisiereFenster() {
		JFrame fenster = new JFrame("AquaApplet"); //JFrame-Hauptobjekt
		   fenster.setSize(fweite, fhoehe);
		   fenster.setLocation(fposx,fposy);
		   fenster.setResizable( false );
		   fenster.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); //beendet das Programm beim schließen des Fensters
		return fenster;
	}
//----------------------------------------------------------------------
//PAINTMETHODE
    public void paintComponent(Graphics g) {   //Paintmethode
        super.paintComponent(g);
        Dot[] dots = this.getNeuesDotArray(3);
        for(int i=0; i<dots.length; i++){
            g.setColor(dots[i].color);
            g.drawLine((int)(dots[i].p.x),(int)(dots[i].p.y),(int)(dots[i].p.x),(int)(dots[i].p.y));
        }
    }
    public Dot[] getNeuesDotArray(int groesse){
    	Dot[] punkte = new Dot[groesse];
    	 for (int n=0;n<groesse;n++) {
             punkte[n] = new Dot(new Vector3D(3*n,10,0),new Vector3D(0.1,0.2,0),r,mass(r),Color.BLUE);
         }
    	 return punkte;
    }
    
    public double mass(double radius){
        double volumen;
        volumen = (4/3)*Math.PI*Math.pow(radius, 3);
        return volumen;
    }
}
```


```
package de.mroedig.vector;

import java.awt.Color;
import java.awt.Rectangle;

class Dot {
	           Vector3D p,v;
	           double r;
	           double m;
	          Color color;
	          
	 
	          public Dot(Vector3D p, Vector3D v, double r, double m, Color color){
	             this.p=p;  //Position
	             this.v=v;  //Geschwindigkeit
	             this.r=r;  //Radius
	             this.m=m;  //Masse
	             this.color=color;  //Farbe
	          }
	          
	          public void move(double dt, Rectangle rect){
	             //check collision with bound-rectangle
	             if(p.x<rect.x+r){
	                p.x=rect.x+r; v.x=-v.x;
	             }else if(p.x>rect.x+rect.width-r){
	                p.x=rect.x+rect.width-r; v.x=-v.x;
	             }else if(p.y<rect.y+r){
	                p.y=rect.y+r; v.y=-v.y;
	             }else if(p.y>rect.y+rect.height-r){
	                p.y=rect.y+rect.height-r; v.y=-v.y;
	             }
	          }
	   }
```


```
package de.mroedig.vector;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		AquaApplet applet = new AquaApplet("AquaApplet");

	}

}
```


```
package de.mroedig.vector;

public class Vector3D {
	//xyz
	   double x,y,z;
	   
	   //constructors
	   public Vector3D(){
	      x=y=z=0.0;
	   }
	   
	   public Vector3D(double _x,double _y,double _z){
	      x=_x; y=_y; z=_z;
	   }
	   
	   public Vector3D(Vector3D v){
	      x=v.x; y=v.y; z=v.z;
	   }
	   
	   //getLength, getSqrLength
	   public double getLength(){
	      return Math.sqrt(x*x+y*y+z*z);
	   }
	   
	   public double getSqLength(){
	      return x*x+y*y+z*z;
	   }
	   
	   // v+v v-v
	   public Vector3D add(Vector3D v){
	      return new Vector3D(x+v.x, y+v.y, z+v.z);
	   }
	   
	   public Vector3D sub(Vector3D v){
	      return new Vector3D(x-v.x, y-v.y, z-v.z);
	   }
	   
	   //v*d v/d
	   public Vector3D mul(double d){
	      return new Vector3D(x*d, y*d, z*d);
	   }
	   
	   public Vector3D div(double d){
	      return new Vector3D(x/d, y/d, z/d);
	   }
	   
	   //scalar and cross products
	   public double dot(Vector3D v){
	      return x*v.x+y*v.y+z*v.z;
	   }
	   
	   public Vector3D cross(Vector3D v){
	      return new Vector3D(y*v.z-z*v.y,
	                     z*v.x-x*v.z,
	                     x*v.y-y*v.x);
	   }
	   
	   //normalize
	   public Vector3D normalize(){
	      return this.div(getLength());
	   }
	   
	   //getCos getSin getAngle
	   public double getCos(Vector3D v){
	      return this.dot(v)/Math.sqrt(this.getSqLength()*v.getSqLength());
	   }
	   
	   public double getSin(Vector3D v){
	      return Math.sqrt(this.cross(v).getSqLength()/(this.getSqLength()*v.getSqLength()));
	   }
	   
	   public double getAngle(Vector3D v){
	      return Math.acos(this.getCos(v));
	   }
	   
	   //some useful static constants and functions
	   public static final Vector3D NULL=new Vector3D(0,0,0);
	   public static final Vector3D eX=new Vector3D(1,0,0);
	   public static final Vector3D eY=new Vector3D(0,1,0);
	   public static final Vector3D eZ=new Vector3D(0,0,1);
}
```

Ich habe die main Methode in eine eigene Klasse ausgelagert - die hat da nix zu suchen.
Die Dot Klasse ist eine eigene Klasse - was spricht dagegen, dass andere diese auch benutzen?


----------



## rom4o (18. Dez 2012)

Hallo Phash,
super ich habe deine Modifikation ausprobiert funktioniert bestens.
Ich habe die Punktgenerierung in den Anfang von AquaApplet gelegt weil ich auch aus anderen Methoden auf die Punkte zugreifen muss. Die Punkte Konstruktormethode habe ich gerade angepasst.

```
public Dot[] getNeuesDotArray(int groesse){
        Dot[] punkte = new Dot[groesse];
        int l = 10;
        int m = 10;
         for (int n=0;n<groesse;n++) {
        	 l=l+10;
        	 if(l>400)l=10;
             punkte[n] = new Dot(new Vector3D(l,m+n,0),new Vector3D(0.01,0.02,0),r,mass(r),Color.BLUE);
             if(n%80==0)m=m+10;
             if(m%400==0)m=10;
         }
         return punkte;
    }
```
Habe damit gerade 300 Punkte erzeugt.
Super Hilfe. Danke
Wann benutzt man denn Unterklassen, so wie ich es zuerst gemacht habe?
Ich wollte halt alles möglichst in einem Code haben. Aber teilen scheint besser zu sein.

Beste Grüße


----------



## Landei (18. Dez 2012)

"Objektorientierung" heißt, jede Klasse weiß über ihre eigenen Angelegenheiten prima Bescheid, und über fremde Angelegenheiten gerade so viel wie nötig. Das hat nicht nur Vorteile für die Programmorganisation, die Transparenz, die Refaktorierbarkeit und die Flexibilität des Systems, sondern auch "mental" - nämlich, dass man sich bei einem Stückchen Code auch immer nur auf einen bestimmten Teilaspekt des Systems konzentrieren muss. Das mag jetzt alles etwas abstakt klingen, aber für die richtige "Granularität" der Klassenaufteilung bekommt man eigentlich recht schnell ein Gefühl - schon deshalb, weil man _merkt_, wenn man es richtig macht: Bei zu vielen kleinen Klassen springt man andauernd zwischen den Dateien, bei zu großen Klassen sucht man sich innerhalb der Dateien tot. Die "richtige" Aufteilung ist der "sweet spot" zwischen diesen Extremen.


----------



## Phash (18. Dez 2012)

Schoen gesagt, Landei

ein Kollege hat mir, in seiner ihm eigenen Weise, eine Weisheit beigebracht, die mir beim proggen sehr hilft:

"Other People's Problem"
Was er damit meint: "alles" in Methoden auslagern und einfach davon ausgehen, dass die Methode schon richtig funktionieren wird.
Damit kann man sich erstmal auf das groessere konzentrieren und sich langsam in diese Methoden vordringen und diese realisieren.


heisst, anstatt sich in einer Methode den Kopf ueber 2-3 Sachen zu zerbrechen, baue ich nur den Ablauf mit eben 2-3 Methoden, die diese Probleme loesen und widme mich erst dem Ganzen und spaeter dem Speziellen.

Braucht ein wenig am Anfang, weil man ja alles gleich funktionierend haben will, aber wenn man sich daran gewoehnt hat, werden die Methoden kleiner, uebersichtlicher und einfacher - aus komplexen Methoden, mit vielen hundert Zeilen werden so Methoden mit wenigen Methodenaufrufen.

Clean Code 


Alles in eine Klasse zu werfen macht es unuebersichtlich.
Der einzige Sinn bestuende darin, diese Klasse private zu machen, damit keiner drauf zugreifen kann... 
aber das scheint hier nicht sinnvoll zu sein, und ich denke protected reicht...

Du hast jetzt die Methode "getNeuesDotArray" aufgeruestet und sie macht etwas anderes.
Das waere schon was fuer eine neue Methode.
eine "getNeuesDotArrayMitBreite(int anzahlPunkte, int breite)" 
dann kannst du da deine Logik reinmachen und dann gibts nocht eine

```
getNeuesQuadratischesDotArray(int anzahlPunkte){
  return getNeuesDotArrayMitBreite(anzahlPunkte, (int) Math.sqr(anzahlPunkte))
}
```


----------

