Mittels For Schleife Klasse erzeugen

N

Neuer001

Gast
Hallo,

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

Java:
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

Top Contributor
dynamische Variablennamen gibts nicht in Java... Du kannst es bspw. mit ner HashMap lösen:
Java:
		HashMap<Character, Oberklasse> objects = new HashMap<Character, Oberklasse>();
		for(char c = 'a'; c<='e'; ++c){
			objects.put(c, new Unterklasse());
		}

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

Gast2

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

Neuer001

Gast
HashMap sagt mir leider überhaupt ncihts und mit einem char-Array schaffe ich es auch nicht.
Java:
char[] c = new char[5];
char buchstabe = 'a';
  for(int i = 0; i<5, i++){
    char[i] = buchstabe;
    Oberklasse c[i] = new Unterklasse();
    buchstabe++;
  }
 
N

Neuer001

Gast
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

Bekanntes Mitglied
z.B.:
Java:
//...
Oberklasse o = objects.get('b');
// o --> eine Instanz von Unterklasse
 

jgh

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

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

ARadauer

Top Contributor
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
 
N

Neuer001

Gast
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:
Java:
class Hauptklasse{
  public static void main(String[] args){
  ...
  }
}
Eine abstrakte Oberklasse in der das Spiel gespielt wird:
Java:
class Spieler{
  
}
Und zwei Unterklassen für die Spielertypen:
Java:
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

Gesperrter Benutzer
Das ist nicht komplex sondern sehr basic.

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

z.B.

Java:
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.
 
N

Neuer001

Gast
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...

Top Contributor
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
Code:
name
. Die Namen könnte man am Anfang in einem String-Array festlegen und in der Schleife den Spieler Objekten zuweisen.[/EDIT]
 
Zuletzt bearbeitet:

timbeau

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

PseudoCode
 
N

Neuer001

Gast
Java:
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:
Java:
class Spieler{
    Spieler(String name) {
    this.name = name;
    Out.println("Spieler " + name + " nimmt teil");
  }
}

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

}
Java:
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.
 
N

Neuer001

Gast
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

Gesperrter Benutzer
Java:
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)
 
N

Neuer001

Gast
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?
 

timbeau

Gesperrter Benutzer
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

Mitglied
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:
Java:
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:
Java:
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.

Java:
		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:
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

Top Contributor
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;

Java:
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

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

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"
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

Top Contributor
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.

Java:
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;
    }
}

Java:
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;
	             }
	          }
	   }
Java:
package de.mroedig.vector;

public class Main {

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

	}

}
Java:
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

Mitglied
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.
Java:
    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

Top Contributor
"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

Top Contributor
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
Java:
getNeuesQuadratischesDotArray(int anzahlPunkte){
  return getNeuesDotArrayMitBreite(anzahlPunkte, (int) Math.sqr(anzahlPunkte))
}
 
Zuletzt bearbeitet:
Ähnliche Java Themen
  Titel Forum Antworten Datum
ravenz Schleife mit for über String Array „zahlen“und prüfen ob Wert „a“ oder „b“ oder „c“ entspricht (mittels || ) Java Basics - Anfänger-Themen 4
Khaled-Abo Ziffern unterscheiden mittels einer For-Schleife Java Basics - Anfänger-Themen 6
V Erste Schritte Potenzen b^n mittels Schleife ermitteln Java Basics - Anfänger-Themen 7
S int-Array mittels Arrays.sort() in einer Schleife sortieren. Java Basics - Anfänger-Themen 2
J mehrere JCheckBoxen mittels Schleife abfragen Java Basics - Anfänger-Themen 13
G Objekte mittels Schleife anlegen und ansprechen Java Basics - Anfänger-Themen 8
E Reihenfolge der Werte umdrehen (mittels statischem int-Array Java Basics - Anfänger-Themen 3
M Anzahl Kommandozeilenparamter mittels Methode Java Basics - Anfänger-Themen 11
B Race Condition mittels Semaphore verhindern Java Basics - Anfänger-Themen 13
B Dom Manipulationen mittels Java Java Basics - Anfänger-Themen 8
D Gerade oder ungerade Zahl mittels Methoden Java Basics - Anfänger-Themen 13
Fats Waller Compiler-Fehler Kann ich einen String und die Summe zweier Char Werte mittels der println Anweisung ausgeben Java Basics - Anfänger-Themen 4
P9cman Vokale in einem String überprüfen mittels Rekursion Java Basics - Anfänger-Themen 8
Poppigescorn Arrayliste Mittels Scanner erweitern Java Basics - Anfänger-Themen 6
TimoN11 Quadratwurzel mittels Funktionswert der Quadratfunktion Java Basics - Anfänger-Themen 9
L Quadratwurzelrechnung mittels Heron-Verfahren Java Basics - Anfänger-Themen 6
P Klassenübergreifende Ausgabe mittels "getter" nicht möglich Java Basics - Anfänger-Themen 21
M Objekte mittels equals vergleichen Java Basics - Anfänger-Themen 14
I csv auslesen, mittels List Java Basics - Anfänger-Themen 18
S XML mittels HTTP Get Anfrage Java Basics - Anfänger-Themen 4
W Teilstring durch Teilstring mittels StringBuilder ersetzen Java Basics - Anfänger-Themen 7
P Liste mit Lücken mittels Filter aggregieren Java Basics - Anfänger-Themen 7
M Methoden Mittelwert rationaler Zahlen mittels Methode Java Basics - Anfänger-Themen 4
P Klassen In einer Autoklasse das Objekt Auto mittels Collection Speichern Java Basics - Anfänger-Themen 4
M Fibonacci rekursiv mittels Cache Java Basics - Anfänger-Themen 17
K Methoden Zahlensysteme umwandeln mittels Rekursion Java Basics - Anfänger-Themen 5
A JavaScript Object Notation einbinden mittels Maven Java Basics - Anfänger-Themen 7
L Liste mittels Stack implementieren Java Basics - Anfänger-Themen 0
J OOP GUI-Einstellungen mittels Preferences Java Basics - Anfänger-Themen 0
J ComboBox mittels neuer Methode befüllen Java Basics - Anfänger-Themen 3
A Android-Lib: Sourcecode Generator mittels Annotation Processing Java Basics - Anfänger-Themen 0
W Erste Schritte Exceltabelle in Datenbank übertragen mittels XDEV Java Basics - Anfänger-Themen 7
L Histogram mittels Schleifen und Arrays Java Basics - Anfänger-Themen 9
S Klassen Tiefe Kopie mittels Kopierkonstruktor Java Basics - Anfänger-Themen 6
S Columnindex mittels Columnname herrausfinden Java Basics - Anfänger-Themen 6
M Explorer oeffnen mittels java.awt.Desktop Java Basics - Anfänger-Themen 18
Dogge URL-Ausgabe/Verarbeitungsproblem mittels einer Applikation Java Basics - Anfänger-Themen 2
H Methoden Array aus Punkten erzeugen, mittels Punkt-Klasse Java Basics - Anfänger-Themen 5
S Dateien mittels Path(s) kopieren und umbenennen. Java Basics - Anfänger-Themen 4
C Dynamische (AJAX) Inhalte einer Webseite mittels Java auslesen Java Basics - Anfänger-Themen 2
B Abfrage mittels Variable vereinfachen Java Basics - Anfänger-Themen 6
D Klassen Zeichnen von Figuren mittels vorgegebener Klasse Java Basics - Anfänger-Themen 3
P Collatz-Folge mittels indirekter Rekursion Java Basics - Anfänger-Themen 8
J Wurzelberechnung (mittels Newton) Java Basics - Anfänger-Themen 14
B Lotto mittels TreeSet Java Basics - Anfänger-Themen 3
C Vererbung "extends" umgehen mittels Objekterzeugung?! Java Basics - Anfänger-Themen 29
A String mittels RegEx filtern Java Basics - Anfänger-Themen 13
U E-Mails mittels Java senden. Java Basics - Anfänger-Themen 2
J Aufruf von Funktionen in *.jar mittels Eclipse Java Basics - Anfänger-Themen 4
E PHP Datei mittels Java aufrufen? Java Basics - Anfänger-Themen 3
P Collections Queue mittels ArrayList Java Basics - Anfänger-Themen 2
F Substring mittels RegEx ermitteln/ersetzen? Java Basics - Anfänger-Themen 2
R 3 Datumsangaben sortieren mittels Switch Java Basics - Anfänger-Themen 9
J Arraylänge mittels "Array.getLength" bestimmen!? Java Basics - Anfänger-Themen 3
I Ascii Bild mittels Scanner einlesen Java Basics - Anfänger-Themen 9
K OOP Datenkapselung mittels private - length Attribut bei Array Java Basics - Anfänger-Themen 3
M Delphi-DLL mittels JNI aufrufen Java Basics - Anfänger-Themen 11
H .jar Consolenprogramm mittels Doppelklick starten Java Basics - Anfänger-Themen 2
S SQL Anweisung mittels PreparedStatement Java Basics - Anfänger-Themen 15
M Additions mittels Rekursion Java Basics - Anfänger-Themen 15
E Array mittels Methode umgekehrt ausgeben Java Basics - Anfänger-Themen 6
Binary.Coder Skalarprodukt mittels long und binärzahlen Java Basics - Anfänger-Themen 5
M Auf Java (Desktop) Applikation mittels Webseite zugreifen Java Basics - Anfänger-Themen 6
W Suche nach strings zwischen eckigen Klammern mittels regulärer Ausdrücke Java Basics - Anfänger-Themen 3
Gonzalez Eingabe des Benutzers mittels readLine()-Methode. Klappt in meinem Beispiel nicht! Java Basics - Anfänger-Themen 7
R JTextField mittels JButton in Konsole ausgeben Java Basics - Anfänger-Themen 2
Z Terminkalender mittels Klassen und Feldern Java Basics - Anfänger-Themen 2
M Benutzer löschen mittels Netbeans Java Basics - Anfänger-Themen 4
I (fremde) IP mittels Applet auslesen Java Basics - Anfänger-Themen 6
G Mittels Runtime prüfen ob ein Programm läuft? Java Basics - Anfänger-Themen 18
M MenuShortcut nur mittels Shift+Taste Java Basics - Anfänger-Themen 3
N einbinden von anderen klassen mittels import Java Basics - Anfänger-Themen 2
M Datei speichern mittels InputStream Java Basics - Anfänger-Themen 13
G Navigations mittels Applet Java Basics - Anfänger-Themen 3
M ArrayList sortieren mittels Comparator Java Basics - Anfänger-Themen 10
C Lösung einer Aufgabe mittels Iteration und Rekursion Java Basics - Anfänger-Themen 12
T Zugriff auf umgebendes Objekt mittels Objekt innerer Klasse Java Basics - Anfänger-Themen 2
K Java-Programm mittels Shell-Skript aufrufen Java Basics - Anfänger-Themen 3
L Vorhandene SVG mittels Batik anzeigen Java Basics - Anfänger-Themen 8
K Datum mittels Thread aktualisieren Java Basics - Anfänger-Themen 6
G mittels Parameter Variable identifizieren Java Basics - Anfänger-Themen 6
T Zeitmesser mittels Threads implementieren Java Basics - Anfänger-Themen 16
V Mittels Java Pfeile erstellen Java Basics - Anfänger-Themen 3
T Erstellen eines Steuerprogramms mittels if-anweisungen Java Basics - Anfänger-Themen 10
R Vector nach Teilzeichenkette durchsuchen (mittels regex) Java Basics - Anfänger-Themen 5
G Mittels RegExp "Variablen" extrahieren Java Basics - Anfänger-Themen 4
T Fernsteuerung mittels Sockets (Architektur okay?) Java Basics - Anfänger-Themen 4
H Subtraktion mittels Negierung auf Addition zurückführen Java Basics - Anfänger-Themen 4
A Programm mittels Konsole öffnen Java Basics - Anfänger-Themen 12
B Querverweise auf eine Hilfedatei mittels ?Button? Java Basics - Anfänger-Themen 4
E Methodenaufruf mittels variable? kA Java Basics - Anfänger-Themen 5
P Collection Vector speichern mittels Serialisierung? Java Basics - Anfänger-Themen 2
M While-Schleife mit Wartezeit Java Basics - Anfänger-Themen 15
T Ich brauche eine Schleife die eine beliebige Zahl so lange durch 10 teilt bis zur Null Java Basics - Anfänger-Themen 5
DrahtEck Schleife soll wieder da anfangen wo ich es möchte ! Java Basics - Anfänger-Themen 17
Finn_lol Fehlermeldung bei Schleife mit Array Java Basics - Anfänger-Themen 4
Ranger229 Endless loop in while Schleife Java Basics - Anfänger-Themen 3
MaZ Quadrat Schleife(Pyramide) Java Basics - Anfänger-Themen 9
M Datentypen While-Schleife eine Java Methode erstellen Java Basics - Anfänger-Themen 3
P Wie kann diese Schleife beenden Java Basics - Anfänger-Themen 1

Ähnliche Java Themen

Neue Themen


Oben