Hallo, ich habe eine Frage zu folgendem Programm.
public class Main {
static void meineMethode() {
int x = 5;
x = (int) Math.pow(x, 2);
System.out.println(„Der Wert von x“ + (char) 253 + „beträgt“ + x);
}
public static void main(String[] args) {
meineMethode();
}
}
Und zwar, wieso kann man den Teil, der unter static void meineMethode() steht, nicht in die main methode schreiben und dafür die andere weglassen?
Hm, ich versteh die Frage nicht. Natürlich kannst Du die Methode weglassen und die Anweisungen in die main schreiben. Spricht compile-technisch nichts dagegen.
Hm, ich versteh die Frage nicht. Natürlich kannst Du die
Methode weglassen und die Anweisungen in die main schreiben.
Spricht compile-technisch nichts dagegen.
Das ist richtig, aber bei guter Software würde man das nicht machen.
Die MAIN-Methode dient der Initialisierung von Variablen, Konstanten und Umgebungsparametern, dann nach wird das eigentliche Programm gestartet.
public class Main
{
public static void meineMethode(int xKonstante)
{
int x = xKonstante;
x = (int) Math.pow(x, 2);
System.out.println("Der Wert von x" + (char) 253 + "beträgt" + x);
}
public static void main(String[] args)
{
meineMethode(5);
}
}
Das Ergebnis sieht dann so aus. Jetzt musst du nur noch deine
meineMethode(int xKonstante)
in eine eigene Klasse kapseln. Damit sind die ersten Schritte für eine gute Struktur fertig.
Die MAIN-Methode dient der Initialisierung von Variablen,
Konstanten und Umgebungsparametern, dann nach wird das
eigentliche Programm gestartet.
Genau genommen gehört sowas bei guter Software auch nicht in die main, sondern in entsprechende Konfigurationen, damit z.B. Testbarkeit gewahrt bleibt. 
Ich finde übrigens, dass man auch die einfachen Beispiele eigentlich so schnell wie möglich aus dieser main-Umgebung rausbringen sollte und echte Klassen erstellen muss. Sonst lernt man direkt am Anfang einen Nicht-OO-Ansatz, der einem das weitere Lernen eher erschwert.
Ich hab aber selbst auch so angefangen, IIRC. Leider machen das die meisten Lehrbücher bzw. Vorlesungsskripte wohl immer noch so. War das bei euch auch so?
Genau genommen gehört sowas bei guter Software auch nicht in
die main, sondern in entsprechende Konfigurationen, damit z.B.
Testbarkeit gewahrt bleibt.
Da gebe ich dir vollkommen recht, aber wenn ich jetzt noch mit Unit-Test anfange, würde ich den Hilfesuchenden nur verwirren. Ich finde mein Vorschlag für den Anfang völlig OK. Wenn er erfahrender ist, kann man auch Themen wie das Testen, Design Pattern usw. mit ins Boot nehmen.
[klugscheiss on]
Wobei eine Konfiguration nicht unbedingt nötig wäre, da es in jedem Unit-Test eine Methode gibt dafür:
@org.junit.Before
public void setUp() throws Exception
{
//hier initialisiere ich den Kram, den sonst die MAIN-Methode macht
}
Nur bei sehr komplexen Konfigurationen/Initialisierungen würde man diese Auslagern z.B. in eine XML-Konfig-Datei und diese mittels XML-Binding (Digester und co.) einlesen oder durch eine externe Konfig einen Laufzeit-Container anschubsen.
[klugscheiss off]
Ist aber nur meine „Klugschiesser-Meinung“ und die muss nicht immer die richtige Lösung sein. Aber wie du schon sagtest, es ist ein Frage der Abwägung, was in jeden einzelnen Fall das Beste ist.
@BackToTopic
Man kann aber festhalten und darüber sind sich alle einig:
In die MAIN-Methode/Klasse gehört nur die Initialisierung der Umgebung für die Anwendung und nicht mehr!!!
Ich hab aber selbst auch so angefangen, IIRC. Leider machen
das die meisten Lehrbücher bzw. Vorlesungsskripte wohl immer
noch so. War das bei euch auch so?
Wenn ich Progggen bei unserem „Godfather of Code“ Prof. Dr. Brandenburg hatte, der schaut sich die JavaDoc-Docu an, dann die grobe Struktur (Klassen-Diagramm), wenn da irgend ein Fehler bzw. Ungereimtheit ist, war Ende mit der Bewertung. Erst wenn Docu und Struktur stimmen, wurde die eigentliche Aufgabe bewertet.
Das war nur ein positives Beispiel, negativ Beispiele gab es dafür aber mehr…was ich persönlich extrem Schei**** finde.
Genau genommen gehört sowas bei guter Software auch nicht in
die main, sondern in entsprechende Konfigurationen, damit z.B.
Testbarkeit gewahrt bleibt.Da gebe ich dir vollkommen recht, aber wenn ich jetzt noch mit
Unit-Test anfange, würde ich den Hilfesuchenden nur verwirren.
Stimmt genau. Ich glaub, am Anfang ist es erstmal wichtiger, die Grundlagen zu verstehen: Was bedeutet das static bei der main? Wieso muss ich Variablen deklarieren und initialisieren? Und wieso gibt es NullPointerExceptions?
Wobei eine Konfiguration nicht unbedingt nötig wäre, da es in
jedem Unit-Test eine Methode gibt dafür:@org.junit.Before
public void setUp() throws Exception
{
//hier initialisiere ich den Kram, den sonst die
MAIN-Methode macht
}
Najaaaa, das stimmt schon. Aber ich hab schon soooo viele interne Abhängigkeiten gesehen, dass man ohne Mocking-Framework wie JMockIt nicht mehr viel ausrichten konnte. Das waren dann nämlich Konfigurationen, die im Konstruktor erledigt wurden (ist für mich so ähnlich wie in der main) und ohne die Möglichkeit, durch eine andere Konfiguration durch einen weiteren Konstruktor mitzugeben - die ich dann nämlich in der setUp erstellt hätte… :-} Naja, anderes Thema.
@BackToTopic
Man kann aber festhalten und darüber sind sich alle einig:
In die MAIN-Methode/Klasse gehört nur die Initialisierung der
Umgebung für die Anwendung und nicht mehr!!!
Ich würd für kleine Programme z.B. das Auswerten von Kommandozeilenparametern in der main machen, falls ich nicht mehr als eine Handvoll Parameter hab.
Das gleiche gilt aber auch für alle anderen Methoden: Ist die zu erledigende Aufgabe einfach genug (bzw haben alle zu tätigenden Aufrufe den gleichen Detailgrad), erledige ich sie in der Methode - ansonsten lagere ich es in die Einzelteile aus.
Vielen Dank für die Antwort.
Ich muss jetzt noch folgende Aufgabenstellung bearbeiten:
Ändern Sie die Methode so ab, dass Ihr ein beliebiger Zahlenwert vom Typ
int übergeben werden kann und überprüfen Sie Ihre Änderung(en).
Ist der Code, den du mir geschickt hast schon die Lösung dafür oder erfüllt mein Programm die Aufgabenstellung:
public class Main {
static void meineMethode() {
int x;
String eingabe;
eingabe = JOptionPane.showInputDialog(„Bitte geben Sie die zu quadrierende Zahl ein“);
x = Integer.parseInt(eingabe);
x = (int) Math.pow(x, 2);
System.out.println(„Der Wert von x“ + (char) 253 + „beträgt“ + x);
}
public static void main(String[] args) {
meineMethode();
}
}
Ja, zunächst beschränken sich alle Beispiele nur auf die main Methode und dann aufeinmal kommen mehrere Methoden dazu, wo ich dann durcheinander komme.
Ja gut, dann habe ich das soweit verstanden.
vielen Dank
Ändern Sie die Methode so ab, dass Ihr ein beliebiger
Zahlenwert vom Typ
int übergeben werden kann und überprüfen Sie Ihre
Änderung(en).Ist der Code, den du mir geschickt hast schon die Lösung dafür
oder erfüllt mein Programm die Aufgabenstellung:
Jupp meine Modifikation der Methode
meineMethode(int xKonstant)
erfüllt den ersten Schritt, den du machen musst.
Mein Vorschlag ist ein perfektes Beispiel für eine gute Struktur. Hättest du die Aufgabe von Anfang an so gebastelt, müsstest du nur vor dem Aufruf der
meineMethode(int xKonstant)
, dir von irgend wo den Wert für xKonstante holen. Eine Änderung der Logik wäre nicht nötig. Genau das zeichnet eine gute Struktur aus. idealer Weise kein Abhängigkeiten oder nur geringe…
Ich kann dir das hier nur empfehlen:
http://www.clean-code-developer.de
ich habe bei meiner Modifikation nur zwei der Prinzipien (teilweise) angewandt.
http://www.clean-code-developer.de/wiki/CcdOrangerGr…
http://www.clean-code-developer.de/wiki/CcdOrangerGr…
Sicherlich erscheint das Ganze bei einer so simplen Aufgabe als überflüssig, aber wenn man das Ganze von ersten Tag an beherzigt, werden die großen Projekt später „locker vom Hocker“ umgesetzt.
Meine Empfehlung für die Aufgabe:
Du brauchst Klassen für die Berechnung, Eingabe, Ausgabe und für das eigentliche Programm.
public class Berechnung
{
private Ausgabe ausgabe;
public Berechnung(Ausgabe ausgabe)
{
this.ausgabe = ausgabe;
}
public void meineMethode(int xKonstante)
{
int x = xKonstante;
x = (int) Math.pow(x, 2);
this.ausgabe.printOnConsole("Der Wert von x" + (char) 253 + "beträgt" + x);
}
}
public class Eingabe
{
public int leseEingabe() throw Exception
{
hier kommt dein Code mit der JOptionPane usw. hin
wenn ein Eingabefehler (NumberFormatException oder NullPointerException) auftritt muss du ein Exception werfen
damit die Benutzende Klasse weiß, hier stimmt was nicht und entsprechend reagieren kann
}
}
public class Ausgabe
{
public void printOnConsole(String ausgabe)
{
System.out.println(ausgabe);
}
}
public class MeinProgramm
{
private Ausgabe ausgabe;
private Eingabe eingabe;
private Berechnung berechnung;
public MeinProgramm()
{
this.ausgabe = new Ausgabe();
this.eingabe = new Eingabe();
this.berechnung = new Berechnung(this.ausgabe);
}
public void starteProgramm()
{
bau hier eine Schleife die entsprechend auf die Eingabe (this.eingabe.leseEingabe():wink: reagiert
und den Wert an Berechnung weiter gibt (this.berechnung.meineMethode(int xKonstante):wink:
Ebenfalls muss du die Exeption welche von der Eingabe kommen entsprechend behandeln, in dem du diese
mit try-catch abfängst und an die Ausgabe einen Text leitest (this.ausgabe.printOnConsole("Ihre Eingabe ist Falsch"):wink:
}
}
public class Main
{
public static void main(String args[])
{
MeinProgramm programm = new MeinProgramm();
programm.starteProgramm();
}
}
Die Initialisierung im Konstruktor der Klasse MeinProgramm wären eingentlich eine Aufgabe für die MAIN-Methode, aber da du mit keinen Interfaces oder Vererbungen arbeitest (kommt später bestimmt) kann man das Ganze auch so machen
Besser wäre
public class Main
{
public static void main(String args[])
{
//init der Umgebung
Ausgabe ausgabe = new Ausgabe();
Eingabe eingabe = new Eingabe();
Berechnung berechnung = new Berechnung(this.ausgabe);
//prog starten
MeinProgramm programm = new MeinProgramm(ausgabe, eingabe, berechnung);
programm.starteProgramm();
}
}
Ich kann dir das hier nur empfehlen:
http://www.clean-code-developer.de
Ah! Ein CCD-Kollege! 
@Mathematikus
Bist Du kompletter Programmieranfänger oder kennst Du andere Sprachen?
Ja ich bin kompletter Programmieranfänger
Ich hatte letztes Jahr Informatik in der Vorlesung, doch hatte ich leider das Pech, einen Professor zu haben, der überhaupt nicht verständlich erklären konnte.
Deswegen habe ich die Klausur auch erstmal verschoben und habe vor die nächstes Semester zu schreiben.
Deswegen will ich mich jetzt schonmal darauf vorbereiten.