# überladen ...



## stev.glasow (18. Jul 2003)

kann ich folgendes überladen:


```
void test(ParentClass x)
{
     ....
}

void test(ChildClass x)
{
    ...
}
```


----------



## Cinimod (18. Jul 2003)

Hi!

Die KindKlasse stellt eine Erweiterung der Elternklasse dar, also kannst du eine KindKlasse anstatt der Elternklasse als Argument übergeben....vorrausgesetzt, ich habe die Frage richtig verstanden ;-)

CU


----------



## Nobody (18. Jul 2003)

ja das sollte funzen den java funzt ja per call by value selbiges gilt ja auch für die konstruktoren, wenn man zb eigene datentypen erstellen will und die wahlweise mit bzw ohne startwert definieren muss (sierpinski dreieck)


----------



## stev.glasow (18. Jul 2003)

mh .. was ist ein sierpinski dreieck ? nur mal so nebenbei ?


----------



## Nobody (19. Jul 2003)

ein rekusives dreieck. besteht aus drei dreicken die um ein dereieck angeordnet. evtl stell ich ma den quelltext oder ein bild davon rein


----------



## stev.glasow (19. Jul 2003)

das wäre nett - danke


----------



## Nobody (19. Jul 2003)

das ganze wird von einer turtle grafik unterstützt. d.h es wird immer die aktuelle position gespeichert und durch die länge der angegebnen strecke wird der punkt berechnet und danach eine linie gezogen (forward)

mit penup/pendown wird die strecke wahlweise gezeichnet oder nicht. funktioniert indem jeweils nur der neue zielpunkt berechnet wird und als aktueller gesetzt wird

mit linie_bis wird von der aktuellen position bis zu den angegeben koordinaten gezeichnet. mit setposition wird die aktuelle position verändert

mit turtleshow wird die fenstergrösse festgelegt. wobei hier gilt: x_min, x_max, y_min, y_max

leider ist es mir nicht gestattet euch die turtle grafik mitzugeben daher die erklärungen:


//frame1 leitet sich von turtle ab

```
int Tiefe=2;
  int x=250;


  public void paint(Graphics g){
    super.paint(g);
    zeichnen();
  }

  public void zeichnen(){
    turtleshow(-0.0,1.0,-0.1,1.0);
    Punkt p1 = new Punkt();
    Punkt p2 = new Punkt(1.0, 0.0);
    Punkt p3 = new Punkt(0.5,(Math.sqrt(3)/2));
    pendown();
    Sierpinski(p1,p2,p3,Tiefe);
  }

  Punkt transLU(Punkt p){
    Punkt hPunkt = new Punkt();
    hPunkt.setX(0.5*p.getX());
    hPunkt.setY(0.5*p.getY());
    return( hPunkt );
  }

  Punkt transRU(Punkt p){
    Punkt hPunkt = new Punkt();
    hPunkt.setX(0.5*p.getX()+0.5);
    hPunkt.setY(0.5*p.getY());
    return( hPunkt );
  }

  Punkt transMO(Punkt p){
    Punkt hPunkt = new Punkt();
    hPunkt.setX(0.5*p.getX()+0.25);
    hPunkt.setY(0.5*p.getY()+Math.sqrt(3)/4);
    return( hPunkt );
  }

  void Sierpinski(Punkt p1, Punkt p2, Punkt p3, int rekTiefe){
    if(rekTiefe>1){
      Sierpinski(transLU(p1), transLU(p2), transLU(p3), rekTiefe-1);
      Sierpinski(transRU(p1), transRU(p2), transRU(p3), rekTiefe-1);
      Sierpinski(transMO(p1), transMO(p2), transMO(p3), rekTiefe-1);
    }
    else{
      setposition(p1.getX(), p1.getY());
      linie_bis(p2.getX(),p2.getY());

      linie_bis(p3.getX(),p3.getY());

 
      linie_bis(p1.getX(),p1.getY());


    }
  }
```

// der quelltext wurde auf die sierpinki methoden reduziert. der rest dient nur zur festlegung der fenstergrösse etc

//klasse punkt

```
package sierpinski;

public class Punkt {


    private double x=0.0;
    private double y=0.0;

    public Punkt (double x, double y){
      this.x=x;
      this.y=y;
    }

    public Punkt(){
      this.x=0;
      this.y=0;
    }

    public double getX(){
      return(this.x);
    }

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

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

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


leider geht die turtlemethode grad nicht in stell noch ein bild rein, sobald es wieder geht


----------

