Informatik: Programmieren - (Teil 1) Einstieg in Java
Released by matroid on Do. 28. April 2005 21:54:49 [Statistics]
Written by Kobe - 21063 x read [Outline] Printable version Printer-friendly version -  Choose language   
Informatik

\(\begingroup\) Programmieren - (Teil 1) Einstieg in Java Hello Matheplanet Ich helfe euch zuerst mit Schwimmflügeln im seichten Java-Gewässer die ersten kleinen Wellen zu erforschen. Dann helfe ich euch weiter ins blaue Java-Meer hinaus, damit Ihr irgendwann alleine den langen Weg auf die kleine Insel in Südindonesion findet, indem ihr mir beweist, dass ihr letztendlich alleine im riesigen, voll Möglichkeiten überlaufenden Java-Ozean zurechtkommt. Viel Spaß

Gliederung

Entstehungsgeschichte Nötige Software Installation Aller Einstieg ist Hello Matheplanet Zweiter kleiner Kontakt Binomialkoeffizient Klassensystem aufbauen Binomialkoeffizient in Swing Polymorphie und Ableiten Definitionen Code beschriebenen Programmen Nachwort

Entstehungsgeschichte

Es mag nicht wichtig erscheinen, den genauen chronologischen Entwicklungsprozess einer Programmiersprache zu kennen. Allerdings ist es schon bedeutsam zu wissen, wann Technologien entstanden sind und wo sie von anderen Technologien ihres Lebenszyklus beeinflusst werden. Deshalb möchte ich Euch kurz eine roadmap der Entwicklung der Programmiersprache Java vorstellen.
  • Die Wurzel der zurückführbahren Java Entwicklungen beginnt im Jahre 1990. Ein Entwicklerprojekt Green der Firma SUN entsteht um Zukunftstrends zu analysieren.
  • 1991 ist man auf der Suche nach einer Programmiersprache eines neu zu entwickelnden Betriebssystems, jedoch wird kein Aspirant den Anforderungen gerecht.
  • Im Laufe des Jahres 1993 entwickelt Green erfolgreich den Prototypen in einer neuen Sprache, die Oak (engl. Eiche) genannt wird
  • Nach erfolgloser Firmengründung der Projektmitarbeiter wird Oak 1994 für das Internet modifiziert. Bei diesem Prozess entstand ebenfalls der Mosaic Browser.
  • 1995 Oak wird über das Internet angeboten. Allerdings unter dem Namen Java
  • Die Beweggründe für die Namenswahl sind nicht eindeutig. Unter Java kannte man in den USA nur die umgangssprachliche Bezeichnung für heissen Kaffee. Allerdings sei erwähnt , dass auch die kleinste, aber bedeutendste der Großen Sundainseln, Indonesiens[Brockhaus] diesen Namen trägt. Weiter geht es mit folgenden Versionen des Java Development Kit.
    1996Version 1.0
    1997Version 1.1
    1998Version 1.2
    2000Version 1.3
    2002Version 1.4
    2003Version 1.5 Betaversion

Nötige Software

Es gibt viele Wege nach Rom und genausoviele Möglichkeiten seinen Code zu kompilieren und auszuführen. Ich gebe hier nur jeweils ein Beispiel, mit dem ich arbeite. J2SE Plattform (rechte Seite unter Related Links kann man die J2SE Verionen relativ übersichtlich auswählen und downloaden) beinhaltet alle nötigen Bibliotheken und Compiler. An und für sich kann man damit schon arbeiten, aber damit man auch für Java eine schöne Benutzeroberfläche hat, eignet sich eine JCreator LE Version, mit dem man Java Programme kompilieren und ausführen kann. Wie genau kompiliert wird, folgt später

Installation

Das Java SDK einfach in ein Verzeichnis nach Wahl installieren. Danach den JCreator installieren, der findet das installierte SDK selbstständig. Aber zur einfacherern Handhabung dieses Editors noch schnell ein paar Einstellungen, die ich sehr praktisch finde Configure - Customize - Keyboard - (Category) Build - Compile File auf F6 (Bei "press new shortcut key") und "assign" Bild das gleiche bei Execute File, das aber auf F7 und "assign" Damit können wir ab sofort Code einfach per dürcken der F6 Taste kompilieren und ihn mit F7 ausführen. Configure - Options - New - Dos Command - \sourceon c:\j2sdk1.4.2_04\bin\javadoc *.java \sourceoff bzw. anstatt j2sdk1.4.2_04 das Verzeichnis, indem das Java SDK installiert ist Bild das gleiche nochmal, aber mit \sourceon c:\j2sdk1.4.2_04\bin\javadoc *.java -package \sourceoff Damit haben wir auf Tool 1 das JavaDoc gesetzt, womit wir alle Java Dateien die in dem aktuellen Verzeichnis stehen (wo die aktuelle Datei gespeichert ist) in eine JavaDoc erstellt können. Dazu aber später noch, was das ist. Mit Tool 2 können wir auch das komplette Paket mit einbinden, aber Tool 1 soll für das gröbste reichen.

Aller Einstieg ist Hello Matheplanet

Nun können wir endich unser ersten Programm schreiben. File - New File gewünschten Namen und Verzeichnis angeben Bei dem Namen der Datei muss man bei Java darauf achten, dass er der gleiche ist, wie die Klasse, die die main Methode enthält. (Präziser: Der Dateiname muss nur mit dem Klassennamen übereinstimmen, wenn die Klasse public ist. Aber man sollte sich dennoch gleich von Anfang an angewöhnen, die Dateien sowie den Klassennamen gleich zu benennen!) In unserem ersten Beispiel nennen wir die Datei Hello.java (das .java macht er automatisch). Bild Und in diese Java Datei schreiben wir folgenden Code \sourceon class Hello { public static void main (String args[]) { System.out.println("Hello Matheplanet!"); } } \sourceoff Dann folgt ein F6. Wir sehen unten (nach einer kurzen Wartephase, da üblicherweise die JavaMachine erstmal gestartet werden muss) Process completed, was uns soviel sagt wie, dass wir im Code keinen syntaktischen Fehler haben. Nach einem F7 erhalten wir auch die gewünschte Ausgabe Bild Oder mit der Konsole: \sourceon >javac Hello.java >java Hello Hello Matheplanet! > \sourceoff Generell zum Kompilieren / Ausführen \sourceon >javac Datei_Name.java >java Datei_Name - zugehörige Konsolenausgabe - > \sourceoff Das ist die generelle Arbeitsweise um (Java)Code zu kompilieren und ausführen. Auch der JCreator macht das, aber eben auf Knopfdruck. Wer unter Windows lieber mit der Konsole arbeitet, sollte sich zu den globalen Variablen das Java bin-Verzeichnis dazu schreiben: Systemeigenschaften (Windowstaste + Pause) - Erweitert - Umgebungsvariablen - Systemvariablen - Path - Bild Was aber heißen die Codezeilen?
  • Java ist eine objekt orientierte (OO) Sprache und arbeitet ausschließlich mit Klassen. Wir müssen also wirklich alles in wenigstens eine Klasse verpacken. Was man oben schön sieht \sourceon class Hello { Hier steht was meine Klasse macht } \sourceoff
  • da wir nur eine Klasse haben und diese auch "aktiv" etwas tun soll, also direkt ausführbar sein muss, braucht sie die Methode main \sourceon public static void main (String args[]) { was main machen soll } \sourceoff Der Modifikator ist public (engl: "öffentlich"), also für jeden zugänglich und von überall aufrufbar. Die Typen sind static, void: static (engl: "statisch") und void (engl: "leer,nichtig"), heißt einfach nur, dass diese Methode beim Beenden nichts zurückgibt, also kein return enthält. Der Parameter ist ein Array das "args" heissen kann und Strings beinhaltet. Die Signatur der main-Methode sowie die Modifikatoren sind zwingend vorgeschrieben. Der Übergabeparameter muss ein String-Array sein, der return-Typ muss void und die Methode muss statisch sein, da sie, zumindest bei "normalen" Java-Programmen ( keine Enterprise-Anwendungen, auf die wir noch später zu sprechen kommen ), von der Java-Virtual-Machine (JVM) zum Startzeitpunkt aufgerufen wird, und es zu diesem Zeitpunkt noch keine Instanz der Klasse "Hello" gibt. \sourceon >java Hello Ein Test \sourceoff Dann wäre args[0]=Ein und args[1]=Test.
  • Und nun die Ausgabe, dazu hat Java einen Streamout \sourceon System.out.println("Text"+Variable); \sourceoff Die Zeile sagt dem System "bitte ausgeben" und das "ln" an print heißt nach der Ausgabe eine neue Zeile beginnen. System.out gibt üblicherweise einen Characterstring auf die Standardausgabe (Monitor) aus. Mit "+" werden unterschiedliche Variablen hier Characterkonstante ("Text") und eine Variable miteinander verknüpft.
Code zu Hello.java

Zweiter kleiner Kontakt

