OOP Eine Frage des Stils aka. Geht das so?

[m²labs]

Hallo Leute,
erstmal muss ich wohl für den nichtssagenden Titel um Verzeihung bitten, aber meine Frage ist etwas zu komplex um sie kurz und prägnant auszudrücken.

Also:
Ich hab für die Schule ein Programm geschrieben, dass eigentlich nix anderes macht, als Counting Sort auf eine Benutzereingabe anzuwenden. Das Programm funktioniert einwandfrei (bin ein wenig stolz drauf) aber ich weiß nicht, ob man es als "schön" bezeichnen kann. Ich hab eben absolut keine Erfahrung, wie man Software "sauber" aufbaut. Es wäre schön, wenn sich jemand das von mir geschriebene mal ansehen würde, im Hinblick auf folgende Gesichtspunkte:

Habe ich die Klassen sinnvoll gewählt?
Habe ich die jeweiligen Methoden sinnvoll in den Klassen angelegt?
Ist es OK, dass ich eigentlich immer Werte direkt über ne Methode bestimme, oder sollte ich die vorher in Variablen speichern?

Ich hoffe, das is jetz nicht zu viel verlangt. Es würde mir halt wirklich weiterhelfen. Hier aber nun der Code der 4 Klassen:

Main:

import java.util.Arrays;
import java.util.Scanner;


public class Main
{
    public static void main(String[] args)
    {
        prntTxt("Hallo, ich bin Sorty.");
        prntTxt("Ich wurde geschrieben, um Zahlen zu sortieren.");
        prntTxt("Dazu benötige ich von dir eine Eingabe.");
        prntTxt("Ich muss aber darum bitten,dass du die Zahlen durch Kommata trennst. Etwa so:");
        prntTxt("4,5,87,7,99.3,10...");
        prntTxt("Umso unordenticher du die Zahlen ei, desto besser kann ich meine Funktion beweisen ;)");
        
        SortRoutine.routine();
    }
    
    public static void prntInt(int x)
    {
        System.out.println(x);
    }
    
    public static void prntTxt(String x)
    {
        System.out.println(x);
    }
    
    public static void prntArray(int[] x)
    {
        System.out.println(Arrays.toString(x));
    }
    
    public static void newLine()
    {
        prntTxt("\n");
    }
    
    public static int[] parseInput(String x)
    {
            String input = x;
            String[] splittedInput = input.split("\\,");
            int[] values = new int[splittedInput.length];
            
                for (int i = 0; i < splittedInput.length; i++)
                    {
                        try
                        {
                            values[i] = Integer.parseInt(splittedInput[i]);
                        }
                        catch(java.lang.NumberFormatException e)
                        {
                            prntTxt("Bitte nur Zahlen durch Komma getrennt eingeben. auch keine Leerzeichen");
                            SortRoutine.routine();
                        }
                    }
            return values;
          
    }
    
    public static int scanAuswahl()
    {
        Scanner input=new Scanner(System.in);
        int auswahl=0;
        try
        {
            auswahl=input.nextInt();
        }
        
        catch(java.util.InputMismatchException e)
        {
            prntTxt("Bitte nur Zahlen Eingeben.");
            SortRoutine.weitermachen();
        }
        
        return auswahl;
    }
}

SortRoutine:

import java.util.Scanner;
    
public class SortRoutine extends Main
{
     public static void routine()
     {
        prntTxt("Bitte gib ein paar Zahlen ein.");
        Scanner scanner=new Scanner(System.in);
        String input=scanner.nextLine();
        prntTxt("Du hast Zahlen zwischen "+MinMax.getMin(parseInput(input))+" und "+MinMax.getMax(parseInput(input))+" eingegeben.");
        prntTxt("Sortiert ergibt das:");
        prntArray(CountSort.sort(parseInput(input)));
        prntTxt("Was möchtest du nun machen?");
        weitermachen();
        
        
        
    }   
    
    public static void weitermachen()
    {
       prntTxt("Neue Zahlen eingeben? (1) oder das Programm beenden? (2)");
       int i=Main.scanAuswahl(); 
         
        switch(i)
        { 
            case 1: 
                routine(); 
                break; 
            case 2: 
                System.exit(0);
                break;
            default: 
                System.out.println("Bitte entweder 1 oder 2 eingeben.");
                weitermachen();
        } 
    }
}

CountSort:

public class CountSort
{
      public static int[] sort(int[] a)
      {
          int minValue=MinMax.getMin(a);
          int maxValue=MinMax.getMax(a);
          int[] b= new int[maxValue+1-minValue];
        
        for(int j=0;j<b.length;j++)
        {
            b[j]=minValue+j;
        }
       
        
        int[] c=new int[b.length];
        
        for (int k=0;k<b.length;k++)
        {
            for(int l=0;l<a.length;l++)
            {
                if (a[l]==b[k])
                {
                    c[k]++;
                }
            }
        }
                
        int[] d=new int[a.length];
        
       int stelle=0;
        
        for (int m = 0; m <b.length; m++)
        { 
            for (int n=0;n<c[m];n++)
            {
                d[stelle]=b[m];
                stelle++;
            }
        
        }
        
        
       return d; 
    }
}

MinMax:

public class MinMax
{
    public static int getMax(int[] a)
    {
        int maxValue=a[0];

        for(int i=0;i<a.length;i++)
            {
                if (a[i]>maxValue)
                {
                    maxValue=a[i];
                }
            }
        return maxValue;
    }
    
    public static int getMin(int[] a)
    {
        int minValue=a[0];
        
        for (int i=0;i<a.length;i++)
        {
            if (a[i]<minValue)
            {
                minValue=a[i];
            }
        }
        return minValue;
    }
}

Für euch Profis sollte das doch n Klaks sein

Grüße,
Markus

 

[Tobse]

Warum SortRoutine von Main erbt schrließt mir nicht ganz. Die Methoden getMin und getMax hätten auch nicht in eine extra-klasse gemusst *.
Ebensowenig machen die Methoden

prntTxt

und

prntInt

sinn. Ausserdem ist [c]prnt[c] eine sehr üble Namensgebung die (fast) jeder Anfänger aus Faulheit begeht. Schreibe Namen, Bezeichnungen und Funktionen immer aus. Denn jemand anderes (oder auch du nach 1-2 Jahren) will auf Anhieb wissen, was eine Methode/Klasse macht ohne erst den (mager kommentierten) Quellcode durchlesen zu müssen.

Aber von der Struktur her ist das Programm eigentlich okey; bei solchen minimalen Anforderungen an ein Programm kann man eigentlich alles mögliche machen ohne großartig gegen Design-Konvetionen zu verstoßen. Wichtig wird soetwas erst wenn das Projekt über mehr als 5-6 Klassen umfasst.

 

[m²labs]

Danke für die schnelle Antwort.
Das mit den Namen werd ich dann mal noch ändern und kommentiert muss der Code vor der Abgabe eh noch werden.

Über die sinnhaftigkeit der beiden Methoden kann sicherlich gestritten werden.

Ich deute die Antwort jetzt aber mal so, dass da keine groben Fehler drin sind und man das so abgeben kann.

Edit: MinMax hab ich eigentlich nur ausgelagert, weil ich da später eventuell noch andere Algorhytmen einbaue und die dann einfach darauf zugreifen können. SortRoutine erbt von Main um mir eben das Main.* jedesmal zu sparen. Ich weiß, eigentlich unsinnig...

 

[Tobse]

Ich deute die Antwort jetzt aber mal so, dass da keine groben Fehler drin sind und man das so abgeben kann.

Das ist korrekt.

Edit: MinMax hab ich eigentlich nur ausgelagert, weil ich da später eventuell noch andere Algorhytmen einbaue und die dann einfach darauf zugreifen können. SortRoutine erbt von Main um mir eben das Main.* jedesmal zu sparen. Ich weiß, eigentlich unsinnig...

Für beide Fälle: Bau die Methoden da ein, wo du sie brauchst. Es gibt in jeder modernen IDE eine Funktion namens "Refactoring" die im gesamten Quellcode alles entsprechend ändert, wenn man Methoden / Klassen verschiebt oder umbenennt.

 

[m²labs]

Ah das is n interessanter Tip. Zur Zeit nutz ich halt nur BlueJ, weil wir das auch in dessen Projektformat abgeben müssern. Werde aber mal den in Eclipse einfügen und dort dann rumexperimentieren.

Any way, Danke für deine geopferte Zeit:applaus:.

P.S.: Mit diesem Post sollte ich dann auch die Marke fürs "Per-Button-Bedanken" erreicht haben:bae: