Methoden Dreieck drehen

[seide]

hi, ich habe eine Dreieck Aufgabe, habe fast alles erledigt, nur habe ich problem mit öffentliche, statische Methoden:
1. alle Seiten eines Dreieck mit einer positiven ganzen Zahl d multiplizieren und so entstandene Dreieck zurückliefern:
Syntax : Dreieck streckeDreieck(Dreieck dreieck, int d)

2.alle Seiten eines Dreieck zyklisch vertauscht und das resultierende Dreieck zurückgeben
Sytax: Dreieck drehe(Dreieck dreieck)

also wie kann ich als Parametr ein dreieck nehmen und jede Seite ändern und dann entstandene Dreieck zurückliefern?

public class Dreieck {
	
	  private double seite1;
	  private double seite2;
	  private double seite3;
	 
	 public Dreieck(){               //Standart Konstruktor
		 this.seite1=seite1;
		 this.seite2=seite2;
		 this.seite3=seite3;
		 setDefault();
	 }
	 /*public Dreieck (double a, double b, double c){
	        setDefault();
	        this.seite1= a;
	        this.seite2 = b;
	        this.seite3 = c;
	    }*/
	    
	 public boolean setSeite1(double s1){
	    if(seite1>0){
		 this.seite1=s1;
		 return true;}
	    else{
	    	//System.out.println("Parametr a kann nicht gleich 0 sein");
	    	return false;
	    }
	 }
	 
	 public boolean setSeite2(double s2){
		 if(seite2>0){
			 this.seite2=s2;
			 return true;}
		    else{
		    //	System.out.println("Parametr b kann nicht gleich 0 sein");
		    	
		    	return false;}		 
	 }
	 
	 public boolean setSeite3(double s3){
		 if(seite3>0){
			 this.seite3=s3;
			 return true;}
		    else{
		    	//System.out.println("Parametr c kann nicht gleich 0 sein");
		    	return false;	 }
	 }
	 
	  public double getSeite1(){
		return seite1;
		 
	 }
	 
	  public double getSeite2(){
		return seite2;
		 
	 }
	 
	 public double getSeite3(){
		return seite3;
	 }
	 
	 public boolean istGleichseitig(){
		 if(seite1==seite2 && seite1==seite3 && seite2==seite3){
			 System.out.println("Dreieck ist gleichseitig");
		 return true;}
		 else{
			 System.out.println("Dreieck ist nicht gleichseitig");
		 return false;}
	 }
	 
	 public boolean istGleichschenklig(){
		 if(seite1==seite2 || seite2==seite3 || seite3==seite1){
		System.out.println("Dreieck ist gleichschenklig");
			 return true;}
		 else{
			 System.out.println("Dreieck ist nicht gleichschenklig");
	    return false;}
		 
	 }
	 
	 public double getUmfang(){
		 double summ=0;
		 if(istZulassig(seite1, seite2, seite3)== false){
			 System.out.println("Umfang kann nicht berechnet sein");
		 }else{
		 summ= seite1+seite2+seite3;}
		 return summ;
	 }
	 
	 public double getFlache(){
		 double area=0;
		 if(istZulassig(seite1, seite2, seite3)== false){
			 System.out.println("Die Flache kann nicht berechnet sein");
		 }else{
			 double s = ((seite1+seite2+seite3)/2);
		   	 area = (s*(s-seite1)*(s-seite2)*(s-seite3)); }
		    return area; 
		 }
	 
	 public void streckeDreieck(double d){
		 double er1= seite1*d;
		 double er2=seite2*d;
		 double er3=seite3*d;
		 System.out.println("strecke a= "+er1+"\nstrecke b= "+er2+"\nstrecke c= "+er3);
	 }
		
	public static Dreieck streckeDreieck(Dreieck dr, double d){
			Dreieck neuDreieck= new Dreieck() ;	
		//????????????????????????????????????????????????????
		return neuDreieck;		
	}
 
