Klassen varibale einer klasse in einer anderen klasse aufrufen und häufigkeit ausgeben

[Hamsey]

Hallo Leute,
habe ein Problem undzwar habe ich folgenden programmcode geschrieben:

public class DreieckmitTypString {

   public static void main(String[] args) {
     int seiten1 = 0;
     int seiten2 = 0;
     int seiten3 = 0;
     int[][] dreieck = { { 2, 2, 4 }, { 3, 4, 5 }, { 5, 5, 5 },
         { 8, 6, 10 }, { 10, 10, 2 }, { 2, 4, 9 }, { 12, 36, 4 },
         { 5, 6, 7 }, { 7, 9, 12 } };

     ladeDreiecke(dreieck);
   }

   public static void ladeDreiecke(int[][] dreieck) {
     int zähler = 0;
     int seiteA = 0;
     int seiteB = 0;
     int seiteC = 0;

     for (int i = 0; i < dreieck.length; i++) {
       for (int j = 0; j < dreieck.length; j++) {
         System.out.print(dreieck[j]);
         System.out.print(" ");
         zähler = zähler + 1;
         if (zähler == 1) {
           seiteA = dreieck[j];
         } else {
           if (zähler == 2) {
             seiteB = dreieck[j];
           } else {
             if (zähler == 3) {
               seiteC = dreieck[j];
               String typ = findeDreiecktyp(seiteA, seiteB, seiteC);
               System.out.print(typ);
               System.out.println();
               zähler = 0;
             }
           }
         }
       }
     }
   }

   public static String findeDreiecktyp(int zahl1, int zahl2, int zahl3) {

     String typ = null;
  
     if (zahlenSortieren(zahl1, zahl2, zahl3) == false) {
       typ = "undefiniert";
     } else {
       if ((zahl1 * zahl1) + (zahl2 * zahl2) == (zahl3 * zahl3)) {
         typ = "rechtwinkliges Dreieck";
         if (zahl1 == zahl2 ^ zahl1 == zahl3 || zahl2 == zahl3) {
           typ =typ+", gleichschenkliges Dreieck";
         }
} else {
         if (zahl1 * zahl1 + zahl2 * zahl2 < zahl3 * zahl3) {
           typ = "stumpfwinkeliges Dreieck";
           if (zahl1 == zahl2 ^ zahl1 == zahl3 || zahl2 == zahl3) {
             typ = typ+", gleichschenkliges Dreieck";
           }
        } else {
           if (zahl1 * zahl1 + zahl2 * zahl2 > zahl3 * zahl3) {
             typ = "spitzwinkeliges Dreieck";
             if (zahl1 == zahl2 && zahl3 == zahl2) {
               typ = typ+", gleichseitiges Dreieck";
             }
             if (zahl1 == zahl2 ^ zahl1 == zahl3 || zahl2 == zahl3) {
               typ = typ+", gleichschenkliges Dreieck";
             }
           }
         }
       }
     }
     return typ;

   }

   private static boolean zahlenSortieren(int zahl1, int zahl2, int zahl3) {
     int a = 0;
     int b = 0;
     int c = 0;
     boolean dreieck = false;

     if (zahl1 >= zahl2) {
       if (zahl2 >= zahl3) {
         a = zahl3;
         b = zahl2;
         c = zahl1;
       } else {
         a = zahl1;
         b = zahl2;
         c = zahl3;
       }
     } else {
       if (zahl1 <= zahl3) {
         if (zahl2 >= zahl3) {
           a = zahl1;
           b = zahl3;
           c = zahl2;
         } else {
           a = zahl1;
           b = zahl2;
           c = zahl3;
         }
       } else {
         a = zahl3;
         b = zahl1;
         c = zahl2;
       }
     }

     if (a + b > c) {
       dreieck = true;
     }
     return dreieck;

   }

}

Nun muss ich eine Klasse erstellen, die die häufigkeit der auftretenden Dreieckstypen ausgibt.
Zum Beispiel:
Ein rechtwinkliges Dreieck kommt x mal vor.
Ein rechtwinkliges, gleichschenkliges Dreieck kommt y mal vor.
usw.
Ich weiß aber nicht wie ich diese klasse mit in die andere Klasse einbinde und somit die varible abrufe und die Häufigkeit der Dreieckstypen festlege.

