Ich schreib hier was ich so mit Java geschafft habe 
Ist spät am Abend werde es daher in den nächsten Tagen mit Inhalt füllen.
Ja, das IST eine Kopie von Muh's Thread
und Nein, ich habe nicht mit Java angefangen weil Muh mit VisualC# angefangen hat 
Java hatte ich schon bevor ich wusste dass Muhlord VisualC# angefangen hat.
Liebe Grüße 
Wie Licht_ fange ich mit dem Standart-Anfänger-Programm an
Hello World !
Zuerst mache ich in Eclipse ein neues Projekt und mach in den src-ordner ein Package.
Ich nenne das Projekt erstmal =S
Und den Package letsmine.java.itsmee
In diesem Paket mach ich die erste Klasse.
Ich nenne sie helloworld_main und lasse von eclipse die public static void main(String[] args) mit generieren. (Wäre btw. nett wenn mir jemand erklären könnte was ich damit machen kann :D)
Jetzt kommt das "Kommando" das Java dazu anweist, auf dem CMD zu schreiben, was ich will.
Ich muss dazu nichts weiter importieren und können daher gleich loslegen !
Ich schreibe:
System.out.println("Hello World");
Wichtig ist, dass "System" groß geschrieben ist und ans Ende vom ganzen ein ; kommt, denn danach kommt nichts mehr
Unten in der "Console" sieht man, dass das ganze so funktioniert. Ist kein sonderlich sinnvolles Programm aber es funktioniert
Nur Hello World ist natürlich ziemlich langweilig
Und jedes Mal den Source umzuschreiben ist ja auch doof.
Ich nehme einfach mal den Scanner, damit ich den Text selber schreiben kann
Dafür erstelle ich eine neue Klasse im Package letsmine.java.itsmee
Ich nenne sie einfach mal scannertext
In der Klasse importere ich den Scanner ( import java.util.Scanner; ) und setze die Variable "input".
package letsmine.java.itsmee;import java.util.Scanner;public class scannertext { public static void main(String[] args{ System.out.println("Bitte schreiben Sie etwas"); Scanner input = new Scanner(System.in); String etwas = input.next(); System.out.println("Sie haben "+etwas+" geschrieben"); }}
Der Input ist für Java nur 1 Wort lang, deswegen kann man auf diesem Weg keinen großen Text schreiben.
Längere Texte kann man mit input.nextLine(); anstatt input.next(); schreiben.
package letsmine.java.itsmee;
import java.util.Scanner;
public static void main(String[] args) {
System.out.println("Bitte schreiben Sie etwas");
Scanner input = new Scanner(System.in);
String etwas = input.nextLine();
System.out.println("Sie haben '"+etwas+"' geschrieben");
}
}Funktioniert anscheinend
package letsmine.java.itsmee;public class datentypen { public static void main(String[] args) { int a = 1,b = 2, c = 3,d = a+b+c; System.out.println(d); }}package letsmine.java.itsmee;public class datentypen { public static void main(String[] args) { int a = 1,b = 2, c = 3,d = a+b+c; System.out.println("D = "+d); int e = a-b-c,f = a*b*c,g = a/b/c; System.out.println("E = "+e); System.out.println("F = "+f); System.out.println("G = "+g); }}Mal sehen was ich aus der Erkenntnis gewinnen kann, dass e und f gleich groß sind
package letsmine.java.itsmee;public class ifelse { public static void main(String[] args) { int a = 1,b = 2,c = 3, e = a+b+c, f = a*b*c; if (e==f) {System.out.println("e = f"); } else {System.out.println("e ist nicht = f");} }}(Mir fällt grad auf dass ich bei diesem Bild bei der Textausgabe 'e' mit 'a' verwechselt habe. Beim Programmieren stört dies nicht aber es gibt halt falschen Text aus 
)
Yoa
Mit ein bisschen mehr Wissen geht auch ein kleiner Taschenrechner 
package letsmine.java.itsmee;
import java.util.Scanner;
public class taschenrechner {
public static void main(String[] args) {
//Zuerst mache ich einen neuen Scanner
Scanner eingabe = new Scanner(System.in);
//Dann lasse ich den User ein paar Zahlen eintippen.
System.out.println("Bitte geben Sie eine Zahl ein");
String a = eingabe.next();
System.out.println("Bitte geben Sie eine weitere Zahl ein");
String b = eingabe.next();
//Hier werden Strings zu doubles umgerechnet, da man Strings nicht miteinander addieren kann.
double dba=Double.valueOf(a), dbb=Double.valueOf(b), dbc = dba+dbb;
System.out.println("Das Ergebnis ist "+dbc);
}
}Ich greif das Thema mal wieder auf.
Heute schreibe ich einen "Dreiecksrechner". Das heißt, ich gebe von einem Dreieck z.B. Höhe und Grundseite an und der Taschenrechner berechnet den Flächeninhalt. Selbiges geht natürlich auch umgekehrt (Ich gebe Grundseite und Flächeninhalt an und er rechnet die Grundseite aus).
package letsmine.java.itsmee;
import java.util.Scanner;
public class dreieckrechner {
public static void main(String[] args) {
System.out.println("Welche Angaben kennen Sie ?");
System.out.println("1 = Höhe + Grundseite");
System.out.println("2 = Höhe + Flächeninhalt");
System.out.println("3 = Grundseite + Flächeninhalt");
Scanner input = new Scanner(System.in);
String a = input.next(); //Bestimmung einer Variable 'a' als String.
int ia = Integer.valueOf(a); //Umwandlung des Strings 'a' in einen int-Wert
if (ia == 1) //Falls 1 eingegeben wird, kommt dieser Codeblock
{
System.out.println("Höhe angeben: ");
String w11 = input.next(); //Bestimmung der Variable w11 als String.
System.out.println("Grundseite angeben:");
String w12 = input.next(); //Bestimmung der Variable w12 als String
double w1d1 = Double.valueOf(w11); //Umwandlung des Strings w11 zu einem Double-Wert
double w1d2 = Double.valueOf(w12); //Umwandlung des Strings w12 zu einem Double-Wert
double w1d3 = w1d1*w1d2/2; //Ausrechnen des Flächeninhaltes (Höhe*Grundseite)
System.out.println("Flächeninhalt: "+w1d3);
}
else
if (ia == 2) //Wenn 2 eingegeben wird, wird kommt dieser Codeblock
{
System.out.println("Höhe angeben");
String w21 = input.next();
System.out.println("Flächeninhalt angeben");
String w22 = input.next();
double w2d1 = Double.valueOf(w21);
double w2d2 = Double.valueOf(w22);
double w2d3 = w2d2/w2d1*2; //Ausrechnen der Grundseite (Fläche/Höhe*2)
System.out.println("Grundseite: "+w2d3);
}
else
if (ia == 3) //Falls 3 eingegeben wird, kommt dieser Codeblock
{
System.out.println("Grundseite angeben");
String w31 = input.next();
System.out.println("Flächeninhalt angeben");
String w32 = input.next();
double w3d1 = Double.valueOf(w31);
double w3d2 = Double.valueOf(w32);
double w3d3 = w3d2/w3d1*2; //Ausrechnen der Höhe (Fläche/Grundseite*2)
System.out.println("Höhe: "+w3d3);
}
}
}Heute zeige ich wie man sich die (Einiges) Systeminformationen anzeigen lassen kann ^,^
Zuerst habe ich das AWT-Gedöhns und javax.swing.* importiert damit ich ein Fenster machen kann. (Im Bild leider nicht zu sehen)
package letsmine.java.itsmee.sysinfo;import java.awt.TextField;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.*;Zuerst baue ich ein Fenster auf.
public class Sysinfomain extends JFrame implements ActionListener
Hier lege ich fest, wie die .class-Datei im Endeffekt heißen wird, dass JFrame erweitern wird und den ActionListener implementiert.
public static void main(String[] args)Die Main-Methode...
/*Wie das Fenster intern heißt (Hier fenster) und welchen Titel er haben wird (Hier Sysinfo)*/JFrame fenster = new JFrame("Sysinfo");/*Was passiert wenn man das kleine X oben rechts klickt*/fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);/*Festlegen, dass es sichtbar sein wird (Unten in der Taskleiste wird es angezeigt etc)*/fenster.setVisible(true);/*Wie groß das Fenster sein wird (Hier 300 breit und 200 hoch)*/fenster.setSize(300, 200);Jetzt wird der Button "Systeminformationen Anzeigen" eingefügt.
/*Wie der Button intern genannt wird.*/JButton sysinfo = new JButton("Systeminformationen anzeigen");/*ActionListener implementieren*/ActionListener evtsysinfo = new ActionListener(){/*Was die Betätigung des Buttons macht*/public void ActionPerformed (ActionEvent evtsysinfo) {/*Strings werden festgelegt. Damit können Später die Systeminformationen ausgegeben werden*/ String osname = System.getProperty("os.version"), osversion = System.getProperty("os.version"), osarch = System.getProperty("os.arch"), javahome = System.getProperty("java.home"), userdir = System.getProperty("user.dir"), userhome = System.getProperty("user.home"), username = System.getProperty("user.name"), userlang = System.getProperty("user.language");//Neues Fenster, welches sich beim Druck des Buttons öffnet, wird eingefügt. Höhe 200 Breite 400 und was passiert, wenn der X-Knopf gedrückt wird.JFrame sysinfo = new JFrame();sysinfo.setSize(400,200)/*Fenster wird geschlossen, allerdings nicht beendet ( kann also jeder Zeit wieder geöffnet werden, wird allerdings nicht mehr in der Taskleiste angezeigt*/sysinfo.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);/*Einfügen der JTextArea, in dem die Informationen stehen.*/JTextArea sysinpage = new JTextArea(200, 300);/*Einstellen, dass die TextArea nicht editierbar sein wird (da (false) );sysinpage.setEditable(false);/* Informationen, die auf der JTextArea stehen */sysinpage.append ("Betriebssystem"+osname+"\n"+"Betriebssystemversion"+osversion+"\n"+"Betriebssystemarchitektur: "+osarch+"\n"+"Java-Pfad: "+javahome+"\n"+"Benutzerverzeichnis: "+userdir+"\n"+"Benutzerhome: "+userhome+"\n"+"Benutzername: "+username+"\n"+"Systemsprache: "+userlang);/* Sichtbar schalten */sysinfo.setVisible(true);/* Die JTextArea in das JFrame einfügen */sysinfo.add(sysinpage);}};Jetzt kommt der ActionListener ins Spiel
sysinfo.addActionListener(evtsysinfo);
/* JPanel erstellen, auf das Panel 'sysinfo' aufsetzen und das JPanel auf das Fenster setzen */
JPanel eingaben = new JPanel();
eingaben.add(sysinfo);
fenster.add(eingaben);Funktioniert (Der fehlende Name ist kein Fail sondern Datenschutz 
Nach einer Ewigkeit mal wieder was in die Java-Ecke =)
Heute ganz viel GUI und der Stuff
Zuerst schreiben wir uns ein kleines Fenster. Wir wollen ein Programm schreiben, das Text in einer GUI ein- und ausgeben kann.
Zuerst baue ich ein Fenster mit JFrame (Dazu javax.swing.* importieren). Ich setze 'setVisible' auf true und setze 'setDefaultCloseOperation' auf 'JFrame.EXIT_ON_CLOSE). Auf das JFrame setze ich 2 JTextField. Den ersten nenne ich 'eingabe'.
Ich muss ihn direkt unter dem class-Namen definieren, sonst wird er innerhalb der ActionListener-Methode nicht erkannt.
Die Eingaben werden hier in der Console ausgegeben. Um ihn in der GUI ausgeben zu lassen, definiere ich ein weiteres JTextField, ich nenne es einfach mal 'ausgabe'.
Jetzt muss ich die actionPerformed-Methode des JTextFields 'eingabe' so modifizieren, dass, wenn ein Text in 'eingabe' eingegeben und mit Enter bestätigt wird, der Text in 'ausgabe' dem neuen Text in 'eingabe gleicht:
Das Problem ist, dass 'eingabe' nach diesem Muster die 'ausgabe' im fenster1 überdeckt.
Ich muss also hinbekommen, dass 'eingabe' und 'ausgabe' klar voneinander getrennt werden. Dazu benutze ich einen Layout-Manager, zum Beispiel GridLayout:
Der GridLayout-Manager trennt die beiden JTextField voneinander und gibt beiden genau den selben Platz.
Insgesamt sieht das dann so aus:
package tut_swing;import javax.swing.*;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;public class swing_windows { static JTextField eingabe = new JTextField(""); static JTextField ausgabe = new JTextField(""); public static void main(String[] args) { //Zuerst müssen wir uns ein paar Fenster bauen. Dies machen wir mit //JFrame JFrame fenster1=new JFrame(); fenster1.setVisible(true); fenster1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); /* Dies ist ein einfaches Fenster. Es hat keine Funktionen * das .setVisble(true) sorgt dafür, dass das Fenster sichtbar wird. * das .setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) sorgt dafür, * dass der Prozess nach dem Schließen des Fensters beendet wird. */ /*Natürlich wollen wir mehr als nur ein langweiliges Fenster, das man nur Schließen kann. * Verpassen wir dem Fenster ein paar Funktionen ! :) */ //Zuerst ein kleines Eingabefenster ausgabe.setEditable(false); eingabe.setForeground(Color.WHITE); eingabe.setBackground(Color.BLACK); fenster1.add(eingabe); fenster1.add(ausgabe); //Jetzt könnten wir uns den Text holen. Dazu müssen wir das JTextField 'eingabe' als static festlegen - und damit über public static void main(String[] args) schreiben //Sonst wird 'eingabe' im ActionListener nicht erkannt. eingabe.addActionListener(new ActionListener() { public void actionPerformed (ActionEvent eingabeneu) { ausgabe.setText(eingabe.getText()); } }); //Jetzt ist da ein zweites JTextField - Die Textausgabe. Leider überdeckt das JTextField 'ausgabe' die 'eingabe'. Das heißt, wir müssen den Beiden einen Platz //zuweisen, so überdeckt die Ausgabe die Eingabe nicht mehr. //Dazu brauchen wir einen Layout-Manager. In diesem Beispiel nehme ich das GridLayout. fenster1.setLayout(new GridLayout(2,2)); }}Da kommen wir auch gleich zum nächsten Thema: Die LayoutManager. Es gibt in Java verschiedene LayoutManager in Java.
Einer davon ist der GridLayout-Manager. Dieser gibt jedem Objekt auf dem entsprechenden Fenster/Label/Whatever genau gleich viel Platz.
Man setzt einfach ein Fenster und beliebig viele Objekte, gibt dem Fenster den Layout-Manager GridLayout(intSeite, intHöhe) und schon hat man ein schönes Gitter eingerichtet. Es gibt natürlich auch die Möglichkeit, Buttons leichter einzusetzen als jeden Einzeln, aber dazu kommen wir später.
package tut_swing;
import java.awt.*;
import javax.swing.*;
public class Layoutmanager {
//Der folgende Abschnitt definiert die JButtons btn1-btn25 Klassenweit, sodass sie in allen Methoden zur Verfügung stehen & verändert werden können.
static JButton btn1 = new JButton(), btn2 = new JButton(), btn3 = new JButton(), btn4 = new JButton(), btn5 = new JButton(), btn6 = new JButton();
static JButton btn7 = new JButton(), btn8 = new JButton(), btn9 = new JButton(), btn10 = new JButton(), btn11 = new JButton(), btn12 = new JButton();
static JButton btn13 = new JButton(), btn14 = new JButton(), btn15 = new JButton(), btn16 = new JButton(), btn17 = new JButton(), btn18 = new JButton();
static JButton btn19 = new JButton(), btn20 = new JButton(), btn21 = new JButton(), btn22 = new JButton(), btn23 = new JButton(), btn24 = new JButton(), btn25 = new JButton();
public static void main(String[] args) {
/*
* Die ganzen schönen Fenster wollen natürlich auch irgendwie programmiert werden.
* Eine Möglichkeit es, Layout-Manager zu verwenden.
*/
//Beispiel 1: Das Grid-Layout
//Das Grid-Layout wird verwendet, wenn man mehrere Objekte in gleicher Größe, gleichem Abstand etc
JFrame frame1 = new JFrame("Grid-Layout");
//Der folgende Abschnitt erstellt in Frame1 ein Grid (Gitter) mit 5 Zeilen und 5 Spalten:
frame1.setLayout(new GridLayout(5,5));
frame1.setSize(500,500);
frame1.setVisible(true);
frame1.add(btn1);
frame1.add(btn2);
frame1.add(btn3);
frame1.add(btn4);
frame1.add(btn5);
frame1.add(btn6);
frame1.add(btn7);
frame1.add(btn8);
frame1.add(btn9);
frame1.add(btn10);
frame1.add(btn11);
frame1.add(btn12);
frame1.add(btn13);
frame1.add(btn14);
frame1.add(btn15);
frame1.add(btn16);
frame1.add(btn17);
frame1.add(btn18);
frame1.add(btn19);
frame1.add(btn20);
frame1.add(btn21);
frame1.add(btn22);
frame1.add(btn23);
frame1.add(btn24);
frame1.add(btn25);
}
}Der letzte Layout-Manager den ich vorstellen möchte ist der Flow-Layout-Manager.
Der Flow-Layout-Manager ist ziemlich simpel. Er setzt die Komponenten (Buttons etc) in eine Reihe. Horizontal ist der FlowLayout immer genau in der Mitte des Fensters zentriert. Das heißt: Sollte das JFrame länger sein als nötig, werden die Komponenten von der Mitte ausgehen.
Heute mal etwas was bestimmt schon mehrere hier versucht haben!
Ein CraftBukkit-Plugin !
Zuerst setzen wir die Eclipse-IDE auf, denn bei der Benutzung einer API, wie Bukkit eine ist, muss
man auf einige Dinge achten.
Zuerst bringen wir Eclipse dazu, uns bei der Benutzung einer Bukkit-Methode bzw. -Klasse keine
Fehlermeldung auszugeben. Dazu fügen wir die Bukkit-Api.jar als externe Library ein.
Wenn das nun unter Dach und Fach ist, können wir die Javadoc für Bukkit hinzufügen. Das führt dazu,
dass Eclipse uns zum Beispiel beim Zeigen mit der Maus auf eine Methode oder Klasse sagt, wie man diese benutzt.
So, dann fangen wir mal mit unserer Klasse an.
Das Package heißt irgendein.random.bukkit.plugin .
Was unwichtig scheint, ist tatsächlich sehr wichtig für die Funktion unseres Plugins ! Aber dazu später.
Was zuerst wichtig ist, ist dass wir "org.bukkit.plugin.java.JavaPlugin" importieren, denn das erweitert später unsere Klasse.
Anders als bei üblichen Klassen ist bei Bukkit-Plugins keine main-Methode notwendig. Die Funktion kann auch von z.B. der onEnable()-Methode übernommen werden.
Auch möglich wäre es, für die Vorgänge eigene Methoden zu schreiben, und diese von der onEnable()-Methode aufzurufen:
@Overridepublic void onEnable(){int i = 10;</p>getLogger().info("Hallo");</p>getLogger().info("Wie gehts ?");</p>if (i==10){</p> getLogger().info("i == 10");</p>}}macht im Grunde genau das, was auch folgender Code tun würde:
public void hallo(){int i = 10;getLogger().info("Hallo");getLogger().info("Wie gehts ?");if (i==10){ getLogger().info("i == 10");}}@Override()public void onEnable(){hallo();}
Sollte dieser Code mehrmals ausgeführt werden, sollte die Methode grundsätzlich bevorzugt werden, da man hiermit schnell den Code verändern kann, falls Änderungen nötig werden.
Das machen wir einfach mal zu:
package irgendein.random.bukkit.plugin;
import org.bukkit.plugin.java.JavaPlugin;
public class Main extends JavaPlugin{
@Override
public void onEnable(){
getLogger().info("Dies wird beim Start in der Konsole erscheinen !");
}
@Override
public void onDisable(){
getLogger().info("Dies wird beim Herunterfahren des Servers in der Konsole erscheinen !");
}
}getLogger().info("") ist quasi das System.out.println("") für Bukkit.
Es gibt einen Text in der Konsole aus.
Es gibt aber noch etwas äußerst Wichtiges, was gemacht werden muss, bevor das Plugin kompiliert werden kann.
Wir müssen eine plugin.yml anlegen, damit CraftBukkit heißt, wie das Plugin heißt und wo es die Hauptklasse (Main.java) findet, sowie die Versionsnummer.
Wir legen also eine Datei an (Rechtsklick -> randomPlugin -> New -> File) und geben ihr den Namen plugin.yml. Finish gedrückt, und der standartmäßige YML-Editor öffnet sich.
Hierfür empfehle ich wärmstens "Notepad++".
Hier kommt jetzt zu Tage, wie wir unser Package genannt haben. Was in der Programmierung selbst eher uninteressant ist (je nachdem, wie groß das Plugin ist, versteht sich) wird beim Schreiben der plugin.yml umso wichtiger.
Denn das Package ist nicht etwa nur so da, nein hinter diesem Package versteckt sich ein Dateipfad.
Sollte man die kompilierte Plugin.jar später mit einem Archiver-Programm (z.B. 7-Zip oder WinRAR) öffnen, so wird man sich erst
durch die ganzen Einträge zwischen den Punkten klicken müssen. Das heißt: Je länger der Packagename und je öfter ein Punkt auftaucht, desto öfter werden Unterverzeichnisse
erstellt, wo sich letztendlich die Main.class (oder wie ihr eure Klassen auch nennen wollt) versteckt.
Bei der Angabe der Main.class muss man unbedingt darauf achten, das ".class" wegzulassen (Sonst wird ja quasi nach einem Unterverzeichnis namens Main gesucht, das es ja nicht gibt -> NullPointerException)
Was man beim Verpacken des Plugins beachten muss ist, dass bei der "JAR File Specification" auch die plugin.yml angewählt ist, damit sie später im Jar-Archiv vorhanden ist.
Wie ihr die .jar-Datei nennt ist um Grunde euch überlassen. Optimalerweise sollte sie natürlich den Namen eures Plugins tragen.
Mal sehen, wie sich unser Plugin so macht:
Das sieht doch gut aus !
Heute schreib ich mal ein wenig über Konstruktoren
Konstruktoren gibt es eigentlich überall in Java. Auch hier haben wir schon einen Konstruktor genutzt:
static JTextField eingabe = new JTextField("");
Der Konstruktor JTextField eingabe = new JTextField(String xyz) erstellt also mit dem String xyz ein Objekt mit dem Namen eingabe des Typs JTextField.
Was ein JTextField so macht, was es kann, wofür es gut ist wird in der Klasse JTextField festgelegt.
In der Klasse sind also Methoden, die jedes Objekt des Typs JTextField beinhält.
Im oberen Beispiel wird also ein Objekt namens 'bacon' des Typs 'Bacon' erstellt, mit dem Namen 'Hanz'. Man könnte auch ein Objekt namens 'ajdw' des Typs 'Bacon' erstellen, das den Namen 'Claudia' hat - solange die Anzahl der Parameter stimmt, ist es egal.
Mit einem Typ namens Bacon können wir aber nichts anfangen.
Nehmen wir einfach mal etwas pauschaleres...
Fahrzeug.
Wichtig bei einer Konstruktorklasse sind die Variablen. Im obigen Beispiel haben wir die Variable hasEngine als boolean und den String type.
Mit dem Konstruktor gibt man diesen Variablen einen Wert ( man siehe hasEngine = mitMotor; ). Um diesen zu geben, muss er natürlich irgendwann festgelegt werden.
Natürlich könnte man einfach Standartwerte einsetzen:
public Fahrzeug(){ hasEngine = false; type = "Fahrrad"; }
Aber das wäre im Falle eines Fahrzeuges Schwachsinn.
Wie dem auch sei - wir haben hier einen Konstruktor....
Na und ?
Noch können wir damit also noch gar nichts machen.
Aber wir können dem ganzen einen Sinn geben !
Fügen wir einfach mal eine int-Variable hinzu und erweitern den Konstruktor um diesen.
Dann schreiben wir eine Methode, mit der wir die int-Variable abrufen können:
Ich habe die Methode (in anderen Sprachen auch 'Funktion' genannt) einfach mal getRaeder genannt. Wie man an der leeren Klammer sieht braucht diese Methode keine Parameter. Man kann also einfach schreiben:
Fahrzeug fahrzeug = new Fahrzeug(true, "Auto", 4);System.out.println(fahrzeug.getRaeder());/*Output: 4*/Es kann aber auch sein dass die Angabe der Räderzahl überflüssig ist - zum Beispiel im Falle eines Fahrrads.
Nehmen wir einfach mal einen neuen Typ herbei:
Fahrrad !
package constructor.whoo;public class Fahrrad extends Fahrzeug{ int age; public Fahrrad(int alter){ super(false, "Fahrrad", 2); age = alter; }}Man beachte hierbei die Wörter 'extends' und 'Fahrzeug'.
Mit 'extends Fahrzeug' wird gesagt:
Diese Klasse stammt von der Klasse 'Fahrzeug' ab und erweitert diese (darum auch 'extends').
Was das bedeutet ?
Ganz einfach:
Die Klasse erweitert die ''Vaterklasse'' um Funktionen - und beinhaltet die Funktionen, die die Vaterklasse auch enthielt.
Man könnte also schreiben:
package constructor.whoo;public class Fahrrad{ int age; boolean hasEngine; String type; public Fahrrad(int alter){ age = alter; hasEngine = false; type = "Fahrrad"; }}Oder in diesem Fall einfach:
package constructor.whoo;public class Fahrrad extends Fahrzeug{ int age; public Fahrrad(int alter){ super(false,"Fahrrad"); age = alter; }}Der Vorteil ergibt sich daher selbst:
Man muss vorhandene Methoden nicht komplett neu schreiben sondern kann einfach die aus der Vaterklasse benutzen - dies kann mitunter äußerst hilfreich.
Eine Sache ist dabei allerdings problematisch:
Bei diesem Beispiel hat das Fahrzeug die Methode getRaeder. Bei einem Fahrrad ist es aber unüblich, weniger oder mehr als 2 zu haben (außer das Fahrrad ist kaputt).
Sinnvoll wäre es also, einfach die Methode getRaeder zu überschreiben:
public int getRaeder(){ return 2;}sonst gibt's eine NullPointerException, da die Variable wheels, die die Vaterklasse Fahrzeuge hier übergeben würde, nicht existiert.
Allerdings kann man auch einfach neue Methoden und Parameter einfügen und sogar vorhandene Parameter entfernen bzw. überflüssig machen! - mit super...
Wie man hier sieht, fehlen 3 Sachen, die in der Vaterklasse 'Fahrzeug' vorhanden waren:
1) Die Motorangabe. Das ist ein Fahrrad, keine Mofa und kein Elektrofahrrad-> Einen Motor gibts nie.
2) Die Typangabe. Der Kontruktor heißt 'Fahrrad'. Eine Typangabe ist unnötig (außer man unterscheidet zwischen Mountainbike und anderen Fahrrädern, aber das lassen wir aus)
3) Die Anzahl der Räder. Ein Fahrrad hat nunmal 2 Räder
Dafür wurde eine Sache hinzugefügt:
Die Altersangabe.
Da, wie bereits erwähnt, die Motor- und Typangabe überflüssig sind, wir die Konstruktoren aber einfügen müssen, nehmen wir einfach mit super() bezug auf die
Vaterklasse.
public Fahrrad(int alter){ super(false, "Fahrrad", 2); age = alter;}Wie wir sehen, muss der Benutzer daher nur noch:
Fahrrad fahrrad = new Fahrrad(1)
angeben um ein Fahrrad zu erstellen.
Ohne super hätte der Nutzer
Fahrrad fahrrad = new Fahrrad(false, "Fahrrad", 2, 1)
eingeben müssen.
Heute behandle ich das Thema 'Listen und Maps'.
Ich werde nicht alle Listen behandeln, denn wichtige Grundinformationen stimmen überein.
Und da fällt schon das erste wichtige Wort: Implementation.
List ist nämlich ein Interface.
Hierzu das Beispiel Diamond-Problem (Einfach Googlen ;-)).
Um das Diamond-Problem zu verhindern, gibt es in Java keine Mehrfachvererbung von Klassen -
Eine Klasse kann also nur eine einzige Klasse als Superklasse haben. Falls man aber trotzdem
mal mehrere Klassen zusammenpacken muss, kommen Interfaces zum Einsatz - aber das soll hier nicht das Thema sein.
So. List ist also ein Interface. Na und ?
Interfaces haben keinen Konstruktor. (Wie willst du auch ein Interface konstruieren ?).
Daher muss man also eine Klasse benutzen die das Interface List implementiert.
Außerdem gibt es einige Methoden, die allgemeingültig sind.
-------------------
Der Vorteil bei Listen gegenüber Arrays ist, dass sie sich besser durchsuchen lassen.
Anstatt über das ganze Array zu Schleifen und jedes einzelne Objekt zu überprüfen, ließe
sich mit list.get(key) einfach das gewünschte Objekt holen. Zudem lassen sich dynamisch neue
Objekte hinzufügen, was bei Arrays nicht möglich ist.
Viel hilfreicher als Listen können aber 'Maps' sein. 'Map' ist, wie List, ein Interface. Mittels Maps
lassen sich quasi Tabellen anlegen, womit man einfach Daten lagern und schnell wieder abrufen kann:
Das Vorteilhafteste gegenüber einem (zweidimensionalen) Array ist, wie bei Listen auch, die get(Key) Methode,
mit welcher man das Durchforsten nach einem bestimmten Wert überflüssig macht.
Konstruiert wird eine Map nach diesem Muster:
Map<K, V> map = new Map<K, V>();
Wie bei Listen auch lässt sich für beide Werte theoretisch jeder Typ einfügen (String, Integer, Long... eigene Klassen, und sogar Listen !)
Wichtig bei primitiven Datentypen ist allerdings,
dass man die Klasse zu dem Typ wählt, nicht aber den Datentyp selbst:
Die Hauptaufgabe von Maps ist also, zu einem bestimmten Schlüssel einen bestimmten Wert zu speichern, Werten einer Eigenschaft zuzuteilen.