Polymorphismus und die richtige Anwendung

[GGG]

Hi,
Ich will ein kleines Paint programm schreiben, und habe mich entschieden folgendes zu tun:

Abstracte Klasse GeometrischeFiguren
Klasse Kreis extends GeometrischeFiguren
Klasse Gui (extends JPanel)

Ich habe in der Klasse Gui ein ArrayList<GeometrischeFiguren> und speichere darin derzeit nur Kreise. Um sie zu zeichnen benutze ich ein JPanel und die Methode paintComponent(Graphics g)
Um die Kreise (später auch andere Figuren) zu zeichnen, mache ich folendes:

public void paintComponent(Graphics g) 
	{
		for(GeometrischeFiguren gf : figuren)
		{
			StringTokenizer st = new StringTokenizer(gf.toString(), ";");
			String klassenname = st.nextToken();
			if(klassenname.equals("Kreis"))
			{
				g.setColor(gf.farbe);
				g.drawOval(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()), (int)Double.parseDouble(st.nextToken()), (int)Double.parseDouble(st.nextToken()));
			}
		}
		
	}

Die Kreis-toString Methode liefert folgende Daten:
Kreis;10;10;10.0;10.0
(Klassenname;xPosition,yPosition,Weite,Höhe)
doch genau hier, dadurch, das ich schaue, welche Klasse es ist, nutzte ich doch nicht den Sinn des Polymorphismus, doch leider weiß ich nicht (auch nicht nach längerer Überlegung), wie ich es anders schreiben sollte...

Hier alle Klassen um eventuelle Fragen vw. Realisierung... Wie hast du denn das oder das geschrieben zu vermeiden:

Gui.java

import java.awt.Color;
import java.awt.Graphics;
import java.util.ArrayList;
import java.util.StringTokenizer;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class Gui extends JPanel 
{
	private JFrame frame;
	private ArrayList<GeometrischeFiguren> figuren = new ArrayList<GeometrischeFiguren>();
	
	public void paintComponent(Graphics g) 
	{
		for(GeometrischeFiguren gf : figuren)
		{
			System.out.println(gf);
			StringTokenizer st = new StringTokenizer(gf.toString(), ";");
			String klassenname = st.nextToken();
			if(klassenname.equals("Kreis"))
			{
				g.setColor(gf.farbe);
				g.drawOval(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()), (int)Double.parseDouble(st.nextToken()), (int)Double.parseDouble(st.nextToken()));
			}
		}
		
	}

	public Gui() 
	{
		GeometrischeFiguren a = new Kreis();
		neueFigur(a);
		
		GeometrischeFiguren b = new Kreis(Color.red, true, 100, 50, 5);
		neueFigur(b);
		
		frame = new JFrame("DrawIt!");
		frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		frame.add(this);
		frame.setSize(500, 500);
		frame.setResizable(false);
		frame.setVisible(true);
	}
	
	public static void main(String[] args) 
	{
		new Gui();
	}

	public boolean neueFigur(GeometrischeFiguren gf)
	{
		return figuren.add(gf);
	}
	
	public GeometrischeFiguren entferneFigur(int index)
	{
		return figuren.remove(index);
	}
}

GeometrischeFiguren.java

import java.awt.Color;

public abstract class GeometrischeFiguren 
{
	protected 	Color 		farbe;
	protected 	boolean 	sichtbar;
	protected 	int			x, y;
	
	public abstract void zeige();
	public abstract void verstecke();
	
	public GeometrischeFiguren()
	{
		this.farbe = Color.black;
		this.sichtbar = true;
		this.x = 10;
		this.y = 10;
	}
	
	public GeometrischeFiguren(Color farbe, boolean sichtbar, int x, int y) 
	{
		this.farbe = farbe;
		this.sichtbar = sichtbar;
		this.x = x;
		this.y = y;
	}
}

Kreis.java

import java.awt.Color;

public class Kreis extends GeometrischeFiguren 
{
	private double radius;
	
	public Kreis()
	{
		super();
		this.radius = 10;
	}
	
	public Kreis(Color farbe, boolean sichtbar, int x, int y, double radius)
	{
		super(farbe, sichtbar, x, y);
		this.radius = radius;
	}
	
	public void verstecke() 
	{
		super.sichtbar = false;
	}

	public void zeige() 
	{
		super.sichtbar = true;
	}
	