Hier möchte ich ein paar grundlegende Operationen anführen, die jedem Programmierer früher oder später in Fleisch und Blut übergehen werden, für den Anfang aber vielleicht noch recht kompliziert und abstrakt aussehen. Dazu erstellen wir uns wieder eine neue Datei und benennen sie wahlweise mit einem sinnvollem Namen \sourceonOperationen public class Operationen { public static void main (String args[]) { } } \sourceoff (Anm: Da jetzt die Klasse wieder public ist, muss die Datei genauso wie die Klasse heißen!) Das ist jetzt nur unsere leere Hülle. In die { } von der main werden wir uns jetzt immer mehr Operationen angucken. Beginnen wir mit dem Deklarieren und Initialisieren. \sourceonin der main zwischen den { } int a,b; // a,b als Integer deklarieren a=0; // a und b b=5; // mit 0 bzw 5 initialisieren int c=10; // c als Integer deklarieren und mit 10 initialisieren \sourceoff Damit wir auch sehen können was wir geschrieben haben, lassen wir uns die Variablen ausgeben \sourceondanach int c=10; // c als Integer deklarieren und mit 10 initialisieren System.out.println("a="+a); // a ausgeben System.out.println("b="+b); // b ausgeben System.out.println("c="+c); // c ausgeben \sourceoff Da sehen wir auch schön, wie die Syntax von dem Ausgabebefehl System.out.println aussieht \sourceonSyntax System.out.println("Zk1"+Var1+"Zk2"+Var2); \sourceoff Zk steht für eine beliebige Zeichenkette. Alles was zwischen " " steht, wird auch genauso auf dem Bildschirm ausgegeben. Var steht für eine deklarierte und initialisierte Variable. Die Parameter werden mit dem + Operator verknüpft. Ebenso wäre auch folgende Syntax möglich \sourceon System.out.println(Var1+Var2+"Zk1"+"Zk2"); \sourceoff Jetzt sind wir in der Lage, beliebig Integerwerte zu erstellen und sie mit Werten zu belegen. Aber Integer ist nur ein Datentyp. \sourceonweiter gehts long l=9223372036854775807l; float f=10.45f; double d=9.782346d; System.out.println("Grenze von long ist "+l +"\n"+(l+1)+" sollte eigentlich 9223372036854775808 sein!"); System.out.println("float f="+f+" und double d="+d); String erg = "Das Ergebnis ist "; System.out.println(erg+(a+c/b)); int z = a+c/b; System.out.println(erg+z+" besser so errechnet"); \sourceoff Floats bekommen ein f, doubles ein d und longs ein l hinter ihre Zahl. Ansonsten sieht man, dass auch die Ausgabemethode noch rechnet, das man aber eigentlich nicht so wie in diesem Fall (a+c/b) ausnutzen sollte. Lieber int z=a+c/b; und z ausgeben. Noch kurz zu den Grenzen. Die Zahlen werden in Java nach IEEE 754 Standard im Zweier-Komplement dargestellt. Dieses Format ist aber nicht abgeschlossen, soll heißen, dass die größte positive Zahl +1 die betragsmäßig größte negative Zahl (bzw. die kleinste) ergibt. Der Compiler bemerkt diesen Übersprung nicht und man sollte in dieser Größenordnung auf seine Zahlenwerte aufpassen. Rechenoperationen sind
Additiona+b
Subtraktiona-b
Multiplikationa*b
Divisiona/b
Rest aus Divisiona%b
Für (deutsche) Programmierneulinge wäre vielleicht noch wichtig, dass Kommata als Punkt geschrieben werden. Also "1,2" (wie man es in der Schule lernt) ist für den Rechner ein "1.2"! Wenn man "1,2" schreibt, dann wird das eigentlich immer als 1 und 2 interpretiert, also als 2 verschiedene Werte. Code dazu

Binomialkoeffizient