Vielen dank schonmal im voraus ^^

 

[Robinson97]

So wie ich das jetzt verstanden habe würde ich einfach für jedes Dreieck eine Variable erstellen und jedes mal wenn die if-Abfrage positiv ausfällt erhöht sich der Wert.

int gleichschenkliches_dreieck;
//---------------------------------
if (zahl1 * zahl1 + zahl2 * zahl2 < zahl3 * zahl3) {
           typ = "stumpfwinkeliges Dreieck";
           if (zahl1 == zahl2 ^ zahl1 == zahl3 || zahl2 == zahl3) {
             typ = typ+", gleichschenkliges Dreieck";
             gleichschenkliches_dreieck++;
           }

 

[Hamsey]

nunja ich habe es so versucht aber es funktioniert noch immer nicht.
ich habe eine neue methode geschrieben um die häufigkeit zu zählen.

public class DreieckmitTypString{
private static void statistikZaehler(String typ) {
        int undefiniert = 0;
        int rechtw = 0;
        int rechtgleich = 0;
        int stumpf = 0;
        int stumpfgleich = 0;
        int spitz = 0;
        int spitzgleichschenk = 0;

       
        if(typ.equalsIgnoreCase("undefiniert")){
            undefiniert = undefiniert+1;
        }else{
            if(typ.equalsIgnoreCase("rechtwinkliges Dreieck")){
                rechtw = rechtw+1;
            }else{
                if(typ.equalsIgnoreCase("rechtwinkliges Dreieck, gleichschenkliges Dreieck")){
                    rechtgleich= rechtgleich+1;
                }else{
                    if(typ.equalsIgnoreCase("stumpfwinkeliges Dreieck")){
                        stumpf=stumpf+1;
                    }else{
                        if(typ.equalsIgnoreCase("stumpfwinkeliges Dreieck, gleichschenkliges Dreieck")){
                            stumpfgleich = stumpfgleich+1;
                        }else{
                            if(typ.equalsIgnoreCase("spitzwinkeliges Dreieck")){
                                spitz = spitz+1;
                            }else{
                                if(typ.equalsIgnoreCase("spitzwinkeliges Dreieck, gleichschenkliges Dreieck")){
                                    spitzgleichschenk = spitzgleichschenk+1;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
}       
    }

ist es möglich das ergebnis aus dieser methode in einer anderen klasse aufzurufen?

public class Statistik {

    public static void main(String[] args) {
        String kategorie1 = "gleichseitig";
        String kategorie2 = "rechtwinkelig";
        String kategorie3 ="stumpfwinkelig";
        String kategorie4 ="spitzwinkelig";
        String kategorie5 ="rechtwinkelig & gleichschenkelig";
        String kategorie6 ="stumpfwinkelig & gleichschenkelig";
        String kategorie7 ="spitzwinkelig & gleichschenkelig";
        String kategorie8 ="undefiniert";
        DreieckmitTypString dreieck = new DreieckmitTypString();
        
-- aufrufen der variablen aus der Klasse DreieckmitTypString()?
}
}

 

[kneitzel]

Bitte mach die { } beim else weg, wenn direkt ein if kommt. Ist sonst total unleserlich weil ständig weiter eingerückt wird!

Und die Zähler sind in der Funktion drin und damit lokal. Da Du aber die Funktion für jedes Dreieck aufrufen musst, wird immer nur jedes Dreieck für sich gezählt.

Also mach die Variablen zu Instanzvariablen, die ausserhalb der Funktion initialisiert werden.

Konrad

 

[Jardcore]

if(typ.equalsIgnoreCase("undefiniert")){
undefiniert = undefiniert+1;
}else{
if(typ.equalsIgnoreCase("rechtwinkliges Dreieck")){
rechtw = rechtw+1;
}else{
if(typ.equalsIgnoreCase("rechtwinkliges Dreieck, gleichschenkliges Dreieck")){
rechtgleich= rechtgleich+1;
}else{
if(typ.equalsIgnoreCase("stumpfwinkeliges Dreieck")){
stumpf=stumpf+1;
}else{
if(typ.equalsIgnoreCase("stumpfwinkeliges Dreieck, gleichschenkliges Dreieck")){
stumpfgleich = stumpfgleich+1;
}else{
if(typ.equalsIgnoreCase("spitzwinkeliges Dreieck")){
spitz = spitz+1;
}else{
if(typ.equalsIgnoreCase("spitzwinkeliges Dreieck, gleichschenkliges Dreieck")){
spitzgleichschenk = spitzgleichschenk+1;
}
}
}
}
}
}
}
}

if (zahlenSortieren(zahl1, zahl2, zahl3) == false) {
typ = "undefiniert";
} else {
if ((zahl1 * zahl1) + (zahl2 * zahl2) == (zahl3 * zahl3)) {
typ = "rechtwinkliges Dreieck";
if (zahl1 == zahl2 ^ zahl1 == zahl3 || zahl2 == zahl3) {
typ =typ+", gleichschenkliges Dreieck";
}
} else {
if (zahl1 * zahl1 + zahl2 * zahl2 < zahl3 * zahl3) {
typ = "stumpfwinkeliges Dreieck";
if (zahl1 == zahl2 ^ zahl1 == zahl3 || zahl2 == zahl3) {
typ = typ+", gleichschenkliges Dreieck";
}
} else {
if (zahl1 * zahl1 + zahl2 * zahl2 > zahl3 * zahl3) {
typ = "spitzwinkeliges Dreieck";
if (zahl1 == zahl2 && zahl3 == zahl2) {
typ = typ+", gleichseitiges Dreieck";
}
if (zahl1 == zahl2 ^ zahl1 == zahl3 || zahl2 == zahl3) {
typ = typ+", gleichschenkliges Dreieck";
}
}
}
}
}

Wenn man das schon sieht müsste einen doch ins Auge fallen, dass man das später nicht mehr auf Anhieb versteht... bzw. das es großer Mist ist, Java ist eine objektorientierte Sprache und kein C 🙂
Versuche objektorientierter an die Sache ran zu gehen.
Du könntest verschiedene Klassen von Dreiecken schreiben, welche alle vom Grundtyp Dreieck erben.
Dadurch kannst du dir später viele der nicht verständlichen abfragen sparen. Und wahrscheinlich würdest du gar nicht zu deinem jetzigen Problem kommen.

public class Dreieck {
    private double a;
    private double b;
    private double c;

    public Dreieick(double a, double b, double c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

Das könnte zum Beispiel deine Grundklasse sein, ein Dreieck das drei Seiten (a,b und c) hat.

public class RechtwinkligesDreieck extends Dreieck {
}

Ein spezieller Typ des Dreiecks wäre dann die Klasse RechtwinkligesDreieck, welche alle Eigenschaften von der Oberklasse Dreieck erbt (extends).

Du solltest also vielleicht dein Vorgehen ändern und versuchen Java als objektorientiere Sprache zu sehen und all die Vorteile auch zu nutzten und dich nicht mit endlosen If Else Statements rumschlagen.

Beste Grüße,
Jar

 

[JStein52]

@Jardcore , kannst du bitte noch kurz erklären wie es dann weitergehen soll ? Er muss ja auf jeden Fall den Typ seines Dreiecks aus den drei Seitenlängen bestimmen, und das sind die Abfragen die du angemerkt hast. Was helfen ihm denn deine Dreiecksklassen ?

 

[Jardcore]

Man müsste wahrscheinlich eine Art DreiecksBuilder erstellen, dieser bekommt die drei Seiten und entscheidet welches spezielle Dreieck erstellt werden soll.
Mit den erstellten Klassen kann man dann weiter arbeiten, und diese zum Beispiel in Listen ablegen. Die Listen geben dann anhand ihrer Größe die Häufigkeit zurück.

Ich kann leider gerade keinen Prototyp entwickeln, ich wollte nur ein paar Denkansätze mitgeben. 🙂

 

[kneitzel]

Also der generelle Ansatz von Jardcore ist in meinen Augen schon richtig. Und da geht es nicht darum, irgendwelche Lösungen komplett vorzugeben sondern mehr darum, sich mit der Materie noch einmal genauer auseinander zu setzen.

Beim objektorientierten Design sehe ich dann auch keine Klasse RechtwinkligesDreick. Es gibt Dreiecke und die haben verschiedene Eigenschaften. "Rechtwinklig" bei einem Dreieck ist wie bei einem Auto "rot" - also nur eine Eigenschaft.

Ich erstelle ja ein Dreieck aus drei Seiten und daraus ergeben sich dann ja viele Eigenschaften.

Und da müsste man noch vielseitiger dran gehen und sich nicht auf diese Seiten a, b und c festlegen und rechtwinklig ist es nur, wenn a^2 + b^2 = c^2 gilt. Wer sagt denn, das die Seite, die als c festgelegt wurde, die Hypothenuse ist? Wenn ich die in a stecke, ist das Dreieck immer noch rechtwinklig 🙂

Aber das ist nur meine Meinung und bei so Schulaufgaben ist so eine Erweiterung maximal als interessante Übung zu sehen. Wirklich interessieren scheint das aber doch eigentlich niemanden, oder irre ich mich und der TE ist noch wirklich interessiert an unseren Fragestellungen?

 

[kneitzel]

Man müsste wahrscheinlich eine Art DreiecksBuilder erstellen, dieser bekommt die drei Seiten und entscheidet welches spezielle Dreieck erstellt werden soll.

Ja, darauf würde so ein Ansatz hinaus laufen, aber da ich da in den Klassen kein unterschiedliches Verhalten sehe, außer dass die Klasse halt nun anders heißt, sehe ich darin kein wirklichen Sinn.

Ein Factory Pattern ist natürlich immer nett und möglich, aber es geht halt doch etwas weg von dem eigentlichen Ansatz, bei dem man schön neue Objekte generieren kann per new. (Wenn man das auch noch zulassen wollte, müsste man z.B. bei Erstellung prüfen, ob es wirklich rechtwinklig ist. Und wie deckst Du ab, dass ein Dreieck rechtwinklig und gleichschenklig ist? In C++ wäre das dann ggf. möglich über Mehrfachvererbung... aber in Java sehe ich da schwarz ...

 

[JStein52]

eine Art DreiecksBuilder erstellen, dieser bekommt die drei Seiten und entscheidet welches spezielle Dreieck erstellt werden soll

Aber dann hast du dort die Abfragen !!

 

[Jardcore]

Irgendwo muss man Abfragen machen, ohne ein If Statement wirds nicht funktionieren... 🙂
Grundsätzlich sollte man aber kilometerlange Abfragen vermeiden.

 

[JStein52]

Genau. Da beisst die Maus keinen Faden ab, er wird genau die Abfragen die er jetzt schon hat auch brauchen. Und da er ja die Aufgabe hat die verschienenen Dreickstypen zu zählen ist der Teil eigentlich vollkommen in Ordnung.

 

[Jardcore]

public static String findeDreiecktyp(int zahl1, int zahl2, int zahl3) {
   String typ = null;

   if (zahlenSortieren(zahl1, zahl2, zahl3) == false) {
     typ = "undefiniert";
   } else {
     if ((zahl1 * zahl1) + (zahl2 * zahl2) == (zahl3 * zahl3)) {
       typ = "rechtwinkliges Dreieck";
       if (zahl1 == zahl2 ^ zahl1 == zahl3 || zahl2 == zahl3) {
         typ =typ+", gleichschenkliges Dreieck";
       }
     } else {
       if (zahl1 * zahl1 + zahl2 * zahl2 < zahl3 * zahl3) {
         typ = "stumpfwinkeliges Dreieck";
         if (zahl1 == zahl2 ^ zahl1 == zahl3 || zahl2 == zahl3) {
           typ = typ+", gleichschenkliges Dreieck";
         }
       } else {
         if (zahl1 * zahl1 + zahl2 * zahl2 > zahl3 * zahl3) {
           typ = "spitzwinkeliges Dreieck";
           if (zahl1 == zahl2 && zahl3 == zahl2) {
             typ = typ+", gleichseitiges Dreieck";
           }
           if (zahl1 == zahl2 ^ zahl1 == zahl3 || zahl2 == zahl3) {
             typ = typ+", gleichschenkliges Dreieck";
           }
         }
       }
     }
   }
   return typ;
}

Das findest du in Ordnung? 🙂

 

[Joose]

Das findest du in Ordnung? 🙂

Jein der Code ansich ist in Ordnung. In Richtung Lesbarkeit kann man es sicher noch optimieren.
Statt zahl1, zahl2, zahl3 lieber "seiteA", "seiteB" und "seiteC" verwenden, die Abfrage ob gleichschenkelig in eine Methode auslagern und/oder nur 1x gegen Ende abfragen, if else if verwenden, ... schon ist der Code lesbar und um 1/3 kürzer 😉

 

[Jardcore]

Es geht ja auch immer darum etwas zu lernen.
Wenn man sagt der Code funktioniert so und ist in Ordnung ohne darauf hinzuweise das, bzw wie man es besser machen könnte, wird man wahrscheinlich das nächste Mal den gleichen Ansatz verfolgen und folglich wieder unleserlichen Code erstellen.

 

[Joose]

Das stimmt natürlich 🙂
Aber diese "if/else" Konstrukt wird gebraucht und lässt sich logisch nur mehr wenig kürzen. Von der Lesbarkeit eben schon (wie habe ich oben schon geschrieben)

 

[JStein52]

Genau. Wenn ich zehn Fälle unterscheiden muss dann sind das halt zehn abfragen. Und dass man sie möglichst lesbar schreiben sollte ist ja klar.

 

[Hamsey]

Hey Leute,
nur um meine Vorgehensweise zu erklären meine Aufagbe war:

Für einen Lederwarenfabrikanten soll ein Programm entwickelt werden, das zur Klassifizierung dreieckiger Lederreststücke dient.
Es soll ein 2-dimensionales int-Array definiert werden, das die Werte folgender dreieckiger Lederreststücke enthält:

Seite1 Seite2 Seite3
2 2 4
3 4 5
5 5 5
8 6 10
10 10 2
2 4 9
12 36 4
5 6 7
7 9 12
Das Programm ermittelt für jedes Lederreststück (Dreieck), um welchen Dreieckstyp es sich handelt an Hand folgender Bedingungen:


Dreieckstyp

rechtwinkelig
a² + b² = c²

stumpwinkelig
a² + b² < c²

spitzwinkelig
a² + b² > c²

gleichseitig (3 Seiten gleich lang)
a = b = c

gleichschenkelig (2 Seiten gleich lang)
entweder a = b oder b = c oder a = c

undefiniert (kein Dreieck)
sonst (Dreiecksbed. nicht erfüllt)

Ausgabe:
Die Ausgabe enthält die drei Seiten des Dreiecks und den Dreieckstyp.

2 2 4 undefiniert
3 4 5 rechtwinkelig
u.s.w.

Hinweis 1:
Bitte beachten Sie, dass ein Dreieck sowohl gleichschenkelig als auch spitzwinkelig oder sowohl gleichschenkelig als auch stumpfwinkelig sein kann. Es kann aber nicht rechtwinkelig und zugleich gleichseitig sein, wohl aber rechtwinkelig und gleichschenkelig.

Hinweis 2:
Beachten Sie ferner, dass zur Überprüfung der Bedingungen für jedes Dreieck gelten muss: a <= b <= c und a + b > c , wobei a und b die Katheten sind und c die Hypothenuse ist. Verlangen Sie nicht, dass die drei Seiten in der richtigen Reihenfolge (a <= b <= c) im Array vorliegen! Das Programm sollte daher die Dreiecksseiten sortieren.

Erweiterung 1: eine Statistik- Klasse
Geben Sie eine Statistik über alle Dreiecke aus. Bei der Ausgabe darf jedes Dreieck nur unter genau eine Kategorie fallen, so dass das Programm die Anzahl der Dreiecke pro Kategorie ausgibt. Achten Sie darauf, dass Dreiecke nicht doppelt gezählt werden! Ein gleichschenkelig und rechtwinkeliges Dreieck soll also nicht einmal unter der Kategorie "gleichschenkelig" und ein zweites Mal unter der Kategorie "rechtwinkelig" auftauchen, sondern unter der Kategorie "gleichschenkelig & rechtwinkelig". Ein gleichseitiges Dreieck soll nicht unter der Kategorie gleichschenkelig mitgezählt werden.
Die Statistik liefert also die Anzahl der Dreiecke, die zu den folgenden Dreieckstypen gehören:

• gleichseitig
• rechtwinkelig
• stumpfwinkelig
• spitzwinkelig
• rechtwinkelig & gleichschenkelig
• stumpfwinkelig & gleichschenkelig
• spitzwinkelig & gleichschenkelig
• undefiniert

Ich habe versucht die Bedingungen die mir vorgegeben wurden im code umzusetzen weshalb da soviele if abfragen vorkommen.

Vielen dank für die Tipps, aber um ehrlich zu sein weiß ich noch immer nicht wie ich das mit dem zählen der Dreieckstypen in eine andere Klasse übergeben soll.
Sollte ich den ganzen code neu schreiben oder kann man damit noch weiterarbeiten?

 

[JStein52]

würde ich einfach für jedes Dreieck eine Variable erstellen und jedes mal wenn die if-Abfrage positiv ausfällt erhöht sich der Wert

Und diese Zähler implemetierst du als Instanzvariablen (bzw. bei dir ist wohl alles static, dann halt diese auch) und machst jeweils eine getterMethode dafür,
Also z.B. public static int getRechtwinkligZaehler() ...... usw. Die Namen kannst du dir ja anpassen, z.B. alles in englisch 😉😉😉 und damit implemetierst du deine Statistikklasse.

 

[Joose]

Sollte ich den ganzen code neu schreiben oder kann man damit noch weiterarbeiten?

Wenn dein Code bisher tut was er soll dann lass ihn so und erledige alle Aufgaben.
Sobald alles fertig ist kann man sich theoretisch daran machen den Code zu optimieren: Lesbarkeit erhöhen, doppelten Code in Methoden auslagern, Vergleiche optimieren, ......
Also nicht während der Entwicklung Sachen 10x neu schreiben weil es so oder so schöner oder auch anders gehen würde. Lieber eine lauffähige Version schaffen und danach überlegen wo man noch ansetzen kann.

Mit der Zeit kommt die Erfahrung und Gewohnheit bestimmte Sachen von Anfang an anders/optimaler zu machen.

 

[Jardcore]

Man kann sich diese Reihenfolge gut merken:
make it run
make it right
make it fast
🙂

 

[kneitzel]

Also diese Iterationen kann ich nicht unterschreiben:
- Clean Code schreibt man von Anfang an. Beim Schreiben wird ggf. direkt Code in eine Methode ausgelagert. Wenn dies nicht zeitnah erfolgt, hast Du später einen viel schwereren und zeitraubenderen Task vor Dir. Wenn es Dir überhaupt noch gelingt. Desweiteren wird es schwer, etwas zum Laufen zu kriegen, wenn es nicht sauber geschrieben ist.
- Das "make it fast" streichst Du bitte komplett. Das ist sowas von irrelevant. Dein Code muss laufen. An Code wird nicht wild rumoptimiert! Wenn Dein Code funktioniert und sauber geschrieben ist, dann kann es sein, das Probleme auftreten. Dann werden diese aber genau analysiert. Was dauert zu lange? Und dann wird das Konzept geprüft. Muss ich Daten evtl. anders vorhalten? Oder muss ich meinen Algorithmus ändern?

An der Stelle möchte ich dann einfach nur auf http://clean-code-developer.de/ verweisen ...

Konrad

 

[JStein52]

Also diese Iterationen kann ich nicht unterschreiben

Das müssen ja nicht unterschiedliche Iterationen sein. Das kann sich alles innerhalb einer Iteration abspielen. Ich sehe auch immer zuerst mal zu dass etwas irgendwie läuft und dann guck ich was davon nur quick and dirty war. Und das ganze natürlich unter Einhaltung des gewählten Designs.