	public String toString()
	{
		return Kreis.class.getName() + ";" + super.x + ";" + super.y + ";" + radius + ";" + radius;
	}
}

Danke schonmal im Vorraus
MfG GGG

 

[hdi]

Aaaaalso... Ich hole jetzt mal etwas weiter aus, weil Polymorphismus und Design sind komplexe
Dinge, die man auch gut verstanden haben muss. Der Text wird wohl recht lang, aber lies bitte
alles aufmerksam durch, ich denke es wird dir helfen.

Noch eine Anmerkung vorweg: Polymorphismus ist ein recht überladener Begriff und beinhaltet
weit mehr als nur Vererbung oder abstrakte Klassen. Wenn ich aber im Weiteren davon spreche,
meine ich nur diese Teilgebiete von Polymorphismus.

Gut, dann fangen wir mal an.

Erstmal Vererbung:
Vererbung macht dann Sinn, wenn du mehrere Objekte hast, die in Teilen identisch sind, d.h. zum
Teil gleiche Eigenschaften oder gleiches Verhalten haben. Du hast gut angefangen: Du hast dir
eine Klasse GF (GeometrischeFiguren, ich kürz das ab hier ab) gemacht, und lässt dann Kreis und weitere
spezifische GF davon erben. Das ist auch die richtige Idee, aber wenn ich mir deinen Code ansehe,
scheint es als würdest du nicht so recht den Unterschied zwischen abstract und nicht abstract kennen.

nicht abstract heisst:
Du schreibst eine Methode in der Oberklasse (hier GF), und jede Klasse die davon erbt hat automatisch
diese Methode. D.h. du sollst diese Methode in der Unterklasse nicht nochmal schreiben, weil du sie dann
überschreibst. Es gibt sie auch so, sie ist ja geerbt (gilt aber nur für public Methoden).

abstract heisst:
Du definierst eine abstrakte Methode in der Oberklasse, und die Unterklassen, die davon erben, müssen
diese Methode einzeln implementieren. Jede Unterklasse implementiert sie dann so, wie es passend für sie ist.
D.h. bei abstrakten Methoden hat man diese Methode in der Oberklasse definiert, aber in den einzelnen
Unterklassen verschieden implementiert.

Bsp: deine Methoden zeige() und verstecke(): Du machst eine Methode dann, und nur dann "abstract",
wenn die Unterklassen verschiedene Dinge bei der Ausführung der Methode tun sollen.
Ich nehme aber mal stark an, dass sich ein Kreis genauso versteckt oder sichtbar macht, wie ein Quadrat
oder jede andere GF.

Also sollten zeige() und verstecke() keine abstrakten Methoden sein, sondern "normale", und demnach sollten
die auch nicht nochmal in der Unterklasse vorkommen. Du implementierst sie einfach in GF:

public void zeige(){
      this.sichtbar = true;
}
public void verstecke(){
      this.sichtbar = false;
}

Jede Unterklasse hat diese Methoden jetzt automatisch.

In diesem Zusammenhang schweife ich kurz ab zu einem anderen fundamentalen Ding beim Programmieren:
Attribute einer Klasse sollten niemals public oder protected sein, sondern immer private.
Das hat Sicherheitsgründe, ich will da nicht so ins Detail gehen. Merk's dir einfach, das macht man nicht.

Da aber private Attribute in anderen Klassen (auch nicht den Unterklassen!!) sichtbar sind, brauchst du
öffentliche Methoden, um sie zu ändern oder zu lesen. Da spricht man dann von "Gettern" und "Settern".

Bsp:

private boolean sichtbar;

/* Getter */
public boolean isSichtbar(){
     return this.sichtbar;
}
/* Setter */
public void setSichtbar(boolean sichtbar){
     this.sichtbar = sichtbar;
}

Okay, nun zurück zum Polymorphismus-Zeugs:
Die Klasse GF an sich ist abstract weil es eigentlich sowas wie ein GF gar nicht gibt: Es gibt ja nur einen Kreis,
oder ein Quadrat, etc. D.h. das hast du vollkommen richtig gemacht.

Dein Problem ist nun, dass du die Idee des Polymorphismus gar nicht nutzt, wie du schon richtig geahnt hast.
Hier ein guter Tipp für Anfänger, wie man Polymorphismus-Fragen im Design lösen kann auch wenn man nicht
soviel praktische Erfahrung hat. Es gibt da nen ganz guten Merksatz:

"Wenn in deinem Programm switch-Konstrukte oder nicht-elementare if-Statements vorkommen, ist das
meistens ein Zeichen für einen Design-Fehler, den man mittels Polymorphismus lösen kann.
Nicht-elementar heisst: Alles, was nicht mittels >,<=,==,||,etc. geprüft wird."

Genau diesen Satz hast du quasi selber gesagt, weil du festgestellt hast, dass die Abfrage der Klasse
das Problem ist:

 if(klassenname.equals("Kreis"))

...et voilá, hier ist tatsächlich dein Fehler, du hast ihn also schon erkannt. Wie löst man das jetzt also?
Zuerst einmal musst du dir bewusst werden, wo eigentlich dein Problem liegt: Du weisst, dass du jedes
Geometrische Objekt zeichnen kannst, aber du weisst auch, dass ein Kreis sich anders malt als ein Quadrat.
Also wie wirst du diese if-Abfrage los? Springe dazu wieder nach oben zurück, wo ich geschrieben habe was
abstrakte Methoden sind und wann man sie verwendet... Genau das brauchst du hier nämlich:

public abstract class GF{
     
          public abstract void male(Graphics g);
          //...
}

Ein Kreis würde jetzt so aussehen:

public class Kreis extends GF{

         @Override
         public void male(Graphics g){
                  g.setColor( getFarbe() ); // wie gesagt: Attribute von GF private machen und dafür getter/setter
                  g.drawOval( getX(), getY(), radius, radius);
          }
}

Und zB ein Quadrat würde so aussehen:

public class Kreis extends GF{

         @Override
         public void male(Graphics g){
                  g.setColor( getFarbe() ) ;
                  g.drawRect( getX(), getY(), kantenlänge, kantenlänge);
          }
}

So, und das ist jetzt der Polymorphismus, den du brauchst. Denn in der Klasse vom Panel kannst du jetzt
einfach machen:

public void paintComponent(Graphics g)
   {
      super.paintComponent(g); // immer als erste Zeile, weil du sonst alles übermalst
      for(GeometrischeFiguren gf : figuren)
      {
          gf.male(g);
      }
   }

Obwohl das Panel nicht weiss, ob "gf" jetzt grad ein Kreis oder ein Quadrat ist, wird die richtige
Methode aufgerufen, weil die Methode male() in GF abstrakt ist, und die einzelnen Unterklassen die Methode
unterschiedlich implementiert haben.

Fertig! Du kannst jetzt superleicht noch tausend weitere Unterklassen von GF machen, und musst immer nur
die male() Methode anders implementieren. Wie du siehst gibt es jetzt keine if() Abfragen mehr.

Zusammenfassung:

1) Merk dir den Merksatz
2) Gewöhn dir an, nur private Attribute zu machen + Getter/Setter
3) nicht-abstrakte Methoden werden automatisch vererbt und müssen in den Unterklassen nicht implementiert werden
4) D.h. wenn gewisse Objekte in Teilen gleich sein sollen, erbst du einfach
5) Wenn verschiedene Objekte die gleiche Funktionalität anbieten sollen, sie aber einzeln anders implementieren müssen,
ist das ein Fall für abstrakte Methoden

Wenn noch was unklar ist, frag nach.

Der Vollständigkeit halber nochmal dein Code, wie er aussehen sollte:

import java.awt.Color;

public abstract class GeometrischeFigur
{
   private Color farbe;
   private boolean sichtbar;
   private int x,y;
   
   public GeometrischeFiguren()
   {
      this(Color.black, true, 10,10);
   }
   
   public GeometrischeFiguren(Color farbe, boolean sichtbar, int x, int y)
   {
      setFarbe(farbe);
      setSichtbar(sichtbar);
      setX(x);
      setY(y);
   }

    public abstract void male(Graphics g);

    public void zeige(){
          setSichtbar(true);
    }
   
     public void verstecke(){
          setSichtbar(false);
    }

        public int getX() {
		return this.x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return this.y;
	}
	public void setY(int y) {
		this.y = y;
	}
	public Color getFarbe() {
		return this.farbe;
	}
	public void setFarbe(Color farbe) {
		this.farbe = farbe;
	}
	public boolean isSichtbar() {
		return this.sichtbar;
	}
	public void setSichtbar(boolean sichtbar) {
		this.sichtbar = sichtbar;
	}
}

public class Kreis extends GeometrischeFigur
{
   private double radius;
   
