Klassen Programm funktionert - aber auch ökonomisch?

[dsfge456]

Nabend Leute!

Ich habe ein etwas komplexeres Programm geschrieben.

Es sollen verschiedene Messdaten (max. 10) eingegeben werden können.
Außerdem soll man diese im Nachhinein alle und einzeln überschreiben können.
Das programm soll mit ihnen rechnen, die ergebnisse formatiert ausgeben und beendet werden können.
Andernfalls läuft es in einer Endlosschleife.

IMO funktioniert auch alles.

Nun wäre die Frage, ob es so auch ökonomisch läuft oder ob man etwas verbessern könnte.
Hier seid ihr nun gefragt!!!

Hier der Code (2 Klassen sind Pflicht, sonst würde ich alles in eine packen):

package paket;

import java.io.*;
import java.text.*;

class Benutzerschnittstelle {
	public static double[] eingabeVariablen = new double [10];
	public static double arithmetischesMittel, minimum, maximum, standardabweichung, median;

	public static void ausgabe (double[] eingabeVariablen) {
		for (int i=0; i<10; i++) {
			System.out.println(eingabeVariablen[i]);
		}
	}
	
	public static double[] eingabe () {
		for (int i=0; i<10; i++) {
			String eingabeWert = javax.swing.JOptionPane.showInputDialog("Bitte geben Sie Wert " + (i+1) + " ein");
			eingabeVariablen[i] = Double.parseDouble(eingabeWert);
		}
		return eingabeVariablen;
		
	}
}

public class Projekt {
	
public static void menue() {
		
		int auswahl;
		
		System.out.println("\n_______________________________________________");
		System.out.println("Menü:");
		System.out.println("[1] Messwerte eingeben");
		System.out.println("[2] Messwert ändern");
		System.out.println("[3] Messwerte sortieren");
		System.out.println("[4] Rechenfunktionen ausführen");
		System.out.println("[5] Ergebnisse ausgeben");
		System.out.println("[0] Programm beenden");
		System.out.print("Bitte wählen Sie die gewünschte Operation aus: ");
		
		auswahl = eingabe();
			
			switch (auswahl) {
			case 1: Benutzerschnittstelle.eingabe();
					menue();
					break;
			case 2: messwertAendern(Benutzerschnittstelle.eingabeVariablen);
					menue();
					break;
			case 3: messwerteSortieren(Benutzerschnittstelle.eingabeVariablen);
					menue();
					break;
			case 4: formatierteAusgabe(Benutzerschnittstelle.eingabeVariablen);
					menue();
					break;
			case 5: Benutzerschnittstelle.ausgabe(Benutzerschnittstelle.eingabeVariablen);
					menue();
					break;
			case 0:	System.out.println("Sie haben folgende Rechenfunktion gewählt: Programm beenden");
					System.exit(0);
			default:	break;
			}
		}

public static double[] messwertAendern (double[] eingabeVariablen) {
	int Messwert, wertMesswert;
	
	System.out.print("\nGeben Sie den Messwert ein, den Sie ändern möchten: ");		
	Messwert = eingabe()-1;
	
	System.out.print("\nGeben Sie den neuen Messwert ein: ");
	wertMesswert = eingabe();
	
	eingabeVariablen[Messwert] = wertMesswert;
	return eingabeVariablen;
}

public static int eingabe () {
	
	String strInput = null;
	int rechenfunktion_int = 0;
	
	BufferedReader input = new BufferedReader (new InputStreamReader(System.in));
	try {
		strInput = input.readLine();
	} catch (IOException e) {
		e.printStackTrace();
	}
	
	rechenfunktion_int = Integer.parseInt(strInput);
	
	return rechenfunktion_int;
	
}

public static void messwerteSortieren (double[] eingabeVariablen) {
	
	String strInput, auf = "AUF", ab = "AB";
	strInput = null;
	
	System.out.println("\n Wie möchten sie Ihre Messwerte sortieren:");
	System.out.print("AUFwärts oder ABwärts? ");
	
	BufferedReader input = new BufferedReader (new InputStreamReader(System.in));
	try {
		strInput = input.readLine();
	} catch (IOException e) {
		e.printStackTrace();
	}
			
	if (strInput.equals(auf)) {
		sortierverfahrenAufwaerts(Benutzerschnittstelle.eingabeVariablen);
	} else if (strInput.equals(ab)) {
		sortierverfahrenAbwaerts(Benutzerschnittstelle.eingabeVariablen);
	} else {
		System.out.println("Ungültige Eingabe!");
		menue();
	}
}

public static double[] sortierverfahrenAufwaerts(double[] eingabeVariablen) {
	for (int i = 0; i < (eingabeVariablen.length ); i++) {
		for (int j = i + 1; j < eingabeVariablen.length; j++) {
			if (eingabeVariablen[i] > eingabeVariablen[j]) {
				double dreieck = eingabeVariablen[i];
				eingabeVariablen[i] = eingabeVariablen[j];
				eingabeVariablen[j] = dreieck;
			}
		}
	}

	return eingabeVariablen;
}

public static double[] sortierverfahrenAbwaerts(double[] eingabeVariablen) {
	for (int i = 0; i < (eingabeVariablen.length ); i++) {
		for (int j = i + 1; j < eingabeVariablen.length; j++) {
			if (eingabeVariablen[i] < eingabeVariablen[j]) {
				double dreieck = eingabeVariablen[i];
				eingabeVariablen[i] = eingabeVariablen[j];
				eingabeVariablen[j] = dreieck;
			}
		}
	}

	return eingabeVariablen;
}

public static double minimum (double[] eingabeVariablen) {
	double minimalwert = eingabeVariablen[0];
	
	for (int i=0; i<eingabeVariablen.length; i++) {
		if (eingabeVariablen[i] < minimalwert) {
			minimalwert = eingabeVariablen[i];
		}
	}
	return minimalwert;
}

public static double maximum (double[] eingabeVariablen) {
	double maximalwert = eingabeVariablen[0];
	
	for (int i=0; i<eingabeVariablen.length; i++) {
		if (eingabeVariablen[i] > maximalwert) {
			maximalwert = eingabeVariablen[i];
		}
	}
	return maximalwert;
}

public static double standardabweichung (double[] eingabeVariablen) {
	double summe = 0;
	
	for (int i=0; i<eingabeVariablen.length; i++) {
		summe = summe + (eingabeVariablen[i]-arithmetischesMittel(eingabeVariablen))*(eingabeVariablen[i]-arithmetischesMittel(eingabeVariablen));
	}
	
	double standardabweichung = Math.sqrt(((1.0/9)*summe));
	return standardabweichung;
}

public static double arithmetischesMittel (double[] eingabeVariablen) {
	double arithmetischesMittel = 0;
	
	for (int i=0; i<eingabeVariablen.length; i++) {
		arithmetischesMittel = arithmetischesMittel + eingabeVariablen[i];
	}
	arithmetischesMittel = arithmetischesMittel / eingabeVariablen.length;
	return arithmetischesMittel;
}

public static double median (double[] eingabeVariablen) {
	sortierverfahrenAufwaerts(eingabeVariablen);
	double Median = (eingabeVariablen[5] + eingabeVariablen[6])/2;
	return Median;
}

public static void formatierteAusgabe (double[] eingabeVariablen) {
	DecimalFormat messwerte = new DecimalFormat("#00.000");
	DecimalFormat ergebnisse = new DecimalFormat("#000.00000");
	System.out.println("Messwerte:\n");
	System.out.println("Messung                1        2        3        4        5        6        7        8        9        10");
	System.out.print("R/Ohm:               ");
	for (int i=0; i<eingabeVariablen.length; i++) {
		System.out.print(messwerte.format(eingabeVariablen[i]) + "   ");
	}
	System.out.println("\n");
	System.out.print("Mittelwert:         " );
	System.out.println(ergebnisse.format(arithmetischesMittel(Benutzerschnittstelle.eingabeVariablen)) + "  Ohm");
	System.out.print("Minimum:            " );
	System.out.println(ergebnisse.format(minimum(Benutzerschnittstelle.eingabeVariablen)) + "  Ohm");
	System.out.print("Maximum:            " );
	System.out.println(ergebnisse.format(maximum(Benutzerschnittstelle.eingabeVariablen)) + "  Ohm");
	System.out.print("Standardabweichung: " );
	System.out.println(ergebnisse.format(standardabweichung(Benutzerschnittstelle.eingabeVariablen)) + "  Ohm");
	System.out.print("Median:             " );
	System.out.println(ergebnisse.format(median(Benutzerschnittstelle.eingabeVariablen)) + "  Ohm");
}

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

DANKE IM VORRAUS!

 

[Antoras]

1. Variablen schreibt man klein
2. die

   static

   sind alle unnötig. Entferne sie und erzeuge statt dessen eigene Objekte auf die zugegriffen wird.
3. Nutze die Standard API:
   

   public static double[] sortierverfahrenAufwaerts(double[] eingabeVariablen) {...}
   // ==>
   public void sortierverfahrenAufwaerts(double[] eingabeVariablen) {
     Arrays.sort(eingabeVariablen);
   }
   
   public static double[] sortierverfahrenAbwaerts(double[] eingabeVariablen) {...}
   // ==>
   public void sortierverfahrenAbwaerts(final Double[] eingabeVariablen) {
   	final List<Double> l = Arrays.asList(eingabeVariablen);
   	Collections.sort(l, new Comparator<Double>() {
   		@Override
   		public int compare(final Double o1, final Double o2) {
   			return (int)(o2 - o1);
   		}
   	});
   	l.toArray(eingabeVariablen);
   }

   Die Variante mit den Listen hätte halt den Nachteil, dass du mit Double anstatt double arbeiten müsstest.
4. foreach-Schleife benutzen:
   

   public static double minimum (double[] eingabeVariablen) {...}
   // ==>
   public double minimum(final double[] eingabeVariablen) {
   	double min = eingabeVariablen[0];
   	for (final double d : eingabeVariablen) {
   		if (d < min) {
   			min = d;
   		}
   	}
   	return min;
   }
   // oder
   public Double minimum(final Double[] eingabeVariablen) {
     return Collections.min(Arrays.asList(eingabeVariablen));
   }

 

[Woodstock]

Hallo,

ich sage mal das hast du etwas eigenartig gelöst:

in der menue-Methode (Zeile 28) rufst du in der switch-Anweisung immer wieder die menue-Methode rekursiv auf. Je nachdem wie oft jemand das Menü benutzt kann es da zu einem StackOverflow kommen. Ist aber eher unwahrscheinlich.

Besser wäre das Ganze mit einer einer Schleife gelöst.

 

[ARadauer]

public static double[] sortierverfahrenAufwaerts(double[] eingabeVariablen) {
    for (int i = 0; i < (eingabeVariablen.length ); i++) {
        for (int j = i + 1; j < eingabeVariablen.length; j++) {
            if (eingabeVariablen[i] > eingabeVariablen[j]) {
                double dreieck = eingabeVariablen[i];
                eingabeVariablen[i] = eingabeVariablen[j];
                eingabeVariablen[j] = dreieck;
            }
        }
    }
 
    return eingabeVariablen;
}

ökonomisch? nein... da gibt es bessere möglichkeiten... Musst du das selbst machen? Habt ihr noch keine Sortierverfahren durchgenommen? Mergesort, Insertsort, Bubblesort? Sortierverfahren ? Wikipedia

 

[bygones]

*kopfkratz* ökonomischer Code ?! ....

 

[ARadauer]

*kopfkratz* ökonomischer Code ?! ....

ja warum nicht? ökonomisch = wirtaschaftlich = erlös/kosten
kann ich den erlös (sortierte liste) auch mit weniger kosten (weniger operationen) haben ist es unwirtschaftlich

 

[KytoN]

Ich glaube, hier ist eher von Performanz denn von Ökonomie die Rede

 

[VfL_Freak]

Moin,

oder geht es eher um Glaubensfragen ???:L
Dann wäre es die Ökomene

Gruß
Klaus

 

[Landei]

Offenbar soll der Code wiederverwendbar sein -> Recycling -> ökologisch.

 

[Andi_CH]

öh - komischer Code
(Nicht böse werden - rumwitzeln brauchts ab und zu)

 

[timbeau]

Das religiöse Ding heißt allerdings ökumene

 

[Landei]

Eventuell sollen wir den Code auf seine ökotoxischen Eigenschaften testen?

 

[VfL_Freak]

Moin,

Das religiöse Ding heißt allerdings ökumene

jau, hast natürlich Recht ... da waren meine Finger zu flink :lol:

Gruß
Klaus

 

[timbeau]

Ich gebs zu, ich wollte es auch schreiben und war mir unsicher

 

[ARadauer]

öh - komischer Code
(Nicht böse werden - rumwitzeln brauchts ab und zu)

:lol:

 

[Andi_CH]

Um doch noch etwas produktives beizutragen:
Und warum das nicht static sein soll weiss ich nicht - auf jeden Fall gibt es keine Nachteile

	public static int menue() {
		System.out.println();
		System.out.println("_______________________________________________");
		System.out.println("Menü:");
		System.out.println("[1] Messwerte eingeben");
		System.out.println("[2] Messwert ändern");
		System.out.println("[3] Messwerte sortieren");
		System.out.println("[4] Rechenfunktionen ausführen");
		System.out.println("[5] Ergebnisse ausgeben");
		System.out.println("[0] Programm beenden");
		System.out.print("Bitte wählen Sie die gewünschte Operation aus: ");
		return eingabe();
	}

	public static void main(String[] args) {
		while (true) {
			switch (menue()) {
			case 1:
				Benutzerschnittstelle.eingabe();
				break;
			case 2:
				messwertAendern(Benutzerschnittstelle.eingabeVariablen);
				break;
			case 3:
				messwerteSortieren(Benutzerschnittstelle.eingabeVariablen);
				break;
			case 4:
				formatierteAusgabe(Benutzerschnittstelle.eingabeVariablen);
				break;
			case 5:
				Benutzerschnittstelle.ausgabe(Benutzerschnittstelle.eingabeVariablen);
				break;
			case 0:
				System.out.println("Sie haben folgende Rechenfunktion gewählt: Programm beenden");
				System.exit(0);
			default:
				break;
			}
		}
	}

Das ist jetzt dermassen öko - da sollte doch der Hintergurund eher grünlich sein

 

[Antoras]

Und warum das nicht static sein soll weiss ich nicht

Weil es nicht objektorientiert ist.

auf jeden Fall gibt es keine Nachteile

Doch. Man lernt nicht wie es richtig geht. An Perfektion nähert man sich nur dann an wenn man versucht sie auch bei den einfachsten und unnötigsten Sachen zu erreichen.

 

[Andi_CH]

Ich habe gerad an anderer Stelle gesagt, dass die erste Begegnung mit Programmieren nicht zwingend in der OO-Welt sein muss - OO ist eine Technik die eingesetzt werden kann wen es etwas bringt, aber nicht eingesetzt werden muss nur weil man Java einsetzt. (Ich kann auch ein "Hello World" Programm objektiorientiert oder rekursiv schreiben, aber es ist unnötig)

Spätestens dann wenn von einer Klasse nur ein einziges Objekt erzeugt würde und keine Vererbung eingesetzt wird, kann bzw. sollte sie static sein.

 

[bygones]

lass mich raten... du testest nicht wirklich oder ?! static hoch zuheben ist mehr als falsch

 

[Landei]

static ist schlechter als Singleton Pattern ist schlechter als Factory Pattern ist schlechter als Abstract Factory Pattern ist schlechter als Dependency Injection ist schlechter als ... (siehe Signatur)

 

[Andi_CH]

Wieso ist ein singleton schlecht? Angeblich weil man es nicht testen kann - vorerst erachte ich das als eine Behauptung (Es ist nichts anderes als ein static-Konstrukt)

Ich bin gespannt ob mir jemand erklären kann warum man static nicht testen kann. Ich bin nur in Wertvorstellunge verankert, nicht beratungsresistent, aber ich will überzeugt werden...

Java hab ich noch nie wirklich seriös getestet (Es hiess wörtlich: Das sei zu teuer - Nicht meine Aussage!)

Ada95 gemischt static und OO habe ich exzessiv (whiteboxtests über mehrere Monate) getestet und es machte definitv keinen Unterschied ob OO oder nicht.


Einfach so 2 Gedanken:

- KISS - Keep It Simple otherwise you're Stupid: Hello World OO ist definitiv daneben
(Softwaremetriken sind nicht meine Welt, aber wozu erst einen Konstruktor aufrufen, wenn ich gleich direkt "print" machen kann? Unnötige Lines of code

- Software wird nicht geschrieben um getestet, sondern um betrieben zu werden

 

[Landei]

Das Problem beim Testen ist nicht das static, sondern der Code, der es benutzt. Angenommen, eine statische Methode liest per JDBC ein paar Werte aus einer Datenbank. Wie soll man Code testen, der dieses Methode benutzt, ohne dass man eine geeignete Datenbank braucht?

Die beste Version ist irgend eine Form von Dependency Injection, etwa Spring oder hier Guice:

punlicinterface GetData { List<Foo> getData(); }

public class GetDbData implements GetData { public List<Foo> getData(){...}; }

public class GetTestData implements GetData { public List<Foo> getData(){...}; }

public class UseData {
  private GetData getData;

  @Inject  //<--- Guice Annotation
  public UseData(GetData getData) { //<--- Parameter getData wird von Guice injiziert
     this.getData = getData; 
  }

  //useData wird hier irgendwo benutzt
}

Durch Umkonfigurieren von Guice kann ohne Codeänderung in UseData, GetData u.s.w. mit Testdaten getestet werden. Dieses Level von Flexibilität hat auch andere Vorteile, der Code wird z.B. "automatisch" modularer und wiederverwendbarer.

 

[Andi_CH]

Den Code verstehe ich nicht wirklich, aber ich vermute du ersetzt Codeteile durch Testcode
EDIT: Kommentar erst jetzt gesehen - Parameter wird gesetzt .....

Ich hab nur ganze Klassen ersetzt und den Rest durch Mokes ersetzt. Sogar eine DB hatten wir da, aber auch die konnte ersetzt werden ;-) (Ach wie einfach ist die Ada-Welt )

Wie willst du den ersetzten Code ohne DB testen wenn er nicht static ist? Es wird ja ein Ersatzcode ausgeführt, der dem Rest vorgaukelt er hätte Daten aus der DB gelesen.

Aber ich denke wir brechen hier ab - es driftet weg.

PS: Wer einen besseren Job hat als den Schrott den ich hier machen muss (Dokumentation und Testen ist zu teuer) einfach melden

 

[Landei]

Durch den Aufruf von static entsteht einfach eine starke Kopplung zwischen zwei Komponenten. Wenn die statische Methode [c]Math.sin()[/c] ist, mag das noch angehen (wer will schon die Definition von Sinus ändern?), aber alles, wo es auch nur die geringste Wahrscheinlichkeit gibt, dass es sich ändern könnte, sollte über ein Interface und weitere geeignete Maßnahmen (Factory, DI...) entkoppelt werden, so dass es "austauschbar" wird.

Nebenbei habe ich festgestellt, dass selbst wenn ich die Möglichkeit des Austauschens gar nicht benutze, meine Anwendungen trotzdem besser strukturiert sind als früher.