Das Grundlegendste wissen wir nun. Gehen wir also einen Schritt weiter, wir wollen ein Programm schreiben, welches uns den Binomialkoeffizient ausrechnet über 2 verschiedene Methoden. 1. Methode (m;k)=m!/(k!(m-k)!) 2. Methode (m;k)=prod((m-i+1)/i,i=1,k) Es gibt nun verschiedene Arten, ein Programm aufzuziehen : Schreibt man zuerst die Methoden und dann eine passende main oder schreibt man sich erstmal eine laufende main mit Eingabe (und Ausgabe) und sich dann langsam die Methoden zurecht schustern. Ich gehe in dem Beispiel den 2. Weg, damit man es besser versteht (generell gehe ich auch diesen Weg, so findet man Fehler schneller, finde ich). Davor sollte man sich noch einen kleinen Schlachtplan machen, was man wie haben möchte. Wir setzen uns als Ziel eine Methode zur Fakultätsberechnung und 2 Methoden für die unterschiedlichen Arten den Binomialkoeffizient zu berechnen. In Pseudocode könnte man sich das wiefolgt notieren, damit wir nicht den Überlick verlieren. \sourceon class BiKo { int fakultät (zahl); int binomkoeff methode 1 (m und k); int binomkoeef methode 2 (m und k); main { eingabe m und k, 2x ausgabe binomkoeff pro methode } } \sourceoff Dabei haben die 3 Methoden einen Rückgabewert der laut Methodendeklaration int (Integer) ist. Dementsprechend muss jede Methode auch ein return int_wert haben. Zu Anfang müssen wir uns natürlich erstmal wieder eine Datei erstellen. Nennen wir sie BiKo. Jetzt können wir uns eine main Methode in die Klasse BiKo schreiben \sourceonBiKo.java class BiKo { public static void main (String args[]) { System.out.println("Bitte m eingeben"); /* 1 */ System.out.println("Bitte k eingeben"); /* 2 */ /* 3 */ System.out.println("m ueber k (Methode 1) ist "); /* 4 */ System.out.println("m ueber k (Methode 2) ist "); } } \sourceoff Und nun haben wir auch schon unser erstes großes Problem. Denn bei Punkt 1 und 2 müssen wir zwei Integer einlesen, aber Java bietet serienmäßig keinen InputStream-Methode wie sie für den Output mit System.out.print wäre. Wir können also nicht System.in.int o.ä. schreiben. Zum Einlesen wollen / müssen wir uns eine eigene Klasse schreiben (die wir später noch erweitern werden). Nennen wir diese Klasse IO \sourceonIO.java import java.io.*; /**Klasse IO steht für Input/Output*/ public class IO { IO() {}; //default konstruktor für javadoc /**Liest einen integer Wert *@return int Wert **/ public static int readInt() //readInt für integer eingabe { BufferedReader in; int zahl = 0; String s; boolean fehler = true; while ( fehler == true) //wenn fehler auftritt nochmal { in = new BufferedReader(new InputStreamReader(System.in)); try { s = in.readLine(); zahl = Integer.parseInt(s); fehler = false; //=> kein fehler } catch (Exception e) { System.out.println("Eingabefehler : "+e.getMessage()); System.out.print("erneute Eingabe : "); } } return zahl; //return int } } \sourceoff Hui, das ist aber eine Fülle an neuem Material. Die Kommentare die mit /** beginnen, sagen lediglich, dass sie in der JavaDoc wieder auftauchen, anders als Kommentare die mit // oder /* beginnen. Ihr könnt ja bei dieser Datei mal Tool 1 betätigen, was zur JavaDoc erstellen ist (s.o. Installation). Dann werden mehrere html Dateien erstellt und die index.htm ist die "Startseite". Das entscheidende bei der Methode aber ist, das man den Datenstrom zur Eingabe beeinflusst. Dazu nutzen wir die Java-Klasse BufferedReader und InputStreamReader. Mit new BufferedReader(new InputStreamReader(System.in) erstellen wir eine neue Instanz vom Datenstrom, wir klinken uns sozusagen ein. Und in dem Moment, wenn s = in.readLine() ausgeführt wird, wird das, was sich gerade in diesem Strom befindet, als String (wegen readLine = String einlesen) auf die Variable s gespeichert. Mit s können wir jetzt machen was wir wollen, aber wir wollen ja gerade einen Integerwert. Also wandeln wir den String via Integer.parseInt(s) in einen Integerwert um. Den können wir so auch behalten und gleich zurückgeben. Aber was ist, wenn man eine falsche Eingabe hat? Z.B. eine Kommazahl? Dafür ist die while(-do)-Schleife da. Am Anfang habe ich die boolean Variable fehler (also 0=false oder 1=true) auf true gesetzt. Und solange sie noch auf true ist, wird diese Schleife immer wieder ausgeführt. Der Fehler wird auf false gesetzt, wenn die Eingabe exception-frei (fehler-frei) geparst wurde, also der try-Block ohne Fehler ausgeführt wurde. Kam es zu einem Fehler so springen wir immer in die catch (Exception e) rein, was nichts anderes heißt, als dass es zu einem Fehler kam, der hier gecatched (abgefangen) wird. Mit dieser IO.java im gleichen Verzeichnis haben wir nun die Möglichkeit, ganzzahlige Werte einzulesen, indem wir die Methode readInt() aus der Klasse aufrufen. Das geschieht folgendermaßen (/* 1 */ bzw. /* 2 */) \sourceon int m; m = IO.readInt(); \sourceoff So wird auf die Integer Variable m ein Integerwert eingelesen der per Tastatur eingegeben wird. Übertragen wir das auf unser Programm, sieht main so aus \sourceonBiKo.java class BiKo { public static void main (String args[]) { System.out.println("Bitte m eingeben"); int m; m = IO.readInt(); System.out.println("Bitte k eingeben"); int k; k = IO.readInt(); /* 3 */ System.out.println("m ueber k (Methode 1) ist "); /* 4 */ System.out.println("m ueber k (Methode 2) ist "); } } \sourceoff Brauchen wir nur noch die Methoden. Die Fakultät einer Zahl berechnet sich ja durch iteratives oder rekursives Multiplizieren aller Zahlen von 1 bis zur gegeben Zahl - das wollen wir jetzt festhalten \sourceonBiKo.java class BiKo { [...] public static int fak (int z) { int f = 1; for (int i = 1; i<=z ; i++) { f *= i; } return f; } public static void main (String args[]) [...] \sourceoff Diese Methode muß auch static sein, da sie aus einem static Zusammenhang (main) aufgerufen wird. Sie multipliziert f genau z mal mit Zahlen, die von 1 bis z um jeweils 1 erhöht werden. Also f = 1*2*3*...*z=prod(i,i=1,z) Dieses f ist ein Integer Wert und mit dem wollen wir in main weiterarbeiten, also soll er via return f zurückgegeben werden. Wir können testen, ob die Methode einwandfrei funktioniert und schreiben in main bspw. \sourceonBiKo.java [...] k = IO.readInt(); int test; test = fak(m); System.out.println(test); /* 3 */ [...] \sourceoff Das gibt uns für positive (kleine) m, die Fakultät aus. Was ist wenn wir eine negative Zahl oder einen Bruch eingeben? Dazu müssten wir noch eine Routine schreiben, die das abfängt, aber das würde unser noch übersichtles Programm unnötig verkomplizieren. Ihr könnt gerne probieren mit einer while-do Schleife die falschen Eingaben abzufangen, aber wir beschränken uns erstmal auf nur positive Eingaben. Gebt mal 17 ein. Da kommt als Fakultät eine große negative Zahl raus - Was soll denn das? Bei 16 gibt er noch ein positives, aber dennoch falsches Ergebnis. Die Antwort lautet, der Rahmen der Integer ist gesprengt und es kommt nur noch Humbug raus! Integer Werte liegen im Interall [-2^31 ; 2^31-1 = -2147483648...2147483647] Doch das reicht uns lange nicht. Und Java weiß das auch und hat für uns die Werte BigInteger parat. Wie können wir damit arbeiten? Als erstes kommt in die erste Zeile unseres Codes \sourceon import java.math.*; \sourceoff Aber so werden alle mathematischen Klassen mit geladen und das ist unnötig. Wenn man genau weiß, was man braucht, sollte man auch nur das importieren. Also \sourceon import java.math.BigInteger; \sourceoff und die modifizierte Methode sieht dann wiefolgt aus \sourceonBiKo.java public static BigInteger fak (int z) { BigInteger f = new BigInteger (""+1);; for (int i = 1; i<=z ; i++) { f = f.multiply( BigInteger.valueOf(i) ); } return f; } \sourceoff Wenn wir in unserem Testbeispiel anstatt int test ein BigInteger test schreiben, dann können wir auch problemlos sehr große Fakultäten berechnen. BigInteger ist aber eine eigene Klasse mit eigenen ("merkwürdigen") Methoden. Mann kann nicht einfach 2 BigInteger multiplizieren mit einem * dazwischen. Diesen Operator kennt die Klasse nicht. Dazu müssen wir schreiben (s. auch JavaDoc zu BigInteger ) \sourceon BigInteger_ergebnis = BigIntger_zahl1.operation(BigInteger_zahl2); \sourceoff mit operation meine ich add, subtract, multiply, divide, ... Jetzt sind wir soweit, beliebig große Fakultäten als BigInteger zu berechnen. Machen wir weiter und schreiben uns die beiden Methoden zur Berechnung des Binomialkoeffizienten ebenfalls mit BigInteger \sourceonBiKo.java import java.math.BigInteger; class BiKo { public static BigInteger fak (int z) { [...] } public static BigInteger bk1 (int m , int k) //Methode I mit Fakultäten { BigInteger binko; // || heisst oder if (k==0 || (m-k) == 0) // falls k==0 wahr oder (m-k)==0 wahr // dann ist binko = 1 { binko = new BigInteger ("1");} else if ((m-k) == 1 || k== 1) { binko = new BigInteger (""+m);} else { BigInteger fakm; fakm = fak(m); // m! BigInteger fakk; fakk = fak(k); // k! BigInteger fakl; fakl = fak(m-k); // l! = (m-k)! binko = fakm.divide(fakk.multiply( fakl)); // m!/(k!*(m-k)!) } return binko; } public static BigInteger bk2 ( int m , int k ) //Methode II mit Produkten { BigInteger binko; BigInteger prod = new BigInteger (""+1); //BigInt = 1 BigInteger bigm = new BigInteger (""+m); //BigInt = m if (k==0 || (m-k) == 0) { binko = new BigInteger ("1");} else if ((m-k) == 1 || k== 1) { binko = new BigInteger (""+m);} else { for (int i = 1 ; i<=k ; i++) //Zähler durchmultiplizieren { // binko2 = m - (i-1) = m - i + 1 BigInteger binko2 = bigm.subtract(BigInteger.valueOf(i-1)); // das Produkt ausrechnen; jeden Faktor multiplizieren // prod *= binko2 prod = binko2.multiply(prod); } BigInteger fakk; fakk = fak(k); binko = prod.divide(fakk); // Produkt (Zähler) durch k! (Nenner) } return binko; } public static void main (String args[]) [...] \sourceoff Was in den Methoden passiert, dürfte verständlich mit den Kommentaren erklärt sein. Die Methoden rufen wir dann in main noch auf und lassen das Ergebnis ausgeben \sourceonBiKo.java [...] k = IO.readInt(); BigInteger binko1 = bk1(m,k); System.out.println("m ueber k (Methode 1) ist "+binko1); BigInteger binko2 = bk2(m,k); System.out.println("m ueber k (Methode 2) ist "+binko2); } } \sourceoff und erhalten Bild Code zu BiKo.java Code zur vollständigen IO.java

Klassensystem für Objektgebrauch

Wenn wir schon mit einer OO Sprache schreiben, wollen wir doch auch deren Vorzüge nutzen. Im Moment haben wir 2 Klassen: BiKo, die die main Methode enthält und mit der wir Binomialkoeffizienten berechnen können und IO, die zur Integereingabe eine Methode beinhaltet. Wir wollen jetzt die main Methode aus BiKo ziehen und sie in eine Main Klasse stecken, in der wir nur mit Objekten arbeiten wollen und keine Methoden oder Konstruktoren enthalten soll. Der erste Schritt, ist einfach komplett \sourceon public static void main (String args[]) { [...] } \sourceoff zu löschen und die Klasse in BiKo2 umbenennen. Nun speichern wir diese neue Klasse auch gleich in die Datei BiKo2.java. Damit ist dann unsere Datei BiKo2.java zwar noch kompilierbar, aber ohne main nicht mehr ausführbar (mit F7). Im zweiten Schritt, wenden wir uns den Konstruktoren zu. Eigentlich brauchen wir nur einen Konstruktor, der mit 2 Parametern umgeht (m und k), aber um den Umgang mit Konstruktoren gleich besser zu verstehen schreiben wir uns 3
  • Default Konstruktor : m = 1 , k = 1
  • 2. Konstruktor : m = Parameter, k = 1
  • 3. Konstruktor : m = Parameter, k = Paramter
  • Ein vierter, bei dem m = 1 und k = Parameter ist, ist sinnlos, da dieser Binomialkoeffizient 1 bzw. 0 ergibt. Erinnerung : (1;k) = 0 \forall\ k\el\IN\and\ k>=2 und (1;m)=1 , m=0\or\1 Doch damit unser Konstruktor auch ordentlich arbeiten kann, brauchen wir Instanzvariablen und/oder Klassenvariablen die der Konstruktor dann manipulieren kann. Nennen wir sie aus dem Zusammenhang m und k sowie bk. Wie sieht so ein Konstruktor mit Instanzvariablen aus? \sourceon Variablentyp a // Das ist eine Instanzvariable static Variablentyp b // Das ist eine Klassenvariable Klassenname ( Parameterliste ) // Das ist der { was der Konstruktor macht } // Konstruktor \sourceoff Wo kommt das hin? An den Anfang der Klasse \sourceon Klassenname { Klassenvariable #1 Klassenvariable #2 [...] Instanzvariable #1 Instanzvariable #2 [...] Konstruktor #1 Konstruktor #2 [...] Methode #1 Methode #2 [...] } \sourceoff Bei uns: \sourceonBiKo2.java import java.math.*; class BiKo2 { m,k bk BiKo2 () { m=1 und k=1 setzen } BiKo2 (int m) { m=m und k=1 setzen } BiKo2 (int m, int k) { m=m und k=k setzen } public static BigInteger fak (int z) [...] public static BigInteger bk1 (int m , int k) [...] public static BigInteger bk2 ( int m , int k ) [...] } \sourceoff Doch so wie es im Moment aussieht, können wir mit den Methoden und Konstruktoren wenig anfangen. Warum? Ganz einfach: Die Methoden sind noch static und solche Methoden sind nicht aus einem nicht-static Kontext aufrufbar. Ja und, wo haben wir denn diesen nicht-static Kontext, main ist immernoch static daher rufen wir das doch alles auf? Stimmt eigentlich auch, aber ich will euch ja zeigen, wie das mit den Konstruktoren funktioniert. Mit einem Konstruktor erstellt man eine Instanz der Klasse und bewegt sich damit nicht mehr im "Klassenbereich" (static) sondern im "Objekt/Instanzbereich" (non-static), jedenfalls was die Methoden angeht. Ich werde es euch gleich zeigen, keine Sorge. (Vielleicht auch mal in die Defintionen nach static gucken!) Um den Unterschied zu verdeutlichen, lassen wir die Methode bk2 static. \sourceonBiKo2.java import java.math.BigInteger; class BiKo2 { //Instanzvariablen int m, k; //Klassenvariable static BigInteger bk; //Konstruktor #1 public BiKo2() { m = 1; k = 1; } //Konstruktor #2 public BiKo2(int m) { this.m = m; k = 1; } //Konstruktor #3 public BiKo2(int m, int k) { this.m = m; this.k = k; } public static BigInteger fak (int z) [...] public BigInteger bk1 () //Methode I mit Fakultäten OHNE static, OHNE Parameter! [...] public static BigInteger bk2 ( int m , int k ) //Methode II mit Produkten { [...] bk = binko; // static Variable bekommt das Ergebnis zusätzlich return binko } //KEINE main Methode mehr !!! } //Klasse schließen \sourceoff Damit steht unsere Rechen-Klasse. Jetzt müssen wir sie nur noch entsprechend aufrufen. Genau, wo ist eigentlich unsere main? Die haben wir ja aus der Klasse einfach rausgeschmissen. Macht nichts, erstellen wir die Datei Start.java und schmeissen sie dort rein: \sourceonStart.java import java.math.BigInteger; public class Start { public static void main (String args[]) { System.out.println("Bitte m eingeben"); int m; m = IO.readInt(); System.out.println("Bitte k eingeben"); int k; k = IO.readInt(); BiKo2 objekt = new BiKo2(m,k); BigInteger binko1 = objekt.bk1(); System.out.println("m ueber k (Methode 1) ist "+binko1); BigInteger binko2 = BiKo2.bk2(m,k); System.out.println("m ueber k (Methode 2) ist "+binko2); System.out.println("m ueber k (static) ist "+BiKo2.bk); } } \sourceoff Ich habe sie gleich unseren Bedürfnissen angepasst. Was ist verändert, was ist wichtig?
  • Die BigInteger-Klasse muss importiert werden, da wir mit Ergebnissen aus der BigInteger Klasse umgehen wollen.
  • Das Einlesen bleibt gleich
  • \sourceonerste Methode BiKo2 objekt = new BiKo2(m,k); BigInteger binko1 = objekt.bk1(); \sourceoff Was ist damit? Nun, wir erstellen ein Objekt, bzw. das Objekt objekt und nicht irgendeins, sondern eins der Klasse BiKo2. Das hat die Eigenschaften (Attribute), wie wir sie in der Klasse BiKo2 per Konstruktor initialisiert haben. Mit new BiKo2(m,k) rufen wir unseren Konstruktor #3 auf, da dieser für 2 Integer Parameter zuständig ist. Dann lassen wir auf unser Objekt die Methode bk1 aus der BiKo2 Klasse wirken. Das geht, indem man dem Objekt per (Punkt) . - Operator die gewünschte Methode anhängt mit den geforderten Parametern (bei uns keiner, da die Instanzvariablen alle Informationen bereitstellen): Objekt.Methode(Parameter). Die Methode bk1 hat ja einen BigInteger Wert als Rückgabe, den lassen wir uns gleich auf die Variable binko1 legen, welche ebenfalls vom Typ des Rückgabetyps BigInteger sein muss.
  • \sourceonzweite Methode BigInteger binko2 = BiKo2.bk2(m,k); System.out.println("m ueber k (Methode 2) ist "+binko2); System.out.println("m ueber k (static) ist "+BiKo2.bk); \sourceoff Das gleiche Spiel mit Rückgabewert und diesen auf binko2 legen. Aber ein gravierender Unterschied : BiKo2.bk2(m,k) - Warum? Weil wir dafür kein Objekt angelegt haben, sondern nur "auf" der Klasse arbeiten. Also müssen wir die Methode auch "von außen" per Referenz auf die Klasse aufrufen mit den geforderten Parametern: Klassenname.Methode(Parameter). Hier müssen wir m und k mit übergeben, da diese Informationen in der Klasse nicht vorliegen (nur als Instanzvariablen, aber ohne Instanz ist der Zugriff auf Instanzvariablen nicht möglich, weil ja die Instanz fehlt). Ein Zusatz noch, durch die vorletzte Zeile der Methode bk2. Indem wir das Ergebnis dieser Methode noch auf die Klassenvariable bk gelegt haben, lässt diese sich (nach Aufrufen der Methode! Sonst zeigt sie nicht initialisiert nur unwillkürlich auf eine RAM-Speicherzelle mit sinnlosem Inhalt) per Klassenreferenz ausgeben: Klassenname.Klassenvariable Das ist das Prinzip der static Member! Code zu BiKo2.java Code zu Start.java

    Binomialkoeffizient in Swing

    Auf gehts mit großen Schritten. Wir wissen wie wir Methoden schreiben, sie aufrufen, Klassen schreiben, dazu gehörige Konstruktoren und static sowie non-static Variablen. Jetzt wollen wir unser Wissen graphisch ausgeben und somit unser Wissen wiederum vergrößern. Ich habe das Swing aus Java gewählt - alternativ gibt es das AWT -, da es am zeitgemäßesten ist. AWT's werden nur noch der Abwärtskompatibilität geschrieben. Unser Ziel: Bild Man sieht schön, dass wir 2 Spalten und 5 Zeilen brauchen, die wir dann in ein JPanel mit GridLayout tun. m, k, bk1 Ergebnis, bk2 Ergebnis, static, static Ergebnis sind String Ausgaben, also JLabels. Die wir mit der entsprechenden Methode manipulieren werden um Ergebnisse zu sehen. 2mal Eingabe dient jeweils zum Lesen von 2 Integerwerten über ein JTextField. bk1, bk2 sind zwei JButtons, die die Methoden bk1 bzw. bk2 einsetzen. Diese beiden brauchen jeweils einen ActionListener (ich glaube die Bezeichnung ist eindeutig). Die eben erwähnten Komponenten eines Swings (JLabel, JPanel, JTextField, JButton, GridLayout) benötigen Informationen aus den entsprechenden Klassen - also importieren! \sourceonBiKoSwing.java import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.JTextField; import javax.swing.JButton; import javax.swing.JFrame; import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.awt.GridLayout; import java.math.BigInteger; public class BiKoSwing { } \sourceoff In dieses Grundgerüst deklarieren wir die oben genannten Eigenschaften als Instanzvariablen und initialisieren diese gleich bzw. im Standard-Konstruktor (parameterlos) \sourceonBiKoSwing.java import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.JTextField; import javax.swing.JButton; import javax.swing.JFrame; import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.awt.GridLayout; import java.math.BigInteger; public class BiKoSwing { JFrame f = new JFrame("Binomialkoeffizient"); JPanel pan; JLabel m = new JLabel("m"); JLabel k = new JLabel("k"); JLabel erg1 = new JLabel("Ergebnis 1"); JLabel erg2 = new JLabel("Ergebnis 2"); JLabel static_label = new JLabel("static"); JLabel static_erg = new JLabel("static Ergebnis"); JTextField m_ein = new JTextField("45"); JTextField k_ein = new JTextField("13"); JButton bk1 = new JButton("bk1"); JButton bk2 = new JButton("bk2"); public BiKoSwing() { //Layout setzen pan = new JPanel(new GridLayout(5,2)); //Komponenten einfügen pan.add(m); pan.add(k); pan.add(m_ein); pan.add(k_ein); pan.add(bk1); pan.add(bk2); pan.add(erg1); pan.add(erg2); pan.add(static_label); pan.add(static_erg); //Frame fertigstellen f.getContentPane().add(pan); f.setSize(200,200); f.setVisible(true); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } } \sourceoff Die GUI (Graphical User Interface) steht damit. Bild Doch hoppla, so geht's eben (noch) nicht. Wo ist die main Methode? Alles klar, eben schnell mal Start2.java schreiben, mit main, welche den Konstruktor der Klasse BiKoSwing aufruft \sourceonStart2.java public class Start2 { public static void main(String args[]) { new BiKoSwing(); } } \sourceoff So, und was haben wir jetzt wieder gemacht? Wir legen ein Layout fest, welches unser Panel bekommt: GridLayout. Das entsteht, indem man Komponenten (JButtons, JLabels, JTextFields, ...) einfügt über add. Es füllt die leeren Stellen von links nach rechts, bis die Zeile voll ist, dann in die nächste Spalte wieder von links nach rechts, usw. Da wir 10 Elemente haben, setzen wir dieses Layout gleich auf 5 Zeilen und 2 Spalten (siehe Konstruktor für das Layout). Jetzt kommt in unserer gewünschten Reihenfolge (von links nach rechts, oben nach unten) die Komponenten per add Methode rein. Zum Schluss sagen wir dem JFrame (Fenster), dass es unser JPanel aufnehmen soll, wie groß es sein soll, dass es angezeigt werden soll und das es "echt" schliessbar ist. Ohne die letzte Anweiseung würde das Fenster nur in den Hintergrund verschoben werden, für uns aber nicht mehr sichtbar, und das Programm würde dadurch nicht beendet werden (können). Zusammenfassung der Vorgehensweise: \frame JFrame, bekommt JPanel, bekommt Layout, bekommt Komponenten Alternativ: JFrame <| JPanels <| Layouts <| Komponenten \frameoff Doch damit wir den Buttons auch eine Funktionalität geben können, müssen wir die ActionEvents (also in dem Fall, dass der Button gedrückt wird) abfangen und eine Aktion daraufhin ausführen. Als erstes, das Event abfangen: \sourceon [...] //Klasse bekommt Zugriff auf Schnittstelle public class BiKoSwing implements ActionListener [...] \sourceoff So binden wir die Schnittstelle ActionListener mit in die Klasse ein. Wenn wir dieses tun, müssen wir alle Methoden der Schnittstelle überschreiben (siehe nächster Absatz). Die Schnittstelle hat nur eine Methode, die wir überschreiben müssen, indem wir sie in unserer Klasse neu schreiben (einfach am Ende unsere Klasse hinschreiben): \sourceon [...] //obere Teil des Codes f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } public void actionPerformed(ActionEvent arg0) { Object source=arg0.getSource(); } } \sourceoff So haben wir die Methode actionPerformed überschrieben. Wie man sieht, bekommt sie als Parameter ein ActionEvent, das sämtliche Daten über den Auslöser enthält (probiert doch mal \sourceon [...] f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Button bk1 wird abgehorcht bk1.addActionListener(this); //Ende des Konstruktors } [...] public void actionPerformed(ActionEvent arg0) { Object source=arg0.getSource(); System.out.println(arg0); } \sourceoff und dann auf den Button bk1 drücken). Das was uns am meisten interessiert, ist der Name des Auslösers. Durch den Namen können wir den Auslöser eindeutig feststellen, da ja nie zwei Komponenten den gleichen Namen haben können. Den Namen bekommen wir über eine Abfrage, ob es dieser oder jener Namen ist \sourceon public void actionPerformed(ActionEvent arg0) { Object source=arg0.getSource(); if (source == bk1) { //Aktion auf den Button } } \sourceoff Alles klar? Also wollen wir doch mal alle Aktionen abfangen und sie dementsprechend mit Funktionen versorgen: \sourceon [...] //Frame fertigstellen f.getContentPane().add(pan); f.setSize(200,200); f.setVisible(true); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Actions bk1.addActionListener(this); bk2.addActionListener(this); } public void actionPerformed(ActionEvent arg0) { Object source=arg0.getSource(); if (source==bk1) { int m = Integer.parseInt(m_ein.getText()); int k = Integer.parseInt(k_ein.getText()); BiKo2 bk = new BiKo2(m,k); BigInteger erg = bk.bk1(); erg1.setText(erg.toString()); } if(source==bk2) { int m = Integer.parseInt(m_ein.getText()); int k = Integer.parseInt(k_ein.getText()); BigInteger erg = BiKo2.bk2(m,k); erg2.setText(erg.toString()); BigInteger erg2 = BiKo2.bk; static_erg.setText(erg2.toString()); } } } \sourceoff Bild Code zu BiKoSwing.java Code zu Start2.java

    Polymorphie und Ableiten

    Wenn ihr aufmerksam gelesen habt, müsstet ihr ohne Erklärung folgenden Code verstehen, außer dem Sinn der letzten Methode \sourceonAngestellter.java public class Angestellter { static int anzahl = 0; String name; int alter, kinder; boolean verheiratet; String gattung = "Angestellter"; Angestellter() { name = "Mustermann"; alter = 40; kinder = 2; verheiratet = true; anzahl ++; } Angestellter(String name, int alter, int kinder, boolean v) { this.name = name; this.alter = alter; this.kinder = kinder; verheiratet = v; anzahl ++; } public void geburt() { kinder ++; } public void ehe(boolean v) { verheiratet = v; } public String wer() { return gattung; } public String toString() { String desc = name+", "+alter+" Jahre alt, "+kinder +" Kinder"; if (verheiratet == true) desc += ", verheiratet"; else desc += ", unverheiratet"; return desc; } } \sourceoff Die Methode toString wurde hier überschrieben. Wie überschrieben? Ohne Oberklasse? Tja, natürlich braucht man eine Oberklasse um eine Methode in deren Unterklasse (abgeleitet) zu überschreiben, aber in Java ist eben wirklich alles eine Klasse. In dem Fall überschreiben wir die Methode der Klasse Object, was die Oberklasse aller Instanzen ist. toString ist dafür da, um die Objekte in einen String zu parsen. Warum? Z.B. System.out.println(5.0), die 5.0 ist vom Typ double, aber die Ausgabe-Methode braucht einen String, den sie auf dem Bildschirm ausgibt. Also parst der Konstruktor automatisch. System.out.println(Angestellter_Instanz) würde nur einen Speicherbereich der Instanz wiedergeben; bspw. Angestellter@119c082. In toString schreiben wir, was ausgegeben werden soll - wir parsen also selber. Jetzt wollen wir Angestellter mal ableiten. Was für einen Angestellten wollen wir uns bauen? Am besten einen Chef. Wir leiten uns einen Chef von der Klasse Angestellter ab, denn jeder Chef ist ja ebenfalls ein Angestellter: \sourceonChef.java public class Chef extends Angestellter { String gattung = "Chef"; String abteilung; public Chef() { //Aufruf Default Konstruktor der Oberklasse super(); abteilung = "Management"; } public Chef(String n, int a, int k, boolean v, String abt) { //Aufruf 2. Konstruktor der Oberklasse super(n,a,k,v); abteilung = abt; } public String wer() { return gattung; } public String toString() { String desc = super.toString(); desc += ", Abteilung : "+abteilung; return desc; } } \sourceoff Mit Unterklasse extends Oberklasse sagen wir in Java, dass die Unterklasse von der Oberklasse abgeleitet ist. Wir haben ebenfalls 2 Konstruktoren in der Unterklasse. Ruft man solch einen Unterklasse-Konstruktor auf, so wird automatisch der Default-Konstruktor der Oberklasse aufgerufen. Möchte man selber Einfluss nehmen, muss man in der ersten Zeile des Unterklasse-Konstruktors den gewünschten Oberklasse Konstruktor plus Parameter aufrufen. Per super(Parameter) ruft man einen Oberklasse-Konstruktor und per super.Methode(Parameter) ruft man eine Oberklassen-Methode. Hier haben wir auch gleich wer und toString überschrieben. Damit wir auch was von den Klassen haben, brauchen wir selbstverständlich eine main: \sourceonPerson.java public class Person { public static void main (String args[]) { //1. Block Angestellter mustermann = new Angestellter(); Angestellter müller = new Angestellter("Mueller",23,0,false); Chef bach = new Chef("Bach",40,3,true,"Sortierung"); System.out.println(mustermann.gattung+" : "+mustermann); System.out.println(müller.gattung+" : "+müller); müller.geburt(); müller.ehe(true); System.out.println(müller.gattung+" : "+müller); System.out.println(bach.gattung+" : "+bach); System.out.println("Mueller (Gattung) : "+müller.wer()); System.out.println("Bach (Gattung) : "+bach.wer()); System.out.println(Angestellter.anzahl+" Mitarbeiter"); //2. Block System.out.println("\n\n ----------- 2. Block --------\n"); Chef hein = new Chef("Hein",50,1,false,"Presse"); Angestellter ahein = hein; //nicht möglich !!! //Chef mann = new Angestellter(); System.out.println(hein.gattung+" : "+hein); System.out.println(ahein.gattung+" : "+hein); System.out.println("Hein : "+hein.wer()); System.out.println("aHein : "+ahein.wer()); } } \sourceoff Der 1. Block bietet wenig spektakuläres, einfach nur den Umgang mit den beiden Klassen. Der 2. Block ist schon weitaus interessanter - Warum? Hingeschaut! Bild Wir erstellen (deklarieren) einen Angestellten ahein, initialisieren ihn aber mit der Referenz der Chefinstanz hein. Ja wie jetzt? Die darauf folgende Ausgabe verdeutlicht es. AHein wird als Angestellter ausgegeben, aber hat dazu noch die Eigenschaft, eine Abteilung zu besitzen. Er ist quasi ein Chef, der sich auf der Ebene der Angestellten aufhält. Sowas nennt man Polymorphie. \frame Der deklarierte Typ der Referenz bestimmt auf welche Klasse zugegriffen wird. (Wichtig, auf welche Variable zugegriffen wird) Der tatsächliche Typ der Instanz bestimmt welche Methode ausgeführt wird. \frameoff Die Referenztypen unterscheiden sich : hein hat Referenztyp Chef und ahein hat Referenztyp Angestellter. Aber vom Typ der Instanz her, sind sie gleich : Chef. Resultat :
  • Wenn wir eine (Instanz/Klassen)Variable ansprechen, bekommen wir unterschiedliche Ausgaben - hier : Klasse.gattung
  • Wenn wir eine Methode aufrufen, ist es in beiden Fällen die gleiche der Unterklasse - hier : Klasse.wer() bzw. Chef.wer()

    Definitionen

    • Klassenkomponenten : Attribute, Konstruktoren (und Destruktoren), Methoden
    • Attribute (Instanzvariablen): Datenfelder bzw. Variablen für die Eigenschaften der einzelnen Objekte 4 Modifikatoren zur Zugriffskontrolle: public, protected, private, ohne Angabe (= public) Die Member einer Klasse können in zwei Ausführungen auftreten: - Instanzmember gehören zu den Instanzen/Objekten - Klassenmember (static member ) gehören zur Klasse static Attribute: • allgemeingültig für die jeweilige Klasse • nur einmal pro Klasse vorhanden (ein und dieselbe) • Initialisierung vor jedem Element/Exemplar • Zugriff von jedem Element der Klasse aus möglich • static-Variable entsprechen globalen Variablen, verursachen aber keine Probleme durch ”Verunreinigung der Namensräume”! Sie gehören zum Namensraum der Klasse Bild
    • Konstruktor spezielle Methoden zur Initialisierung (literatur: "keine Methode, aber methodenähnlich") Name des Konstruktors = Name der Klasse, zu der er gehört mit einem Parameter auch zur Konvertierung von Daten nutzbar mehrere Konstruktoren oft sinnvoll, um Objekte auf verschiedene Arten initialisieren zu können =>
    • Methoden werden ausgeführt als Reaktion auf Nachrichten, z.B. Verarbeitung der Daten, Dienste, Weitergabe von Nachrichten,... Methoden können den selben Namen haben, wenn sie verschiedene Parameterlisten haben (=Überladen von Methoden) wichtigste Methode = main Methode Methodensignatur: modifikatoren typ name ( Parameterliste ) [ throws ausnahmen ] Modifikatoren sind public, protected, private, abstract, final, static, synchronized, volatile, const Typ: Rückgabewert (int, double,...) Name: Name der Methode Parameterliste: welche Parameter übergeben werden, kann auch leer sein throws: wenn man eine Ausnahme abfangen will (nur selten gebraucht)
    • Referenz ("Zeiger") Referenz ist Java Sprache und Pointer (Zeiger) ist C++ Sprache. Man kann es sich einfach als einen Pfeil vorstellen, der auf einen Speicherplatz im RAM zeigt, wo sich ein Objekt befindet.
    • Parameter siehe Methodensignatur Parameter = Objektreferenz, bei Call-by-Reference Parameter = Kopie vom Objekt, bei Call-by-Value
    • Instanz = Exemplar/ Objekt einer Klasse alle Eigenschaften der Klasse gelten
    • Instanzvariable : interne Variablen eines Objekts
    • Klassenvariable : static Variable, die in der Klasse global verfügbar ist, also für jedes Objekt gültig ist
    • Klasse eine Klasse class is m1; ...;mn; end besteht aus Merkmalen m1; ...;mn ein Merkmal (in C++ und Java: member (Mitglied)) ist eine Attributvereinbarung oder eine Methodenvereinbarung eine Methodenvereinbarung ist eine Prozedur- oder Funktionsdefinition Eine Klasse A ist eine Referenzklasse, wenn der durch A definierte Typ ein Zeigertyp ist, sonst ist A eine Wertklasse
    • Datenstrom Ein Stream ist ein Weg, den Daten in einem Programm zurücklegen. Ein Eingabestream sendet Daten aus einer Quelle in ein Programm. Ein Ausgabestrom sendet Daten aus einem Programm an ein Ziel. Man unterscheidet zumeinst zwei Arten von Streams. Byte-streams: Ganz verschiedene Daten können über den Bystestream transportiert werden, z.b. Daten, ausführbare Programme, Internetverbindungen etc. Zeichen-Streams: Das sind spezielle Byte-Sreams, der nur Textdaten beinhalten. Sie unterscheiden sich deswegen von Bytestreams, da Java Unicode unterstützt. Egal ob Byte- oder Zeichenstream. Bei einem Eingabestream erstellt man zunächst ein Objekt, das mit der Datenquelle assoziiert (verbunden) ist (Standardeingabe System.in ). Wenn man das Streamobjekt hat, kann man durch Verwendung von Methoden Daten aus dem Stream lesen. BufferedReader macht nicht anderes als aus Effizienzgründen einen Eingabestrom zu lesen und ihn zu puffern. Ein BufferedReader braucht (zur Erzeugung) ein existierendes Reader Objekt, also den Eingabestrom.
    • überladen Es ist üblich Konstruktoren zu überladen, indem man mehrere Konstruktoren einer Klasse schreibt mit unterschiedlichen Parametern. Wenn es eine Methode (Konstruktoren sind auch Methoden) mehrmals gibt (also ihr Namen mehrmals) mit unterschiedlichen Parameter, so ist sie überladen
    • überschreiben Eine Methode kann man beim Ableiten von Klassen überschreiben. Dabei wird der Name einer Methode der Oberklasse ebenfalls in der Unterklasse benutzt. Dementsprechend gibt es die gleiche Methode (weil Name gleich) in der Ober- und Unterklasse. Überlicherweise erweitert man in der Unterklasse die Überschriebene; z.B. fügt man in der Unterklasse ein neues Attribut ein und initialisiert es in der Methode.
    • deklarieren ein Datentyp wird deklariert, indem man ihm den Typ zuweist : int a; (oder double,...)
    • initialisieren ein Datentyp wird initialisiert wenn er einen Wert zugewiesen bekommt : a = 5;
    • Datentypen
      DatentypGrößeBereichAnmerkung
      int4 byte-231 bis 231-1
      (-2147483648 bis 2147483647)
      nur ganzzahlige Werte
      long8 byte-263 bis 263-1
      (-9223372036854775808 bis 9223372036854775807)
      doppelte int
      float4 byte1,40239846E-45f bis 3,40282347E+38fFließkomma-Zahl, für "Komma-Zahlen"
      double8 byte4,94065645841246544E-324 bis 1,79769131486231570E+308doppelte float
      boolean1 byte0 oder 1
      nein oder ja
      false oder true
      für Wahrheitswerte, Vergleiche
      Anm: E+308 heißt der Exponent zur Basis 10, also 10308 Es gibt zudem noch short, byte und char als Datentyp, aber diese werden nur sehr selten gebraucht. String's sind Objekte, keine Datentypen, deshalb habe ich sie nicht in der Liste erwähnt. Aber die meisten werden mit ihnen wie mit "normalen" Datentypen umgehen.
    • call by value in der Funktion wird von dem übergebenen Parameter eine Kopie erstellt und mit dieser Kopie gearbeitet; so ändert sich der eigentliche übergeben Parameter nicht
    • call by reference die Funktion bekommt eine Reference (siehe oben). Dadurch wird auf dem Speicherplatz gearbeitet, wohin diese Reference zeigt. Also wird dann direkt an der Instanz Änderungen vorgenommen. Möchte man diese Variable nicht ungewollt ändern, muss man dem Parameter in der Methode ein const spendieren (C++)
    • Überblick der Parameterübergabe bei C++ und Java
      C++Java
      Call-by-Valueerfolgt bei normaler Paramterübergabegenerell ist jede Parameterübergabe so
      Call-by-Referencemuss explizit mit & bzw. mit *, aufgerufen werdenwenn der Parameter keine elementarer Datentyp ist, also mit dem new Operator erstellt und dadurch einen Speicherplatz auf dem allgegenwärtigen Heap hat, aber selbst da ist es eigentlich Call-by-Value : es wird eine Kopie der Referenz der Instanz übergeben, aber da diese Kopie der Referenz ja schließlich auf das "wahre" Objekt zeigt, manipuliert man das Objekt dennoch

    Quellcodes zu den Beispielen

    \sourceonOperationen.java public class Operationen { public static void main (String args[]) { int a,b; // a,b als Integer deklarieren a=0; // a und b b=5; // mit 0 bzw 5 initialisieren int c=10; // c als Integer deklarieren und mit 10 initialisieren System.out.println("a="+a); // a ausgeben System.out.println("b="+b); // b ausgeben System.out.println("c="+c); // c ausgeben long l=9223372036854775807l; float f=10.45f; double d=9.782346d; System.out.println("Grenze von long ist "+l +"\n"+(l+1)+" sollte eigentlich 9223372036854775808 sein!"); System.out.println("float f="+f+" und double d="+d); String erg = "Das Ergebnis ist "; System.out.println(erg+(a+c/b)); int z = a+c/b; System.out.println(erg+z+" besser so errechnet"); } } \sourceoff \sourceonHello.java class Hello { public static void main (String args[]) { System.out.println("Hello Matheplanet!"); } } \sourceoff \sourceonBiKo.java import java.math.BigInteger; class BiKo { public static BigInteger fak (int z) { BigInteger f = new BigInteger (""+1);; for (int i = 1; i<=z ; i++) { f = f.multiply( BigInteger.valueOf(i) ); } return f; } public static BigInteger bk1 (int m , int k) //Methode I mit Fakultäten { BigInteger binko; if (k==0 || (m-k) == 0) { binko = new BigInteger ("1");} else if ((m-k) == 1 || k== 1) { binko = new BigInteger (""+m);} else { BigInteger fakm; fakm = fak(m); // m! BigInteger fakk; fakk = fak(k); // k! BigInteger fakl; fakl = fak(m-k); // l! = (m-k)! binko = fakm.divide(fakk.multiply( fakl)); // m!/(k!*(m-k)!) } return binko; } public static BigInteger bk2 ( int m , int k ) //Methode II mit Produkten { BigInteger binko; BigInteger prod = new BigInteger (""+1); //BigInt = 1 BigInteger bigm = new BigInteger (""+m); //BigInt = m if (k==0 || (m-k) == 0) { binko = new BigInteger ("1");} else if ((m-k) == 1 || k== 1) { binko = new BigInteger (""+m);} else { for (int i = 1 ; i<=k ; i++) //Zähler durchmultiplizieren { // binko2 = m - (i-1) = m - i + 1 BigInteger binko2 = bigm.subtract(BigInteger.valueOf(i-1)); // das Produkt ausrechnen; jeden Faktor multiplizieren // prod *= binko2 prod = binko2.multiply(prod); } BigInteger fakk; fakk = fak(k); binko = prod.divide(fakk); // Produkt (Zähler) durch k! (Nenner) } return binko; } public static void main (String args[]) { System.out.println("Bitte m eingeben"); int m; m = IO.readInt(); System.out.println("Bitte k eingeben"); int k; k = IO.readInt(); BigInteger binko1 = bk1(m,k); System.out.println("m ueber k (Methode 1) ist "+binko1); BigInteger binko2 = bk2(m,k); System.out.println("m ueber k (Methode 2) ist "+binko2); } } \sourceoff Meine komplette IO.java, mit vielen Ein- und Ausgabe Möglichkeiten \sourceonIO.java import java.io.*; /**Klasse IO steht für Input/Output*/ public class IO { IO() {}; //default konstruktor für javadoc /**Liest einen double Wert *@return double Wert **/ public static double readDouble() { BufferedReader in; double zahl = 0.0; String s; boolean fehler = true; while ( fehler == true) { in = new BufferedReader(new InputStreamReader(System.in)); try { s = in.readLine(); zahl = Double.parseDouble(s); fehler = false; } catch (Exception e) { System.out.println("Eingabefehler : "+e.getMessage()); System.out.print("erneute Eingabe : "); } } return zahl; } /**Liest einen integer Wert *@return int Wert **/ public static int readInt() //readInt für integer eingabe { BufferedReader in; int zahl = 0; String s; boolean fehler = true; while ( fehler == true) //wenn fehler auftritt nochmal { in = new BufferedReader(new InputStreamReader(System.in)); try { s = in.readLine(); zahl = Integer.parseInt(s); fehler = false; //=> kein fehler } catch (Exception e) { System.out.println("Eingabefehler : "+e.getMessage()); System.out.print("erneute Eingabe : "); } } return zahl; //return int } /**Liest die Datei datei * @param Dateiname * @return ein Object **/ public static String readFile (String datei) { String line="init"; String file=""; try { BufferedReader br = new BufferedReader(new FileReader(datei)); while ((line = br.readLine()) != null) { file+=line+"\n"; } br.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return file; } /**Liest einen String * @return gibt String zurück **/ public static String readString() { BufferedReader in; String s = ""; in = new BufferedReader(new InputStreamReader(System.in)); try { s = in.readLine(); } catch (Exception e) { System.out.println("Eingabefehler : "+e.getMessage()); System.out.print("erneute Eingabe : "); } return s; } /**Schreibt text in die Datei filename * @param String text * @param String filename **/ public static void writeFile(String text,String filename ) { FileWriter fw = null; try { fw = new FileWriter(filename,true ); fw.write(text); } catch ( IOException e ) { System.out.println( "Konnte Datei nicht erstellen" ); } finally { try { if ( fw != null ) fw.close(); } catch ( IOException e ) {} } } /**Löscht die Datei filename * @param filename **/ public static void delFile(String filename) { File fw = null; fw = new File(filename); fw.delete(); } /**Schreibt das Objekt obj in die Datei filename * @param obj * @param filename **/ public static void saveObj(Object obj, String filename) { try { FileOutputStream file = new FileOutputStream( filename ); ObjectOutputStream o = new ObjectOutputStream( file ); o.writeObject ( obj ); o.close(); } catch ( IOException e ) { System.err.println( e ); } } /**Lädt aus filename ein Objekt und gibt es zurück * @param filename * @return Object **/ public static Object loadObj(String filename) { Object obj = null; try { FileInputStream file = new FileInputStream( filename ); ObjectInputStream o = new ObjectInputStream( file ); obj = o.readObject(); o.close(); } catch ( IOException e ) { System.err.println( e ); } catch ( ClassNotFoundException e ) { System.err.println( e ); } return obj; } /**Lädt die Datei filename, falls das Programm aus einem * jar-Archiv gestartet wird * @param filename */ public static String readJarFile(String filename) { String inhalt = ""; InputStream in = IO.class.getResourceAsStream( filename ); if (in != null) { StringBuffer sb = new StringBuffer(); try { while (true) { int c = in.read(); if (c == -1) { break; } sb.append((char)c); } in.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } inhalt = sb.toString(); } return inhalt; } } \sourceoff \sourceonBiKo2.java import java.math.BigInteger; class BiKo2 { //Instanzvariablen int m, k; //Klassenvariable static BigInteger bk; //Konstruktor #1 public BiKo2() { m = 1; k = 1; } //Konstruktor #2 public BiKo2(int m) { this.m = m; k = 1; } //Konstruktor #3 public BiKo2(int m, int k) { this.m = m; this.k = k; } public static BigInteger fak (int z) { BigInteger f = new BigInteger (""+1);; for (int i = 1; i<=z ; i++) { f = f.multiply( BigInteger.valueOf(i) ); } return f; } public BigInteger bk1 () //Methode I mit Fakultäten { BigInteger binko; if (k==0 || (m-k) == 0) { binko = new BigInteger ("1");} else if ((m-k) == 1 || k== 1) { binko = new BigInteger (""+m);} else { BigInteger fakm; fakm = fak(m); // m! BigInteger fakk; fakk = fak(k); // k! BigInteger fakl; fakl = fak(m-k); // l! = (m-k)! binko = fakm.divide(fakk.multiply( fakl)); // m!/(k!*(m-k)!) } return binko; } public static BigInteger bk2 ( int m , int k ) //Methode II mit Produkten { BigInteger binko; BigInteger prod = new BigInteger (""+1); //BigInt = 1 BigInteger bigm = new BigInteger (""+m); //BigInt = m if (k==0 || (m-k) == 0) { binko = new BigInteger ("1");} else if ((m-k) == 1 || k== 1) { binko = new BigInteger (""+m);} else { for (int i = 1 ; i<=k ; i++) //Zähler durchmultiplizieren { // binko2 = m - (i-1) = m - i + 1 BigInteger binko2 = bigm.subtract(BigInteger.valueOf(i-1)); // das Produkt ausrechnen; jeden Faktor multiplizieren // prod *= binko2 prod = binko2.multiply(prod); } BigInteger fakk; fakk = fak(k); binko = prod.divide(fakk); // Produkt (Zähler) durch k! (Nenner) } bk = binko; return binko; } } \sourceoff \sourceonStart.java import java.math.BigInteger; public class Start { public static void main (String args[]) { System.out.println("Bitte m eingeben"); int m; m = IO.readInt(); System.out.println("Bitte k eingeben"); int k; k = IO.readInt(); BiKo2 objekt = new BiKo2(m,k); BigInteger binko1 = objekt.bk1(); System.out.println("m ueber k (Methode 1) ist "+binko1); BigInteger binko2 = BiKo2.bk2(m,k); System.out.println("m ueber k (Methode 2) ist "+binko2); System.out.println("m ueber k (static) ist "+BiKo2.bk); } } \sourceoff \sourceonBiKoSwing.java import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.JTextField; import javax.swing.JButton; import javax.swing.JFrame; import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.awt.GridLayout; import java.math.BigInteger; public class BiKoSwing implements ActionListener { JFrame f = new JFrame("Binomialkoeffizient"); JPanel pan; JLabel m = new JLabel("m"); JLabel k = new JLabel("k"); JLabel erg1 = new JLabel("Ergebnis 1"); JLabel erg2 = new JLabel("Ergebnis 2"); JLabel static_label = new JLabel("static"); JLabel static_erg = new JLabel("static Ergebnis"); JTextField m_ein = new JTextField("45"); JTextField k_ein = new JTextField("13"); JButton bk1 = new JButton("bk1"); JButton bk2 = new JButton("bk2"); public BiKoSwing() { //Layout setzen pan = new JPanel(new GridLayout(5,2)); //Komponenten einfügen pan.add(m); pan.add(k); pan.add(m_ein); pan.add(k_ein); pan.add(bk1); pan.add(bk2); pan.add(erg1); pan.add(erg2); pan.add(static_label); pan.add(static_erg); //Frame fertigstellen f.getContentPane().add(pan); f.setSize(200,200); f.setVisible(true); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Actions bk1.addActionListener(this); bk2.addActionListener(this); } public void actionPerformed(ActionEvent arg0) { Object source=arg0.getSource(); if (source==bk1) { int m = Integer.parseInt(m_ein.getText()); int k = Integer.parseInt(k_ein.getText()); BiKo2 bk = new BiKo2(m,k); BigInteger erg = bk.bk1(); erg1.setText(erg.toString()); } if(source==bk2) { int m = Integer.parseInt(m_ein.getText()); int k = Integer.parseInt(k_ein.getText()); BigInteger erg = BiKo2.bk2(m,k); erg2.setText(erg.toString()); BigInteger erg2 = BiKo2.bk; static_erg.setText(erg2.toString()); } } } \sourceoff \sourceonStart2.java public class Start2 { public static void main(String args[]) { new BiKoSwing(); } } \sourceoff
    Nachwort Ich möchte dann zum Schluß noch festhalten, dass ich durch mein Semester Praxis des Programmierens bei Herrn Dr. Blaar (Martin Luther Universität Halle) inspiriert wurde und teils mich eng an seinen Übungen bzw. Vorlesung orientiert habe. Zudem übernehme ich keine Haftung, falls die von mir vorgeschlagenen Beispiele, Programme und Software nicht funktionieren sollten oder Schaden anrichten könnten (alles in falschen Händen kann Schaden anrichten, aber an und für sich habe ich nur "leichtes" angegeben, also keine Bange) - es sind nur wenige Möglichkeiten von vielen. Und dann kommt natürlich noch der Dank an murmelbaerchen, denn ohne das Hilfebaerchen wäre der Artikel nicht entstanden bzw. beendet worden. Danke für's Lesen das wars ........
    \(\endgroup\)
  • Get link to this article Get link to this article  Printable version Printer-friendly version -  Choose language     Kommentare zeigen Comments  
    pdfFür diesen Artikel gibt es keine pdf-Datei


    Arbeitsgruppe Alexandria Dieser Artikel ist im Verzeichnis der Arbeitsgruppe Alexandria eingetragen:
    : Schüler aufwärts :: Informatik :: Programmierung :
    Programmieren - (Teil 1) Einstieg in Java [von Kobe]  
    Eine praktische Einführung in die Programmierung mit Java.
    [Die Arbeitsgruppe Alexandria katalogisiert die Artikel auf dem Matheplaneten]

     
     
    Aufrufzähler 21063
     
    Aufrufstatistik des Artikels
    Insgesamt 608 externe Seitenaufrufe zwischen 2012.01 und 2021.12 [Anzeigen]
    DomainAnzahlProz
    https://matheplanet.com71.2%1.2 %
    https://google.com142.3%2.3 %
    http://google.de52786.7%86.7 %
    http://google.rs152.5%2.5 %
    http://google.dj122%2 %
    https://google.de81.3%1.3 %
    http://www.bing.com40.7%0.7 %
    http://images.google.de20.3%0.3 %
    http://search.babylon.com10.2%0.2 %
    http://suche.t-online.de10.2%0.2 %
    http://suche.web.de20.3%0.3 %
    https://duckduckgo.com10.2%0.2 %
    http://www.ecosia.org10.2%0.2 %
    https://onedrive.live.com10.2%0.2 %
    http://google.com10.2%0.2 %
    http://int.search.myway.com20.3%0.3 %
    http://search.snap.do10.2%0.2 %
    http://google.at10.2%0.2 %
    http://r.duckduckgo.com10.2%0.2 %
    http://vk.com10.2%0.2 %
    http://de.search.yahoo.com30.5%0.5 %
    http://google.ch10.2%0.2 %
    http://search.icq.com10.2%0.2 %

    Aufrufer der letzten 5 Tage im Einzelnen
    Insgesamt 7 Aufrufe in den letzten 5 Tagen. [Anzeigen]
    DatumAufrufer-URL
    2021.11.06-2021.12.02 (6x)viewtopic.php?topic=44899
    2021.11.28 23:34fav.php?agid=1&keyword=Schüler aufwärts&keyword2=Informatik

    Häufige Aufrufer in früheren Monaten
    Insgesamt 569 häufige Aufrufer [Anzeigen]
    DatumAufrufer-URL
    2013-2016 (175x)http://google.de/url?sa=t&rct=j&q=
    2012-2013 (73x)http://google.de/url?sa=t&rct=j&q=java einstieg
    201210-10 (37x)http://google.de/url?sa=t&rct=j&q=java programmierung math
    2012-2013 (35x)http://google.de/url?sa=t&rct=j&q=java programmieren mathematik
    201205-05 (33x)http://google.de/url?sa=t&rct=j&q=zwei biginteger multiplizieren
    201211-11 (29x)http://google.de/url?sa=t&rct=j&q=mathe programmierung java
    201204-04 (27x)http://google.de/url?sa=t&rct=j&q=java einstieg für anfänger
    201201-01 (25x)http://google.de/url?sa=t&rct=j&q=zahl um 0.1 erhöhen java.io*
    201305-05 (17x)http://google.de/url?sa=t&rct=j&q=java einstiegsaufgaben
    201206-06 (15x)http://google.de/url?sa=t&rct=j&q=programmieren mathe mit java
    201304-04 (15x)http://google.rs/url?sa=t&rct=j&q=schreibe ein programm java dass zahlen enli...
    201209-09 (14x)http://google.de/url?sa=t&rct=j&q=leichter einstieg in java
    201303-03 (14x)http://google.de/url?sa=t&rct=j&q=java einstieg programme
    201212-12 (12x)http://google.de/url?sa=t&rct=j&q=mathematik programmieren java
    201312-12 (12x)http://google.dj/url?sa=t&rct=j&q=
    2020-2021 (11x)https://google.com/
    201401-01 (8x)http://google.de/url?sa=t&rct=j&q=mathematisches programmieren java
    201302-02 (8x)http://google.de/url?sa=t&rct=j&q=panel java nicht kompilierbar
    202102-03 (5x)https://google.de/
    201601-01 (4x)http://google.de/

    [Top of page]

    "Informatik: Programmieren - (Teil 1) Einstieg in Java" | 15 Comments
    The authors of the comments are responsible for the content.

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: Ollie am: Do. 28. April 2005 23:25:37
    \(\begingroup\)Ein sehr interessanter Artikel! Leider bin ich schon zu blöd um überhaupt auf der Homepage von sun den download für j2SE zu finden. Dies ist die unübersichtlichste Seite die ich jemals gesehen habe. Ansonsten: ein großes Lob für deine Arbeit. mfG \(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: murmelbaerchen am: Do. 28. April 2005 23:39:34
    \(\begingroup\)Hallo Ollie, da sagst Du was Wahres. Java 1.5 Dann JDK 5.0 Update 3 -> agreement abhaken -> platform wählen Sollte reichen. Viele Grüsse sunbärchen P.S. Kobe, Dir zu diesen sehr schönen ausführlichen Artikel einen herzlichen Dank.\(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: kostja am: Do. 28. April 2005 23:45:38
    \(\begingroup\)Hallo Kobe, ich danke Dir für Deine Mühe und diese sehr gelungene Arbeit. Ich habe sie schon mal angelesen, konnte mich aber noch nicht richtig damit berschäftigen. Ich finde es jedoch schade, dass Du bei der IDE auf ein nur für Windows verwendbares Produkt setzt. Bei JAVA hätten sich doch z.B. die Plattform unabhängigen IDEs Netbeans und Eclipse gut angeboten. Ich freue mich schon auf die Fortsetzung! mfG Konstantin\(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: murmelbaerchen am: Fr. 29. April 2005 00:01:18
    \(\begingroup\)Hallo an alle IDEler NetBeans findet man unter dem oben genannten link. Hier findet man Eclipse. Es ist kostenfrei und benötigt nach dem Download noch eine JRE. Viele Grüsse Murmelbärchen\(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: shredhead am: Fr. 29. April 2005 00:27:58
    \(\begingroup\)Hi Kobe Erstmal vorweg: Du hast dir sehr viel Mühe gegeben, und es ist ein recht ansehnlicher Artikel entstanden. Allerdings habe ich (wie immer?*g*) etwas zu kritisieren. An einigen Stellen ist deine Quellcode Formatierung nicht sehr schön anzusehen(Einrückung sowie Klammersetzung), aber das habe ich dir ja schonmal im Forum gesagt. Ich denke, dass man einige Stellen als blutiger Java Anfänger nicht ganz nachvollziehen kann. Da hättest du vielleicht noch etwas klarer schreiben können. Dann fiel mir auf, dass du die Klasse Chef von Angestellter hast erben lassen. Das kann man machen, ich hätte es aber logischer gefunden, wenn du Angestellter vielleicht umbenannt hättest zu Mitarbeiter, denn Chefs sind ja keine Angestellte. Es ist also keine richtige "is a"-Beziehung. In der Klasse Angestellter schreibst du auch: public void geburt(String name) { kinder ++; } public void ehe(boolean v) { boolean verheiratet = v; } Frage: Warum übergibst du in geburt einen String um dann die Variable kinder um 1 zuerhöhen(hier wäre auch ein this.kinder++ und eventuell ein this.name=name besser)? Und warum schreibst du bei ehe: boolean verheiratet = v; , anstatt this.verheiratet=v ? Da bist du nicht sehr konsistent. Vielleicht hättest du auch noch was zu Assoziation und Aggregation sagen sollen, wenn du schon die Vererbung dastellst. So genug gemeckert. Ohje, das klingt jetzt aber alles negativ. Es ist aber nur konstruktive Kritik. *g* Man kanns ja nicht immer jedem Recht machen. *g* Gruß Jörg PS: Ich hätte nochmehr zu bemängeln, aber ich denke ich belasse es mal dabei. Alles das was ich vermisst habe kannst du ja in einer eventuellen Fortsetzung bringen! *g* Das mit kinder oder this.kinder finde ich nicht so schlimm, unsinniger ist, dass der Übergabewert name überhaupt nicht verwertet wird, ausserdem ist in der methode ehe der "boolean verheiratet" lokal definiert, so dass er nach austritt aus der methode vom GC (Garbage Collector) weggeworfen wird und somit überhaupt nichts bringt... \(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: Kobe am: Fr. 29. April 2005 15:00:21
    \(\begingroup\)So, melde ich mich doch mal, um der (konstruktiven) Kritik Rede und Antwort zu stehen: @ollie wird / ist bearbeitet @kostja Ich habe nur mit dieser IDE Erfahrung und eigentlich auch nur gute. Wenn man etwas anderes nutzen will, kann man das ruhig tun, an den Programmen ändert sich dabei ja nichts. @shredhead Bei Einrückung gebe ich dir teils recht. Sehe grad, dass z.B. bei BiKo2 eine else Anweisung häßlich verrückt ist. Ich muss mich mal an den Großen wenden, warum das passiert. Wenn ich es schreibe, sind die tab's korrekt sichtbar. Was ich an Klammersetzung häßlich setze, weiss ich nicht. Ich habe mir das so angwöhnt, und finde es so übersichtlich. V.a. wenn die geschweiften Klammern in der Höhe der zugehörigen Anweisung beginnen und enden, wenn sie sich über mehrere Zeilen hinwegdehnen. Zwecks Mitarbeiter oder Angestellter, finde ich die Diskussion unsinnig. Mitarbeiter <=> Angestellter (wahrscheinlich meldet sich gleich martin_infinite). Ich hätte auch Arbeitnehmer schreiben können. Zwecks this, bin ich nicht sehr konsistent um den Unterschied zu verdeutlichen. Man kann, muss aber nicht this setzen. Ich finde es schöner, wenn man this so wenig wie möglich benutzt. Zu Anfang meiner Java-Zeit habe ich alles mit this geschrieben, wo man es schreiben konnte, ohne zu wissen was es macht (und das es manchmal auch ohne geht). Soviel dazu Dennoch danke der Kritik!\(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: shredhead am: Fr. 29. April 2005 17:59:18
    \(\begingroup\)Hi Kobe Ok, ich weiß ja schon, dass du dich nicht leicht überzeugen lässt.*g* Aber gut, dann erkläre mir dochmal bitte was die Methode "public void geburt(String name)" so alles macht in deinen Augen. Und warum du in der Methode "public void ehe(boolean v)" eine Variable(Bezeichner) vom Typ boolean mit dem Namen verheiratet deklarierst, obwohl verheiratet schon ein Attribut der Klasse ist.Ok, das kann man machen, aber warum machst du das? Und meine letzte Frage ist, was du an "this" nicht magst. Ich finde das man mit this doch sehr schön differenzieren kann, was da gerade gemacht wird (das bei this eben das Attribut gemeint ist). Wenn man das weglässt, sieht es eben nicht mehr so eindeutig aus. Und wenn du einmal this in einer Methode schreibst, dann würde ich auch dabei bleiben, denn der Artikel soll ja für Java Einsteiger gedacht sein und nicht für Leute die genau wissen was da passiert. Deswegen halte ich deinen "Stil" für nicht konsistent und deswegen ist er in meinen Augen "nicht gut". Das du das anders siehst, weiß ich! *g* Naja, es ist dein Artikel, ich kann dir nur meine Meinung dazu sagen. Gruß Jörg \(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: shredhead am: Sa. 30. April 2005 13:46:34
    \(\begingroup\)Hi Alle Wir (Kobe und ich) haben uns noch per PM verständigt und Kobe hat noch ein paar kleine Fehler ausgemerzt. Ich finde es gut Kobe, dass du dir soviel Mühe gemacht hast. Die Formatierung ist an manchen Stellen irgendwie verrutscht, aber dafür kannst du nichts. Ansonsten haben wir jetzt einen guten Artikel über Java und ich bin gespannt auf den 2. Teil. Vielleicht kommst du ja sogar noch Kostjas Vorschlag nach und benutzt Eclipse. Das benutze ich nämlich auch. Ist leider ein bisschen langsam, aber die Entwicklungsumgebung ist echt chic 😉 Gruß Jörg\(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: Hans-im-Pech am: Di. 03. Mai 2005 20:17:08
    \(\begingroup\)Hallo Kobe, ein sehr schöner Artikel, viel Arbeit hast Du Dir gemacht. Einfach zu lesen und doch innovativ! Ich freu mich auf die Fortsetzung! 😉 Gruß, HiP\(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: Wolti am: Mo. 09. Mai 2005 22:42:55
    \(\begingroup\)Hallo Alle! Ich denke zwar, dass ein guter Editor den Einstieg in die Programmierung sehr erleichtern kann, aber auch wenn das folgende Programm dieses Kriterium nicht unbedingt erfüllt, ist es speziell für die objektorientierte Programmierung in Java auch doch mal ganz schön, die Objekte "in Action" zu sehen! Auf jeden Fall einen Blick Wert: www.bluej.org MfG, Wolti PS: Ach ja, fast vergessen: guter Artikel 😄\(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: stream am: Fr. 21. April 2006 10:41:53
    \(\begingroup\)Ein wirklich guter Artikel Kobe und murmelbaerchen! Mein Java Prof meinte mal: "Schwimmen lernt man nicht vom Lesen, also rein ins Becken!" seitdem kann ich im Java Meer paddeln :P \(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: Ex_Mitglied_40174 am: Sa. 06. Mai 2006 01:30:08
    \(\begingroup\)Interessant und innovativ freue mich auf Teil 2 Danke\(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: Ex_Mitglied_40174 am: Do. 28. September 2006 13:08:28
    \(\begingroup\)Hallo Kobe, ein schöner Artikel für Java-Neulinge... Ich hab nur eine Anmerkung zu Deinen Erläuterungen bzgl. der main-Methode: In "klassischen" Java-Anwendungen (also kein J2EE) ist diese Methode mit ihrer Signatur(String[] xx),Sichtbarkeit(public) und Returnwert(void) zwingend so vorgeschrieben, ansonsten gibts beim Ausführen eine "NoSuchMethodError"-Exception. Für Neulinge, die vielleicht nicht verstehen, warum die Methode statisch sein muss, sei erläuternd hinzugefügt, das diese von der JVM (Java Virtual Machine) als Eintrittspunkt für das Programm dient, und es zu diesem Zeitpunkt noch keine Instanz dieser Klasse (Hello) gibt. Ich denke, das ist wichtig zu verstehen... Viele Grüsse Peter\(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: Ex_Mitglied_40174 am: Do. 17. Mai 2007 18:29:44
    \(\begingroup\)Hilfe, bei mir steht nur "Error : Invalid path, \bin\javac.exe -classpath C: -d C: C:\Hello.java" und ich kann das Programm nicht ausführen O.o Danke schonmal für Hilfe :)\(\endgroup\)
     

    Re: Programmieren - (Teil 1) Einstieg in Java
    von: Ex_Mitglied_40174 am: Mi. 09. März 2011 17:00:49
    \(\begingroup\)Was ist der Unterschied zwischen Klasse und Instanz? Hier wird es erklärt: bit.ly/dIRUuM \(\endgroup\)
     

     
    All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest © 2001-2021 by Matroids Matheplanet
    This web site was originally made with PHP-Nuke, a former web portal system written in PHP that seems no longer to be maintained nor supported. PHP-Nuke is Free Software released under the GNU/GPL license.
    Ich distanziere mich von rechtswidrigen oder anstößigen Inhalten, die sich trotz aufmerksamer Prüfung hinter hier verwendeten Links verbergen mögen.
    Lesen Sie die Nutzungsbedingungen, die Distanzierung, die Datenschutzerklärung und das Impressum.
    [Seitenanfang]