   public Kreis()
   {
      super();
      setRadius(10.);
   }

   public void setRadius(double radius){
      this.radius = radius;
   }

   public double getRadius(){
       return this.radius;
   }

   @Override
   public void male(Graphics g){
        g.setColor(getFarbe());
        g.drawOval(getX(), getY(), getRadius(), getRadius());
   }
}

// .... in deiner Panel-Klasse

public void paintComponent(Graphics g){

      super.paintComponent(g);
      for(GeometrischeFiguren gf : figuren)
      {
          if( gf.isSichtbar() ){
                  gf.male(g);
          }
      }
}

 

[Murray]

Du schreibst eine Methode in der Oberklasse (hier GF), und jede Klasse die davon erbt hat automatisch
diese Methode. D.h. du sollst diese Methode in der Unterklasse nicht nochmal schreiben, weil du sie dann
überschreibst. Es gibt sie auch so, sie ist ja geerbt (gilt aber nur für public Methoden).

Wieso diese Beschränkung?

 

[hdi]

Naja private Methoden sind wie gesagt selbst in Unterklassen nicht sichtbar. Du kannst sie daher auch nicht überschreiben. Und insofern spielen sie für Vererbung auch keine Rolle, natürlich kann eine Vaterklasse auch private Methoden haben, die dann in öffentlichen Methoden aufgerufen werden (zB Hilfsmethoden). Aber das interessiert ja eine Unterklasse nicht, wie genau die Oberklasse etwas berechnet.

Man könnte noch genauer sein und sagen "gilt für public und protected", aber protected == public in 99% der Fälle, vorallem wenn es um Sichtbarkeit mit Vererbung geht.

 

[GGG]

Also erstmal ein fettes DANKE von mir! War sicher viel Arbeit sich das ganze anzuschauen... Weiter so :toll:

btt:
Ich werde mir den Text sicher noch mindestens einmal durchlesen da es ziemlich viel ist, aber jetzt verstehe ich (langsam) aber dennoch schon was ich falsch gemacht habe. Auf diese Lösung wäre ich auf jedenfall nicht so schnell gekommen...

Ein paar Fragen habe ich noch

1. man soll zwar alle Attribute private machen (gemerkt :toll: ) doch gilt das auch für ein ArrayList falls ich zb aus einer anderen Klasse daraus zugreifen will oder schreibe ich dann eine getElement(int index) Methode von der ich auf jedes gespeicherte Element zugreifen kann. ansonsten wäre es ja Klassenname.Arrayname.get(x)

2. Was bedeutet die serialVersionUID, die er mir anzeigt das sie fehlt:

private static final long serialVersionUID = -6220738077186953925L;

3. Wenn ich in der Konsole (Terminal) die Color zb farbe = Color.red ausgeben möchte, gibt er mir die RGB Werte aus, wie ändere ich die toString() Methode der Color Klasse so, das er mir "red" || "BLACK" ausgeben würde?

Sonst glaube und hoffe ich alles verstanden zu haben.

Danke nochmals
GGG

 

[GGG]

Anhang:
Was ich vergessen hatte zu fragen, ist folgendes:

1.
Ich habe zur Gui eine JToolBar hinzugefügt mit dem JButton kreis, sobald man den Kreisbutton drückt (hier mit ActionEvent) soll man sobald man in die Zeichenfläche "hineingeht" soll man einen Kreis sehen den man mit der Maus bewegt (also quasi unter oder statt dem Mauszeiger) der mit dem ersten Klick(links)dann (positioniert) "festklebt".

2. sobald 1. funktioniert
Wenn man jetzt nach links oder rechts geht soll er die größe verändern (je näher zum mittelpunkt desto kleiner wird der kreis, je weiter weg vom mittelpunkt desto größer wird er. Durch den Klick soll der Kreis dann eine feste fixe unveränderbare (fürs erste) größe haben.

Für eventuell auftretende Fragen zum derzeitigen modifizierten Code:

Gui.java

import java.awt.BorderLayout;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JToolBar;

public class Gui extends JPanel
{
	private static final long serialVersionUID = -6220738077186953925L;
	private JFrame frame;
	private ArrayList<GeometrischeFiguren> figuren = new ArrayList<GeometrischeFiguren>();
	JToolBar jtb = new JToolBar();
	JButton kreis = new JButton("Kreis");

	public void paintComponent(Graphics g)
	{
		super.paintComponent(g);
		for (GeometrischeFiguren gf : figuren)
		{
			gf.male(g);
		}
	}

	public Gui()
	{
		zeichneFenster();
		events();
	}
	
	public void zeichneFenster()
	{
		frame = new JFrame("DrawIt!");
		frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		frame.add(this);
		frame.setSize(500, 500);
		frame.setResizable(false);
		jtb.add(kreis);
		frame.add(jtb, BorderLayout.NORTH);
		frame.setVisible(true);
	}
	
	public void events()
	{
		kreis.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            { 
            	//ab jetzt zeige unter oder statt dem Mauszeiger den Kreis an
            }
        });
	}

	public static void main(String[] args)
	{
		new Gui();
	}

	public boolean neueFigur(GeometrischeFiguren gf)
	{
		return figuren.add(gf);
	}

	public GeometrischeFiguren entferneFigur(int index)
	{
		return figuren.remove(index);
	}
}

