Java Schnell-Referenz

Tarantoga

Moderator
Java Schnell-Referenz


Ein Wort vorweg


Obwohl ich mich bei diesem Text um eine leicht verständliche Sprache bemüht habe und auch zahlreiche kurze Beispiele zur Veranschaulichung eingestreut habe, ist dies weniger ein Tutorial für Programmier-Anfänger, sondern eher ein Quickguide für Programmierer die noch nie mit Java gearbeitet haben oder ein Nachschlagewerk für Java-Coder die etwas eingerostet sind. Wer keine Ahnung hat was objektorientiertes Programmieren bedeutet oder was Kontrollstrukturen sind, ist wohl besser bedient sich in den endlosen Weiten des Internet ein Tutorial für Programmier-Anfänger zu suchen - trotzdem hoffe ich das der eine oder andere diese Einführung nützlich findet. Für alle Fragen deren Beantwortung über diese kurze Einführung hinausgehen empfehle ich das Buch Java ist auch eine Insel, das praktisch eine Bibel für Java-Coder darstellt und im Internet als Openbook zur Verfügung steht.
Link: http://openbook.galileocomputing.de/javainsel8/

MfG,
Tarantoga


Inhalt
1 – Grundlagen
1.1 Namenskonventionen
1.2 Operatoren
1.3 Kommentare
2 – Datentypen
2.1 primitive Datentypen
2.2 Datenklassen
2.2.1 Zeichenketten (Strings)
2.2.2 Felder (Arrays)
2.3 Referenztypen
3 – Kontrollstrukturen
3.1 Bedingte Anweisungen
3.2 Schleifen
3.3 Mehrfachverzweigungen
4 – Klassen & Objeke
4.1 Klassen definieren
4.2 Vererbung
4.3 Interfaces


1 – Grundlagen


Java ist eine objektorientierte Programmiersprache die von Sun Microsystems entwickelt wurde und die sich seit Mitte der 90er Jahre vor allem im Internet rasant ausgebreitet hat. Optisch erinnert Java stark an C++, was nicht zuletzt daran liegt, dass große Teile der Funktionalität und Syntax von dieser Programmiersprache übernommen wurden. Der Hauptunterschied zu C++ (und anderen objektorientierten Sprachen) und zugleich der Hauptgrund für den Erfolg von Java ist die Plattformunabhängigkeit, d. h. Java-Programme laufen auf jedem beliebigen System (unabhängig von dessen Hard- und Softwarearchitektur) auf dem eine Java Runtime Environment (JRE) installiert ist. Die JRE besteht aus zwei Komponenten: Der sogenannten Virtual Machine (VM) und der Java-API. Die VM ist der Grund für Plattformunabhängigkeit von Java und man kann sie sich gut als simulierten Computer vorstellen, auf dem die eigentlichen Java-Programme ausgeführt werden – da auf jedem System der gleiche Computer simuliert wird, spielt die Hard- und Softwareumgebung des eigentlichen Systems keine Rolle. Die Java-API ist eine Bibliothek die umfangreiche Softwarekomponenten bereitstellt, deren Funktionalität bequem in ein Java-Programm eingebunden werden kann.
Um eigene Java-Programme schreiben zu können benötigt man darüberhinaus ein Java Development Kit (JDK), eine Entwicklungsumgebung die kostenlos bei Sun Microsystems heruntergeladen werden kann und die - unter anderem – den Compiler Javac enthält und einen beliebigen Editor. Mit dem Editor kann man nun ein Programm schreiben und mit der Erweiterung java abspeichern (spezielle Java-Editoren erledigen das automatisch). Die so erhaltene Datei datei.java enthält den Quellcode, der durch den Compiler in Bytecode umgewandelt werden kann – dazu gibt man einfach javac datei.java in der Kommandozeile ein. Der Befehl javac ruft den Java-Compiler auf, datei.java sagt dem Compiler welche Datei er von Quellcode in Bytecode compilieren soll. Sollte der Quellcode fehlerfrei sein erhält man als Ergebnis eine Datei namens datei.class im selben Verzeichnis.
Java kennt zwei Arten von Programmen: Applikationen und Applets. Applikationen sind lauffähige Anwendungen die mit einem Interpreter ausgeführt werden und z. B. über die Kommandozeile aufgerufen werden können.
Applets sind Anwendungen die beispielsweise in eine Website eingebettet wurden und nur mittels eines Browsers ausgeführt werden können. Obwohl Applets vermutlich die verbreitetste Form von Java-Anwendungen sind, werden in diesem Text ausschließlich Applikationen behandelt – da es hier nur um die Java Grundlagen geht.
Wenn wir also davon ausgehen das es sich bei datei.java um eine Applikation handelt, erhalten wir mit datei.class eine ausführbare Bytecode-Datei, die sich mit dem Befehl java datei ganz einfach starten lässt.
Sehen wir uns nun den typischen Aufbau einer Java-Anwendung, anhand des gängigen Hello World Programms, an:


classHelloWorld
{
public static void main (String[]args)
{
System.out.println(“Hello World!“);
}
}


Der obere Quellcode ist das denkbar einfachste Beispiel für eine Java-Anwendung, zeigt jedoch deutlich das ein Java-Programm aus mindestens einer Klasse besteht, gibt es nur eine Klasse muss diese mindestens die Methode main enthalten.
Die Definition einer Klasse beginnt mit dem Schlüsselwort class, gefolgt von dem Namen (im oberen Fall HelloWorld) und dem eigentlichen Inhalt der Klasse, der von geschweiften Klammern umrahmt wird. Diese Klasse enthält lediglich die Methode main, die nach dem starten einer Anwendung immer als erstes aufgerufen wird und daher unabdingbar für eine Applikation ist. Die Methode main wird von den Schlüsselwörtern public, static und void eingeleitet, deren genaue Bedeutung an dieser Stelle nicht so wichtig ist, kurz gesagt gibt public an welche Programmteile auf die Funktion zugreifen dürfen, static sagt aus das die Methode Teil einer Klasse und keines Objekts ist und void zeigt an das die Methode keinen Wert zurückgibt. Der Ausdruck in den runden Klammern (String[]args) braucht uns hier ebenfalls nicht zu interessieren – es sei lediglich gesagt das damit ein Feld (Array) namens args für Zeichenketten (Strings) definiert wird. Genau wie bei der Klasse befindet sich der eigentliche Inhalt der Methode innerhalb der geschweiften Klammern. In Java dienen geschweifte Klammern grundsätzlich dazu Anweisungen zu einem Block zusammenzufassen. Einzelne Anweisungen (wie z. B. das >>System.out.println(“Hello World!“;<<) beendet man in Java für gewöhnlich mit einem Semikolon. Gibt man diese Zeilen nun mit einem Editor ein und speichert sie unter HelloWorld.java, kann man mit javac HelloWorld.java die Bytecode-Datei HelloWorld.class erzeugen, die sich wiederum mit java HelloWorld ausführen lässt – als Ergebnis würde das Programm den Text Hello World! auf dem Bildschirm ausgeben und dann beendet werden.


1.1 Namenskonventionen


Namenskonventionen dienen dazu Programme lesbarer zu machen und somit Programmierern auch das arbeiten mit fremden Quellcode zu erleichtern. Prinzipiell sollten immer aussagekräftige und eindeutige Namen verwendet werden, darüberhinaus gelten in Java folgende Konventionen:


Klassen
Klassennamen repräsentieren Objekte und sollten daher Nomen sein, die aus Groß- und Kleinbuchstaben bestehen sollten, wobei jeweils nur der erste Buchstabe eines Wortes groß geschrieben werden sollte.
Beispiel: class Rechner {...} / class TaschenRechner {..}


Methoden
Methoden dienen dazu Objekte Aktionen ausführen zu lassen und sollten daher ein Verb enthalten, sie sollten Groß- und Kleinbuchstaben enthalten, wobei der erste Buchstabe kleingeschrieben und der erste Buchstabe jedes internen Wortes großgeschrieben werden sollte. Methodennamen dürfen auch Nomen und Adjektive enthalten.
Beispiel: public void berechne() / public void hohleZahl()


Interfaces
Wenn das Interface eine Fähigkeit zu Verfügung stellt sollte der Name ein Adjektiv sein und auf -bar (bzw. -able oder -ible in englischer Notation) enden, andernfalls sollte der Name ein Nomen sein. Der erste Buchstabe des Namens, sowie der erste Buchstabe jedes internen Wortes, sollte großgeschrieben werden.
Beispiel: public interface Verschiebbar{...} / public interface SchiebeRegler{...}


Instanzvariablen / statische Variablen
Die Namen von Instanzvariablen / statischen Variablen sollten Nomen sein. Der erste Buchstabe des Namens sollte kleingeschrieben werden, der erste Buchstabe jedes internen Wortes sollte großgeschrieben werden.
Beispiel: private string name; / private string strassenName;


Parameter / lokale Variablen
Die Namen von Parametern und lokalen Variablen sollten kurze Wörter oder aussagekräftige Abkürzungen oder Akronyme sein. Der erste Buchstabe des Namens sollte kleingeschrieben, der erste jedes internen Namens sollte großgeschrieben werden.
Beispiel: int zahl; / int hoechsteZahl;


Konstanten
Namen von Konstanten sollten komplett großgeschrieben, mehre Wörter durch Unterstriche getrennt werden.
Beispiel: final int ZAHL=100; / final int ZAHL_MAX=1000;


Pakete
Der Name eines Paketes (Package) sollte eindeutig sein und nur aus Kleinbuchstaben bestehen, mehrere Wörter können mit Unterstrichen getrennt werden.
Beispiel: package rechner / package taschen_rechner


Akronyme
Wenn in Namen Akronyme verwendet werden, sollte nur der erste Buchstabe des Akronyms großgeschrieben werden.
Beispiel: pruefeGpsKoordinaten();


1.2 Operatoren


Java kennt folgende Operatoren:


Mathematische Operatoren:
+ Addition
- Subtraktion
* Multiplikation
/ Division
% Modulo
Mathematische Berechnungen für die kein Operator zu Verfügung, wie z B. Potenzrechnung und Winkelfunktionen, werden mit Methoden der Klasse java.lang.Math erledigt, die Teil der Java-API ist. Um diese Methoden in einem eigenen Programm nutzen zu können muss man diese Klasse lediglich importieren.


Vergleichs- & Gleichheitsoperatoren:
< kleiner als
> größer als
<= kleiner oder gleich
>= größer oder gleich
== gleich
!= ungleich
instanceof Typenvergleich


Logische Operatoren:
! NICHT
&& UND
|| ODER


1.3 Kommentare


Kommentare dienen dazu ein Programm verständlicher zu machen, gerade längere Programme werden schnell unübersichtlich, deshalb kann man mit Kommentaren die Funktion einzelner Programmteile erklären. Kommentare werden vom Compiler ignoriert und tauchen lediglich im Quellcode auf. Java kennt zwei Arten von Kommentaren:
Einzeilige Kommentare, die von zwei Schrägstrichen eingeleitet werden und Mehrzeilige Kommentare die mit einem Schrägstrich und einem Stern eingeleitet und mit einem Stern und einem Schrägstrich beendet werden
//Dies ist ein einzeiliger Kommentar


/* Und dies ist ein
* mehrzeiliger Kommentar */


Anmerkung: Kommentare sind wirklich sehr nützlich und es lohnt sich Kommentare möglichst exzessiv zu verwenden!


2 – Datentypen


Wie alle Programmiersprachen wird Java erst dadurch zu einem mächtigen und nützlichen Werkzeug, dass sie uns erlaubt die verschiedensten Daten zu verarbeiten und mit ihnen die unterschiedlichsten Operationen durchzuführen. Zu diesem Zweck stellt Java dem Programmierer unterschiedliche Datentypen mit jeweils unterschiedlichen Eigenschaften und Wertbereichen zu Verfügung.


2.1 primitive Datentypen


Typ Bit Wertebereich
boolean 1 false / true
byte 8 -128 / 127
short 16 -32.768 / 32.767
int 32 -2.147.483.648 / 2.147.483.647
long 64 -9.223.372.036.854.755.808 / 9.223.372.036.854.755.807
char 16 0 / 65.535 (Unicode)


Fließkomma-Datentypen


Typ Größe Genauigkeit
float 32Bit 6-7 Stellen
double 64Bit 15-16 Stellen


Primitive Datentypen sind in Java Variablen die, wie in der Mathematik, als Platzhalter verwendet werden. Man unterscheidet lokale Variablen, die nur für eine Methode oder einen Anweisungsblock definiert sind und auch nur dort gültig sind, und Instanzvariablen, die auf Klassen-Ebene definiert werden und innerhalb der ganzen Klasse gültig sind.
In Java werden Variablen deklariert indem man erst ihren Typ angibt und ihr dann einen eindeutigen Namen oder Bezeichner zuweist.
Beispiel: int zahl;
Werden mehrere Variablen des gleichen Typs deklariert ist es zulässig die Namen, durch Kommatas getrennt, hintereinander aufzuführen.
Beispiel: int zahl1, zahl2, zahl2;


Die Wertzuweisung (Initalisierung) erfolgt in Java mit einem Gleichheitszeichen.
Beispiel: zahl=1;
Natürlich ist es zulässig (und in der Regel empfehlenswert) die Deklaration und die Initialisierung in einer Zeile zusammenzufassen.
Beispiel: int zahl=1;
Bei der Initialisierung von Variablen des Typs char muss der Wert von Hochkommatas umrahmt werden.
Beispiel: char zahl='1';
Anmerkung:
Instanzvariablen wird in Java automatisch der Default-Wert null zugewiesen und können daher verwendet werden ohne das der Programmierer sie selbst initialisiert. Lokale Variablen haben keinen Default-Wert und müssen daher immer vor der Verwendung vom Programmierer initalisiert werden, da sonst ein Compiler-Fehler produziert wird.


2.2 Datenklassen


2.2.1 Zeichenketten (Strings)


Zeichenketten oder Strings sind in Java Objekte, d. h. ein besonderer Speicherbereich im Programm der Daten und vielfältige Methoden zu deren Bearbeitung enthält. Java kennt zwei unterschiedliche Klassen von Strings: Die Klasse String und die Klasse StringBuffer.
Objekte der Klasse String sind nur bedingt veränderbar und stellen Zeichenketten einer festen Länge dar. Die Methoden dieser Klasse dienen hauptsächlich dem Vergleich von Zeichenketten, einige bilden aber auch Teilketten oder permutieren Zeichen – solche Methoden erzeugen immer neue Objekte, das Original wird nicht manipuliert.
Objekte der Klasse StringBuffer ermöglichen es die Zeichenkette zur Laufzeit des Programms auf vielfältige Art zu manipulieren. Die Methoden dieser Klasse dienen hauptsächlich dem Anhängen oder Einfügen von Text – wobei der benötigte Speicherplatz automatisch der Größe angepasst wird.
Objekte der Klassen String und StringBuffer lassen sich in Java wie primitive Datentypen deklarieren, indem zuerst der Typ und dann ein Name/Bezeichner angegeben wird.
Beispiel: String name; / StringBuffer name;
Die Initialisierung erfolgt ebenfalls mittels eines Gleichheitszeichens wobei die Zeichenkette jedoch von Anführungszeichen umrahmt werden muss.
Beispiel: String name=“Max Mustermann“; / StringBuffer name=“Max Mustermann“;
Da es sich bei Zeichenketten vom Typ String oder StringBuffer jedoch um Objekte handelt können sie auch durch einen Konstruktor mit Hilfe des Schlüsselwortes new erzeugt und initalisiert werden.
Beispiel: String name=new String(“Max Mustermann“);


2.2.2 Felder (Arrays)


Datenfelder oder Arrays sind in Java ebenfalls Objekte und dienen dazu viele Daten des selben Typs unter einem Namen zu speichern. Felder werden in Java ganz ähnlich wie primitive Datentypen deklariert in dem man erst ihren Typ und dann einen Namen/Bezeichner angibt – der einzige Unterschied ist das nach dem Typ leere eckige Klammern erscheinen.
Beispiel: int[] monat;
Anmerkung: Die eckigen Klammern „verraten“ dem Compiler das es sich bei dem Objekt um ein Feld vom angegeben Typ handelt. Theoretisch können die Klammern auch nach dem Namen/Bezeichner erscheinen, die oben gezeigte Schreibweise ist jedoch die in Java übliche Schreibweise.
Als Objekt muß ein Feld erst mittels eines Konstruktors angelegt werden, bevor man es mit Daten initialisieren kann.
Beispiel: monat=new int[31];
In diesem Beispiel wird ein Feld vom Typ int erzeugt, das Speicherplatz für 31 Variablen bietet. Der Wert in den eckigen Klammern wird als Index bezeichnet und gibt an wieviele Variablen ein Feld aufnehmen kann, gleichzeitig dient der Index dazu einzelne „Fächer“ des Feldes gezielt anzusprechen.
Natürlich ist es ebenfalls möglich die Deklaration und die Erzeugung des Feldes in einer Zeile zusammenzufassen.
Beispiel: int[] monat=new int[31];
Ebenso ist es möglich auf das Schlüsselwort new zu verzichten und das Feld direkt zu initalisieren.
Beispiel: int[] beispiel={1, 2, 3, 4, 5};
Diese Codezeile würde ein Feld namens beispiel erzeugen, das fünf (Anzahl der Werte in den geschweiften Klammern!) Variablen speichern kann und die „Fächer“ mit den Werten aus den geschweiften Klammern initalisieren.
Felder können in Java natürlich auch mehrdimensional sein dazu muss man bei der Deklaration nur für jede gewünschte Dimension ein Paar eckiger Klammern hinzufügen, da natürlich jede Dimension über einen eigenen Index verfügen muss – und selbstverständlich muss bei der Erzeugung des Objekts jeder Dimension eine feste Index-Länge zugewiesen werden.
Beispiel: int[][][] beispiel=new int[5][10][15];
Anmerkung: Wurde ein Feld einmal erzeugt ist die Index-Länge des Feldes eine feste Größe und kann nicht mehr verändert werden. Außerdem beginnt der Index in Java mit 0, also verfügt ein Feld int[3] über drei „Fächer“ die mit [0], [1] und [2] angesprochen werden können. Der Versuch auf ein ungültiges „Fach“ zuzugreifen produziert eine IndexOutOfBound-Fehlermeldung.



2.3 Referenztypen


Java kennt eine unendliche Anzahl von Referenztypen, da Referenztypen vom Programmierer definiert werden. Man nennt diesen Typ Referenztyp da nicht der eigentliche Inhalt, sondern eine Referenz auf die Daten gespeichert wird.


3 – Kontrollstrukturen


Die wichtigsten Werkzeuge des Programmierers sind die Kontrollstrukturen, die den Ablauf eines Programms steuern und praktisch in jeder Programmiersprache gleich sind. Daher stellt der folgende Teil lediglich die in Java verwendete Syntax der Kontrollstrukturen vor.


3.1 Bedingte Anweisungen


If-Anweisung
Die einfachste Form der Programmsteuerung sind bedingte Anweisungen, bei denen ein logischer Ausdruck ausgewertet wird und, je nach Ergebnis, ein bestimmter Anweisungsblock ausgeführt wird.
Syntax: if (ausdruck)
{anweisungen1;}
else
{anweisungen2;}
Anmerkung: Bei der if-Anweisung muss der Ausdruck immer vom Typ boolean sein, ergibt die Auswertung true werden die Anweisungen nach dem if ausgeführt, ergibt die Auswertung false werden die Anweisungen hinter dem else ausgeführt. Man kann eine if-Anweisung auch ohne einen else-Zweig schreiben, in diesem Fall wird bei false die Anweisung des if-Blockes übersprungen und das Programm hinter der geschweiften Klammer fortgesetzt.


else if
Die else if-Anweisung ist eine Erweiterung der if-Anweisung, mit der eine Kette von Abfragen aufgebaut werden kann.
Syntax: if (ausdruck1)
{anweisungen1;}
else if (ausdruck2)
{anweisungen2;}
else if (ausdruck3)
{anweisungen3;}
else
{anweisungen4;}
Anmerkung: Wie bei der gewöhnlichen if-Anweisung muß auch hier jeder Ausdruck vom Typ boolean sein, ergibt keine Prüfung der logischen Ausdrücke ein true wird die Anweisungen hinter dem else ausgeführt. Anstelle einer solch verschachtelten bedingten Anweisung benutz man in der Praxis jedoch häufig lieber eine switch-Anweisung.


3.2 Schleifen


for-Schleife
Schleifen (auch Iterationen genannt) sind Kontrollstrukturen die es ermöglichen einen Programmteil mehrmals auszuführen, die einfachste Form der Schleife ist die for-Schleife – eine sogenannte Zählschleife.
Syntax: for (startwert; bedingung; schrittweite)
{anweisungen;}
Anmerkung: Bei der for-Schleife muß der Programmierer vorher wissen wie oft die Schleife durchlaufen werden soll. Die genaue Anzahl der Durchläufe (Iterationen) wird in der runden Klammer wie folgt festgelegt: Zuerst wird eine Variable startwert initialisiert, dann wird mit der bedingung ein logischer Ausdruck vom Typ boolean überprüft und zuletzt legt schrittweite fest um welchen wert startwert erhöht, bzw. verringert wird. Die Schleife (und damit der Anweisungsblock innerhalb der geschweiften Klammern) wird solange durchlaufen bis die Auswertung von bedingung ein true ergibt. Beispiel: for (int i=0; i=10; i++)

while-Schleife
Die while-Schleife ist eine Bedingungsschleife die dafür sorgt das ein Programmteil solange ausgeführt wird, bis eine bestimmte Bedingung nicht mehr erfüllt ist.
Syntax: while (ausdruck)
{anweisung;}
Anmerkung: Auch hier muß der ausdruck vom Typ boolean sein, ergibt die Prüfung ein true wird die anweisung ausgeführt – bei false wird das Programm hinter der geschweiften Klammer fortgesetzt. Ergibt ausdruck von Anfang an ein false wird die Schleife gar nicht ausgeführt! Um keine Endlos-Schleife zu produzieren muß der Programmierer dafür sorgen das ausdruck schließlich false wird.


do-Schleife
Die do-Schleife ist eng mit der while-Schleife verwandt.
Syntax: do {anweisung;}
while (ausdruck)
Anmerkung: Der einzige Unterschied zur while-Schleife liegt im Zeitpunkt der Prüfung des ausdruck. Bei der do-Schleife wird der Ausdruck erst nach dem Anweisungsblock geprüft – die Schleife wird also auf jeden Fall mindestens einmal durchlaufen! Auch hier ist es natürlich die Verantwortung des Programmierers keine Endlosschleife zu produzieren.


3.3 Mehrfach-Verzweigungen


switch-Anweisung
Die switch-Anweisung funktioniert ähnlich wie die else if-Anweisung ist aber übersichtlicher.
Syntax: switch (ausdruck)
{case konstante1:
anweisung1;
break;
case konstante2:
anweisung2;
break;
default:
anweisung3;
}
Anmerkung: Zuerst wird der ausdruck hinter dem switch ausgewertet – der vom Typ char, byte, short oder int sein muß – und mit den konstanten hinter den case-Anwesiungen verglichen. Bei einer Übereinstimmung wird der betreffende Anweisungsblock ausgeführt – gibt es keine Übereinstimmungen wird der Anweisungsblock hinter dem default ausgeführt. Die break-Anweisungen unterbricht die Ausführung und läßt das Programm hinter die switch-Anweisung springen.


4 – Klassen & Objekte


Eine der größten Stärken von Java (bzw. von objektorientierten Programmiersprachen) ist das Konzept des Objekts. Doch was ist so ein Objekt überhaupt? Vereinfacht gesagt ist ein Objekt eine Variable – allerdings die Deluxe-Version einer Variable. Eine gewöhnliche Variable besteht aus ihrem Namen/Bezeichner und ihrem Inhalt. In einer Variablen vom Typ int kann man beispielsweise Integer-Daten speichern und später über den Namen/Bezeichner wieder ansprechen und verarbeiten. Ein Objekt hingegen kann viele Datenfelder, auch unterschiedlichen Typs, enthalten und darüberhinaus auch Methoden, die auf diese Daten zugreifen können. Den Bauplan eines Objekts liefert dabei die Klasse, die das betreffende Objekt instanziert. Eine Klasse ist also eine Art Schablone mit deren Hilfe man beliebig viele Objekte (in diesem Zusammenhang wird häufig auch der Begriff Instanz synonym für Objekt verwendet) erzeugen kann.


4.1 Klassen definieren


Bereits bei den Grundlagen haben wir einen kurzen Blick auf den Aufbau einer Klasse geworfen, nun wird es Zeit sich etwas näher mit der Klassendefinition zu beschäftigen. Die korrekte Syntax zum erstellen einer Klasse lautet:


Syntax:
[Modifizierer] class Klassenname
{
Datenfelder;
Konstruktoren;
Methoden;
}


Modifizierer
Einer der Aspekte bei der Entwicklung von Java war die Sicherheit, zu diesem Zweck erlaubt Java die sogenannte Kapselung von Daten mit der diese Daten vor unerlaubten Zugriff geschützt werden können. Eine Möglichkeit dazu besteht darin Teile von Objekten mit bestimmten Schlüsselwörtern, den sicherheitsrelevanten Modifizieren, zu versehen. Java kennt drei solcher sicherheitsrelevanten Modifizierer: public, private und protected.
public: Wird ein Programmteil mit dem Modifizierer public versehen, dürfen alle Objekte darauf zugreifen.
private: Wird ein Programmteil mit dem Modifizierer private versehen, dürfen nur Objekte der selben Klasse darauf zugreifen.
protected: Wird ein Programmteil mit dem Schüsselwort protected versehen, dürfen auch Objekte anderer Klassen darauf zugreifen, aber nur wenn diese Klassen von dieser Klasse abgeleitet wurden oder sich im gleichen Paket befinden.
Anmerkung: In der Regel ist es sinnvoll die Datenfelder einer Klase als private (oder protected) zu deklarieren und die Methoden als public.


Datenfelder
Datenfelder (manchmal auch als Attribute bezeichnet) enthalten die Daten einer Klasse, also Variablen, Strings und Arrays die von der Klasse benötigt werden. Bei den Datenfeldern handelt es sich also um das „Wissen“ einer Klasse. In Java hat es sich eingebürgert die Daten zu Beginn der Klasse zu deklarieren. Datenfelder können mit dem Modifizierer static auch als Klassenattribut deklariert werden, solche Klassenattribute werden nur an einer Stelle initalisiert und sind für die ganze Klasse gültig.


Konstruktoren
Konstruktoren dienen dazu aus dem Bauplan der Klasse Objekte zu erzeugen (instanzieren) und werden grundsätzlich über das Schlüsselwort new aufgerufen. Das Ergebnis eines solchen Aufrufs ist immer eine Referenz auf ein neues Objekt. Es hat sich in Java eingebürgert die Konstruktoren nach den Datenfeldern zu definieren.
Syntax:
Klassenname objektname=new Klassenname();
Beispiel: Monat januar=new Monat();
Das obere Beispiel würde ein neues Objekt namens januar aus der Klass Monat erzeugen.
Natürlich ist es auch möglich dem Objekt direkt bei der Erzeugung einen Wert (Parameter) mitzugeben.
Beispiel: Monat januar=new Monat(31);
Anmerkung: Wenn der Programmierer keinen Konstruktor definiert, erzeugt der Compiler einen parameterlosen Standardkonstruktor.


Methoden
Methoden dienen dazu die Daten der Datenfelder zu bearbeiten und stellen somit das „Können“ einer Klasse dar. Es hat sich in Java eingebürgert die Methoden nach den Konstruktoren zu definieren.
Syntax:
[Modifizierer] [Typ] Methodenname (Parameter)
{
Anweisungen;
}


Modifizierer
Wie eine Klasse kann eine Methode als public, private oder protected deklariert werden. Ein weiterer Modifizierer ist das Schlüsselwort static das eine Methode zur Klassenmethode deklariert, solche Methoden dienen dazu auf statische Datenfelder zuzugreifen, d. h. Datenfelder deren Initialisierung nur einer Stelle erfolgt und für die ganze Klasse gültig ist.


Typ
Wenn eine Methode keinen Wert zurück gibt ist sie vom Typ void. Ansonsten hat die Methode den selben Typ wie der Wert den sie zurückgibt. Gibt eine Methode z. B. einen String zurück ist sie vom Typ String (und muss auch so deklariert werden!).


Parameter
Innerhalb der runden Klammern kann man einer Methode Parameter mitgeben, also Werte die von der Methode bearbeitet werden können. Diese Parameterliste bezeichnet man auch als Signatur. Gibt man einer Methode einen Parameter mit, so wird in der runden Klammer erst sein Typ und dann sein Name/Bezeichner angegeben. Wenn man einer Methode keinen Parameter mitgeben will lässt man die runden Klammern leer.
Beispiel: rechnen() {Anweisungen;} / rechnen (int zahl) {Anweisungen;}
Anmerkung: Java erlaubt es das mehre Methoden (und Konstruktoren) einer Klasse den gleichen Namen tragen, solange sich die Signatur (also die Parameter) unterscheiden, diesen Vorgang nennt man überladen.


4.2 Vererbung


Ein wichtiger Aspekt objektorientierter Programmiersprachen ist die sogenannte Vererbung. Der Gedanke hinter der Vererbung ist, das es nicht nötig ist das Rad jedesmal neu zu erfinden, sondern bedeutend sinnvoller ist bestehenden Programmcode wiederzuverwenden. Vererbung erlaubt es bereits bestehenden Programmcode zu verwenden und den eigenen Bedürfnissen anzupassen, ohne das Original zu beeinflussen. Die Klasse die etwas vererbt nennt man Oberklasse, die davon abgeleitete Klasse konsequenterweise Unterklasse. Eine Unterklasse kann die als public und protected deklarierten Datenfelder und Methoden ihrer Oberklasse erben, nicht aber die als private deklarierten. Das Schlüsselwort extends zeigt an das eine Klasse Datenfelder und Methoden von einer Oberklasse erbt.
Syntax: public class Unterklasse extends Oberklasse
{
Datenfelder;
Konstruktoren;
Methoden;
}
Anmerkung: Java erlaubt es in Unterklassen bestehende Methoden der Oberklasse zu ändern, diesen Vorgang nennt man Überschreiben. Zum Überschreiben einer Methode definiert man in der Unterklasse eine Methode mit exakt der gleichen Signatur (Name und Parameter) wie in der Oberklasse, die sich jedoch bei den Anweisungen von der ursprünglichen Methode unterscheidet.


4.3 Interfaces


Bei einem Interface handelt es sich um die Schnittstelle einer Klasse zu ihrer Umgebung, sie beinhalten einen Satz als public deklarierter Methoden ohne jedoch deren Funktionalität zu definieren - eine Klasse die ein Interface beinhaltet muss also auch die korrekte Definition der Methoden enthalten. Ein Interface ähnelt in seiner Struktur dem Aufbau einer Klasse, mit dem Unterschied das es mit dem Schlüsselwort interface statt class definiert wird und nur Konstanten anstelle von Variablen enthält, auch sind die Methoden in einem Interface nur deklariert und nicht implementiert. Eine Klasse die ein Interface enthält muss das in ihrer Signatur mit dem Schlüsselwort implements angeben.
Syntax:
interface Name
{
...
}


Anmerkung: Klassen können mehrere Interfaces implementieren und Interfaces können mehrere Interfaces erweitern.
 

w4sp

New member
Wie immer schönes tut :)

#offtopic
Java ist auch eine Insel gibts als openbook?? Und ich blätter 50€ dafür hin..

Gesendet von meinem ST21i mit Tapatalk 2
 

ikkebins

Stammuser
Wenn man die Openbooks bei Galileo Computing regelmäßig ließt, sollte man dem Autor auch die 50 € gönnen.
 

chr0n0s

Stammuser
Wenn man die Openbooks bei Galileo Computing regelmäßig ließt, sollte man dem Autor auch die 50 € gönnen.

Wozu? Wenn der Autor und das Verlagshaus am Hungertod nagt, würden die wohl kein Openbook zur Verfügung stellen, oder?!

Ebenfalls steht auch nirgends, das man doch bitte Spenden soll o.ä.! Und es gibt trotzdem genug leute (ich z.Bsp.), welche lieber in gedruckter Form Bücher lesen als Online.

Ich gehe mal nicht davon aus, dass Du Deine komplett "freie" Software auf Deinem PC in irgendeiner Form bezahlt hast.
 
Oben