             public static Dreieck drehe(Dreieck dreieck){
                   ????????????????????????????????????????????????????
             }

	
	private void setDefault(){
		this.seite1=2;
		this.seite2=3;
		this.seite3=4;
		istZulassig(seite1, seite2, seite3);
	}
	
	private boolean istZulassig(double a, double b, double c){
		if(setSeite1(a) && setSeite2(b) && setSeite3(c) && seite1+seite2>seite3 && seite1+seite3>seite2 && seite2+seite3>seite1){
		return true;
		}
		return false;		
	}
	
	public static void main(String[] args){
		Dreieck d= new Dreieck();		
		System.out.println("Die Flache = "+d.getFlache());
		System.out.println("Umfang = "+d.getUmfang());
		d.istGleichschenklig();
		d.istGleichseitig();
		d.streckeDreieck(3);
	}

}

 

[SlaterB]

du kannst doch alle drei Seiten aus dem alten Dreieck abfragen, beliebig verändern und an das neue Dreieck übergeben?
nach Möglichkeit schon vorhandene Methoden wie streckeDreieck() verwenden, aber notfalls alles außerhalb neu berechnen



--------

     public Dreieck(){               //Standart Konstruktor
         this.seite1=seite1;
         this.seite2=seite2;
         this.seite3=seite3;

die drei Zuweisungen sind recht sinnlos an dieser Stelle

     public boolean istGleichseitig(){
         if(seite1==seite2 && seite1==seite3 && seite2==seite3){

der dritte Vergleich ist strenggenommen überflüssig, folgt aus den ersten beiden

------

die Methode istZulassig(double a, double b, double c) klingt als würde sie nur prüfen, setzt aber gleichzeitig die drei Seiten..

private void setDefault(){
        this.seite1=2;
        this.seite2=3;
        this.seite3=4;
        istZulassig(seite1, seite2, seite3);
    }

könnte man dann auch als

private void setDefault(){
        istZulassig(2, 3, 4);
    }

schreiben, da ja zugewiesen wird,
wenn der Rückgabewert nicht angeschaut wird ist der Aufruf vorher umso merkwürdiger

 

[seide]

danke dir, aber ich denke

 public Dreieck(){               //Standart Konstruktor
		 this.seite1=seite1;
		 this.seite2=seite2;
		 this.seite3=seite3;
		 setDefault();
	 }

brauche ich für die Methode

	public static Dreieck streckeDreieck(Dreieck dr, double d){
			Dreieck neuDreieck= new Dreieck() ;
			return neuDreieck;		
	}

oder nicht?

und wenn ich nur istZulassig(2, 3, 4) lasse , dann gibt es "Dreieck ist gleichschenklig" und "Dreieck ist nicht gleichseitig" aus.

kannst du bitte im Detail erläutern, weil ich verstehe nicht

du alle drei Seiten aus dem alten Dreieck abfragen, beliebig verändern und an das neue Dreieck übergeben

soll ich die Attribute als private static setzen?

 

[SlaterB]

> danke dir, aber ich denke [..] brauche ich für die Methode [..] oder nicht?
wenn du keine Begründung oder ein Beispiel nennst (wie beim nächsten Punkt) sehe ich keinen Grund, dir zuzustimmen

den Konstruktor an sich brauchst du, klar, da sage ich nix gegen, aber die drei Codezeilen haben keine Auswirkung,
oder was versprichst du dir davon, was wäre anders wenn sie nicht da wären?
selbst wenn wie etwas setze würden, in setDefault() wird dannn ja eh wieder 2, 3, 4 gesetzt

> und wenn ich nur istZulassig(2, 3, 4) lasse , dann gibt es "Dreieck ist gleichschenklig" und "Dreieck ist nicht gleichseitig" aus.

hier habe ich in der Tat nicht ausprobiert, istZulassig() ändert nur dann die Seiten, wenn dieser vorher 0 waren,
noch komplizierter und meiner Ansicht nach falsch, die Methode sollte nichts ändern,

-------

dir ist nicht klar wie du Werte aus dem Dreieck rausbekommst oder wieder hineinsetzen kannst,
obwohl es Methoden wie getSeite1() und setSeite1() gibt?

die set-Methoden funktionieren ja wie gesagt nur wenn die bisher gesetzten Seiten nicht 0 sind,
zum Glück werden sie von setDefault() auf 2, 3, 4 gesetzt, sonst könnte man nichts machen..

sollten die set-Methoden nicht eher die übergebenen Parameter prüfen?

 

[Blakh]

public boolean setSeite1(double s1){
        if(seite1>0){
         this.seite1=s1;
         return true;}
        else{
            //System.out.println("Parametr a kann nicht gleich 0 sein");
            return false;
        }
     }

Wenn du mit Parameter a das meinst was gesetzt werden soll, dann solltest dir die Methode nochmal genau anschauen.

 

[seide]

Wenn du mit Parameter a das meinst was gesetzt werden soll, dann solltest dir die Methode nochmal genau anschauen.

public boolean setSeite1(double s1){
        if(s1>0){
         this.seite1=s1;
         return true;}
        else{
            //System.out.println("Parametr a kann nicht gleich 0 sein");
            return false;
        }
     }

so meinst du?

kann ich mit strecke so machen?

public static Dreieck streckeDreieck(Dreieck dr, double d){
			Dreieck neuDreieck= new Dreieck() ;
			double erg1= getSeite1()*d;
			neuDreieck.setSeite1(erg1);
			double erg2= getSeite2()*d;
			neuDreieck.setSeite2(erg2);
			double erg3 = getSeite3()*d;
			neuDreieck.setSeite3(erg3);
			System.out.println("a= "+erg1+" b= "+erg2+" c= "+erg3);
		return neuDreieck;
		
	}

 

[SlaterB]

wie du beim Ausprobieren hoffentlich festgestellt hast führt dies zum Ziel ja,
schöner wäre z.B.

public static Dreieck streckeDreieck(Dreieck dr, double d){
            Dreieck neuDreieck= new Dreieck(dr) ;
            neuDreieck.streckeDreieck(d);
            System.out.println("a= "+erg1+" b= "+erg2+" c= "+erg3);
        return neuDreieck;
        
    }

einen Konstruktor der die Werte des anderen übernimmt müsstest du noch schreiben,
falls du das haben möchtest

die vorhandene streckeDreieck() speichert die geänderten Werte bisher nicht, ist also auch noch nicht fertig,
falls die sonst nicht benötigt und nur hierfür geschrieben ist, spart das dann natürlich auch nicht soviel,
verschiebt die Code-Zeilen nur von hier nach dort

übrigens ruhig Widerholung sparen:
eine Methode in der Klasse Dreieck braucht kaum wieder Dreieck im Namen, strecke() ginge kürzer

 

[seide]

und mit zyklische vertauscht, drehen, kann ich einfach machen seite1=seite2 ?

 

[SlaterB]

das ist ein Ansatz den du verfolgen kannst, ja,
gut prüfen ob am Ende das richtige rauskommt

 

[seide]

das ist ein Ansatz den du verfolgen kannst, ja,
gut prüfen ob am Ende das richtige rauskommt

kann man void drehe schöner schreiben ?

public void drehe(){
		double tmp = seite1;
		seite1 = seite2;
		seite2 = tmp;
		double tmp1=seite2;
		seite2=seite3;
		seite3=tmp1;
		System.out.println(seite1 +" "+ seite2+" "+seite3);
		}
	
	public static Dreieck drehe(Dreieck dreieck){
	    Dreieck nDr= new Dreieck();
	    nDr.drehe();		
		return nDr;
	}

 

[SlaterB]

im Moment tauschst du seite1 mit seite2 und dann seite2 mit seite3, damit wandert die ursprüngliche erste Seite gleich 2x,
das ist nicht gut, wobei wohl korrektes rauskommt,

du brauchst auch nur eine temp-Variable,
z.B. 1 in temp rein auf 1 2 speichern, auf 2 3 speichern und auf 3 dann temp

noch schöner geht so ein Ringtausch nicht, nein

 

[seide]

....

danke dir, für hilfe!!!