GeometrischeFiguren.java

import java.awt.Color;
import java.awt.Graphics;

public abstract class GeometrischeFiguren
{
	private Color farbe;
	private boolean sichtbar;
	private int x, y;

	public GeometrischeFiguren()
	{
		this(Color.black, true, 10, 10);
	}

	public GeometrischeFiguren(Color farbe, boolean sichtbar, int x, int y)
	{
		setFarbe(farbe);
		setSichtbar(sichtbar);
		setX(x);
		setY(y);
	}

	public abstract void male(Graphics g);

	public void zeige()
	{
		setSichtbar(true);
	}

	public void verstecke()
	{
		setSichtbar(false);
	}

	/**
	 * Getter und Setter
	 */
	public int getX()
	{
		return this.x;
	}

	public void setX(int x)
	{
		this.x = x;
	}

	public int getY()
	{
		return this.y;
	}

	public void setY(int y)
	{
		this.y = y;
	}

	public Color getFarbe()
	{
		return this.farbe;
	}

	public void setFarbe(Color farbe)
	{
		this.farbe = farbe;
	}

	public boolean isSichtbar()
	{
		return this.sichtbar;
	}

	public void setSichtbar(boolean sichtbar)
	{
		this.sichtbar = sichtbar;
	}
}

Kreis.java

import java.awt.Graphics;

public class Kreis extends GeometrischeFiguren
{
	private double radius;

	public Kreis()
	{
		super();
		setRadius(10.);
	}

	public void setRadius(double radius)
	{
		this.radius = radius;
	}

	public double getRadius()
	{
		return this.radius;
	}

	public void male(Graphics g)
	{
		g.setColor(getFarbe());
		g.drawOval(getX(), getY(), (int) getRadius(), (int) getRadius());
	}
}

 

[hdi]

Zu deinen Fragen

1) private gilt i.d.R. immer, egal ob statisch oder nicht statisches Attribut. Wenn du in einer Klasse das Array
von Figuren holen möchtest, dann sollte die Klasse, die diese Array besitzt, entweder eine Methode bereitstellen
um dieses Array zu holen:

public List getList(){
      return arrayList;
}

oder halt wie du schon selbst sagtest eine Wrapper-Funktion machen, die das einfach weiterleitet:

public Object getListElementAt(int index){
    return arrayList.get(index);
}

Also Variablen sind immer private, wenn du was damit machen willst in anderen Klassen, machst du public Getter bzw. Setter

2) Das garantiert nur die Eindeutigkeit einer Klasse im Falle von Serialisierung (hat was mit Netzwerken zu tun, wenn
die Klasse über Client & Server laufen soll usw.). Kann man weglassen dass hat nix zu bedeuten wenn du keine
Serialisierung machst, was in 99% der Fälle so ist

3) Du musst toString() in der Color-Klasse überschreiben. Das kannst du entweder mit inner classes lösen
oder wenn du eine Klasse machst, die von Color erbt und dort überschreibst du dann toString(). Aber ganz ehrlich:
Lass das! Ist schon okay so, wie Color sich als String darstellt. Du willst doch jetzt nicht anfangen für alle möglichen
Farben zwischen 255,255,255 und 0,0,0 Namen zu erfinden oder?

Zu deinem Vorhaben mit dem Kreis: Lass erstmal diese Sache mit ActionListener des buttons und "sobald man ins
Panel geht" weg... Versuch erstmal nen Kreis auf dem Panel zu definieren mit der Maus, und wenn das funktioniert,
baue es als ActionEvent von nem Button