==Berechnung der Vorzeichenbetragszahlen==

Um eine Dezimalzahl in eine Binärzahl in Vorzeichenbetragsdarstellung zu überführen, muss die Dezimalzahl zunächst in eine Binärzahl umgewandelt werden. Bei der Vorzeichenbetragsdarstellung ist das erste Bit das Vorzeichenbit. Wenn dieses gesetzt ist, dann ist die Binärzahl, die hinter dem ersten Bit steht, negativ, ansonsten ist sie positiv.

==Beispiel==

'''1101 1001''' : Signifikantestes Bit ist 1, also ist die Zahl negativ. '''101 1001''' in Dezimal ist 1 + 8 + 16 + 64 = 89. Die repräsentierte Zahl ist also die -89.

'''0101 1001''' : Signifikantestes Bit ist 0, also ist die Zahl positiv. '''101 1001''' ist wie oben 89. Die Repräsentierte Zahl ist also die 89.

Hauer: /* Beispiel */

Call by Reference

2016-09-26T16:02:34Z

Hauer:

Methode

2016-09-26T15:56:22Z

Hauer: /* Parameter */

Eine '''Methode''' definiert ein (Teil-)Programm.

=Unterscheidung Methode und Funktion=

Üblicherweise wird eine Methode von einer '''Funktion''' unterschieden: Eine Methode wird auf einem [[Objekt]] ausgeführt, eine Funktion wird nach Belieben aufgerufen. Bei der Deklaration unterscheidet man zwischen Methode und Funktion nur durch den [[Modifikator]] [[static]].

Eine Funktion wird im '''statischen Kontext''' der [[Klasse]] ausgeführt und hat daher nur Zugriff auf Klassenattribute und lokale Variablen, während eine Methode zusätzlich Zugriff auf Attribute der '''Objektinstanz''' hat.

= Syntaxdiagramm =

[[Datei:method_declaration.png]]

= Deklaration =

==Erläuterung==

Eine (statische) Methode wird innerhalb des Klassenrumpfes mit Angabe der [[Modifikator]]en (''visibility'' und ''functional modifier''), des [[Datentyp|Rückgabetyps]] (''primitive type'' oder ''identifier'') und des Namens (''identifier'') deklariert. Darauf folgen in runden Klammern die Parameter. Danach kommt der eigentliche Rumpf der Methode innerhalb von geschweiften Klammern in Form eines [[Block | Blocks]].

Wird der Modifikator [[abstract]] verwendet, so wird nur die [[Signatur]] der Methode, nicht aber ihr Rumpf angegeben. Die Deklaration wird mit einem Semikolon abgeschlossen.

== Beispiele ==

<source lang="java" title="Beispiel 1">
private static int foo(int bar){
// ... //
}
</source>

Dies ist eine [[privat]]e, [[statisch]]e Methode, die einen [[int]] berechnet, [[foo]] heißt und einen '''int''' namens [[bar]] als Parameter erwartet. Die Methode benötigt eine Implementierung, die hier aber nicht weiter relevant ist.

<source lang="java" title="Beispiel 2">
public abstract double bar(double foo);
</source>

Dies ist eine [[öffentlich]]e, [[abstrakt]]e Methode, die einen [[double]] berechnet, '''bar''' heißt und einen '''double''' namens '''foo''' als Parameter erwartet. Dem Methodenkopf folgt keine Implementierung, da sie als abstrakt deklariert ist und von einer [[Vererbung | erbenden Klasse]] implementiert werden soll.

= Parameter =

Die '''Parameter''' einer Methode sind [[Variable]]n, deren Wert beim '''Aufruf''' der Methode festgelegt werden. Ein '''Parameter''' ist daher immer mit einem Wert initialisiert. Die Übergabe von '''Parametern''' geschieht per [[Call by Value]] bei [[primitiver Datentyp | primitiven Datentypen]], per [[Call by Reference]] bei Objekten.

= Organisation =

Funktionen und Methoden werden hauptsächlich deklariert, um den Quellcode zu strukturieren. Es bietet sich immer an, häufig verwendete Codefragmente als eigene Funktion auszulagern.

Die Funktionalität eines Objektes sollte durch seine verfügbaren Methoden repräsentiert werden. Diese Funktionalitäten sollten relativ einfach formulierbar sein (frei nach dem Motto "Do one thing, and do it well!"<ref>Unix Philosophy</ref>). Meistens beinhalten diese insbesondere die Fähigkeit, Attribute des Objektes zu manipulieren oder in Abhängigkeit von diesen spezielle Aufgaben zu erfüllen.

= Statisch vs. nicht statisch =

Ein [[Java]]-Programm beginnt immer in der [[main]]-Methode im '''statischen''' Kontext. Das heißt die Ausführung des Programms findet nicht innerhalb einer Instanz eines [[Objekt|Objektes]] statt.

Wird auf einem Objekt eine Methode ausgeführt, wechselt das Programm in einen '''nicht statischen''' Kontext, in dem die Ausführung des Programms abhängig vom Zustand des Objektes ist, auf dem die Methode ausgeführt wird.

Innerhalb einer Klasse selbst können aus einem statischen Kontext heraus keine nicht-statischen Methoden aufgerufen oder nicht-statische Attribute manipuliert werden; es ist kein Objekt vorhanden, dass dies machen könnte. Möchte man es trotzdem tun, so muss man aus dem statischen Kontext heraus eine Objektinstanz erstellen und auf dem erstellen Objekt die gewünschte Methode aufrufen. In den meisten Fällen ergibt das jedoch für den Ablauf des Programms keinen Sinn.

In der '''Praxis''' möchte man in der [[Objektorientierte Programmierung|'''objektorientierten Programmierung''']] den Ablauf eines Programms so schnell wie möglich in einen an ein Objekt gebundenen, nicht-statischen Kontext überführen und, außer in Spezialfällen<ref>Verwendung von hilfreichen Funktionen, die keinen Objektzustand benötigen und keinen neuen erzeugen, wie z.B. mathematische Funktionen wie <code>cos</code>. Diese berechnen meist eine einfache Funktion und geben einen Wert zurück, ohne den Zustand des Programmes in irgendeiner Weise zu beeinflussen.</ref>, in diesem verbleiben.

= Rückgabe =

==Erläuterung==

Der von einer Methode berechnete Wert wird als ihr '''zurückgegebener Wert''' bezeichnet. Der Programmfluss kehrt sozusagen nach dem Aufruf der Methode mit ihrem Wert in die Programmzeile zurück, in der sie aufgerufen wurde.

Im Quellcode wird das '''Ergebnis''' der Berechnung mit dem [[Schlüsselwort]] '''return''' (engl. ''zurückgeben/zurückkehren'') gekennzeichnet. Hinter dem Schlüsselwort wird der Term notiert, der das Ergebnis beschreiben soll.

Egal auf welche Art und Weise eine Methode terminiert, als letzte Anweisung muss ein Wert zurückgegeben werden. Das heißt, die letzte Anweisung muss immer ein '''return''' sein. Ansonsten ist die Methode unvollständig und wird vom Compiler nicht akzeptiert.

Die einzige Ausnahme hierzu sind Methoden mit dem '''Rückgabetyp''' [[void]]. Sie werden auch häufig als '''Prozeduren''' bezeichnet. Prozeduren berechnen keine Ergebnisse und müssen daher auch keine Werte zurückgeben. Mit einem einzelnen '''return''' als Anweisung kann die Ausführung der Prozedur jedoch vor Erreichen der letzten Anweisung beendet werden und zum Aufrufer zurückkehren.

Ein Beispiel für eine Methode mit diesem Rückgabetyp ist die [[main]]-Methode.

== Beispiele ==

<source lang="java" title="Normale Rückgabe">
public int average(int x, int y){
return (x + y) / 2; // Gibt das Ergebnis zurück.
}
</source>

<source lang="java" title="Vorzeitiger Abbruch">
public void printIfPositive(int x){
if(x < 0) return; // Bricht die Ausführung der Prozedur vorzeitig ab, wenn x kleiner 0 ist.
System.out.println(x);
}
</source>

== Negativbeispiel ==

<source lang="java">
/**
* Soll zwei Zahlen miteinander dividieren,
* solange der Nenner y ungleich 0 ist.
*/
public double div(int x, int y){
if(y != 0) return (double) x / (double) y;
}
</source>
Hier liegt ein Syntaxfehler vor, da die Methode für den Fall ''y ist 0'' keinen Wert zurückgibt.

= Fußnoten =
<references />

Methode

2016-09-26T15:56:02Z

Hauer: /* Parameter */

Eine '''Methode''' definiert ein (Teil-)Programm.

=Unterscheidung Methode und Funktion=

Üblicherweise wird eine Methode von einer '''Funktion''' unterschieden: Eine Methode wird auf einem [[Objekt]] ausgeführt, eine Funktion wird nach Belieben aufgerufen. Bei der Deklaration unterscheidet man zwischen Methode und Funktion nur durch den [[Modifikator]] [[static]].

Eine Funktion wird im '''statischen Kontext''' der [[Klasse]] ausgeführt und hat daher nur Zugriff auf Klassenattribute und lokale Variablen, während eine Methode zusätzlich Zugriff auf Attribute der '''Objektinstanz''' hat.

= Syntaxdiagramm =

[[Datei:method_declaration.png]]

= Deklaration =

==Erläuterung==

Eine (statische) Methode wird innerhalb des Klassenrumpfes mit Angabe der [[Modifikator]]en (''visibility'' und ''functional modifier''), des [[Datentyp|Rückgabetyps]] (''primitive type'' oder ''identifier'') und des Namens (''identifier'') deklariert. Darauf folgen in runden Klammern die Parameter. Danach kommt der eigentliche Rumpf der Methode innerhalb von geschweiften Klammern in Form eines [[Block | Blocks]].

Wird der Modifikator [[abstract]] verwendet, so wird nur die [[Signatur]] der Methode, nicht aber ihr Rumpf angegeben. Die Deklaration wird mit einem Semikolon abgeschlossen.

== Beispiele ==

<source lang="java" title="Beispiel 1">
private static int foo(int bar){
// ... //
}
</source>

Dies ist eine [[privat]]e, [[statisch]]e Methode, die einen [[int]] berechnet, [[foo]] heißt und einen '''int''' namens [[bar]] als Parameter erwartet. Die Methode benötigt eine Implementierung, die hier aber nicht weiter relevant ist.

<source lang="java" title="Beispiel 2">
public abstract double bar(double foo);
</source>

Dies ist eine [[öffentlich]]e, [[abstrakt]]e Methode, die einen [[double]] berechnet, '''bar''' heißt und einen '''double''' namens '''foo''' als Parameter erwartet. Dem Methodenkopf folgt keine Implementierung, da sie als abstrakt deklariert ist und von einer [[Vererbung | erbenden Klasse]] implementiert werden soll.

= Parameter =

Die '''Parameter''' einer Methode sind [[Variable]]n, deren Wert beim '''Aufruf''' der Methode festgelegt werden. Ein '''Parameter''' ist daher immer mit einem Wert initialisiert. Die Übergabe von '''Parametern''' geschieht per [[Call by Value]] bei [[primitiven Datentypen]], per [[Call by Reference]] bei Objekten.

= Organisation =

Funktionen und Methoden werden hauptsächlich deklariert, um den Quellcode zu strukturieren. Es bietet sich immer an, häufig verwendete Codefragmente als eigene Funktion auszulagern.

Die Funktionalität eines Objektes sollte durch seine verfügbaren Methoden repräsentiert werden. Diese Funktionalitäten sollten relativ einfach formulierbar sein (frei nach dem Motto "Do one thing, and do it well!"<ref>Unix Philosophy</ref>). Meistens beinhalten diese insbesondere die Fähigkeit, Attribute des Objektes zu manipulieren oder in Abhängigkeit von diesen spezielle Aufgaben zu erfüllen.

= Statisch vs. nicht statisch =

Ein [[Java]]-Programm beginnt immer in der [[main]]-Methode im '''statischen''' Kontext. Das heißt die Ausführung des Programms findet nicht innerhalb einer Instanz eines [[Objekt|Objektes]] statt.

Wird auf einem Objekt eine Methode ausgeführt, wechselt das Programm in einen '''nicht statischen''' Kontext, in dem die Ausführung des Programms abhängig vom Zustand des Objektes ist, auf dem die Methode ausgeführt wird.

Innerhalb einer Klasse selbst können aus einem statischen Kontext heraus keine nicht-statischen Methoden aufgerufen oder nicht-statische Attribute manipuliert werden; es ist kein Objekt vorhanden, dass dies machen könnte. Möchte man es trotzdem tun, so muss man aus dem statischen Kontext heraus eine Objektinstanz erstellen und auf dem erstellen Objekt die gewünschte Methode aufrufen. In den meisten Fällen ergibt das jedoch für den Ablauf des Programms keinen Sinn.

In der '''Praxis''' möchte man in der [[Objektorientierte Programmierung|'''objektorientierten Programmierung''']] den Ablauf eines Programms so schnell wie möglich in einen an ein Objekt gebundenen, nicht-statischen Kontext überführen und, außer in Spezialfällen<ref>Verwendung von hilfreichen Funktionen, die keinen Objektzustand benötigen und keinen neuen erzeugen, wie z.B. mathematische Funktionen wie <code>cos</code>. Diese berechnen meist eine einfache Funktion und geben einen Wert zurück, ohne den Zustand des Programmes in irgendeiner Weise zu beeinflussen.</ref>, in diesem verbleiben.

= Rückgabe =

==Erläuterung==

Der von einer Methode berechnete Wert wird als ihr '''zurückgegebener Wert''' bezeichnet. Der Programmfluss kehrt sozusagen nach dem Aufruf der Methode mit ihrem Wert in die Programmzeile zurück, in der sie aufgerufen wurde.

Im Quellcode wird das '''Ergebnis''' der Berechnung mit dem [[Schlüsselwort]] '''return''' (engl. ''zurückgeben/zurückkehren'') gekennzeichnet. Hinter dem Schlüsselwort wird der Term notiert, der das Ergebnis beschreiben soll.

Egal auf welche Art und Weise eine Methode terminiert, als letzte Anweisung muss ein Wert zurückgegeben werden. Das heißt, die letzte Anweisung muss immer ein '''return''' sein. Ansonsten ist die Methode unvollständig und wird vom Compiler nicht akzeptiert.

Die einzige Ausnahme hierzu sind Methoden mit dem '''Rückgabetyp''' [[void]]. Sie werden auch häufig als '''Prozeduren''' bezeichnet. Prozeduren berechnen keine Ergebnisse und müssen daher auch keine Werte zurückgeben. Mit einem einzelnen '''return''' als Anweisung kann die Ausführung der Prozedur jedoch vor Erreichen der letzten Anweisung beendet werden und zum Aufrufer zurückkehren.

Ein Beispiel für eine Methode mit diesem Rückgabetyp ist die [[main]]-Methode.

== Beispiele ==

<source lang="java" title="Normale Rückgabe">
public int average(int x, int y){
return (x + y) / 2; // Gibt das Ergebnis zurück.
}
</source>

<source lang="java" title="Vorzeitiger Abbruch">
public void printIfPositive(int x){
if(x < 0) return; // Bricht die Ausführung der Prozedur vorzeitig ab, wenn x kleiner 0 ist.
System.out.println(x);
}
</source>

== Negativbeispiel ==

<source lang="java">
/**
* Soll zwei Zahlen miteinander dividieren,
* solange der Nenner y ungleich 0 ist.
*/
public double div(int x, int y){
if(y != 0) return (double) x / (double) y;
}
</source>
Hier liegt ein Syntaxfehler vor, da die Methode für den Fall ''y ist 0'' keinen Wert zurückgibt.

= Fußnoten =
<references />

Basisvokabular

2016-09-26T15:54:56Z

Hauer: /* Auflistung */

Auf dieser Seite werden Begriffe erklärt, die häufig in den Artikeln verwendet werden und zum '''Basisvokabular der Informatik''' gehören. Es handelt sich hierbei größtenteils um Begriffe, die keinen eigenen Artikel haben.

Ergänzungen sind erwünscht.

=Auflistung=

*'''äquivalent'''=austauschbar; gleichwertig; eindeutig einander zugeordnet. Das Symbol dafür ist &equiv;. In der [[Boolesche Algebra|Booleschen Algebra]] kann man Äquivalenz daran erkennen, dass zwei Aussagen in jeder möglichen Situation (d.h. Belegung der Variablen) den gleichen Wahrheitsgehalt haben.

*'''arbiträr''' = willkürlich

*'''Ausgabe''' = Text, Bild oder Ton, der dem Benutzer durch ein Programm präsentiert wird. Siehe auch: [[Algorithmus#Rückgabe und Ausgabe | Rückgabe und Ausgabe]]

*'''Deklaration''': Bei der Deklaration wird festgelegt, '''was''' etwas ist. Siehe: [[Deklaration]]

*'''Implementierung''': Die Implementierung sagt aus, '''wie''' etwas funktioniert. Sie ist sozusagen der '''Inhalt''' von z.B. einer [[Methode]].

*'''Initialisierung''': Bei der Initialisierung wird festgelegt, welchen '''Wert''' etwas zu Beginn hat, z.B. bei [[Variablen]].

*'''Instanziierung''': Die Instanziierung beschreibt das Erstellen eines neuen [[Objekt]]es anhand des von einer [[Klasse]] vorgegebenen Bauplans. Man erstellt also eine Instanz der Klasse.

*'''Iteration''' = Durchlauf, wird vor allem im Zusammenhang mit [[Schleifen]] verwendet.

*'''Maschine''': Dieser Begriff umfasst alle nichtmenschlichen Rechner.

*'''Modulo''': Modulo ist ein [[Operator]], der den Rest einer Division berechnet.

*'''Rückgabe''' = Ergebnis der Berechnung einer Methode. Siehe: [[Methode#Rückgabe|Rückgabe]]

*'''terminieren''' = beenden; ein Vorgang hört auf zu arbeiten

*'''Übergabe''' = Aufrufen einer Methode mit angegebenen Werten. Werte werden an Methoden übergeben, die diese benutzen um ein Unterprogramm auszuführen.

Glossar (vorlesungsorientiert)

2016-09-08T15:02:15Z

Hauer: /* 0. Kapitel */

[[Glossar (alphabetisch)]]

=Glossar (vorlesungsorientiert)=

==0. Kapitel==
*[[Informatik]]
* [[Algorithmus]]
* [[Problemklasse]]
* [[Einzelproblem]]
* Verifikation (bzgl. dieser Klassen)
* [[Programmierung]]
* [[Effizienz]]
* Zeitkomplexität
* Raumkomplexität
* Entwurfsmethodik
* [[Syntax_und_Semantik | Syntax]]
* [[Syntax_und_Semantik | Semantik]]
* [https://de.wikipedia.org/wiki/Computer Computer]
* [https://de.wikipedia.org/wiki/Rechner Rechner]
* [[Java]]
* [[Sortieren]]
* [[Suchen]]
* [[Numerik]]
* [[Imperative Programmierung]]
* [[Objektorientierte Programmierung]]

==1. Kapitel==
*Rechensysteme
* [[Hardware]]
* [[Software]]
* [[Prozessor | CPU/Prozessor]]
* [[Speicher]]
* [[Eingabe/Ausgabe | E-/A-Medien / I-/O-Medien]]
* [[Virtuelle Maschine]]
* [[Teile und herrsche]]
* [[Betriebssytem]]
* Kommunikationsprotokoll
* Informationsverarbeitung
* Datenverarbeitung
* Repräsentation (von Daten)
* Interpretation
* Abstraktion
* [[Bit]]
* [[Bit | Nibble]]
* [[Bit | Byte]]
* [[Bitfolge]]
* [[Dezimal-_und_Bin%C3%A4rsystem | Binärzahlen]]
* Hexadezimalzahlen
* Texte (Darstellung)
* ASCII
* Unicode
* Quelltext/-code
* [[Compiler]]
* [[Maschinensprache]]
* Rastergrafik
* Vektorgrafik
* [[Bool'sche Algebra]]
* Darstellung natürlicher Zahlen
* Umrechnungsverfahren
* Darstellung ganzer Zahlen
* [[Vorzeichenbetragszahlen]]
* [[Zweierkomplement]]
* Standardformate
* Festpunktzahlen
* Gleitpunktzahlen

==2. Kapitel==
*Spezifikation
* [[Programm]]
*Vorgehensweise (Erstellung eines Programms)
*Problembeschreibung
*Vorbedignung
*Nachbedingung
* [[Algorithmus]] (Definition)
* [[Relation]]
*Kreuzprodukt
*Ein- und Ausgabe
* [[Elementaroperationen]]
*Terminierung
* [[Determinismus]]
*Determiniertheit
*Pseudocode
*Allgemeinheit
*Robustheit
*Einfache Grundoperationen
*Sequentieller Algorithmus
*Nebenläufiger Algorithmus
*Parallele Ausführung
*ggt nach Euklid
* [[Programmiersprache]] / algorithmische Sprache
* [[Programm]]
* [[Programmieren]]
*Programmierparadigma
* [[Imperative Programmierung]]
* [[Funktionale Programmierung]]
* [[Logische Programmierung]]
* [[Objektorientierte Programmierung]]
* [[Syntaxdiagramm]]
*operationale Semantik
*denotationale Semantik
*verbale Semantik

==3.1. Kapitel==
* [[Variable]]
*Deklaration
* [[Datentyp]]
*Initialisierung
* [[Integer]]
* [[Byte]] (Javadatentyp)
* [[Long]]
* [[Short]]
* [[Float]]
* [[Double]]
* [[Ausdruck]]
* [[Rückgabe]]
* [[Methode]]
* [[Zuweisung]]
*Wert
* [[Operator | Kurzformen]] (+=)
*Hilfsvariale
* [[Primitive Datentypen]]
*konstruierter, komplexer Datentyp
* [[Speicheraddresse]]
*Bedeutung Gleichzeichen
* [[Operator | Operation]]
* [[Boolean]]
*[[Operator#Priotitäten von Operatoren | Priotitäten von Operatoren ]]
* [[Char]]
*Konstante
*Steuerzeichen
* [[String]]
* [[new | new-Operator]]
*Streng getypte Sprache
*Typkomplexität
*Implizite Typanpassung

==3.2. Kapitel==
* [[Kontrollstruktur]]
* [[Sequenz]]
* [[Block]]
* [[Bedingte Anweisung]]
* [[Bedinung]]
* [[Fallunterscheidung | switch]]
* [[Schleife | Iteration]]
* [[Schleife]]
* [[while | while-Schleife]]
* [[do | do-while-Schleife]]
* [[for | for-Schleife]]

==3.3. Kaptiel==
*die 3 Teile/Struktur einer Schleife
* [[Schleife#Laufvariable | Laufvariable]]
* [[Schleife | continue]]
* [[Schleife | break]]

==4. Kapitel==
* [[Unterprogramm]]
* [[Funktion]]
* [[Prozedur]]
* [[Rückgabewert]]
* [[Parameter]]
* prozedurale (funkt.) Abstraktion
* [[main | Main-Methode]]
* [[public]]
* [[static]]
* top-down Entwurf
* [[globale Variablen]]
* Kommunikation über Parameter
* Variablenparameter
* Werteparameter
* [[call by value]]
* [[lokale Variable | funktionslokal]]
* [[call by reference]]
* [[Stack | Abarbeitung von Funktionsaufrufen]]
* Verwaltungsinformation
* [[Programmcode]]
* [[Heap]]
* [[Stack]]
* [[Rekursion | Rekursive Funktion]]
* Terminierungsbedingung
* Türme von Hanoi

==5. Kapitel==
* [[Array]]
* [[Datenstruktur]]
* Vektor / Matrix
* Dimensierung
* Zuweisung (Array)
* [[Sortieralgorithmen]]
* Internes Sortieren
* Aufwand
* [[O-Notation]]
* externes Sortieren
* Einfügen
* Verschmelzen
* [[Heapsort]]
* [[binärer Baum]]
* Heapify

==6. Kapitel==
* [[Klasse]]
* [[Objekt]]
* [[Objekt | Instanz]]
* [[Vererbung]]
* [[Interface]]
* [[Programm | Java-Programm]]
* ->Rumpf
* ->Kopf
* Klassendefinition
* Methodendefinition
* [[Attribut]]
* [[Methode]]
* ->Deklaration
* ->Definition
* ->Aufruf
* [[private]]
* [[public]]
* [[main]]
* [[Testklasse]]
* [[Konstruktor]]
* [[Referenzen]]
* Parameterübergabe
* [[Attribut | Klassenatribute/-methoden]]
* [[Überladen]] von Methoden
* [[this]]
* [[Überdecken]] von Attributen

==7. Kapitel==
* [[Vererbung]]
* [[Superklasse]]
* [[Subklasse]]
* Abstraktion
* Spezialisierung
* [[extends]]
* [[protected]]
* [[final]]
* [[abstrakte Methode]]
* [[abstrakte Klasse]]
* [[Polymorphie]]
* Vererbungshierarchie

==8. Kapitel==
*Dynamische Datenstruktur
*Liste
*lineare Liste
*doppeltverkettete Liste
*Bäume
*binärer Suchbaum
*Graph
*ungerichtete Graphen
*gerichtete Graphen
*Stack
*Schlangen (queue)
*Mengen
*null
*Wurzel
*Knoten
*Blatt
*Punkt-Operator
*Vollständige Induktion
*balancierter Baum
*AVL-Baum
*Tiefendurchlauf
*preorder
*inorder
*postorder
*Breitendurchlauf

==weitere Begriffe==
[[Schlüsselwörter]]

==fehlende Begriffe==

Boolesche Algebra

2016-09-07T19:35:53Z

Hauer: /* Disjunktion (OR) */

Die '''boolesche Algebra''' ist eine algebraische Struktur und beschreibt die Operationen '''UND''', '''ODER''' und '''NICHT''', die auf logische Aussagen angewendet werden können. Die Kenntnis dieser Struktur ist hilfreich für den Umgang mit dem [[Datentyp]] [[boolean]].

==Die booleschen Operatoren==

===Konjunktion (AND)===

Die '''Konjunktion''' ist eine der grundlegenden logischen Verknüpfungen der Aussagenlogik. Die Konjunktion zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn ''A'' '''und''' ''B'' (sowohl als auch) wahr sind. Das mathematische Symbol ist '''&and;'''. In [[Java]] wird das '''AND''' durch '''&&''' repräsentiert.
[[Datei:venn_and.png|right]]

{| class = "wikitable" width=50% align="center"
! A !! B !! A &and; B
|-
| ''false'' || ''false'' || ''false''
|-
| ''false'' || ''true'' || ''false''
|-
| ''true'' || ''false'' ||''false''
|-
| ''true'' ||''true'' || ''true''
|}

===Disjunktion (OR)===

Die '''Disjunktion''' ist eine der grundlegenden logischen Verknüpfungen der Aussagenlogik. Die Disjunktion zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn mindestens eine der Aussagen ''A'' '''oder''' ''B'' wahr ist. Das mathematische Symbol ist '''&or;'''. In [[Java]] wird das '''OR''' durch '''||''' repräsentiert.

[[Datei:venn_or.png|right]]

{| class = "wikitable" width=50% align="center"
! A !! B !! A &or; B
|-
| ''false'' || ''false'' || ''false''
|-
| ''false'' || ''true'' || ''true''
|-
| ''true'' || ''false'' ||''true''
|-
| ''true'' ||''true'' || ''true''
|}

''Venn-Diagramm?''

===Negation (NOT)===

Die '''Negation''' ist eine wichtige Operation in der Aussagenlogik. Die Negation einer Aussage ''A'' führt zur ihrer Verneinung. Das heißt aus einer wahren Aussage wird eine falsche Aussage und umgekehrt. Das mathematische Symbol ist '''¬'''. In [[Java]] wird das '''NOT''' durch '''!''' repräsentiert.

{| class = "wikitable" width=50% align="center"
! A !! ¬A
|-
| ''false'' || ''true''
|-
| ''true'' || ''false''
|}

===Kontravalenz (XOR)===

Die '''Kontravalenz''' ist eine erweiterte logische Verknüpfung in der Aussagenlogik. Die Kontravalenz zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn '''entweder''' ''A'' '''oder''' ''B'', aber nicht beide wahr sind. Das mathematische Symbol ist '''⊕'''. In [[Java]] wird das '''XOR''' durch '''^''' repräsentiert.

{| class = "wikitable" width=50% align="center"
! A !! B !! A ⊕ B
|-
| ''false'' || ''false'' || ''false''
|-
| ''false'' || ''true'' || ''true''
|-
| ''true'' || ''false'' ||''true''
|-
| ''true'' ||''true'' || ''false''
|}

''Venn-Diagramm?''

===Implikation===

Die '''Implikation''' ist eine erweiterte logische Verknüpfung in der Aussagenlogik. Die Implikation zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn ''A'' falsch oder ''B'' wahr ist. Das mathematische Symbol ist '''⇒'''. Die Implikation ist semantisch äquivalent zu ¬A &or; B. In [[Java]] gibt es keinen Implikationsoperator.

Eine Implikation wird im Deutschen meistens durch "'''wenn''' ''A'', '''dann''' ''B''" ausgedrückt. Es handelt sich hierbei um eine einfache Folgerung. Aus einer falschen Ausgangsaussage '''A''' lässt sich alles folgern, daher kann die Gesamtaussage nicht falsch werden.

{| class = "wikitable" width=50% align="center"
! A !! B !! A ⇒ B
|-
| ''false'' || ''false'' || ''true''
|-
| ''false'' || ''true'' || ''true''
|-
| ''true'' || ''false'' ||''false''
|-
| ''true'' ||''true'' || ''true''
|}

''Venn-Diagramm?''

===Äquivalenz (XNOR)===

Die '''Äquivalenz''' ist eine erweiterte logische Verknüpfung in der Aussagenlogik. Die Äquivalenz zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn ''A'' und ''B'' wahr oder ''A'' und ''B'' falsch sind. Das mathematische Symbol ist '''⇔'''. Die Äquivalenz ist semantisch äquivalent zu A &and; B &or; ¬A &and; ¬B. In [[Java]] gibt es keinen Operator hierfür.

Die Äquivalenz wird im Deutschen meistens durch "'''genau dann''' ''A'', '''wenn''' ''B''" ausgedrückt. "Genau" heißt immer und nur unter dieser Bedingung. '''A''' gilt genau dann, wenn '''B''' gilt. '''A''' und '''B''' sind äquivalent, also austauschbar. Das heißt die vorherige Aussage gilt auch anders herum: '''B''' gilt genau dann, wenn '''A''' gilt.

{| class = "wikitable" width=50% align="center"
! A !! B !! A ⇔ B
|-
| ''false'' || ''false'' || ''true''
|-
| ''false'' || ''true'' || ''false''
|-
| ''true'' || ''false'' ||''false''
|-
| ''true'' ||''true'' || ''true''
|}

''Venn-Diagramm?''

==Peano-Axiome (erweitertes Wissen)==

===Kommutativgesetze===

(1) ''A'' &and; ''B'' &equiv; ''B'' &and; ''A''

(1') ''A'' &or; ''B'' &equiv; ''B'' &or; ''A''

Das Vertauschen der Argumente ''A'' und ''B'' ist hier möglich, ohne dass sich das Ergebnis der Operation ändert.

===Assoziativgesetze===

(2) (''A'' &and; ''B'') &and; ''C'' &equiv; ''A'' &and; (''B'' &and; ''C'')

(2') (''A'' &or; ''B'') &or; ''C'' &equiv; ''A'' &or; (''B'' &or; ''C'')

Die Klammerung der oben durchgeführten Operationen hat keinen Einfluss auf das Ergebnis.

===Idempotenzgesetze===

(3) ''A'' &and; ''A'' &equiv; ''A''

(3') ''A'' &or; ''A'' &equiv; ''A''

Die Eigenschaften des Arguments ''A'' bleiben bestehen, auch wenn dieses mit sich selbst verknüpft wird.

===Distributivgesetze===

(4) ''A'' &and; (''B'' &or; ''C'') &equiv; (''A'' &and; ''B'') &or; (''A'' &and; ''C'')

(4') ''A'' &or; (''B'' &and; ''C'') &equiv; (''A'' &or; ''B'') &and; (''A'' &or; ''C'')

Auswirkung des Auflösens von Klammern um Verknüpfungen von Operationen; ähnlich dem "Ausmultiplizieren" in der Schulmathematik.

===Neutralitätsgesetze===

(5) ''A'' &and; ''true'' &equiv; ''A''

(5') ''A'' &or; ''false'' &equiv; ''A''

Der Wert des Argumentes ''A'' wird durch die oben ausgeführten Operationen nicht verändert.

===Extremalgesetze===

(6) ''A'' &and; ''false'' &equiv; ''false''

(6') ''A'' &or; ''true'' &equiv; ''true''

Das Ergebnis der oben beschriebenen Operationen ist unabhängig vom Wert des Arguments ''A''.

===Doppelnegationsgesetz===

(7) ¬(¬''A'') &equiv; ''A''

"Doppelte Verneinung": Der Wert von ''A'' wird durch zweimaliges Ausführen des ¬ -Operators nicht beeinflusst.

===De Morgansche Gesetze===

(8) ¬(''A'' &and; ''B'') &equiv; ¬''A'' &or; ¬''B''

(8') ¬(''A'' &or; ''B'') &equiv; ¬''A'' &and; ¬''B''

Alltagsbeispiele:

(8) Peter hat sich einen Tee zubereitet, in dem nicht Zitronensaft und Zucker enthalten sind.
Beschreibe die Boolesche Variable '''A''' den Zustand, dass Zucker im Tee ist und '''B''' den Zustand, dass sich Zitronensaft im Tee befindet. Dann lautet die Antwort auf die Frage, ob Peters Tee Zucker und Zitronensaft (beides auf einmal) beinhaltet (also '''A''' = '''true''' und '''B''' = '''true''':

¬(''A'' &and; ''B'') = ¬(''true'' &and; ''true'') = ¬''true'' =''false''. In Peters Tee ist kein Zitronensaft und Zucker.

Diese Aussage ist äquivalent zu der Aussage "In Peters Tee ist kein Zitronensaft oder kein Zucker" (also mindestens eins von beiden ist nicht enthalten). Das heißt bei gleicher Belegung der Variablen erhält man das gleiche Ergebnis:

¬''A'' &or; ¬''B'' = ¬''true'' &or; ¬''true'' = ''false'' &or; ''false'' = false.

Damit die jeweilige Aussage wahr ist, muss mindestens eine der beiden Zutaten nicht in Peters Tee enthalten sein.

(8') Petras Kaffee enthält nicht Milch oder Zucker. Die Variable '''A''' beschreibe den Zustand, dass der Kaffee Milch enthält und '''B''', dass Zucker enthalten ist. Die Antwort auf die Frage, ob der Kaffee Milch aber keinen Zucker enthält (also '''A''' = '''true''' und '''B''' = '''false''') lautet dementsprechend:

¬(''A'' &or; ''B'') =¬(''true'' &or; ''false'') = ¬''true'' = ''false''. In Petras Kaffee ist weder Milch noch Zucker.

Diese Aussage ist äquivalent zu "Petras Kaffee enthält keine Milch und keinen Zucker." Das heißt bei gleicher Belegung der Variablen kommt das gleiche Ergebnis heraus:

¬''A'' &and; ¬''B'' = ¬''true'' &and; ¬''false'' = ''false'' &and; ''true'' = ''false''.

===Komplementärgesetze===

(9) ''A'' &and; ¬''A'' &equiv; ''false''

(9') ''A'' &or; ¬''A'' &equiv; ''true''

Es können nicht gleichzeitig ''A'' und die Negation von ''A'' gelten: Beispielsweise kann der Himmel nicht gleichzeitig blau und nicht-blau sein (9).
Allerdings ist der Himmel entweder blau oder nicht-blau gefärbt (9').

===Dualitätsgesetze===

(10) ¬false &equiv; true

(10') ¬true &equiv; false

Der Wert '''true''' ist das Komplement zu '''false'''. Ist eine Aussage nicht-wahr, so ist sie falsch. Umgekehrt gilt für eine nicht-falsche Aussage, dass sie wahr sein muss.

Boolesche Algebra

2016-09-07T19:35:45Z

Hauer: /* Disjunktion (OR) */

Die '''boolesche Algebra''' ist eine algebraische Struktur und beschreibt die Operationen '''UND''', '''ODER''' und '''NICHT''', die auf logische Aussagen angewendet werden können. Die Kenntnis dieser Struktur ist hilfreich für den Umgang mit dem [[Datentyp]] [[boolean]].

==Die booleschen Operatoren==

===Konjunktion (AND)===

Die '''Konjunktion''' ist eine der grundlegenden logischen Verknüpfungen der Aussagenlogik. Die Konjunktion zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn ''A'' '''und''' ''B'' (sowohl als auch) wahr sind. Das mathematische Symbol ist '''&and;'''. In [[Java]] wird das '''AND''' durch '''&&''' repräsentiert.
[[Datei:venn_and.png|right]]

{| class = "wikitable" width=50% align="center"
! A !! B !! A &and; B
|-
| ''false'' || ''false'' || ''false''
|-
| ''false'' || ''true'' || ''false''
|-
| ''true'' || ''false'' ||''false''
|-
| ''true'' ||''true'' || ''true''
|}

===Disjunktion (OR)===

Die '''Disjunktion''' ist eine der grundlegenden logischen Verknüpfungen der Aussagenlogik. Die Disjunktion zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn mindestens eine der Aussagen ''A'' '''oder''' ''B'' wahr ist. Das mathematische Symbol ist '''&or;'''. In [[Java]] wird das '''OR''' durch '''||''' repräsentiert.

[[Datei:venn_or.png]]

{| class = "wikitable" width=50% align="center"
! A !! B !! A &or; B
|-
| ''false'' || ''false'' || ''false''
|-
| ''false'' || ''true'' || ''true''
|-
| ''true'' || ''false'' ||''true''
|-
| ''true'' ||''true'' || ''true''
|}

''Venn-Diagramm?''

===Negation (NOT)===

Die '''Negation''' ist eine wichtige Operation in der Aussagenlogik. Die Negation einer Aussage ''A'' führt zur ihrer Verneinung. Das heißt aus einer wahren Aussage wird eine falsche Aussage und umgekehrt. Das mathematische Symbol ist '''¬'''. In [[Java]] wird das '''NOT''' durch '''!''' repräsentiert.

{| class = "wikitable" width=50% align="center"
! A !! ¬A
|-
| ''false'' || ''true''
|-
| ''true'' || ''false''
|}

===Kontravalenz (XOR)===

Die '''Kontravalenz''' ist eine erweiterte logische Verknüpfung in der Aussagenlogik. Die Kontravalenz zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn '''entweder''' ''A'' '''oder''' ''B'', aber nicht beide wahr sind. Das mathematische Symbol ist '''⊕'''. In [[Java]] wird das '''XOR''' durch '''^''' repräsentiert.

{| class = "wikitable" width=50% align="center"
! A !! B !! A ⊕ B
|-
| ''false'' || ''false'' || ''false''
|-
| ''false'' || ''true'' || ''true''
|-
| ''true'' || ''false'' ||''true''
|-
| ''true'' ||''true'' || ''false''
|}

''Venn-Diagramm?''

===Implikation===

Die '''Implikation''' ist eine erweiterte logische Verknüpfung in der Aussagenlogik. Die Implikation zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn ''A'' falsch oder ''B'' wahr ist. Das mathematische Symbol ist '''⇒'''. Die Implikation ist semantisch äquivalent zu ¬A &or; B. In [[Java]] gibt es keinen Implikationsoperator.

Eine Implikation wird im Deutschen meistens durch "'''wenn''' ''A'', '''dann''' ''B''" ausgedrückt. Es handelt sich hierbei um eine einfache Folgerung. Aus einer falschen Ausgangsaussage '''A''' lässt sich alles folgern, daher kann die Gesamtaussage nicht falsch werden.

{| class = "wikitable" width=50% align="center"
! A !! B !! A ⇒ B
|-
| ''false'' || ''false'' || ''true''
|-
| ''false'' || ''true'' || ''true''
|-
| ''true'' || ''false'' ||''false''
|-
| ''true'' ||''true'' || ''true''
|}

''Venn-Diagramm?''

===Äquivalenz (XNOR)===

Die '''Äquivalenz''' ist eine erweiterte logische Verknüpfung in der Aussagenlogik. Die Äquivalenz zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn ''A'' und ''B'' wahr oder ''A'' und ''B'' falsch sind. Das mathematische Symbol ist '''⇔'''. Die Äquivalenz ist semantisch äquivalent zu A &and; B &or; ¬A &and; ¬B. In [[Java]] gibt es keinen Operator hierfür.

Die Äquivalenz wird im Deutschen meistens durch "'''genau dann''' ''A'', '''wenn''' ''B''" ausgedrückt. "Genau" heißt immer und nur unter dieser Bedingung. '''A''' gilt genau dann, wenn '''B''' gilt. '''A''' und '''B''' sind äquivalent, also austauschbar. Das heißt die vorherige Aussage gilt auch anders herum: '''B''' gilt genau dann, wenn '''A''' gilt.

{| class = "wikitable" width=50% align="center"
! A !! B !! A ⇔ B
|-
| ''false'' || ''false'' || ''true''
|-
| ''false'' || ''true'' || ''false''
|-
| ''true'' || ''false'' ||''false''
|-
| ''true'' ||''true'' || ''true''
|}

''Venn-Diagramm?''

==Peano-Axiome (erweitertes Wissen)==

===Kommutativgesetze===

(1) ''A'' &and; ''B'' &equiv; ''B'' &and; ''A''

(1') ''A'' &or; ''B'' &equiv; ''B'' &or; ''A''

Das Vertauschen der Argumente ''A'' und ''B'' ist hier möglich, ohne dass sich das Ergebnis der Operation ändert.

===Assoziativgesetze===

(2) (''A'' &and; ''B'') &and; ''C'' &equiv; ''A'' &and; (''B'' &and; ''C'')

(2') (''A'' &or; ''B'') &or; ''C'' &equiv; ''A'' &or; (''B'' &or; ''C'')

Die Klammerung der oben durchgeführten Operationen hat keinen Einfluss auf das Ergebnis.

===Idempotenzgesetze===

(3) ''A'' &and; ''A'' &equiv; ''A''

(3') ''A'' &or; ''A'' &equiv; ''A''

Die Eigenschaften des Arguments ''A'' bleiben bestehen, auch wenn dieses mit sich selbst verknüpft wird.

===Distributivgesetze===

(4) ''A'' &and; (''B'' &or; ''C'') &equiv; (''A'' &and; ''B'') &or; (''A'' &and; ''C'')

(4') ''A'' &or; (''B'' &and; ''C'') &equiv; (''A'' &or; ''B'') &and; (''A'' &or; ''C'')

Auswirkung des Auflösens von Klammern um Verknüpfungen von Operationen; ähnlich dem "Ausmultiplizieren" in der Schulmathematik.

===Neutralitätsgesetze===

(5) ''A'' &and; ''true'' &equiv; ''A''

(5') ''A'' &or; ''false'' &equiv; ''A''

Der Wert des Argumentes ''A'' wird durch die oben ausgeführten Operationen nicht verändert.

===Extremalgesetze===

(6) ''A'' &and; ''false'' &equiv; ''false''

(6') ''A'' &or; ''true'' &equiv; ''true''

Das Ergebnis der oben beschriebenen Operationen ist unabhängig vom Wert des Arguments ''A''.

===Doppelnegationsgesetz===

(7) ¬(¬''A'') &equiv; ''A''

"Doppelte Verneinung": Der Wert von ''A'' wird durch zweimaliges Ausführen des ¬ -Operators nicht beeinflusst.

===De Morgansche Gesetze===

(8) ¬(''A'' &and; ''B'') &equiv; ¬''A'' &or; ¬''B''

(8') ¬(''A'' &or; ''B'') &equiv; ¬''A'' &and; ¬''B''

Alltagsbeispiele:

(8) Peter hat sich einen Tee zubereitet, in dem nicht Zitronensaft und Zucker enthalten sind.
Beschreibe die Boolesche Variable '''A''' den Zustand, dass Zucker im Tee ist und '''B''' den Zustand, dass sich Zitronensaft im Tee befindet. Dann lautet die Antwort auf die Frage, ob Peters Tee Zucker und Zitronensaft (beides auf einmal) beinhaltet (also '''A''' = '''true''' und '''B''' = '''true''':

¬(''A'' &and; ''B'') = ¬(''true'' &and; ''true'') = ¬''true'' =''false''. In Peters Tee ist kein Zitronensaft und Zucker.

Diese Aussage ist äquivalent zu der Aussage "In Peters Tee ist kein Zitronensaft oder kein Zucker" (also mindestens eins von beiden ist nicht enthalten). Das heißt bei gleicher Belegung der Variablen erhält man das gleiche Ergebnis:

¬''A'' &or; ¬''B'' = ¬''true'' &or; ¬''true'' = ''false'' &or; ''false'' = false.

Damit die jeweilige Aussage wahr ist, muss mindestens eine der beiden Zutaten nicht in Peters Tee enthalten sein.

(8') Petras Kaffee enthält nicht Milch oder Zucker. Die Variable '''A''' beschreibe den Zustand, dass der Kaffee Milch enthält und '''B''', dass Zucker enthalten ist. Die Antwort auf die Frage, ob der Kaffee Milch aber keinen Zucker enthält (also '''A''' = '''true''' und '''B''' = '''false''') lautet dementsprechend:

¬(''A'' &or; ''B'') =¬(''true'' &or; ''false'') = ¬''true'' = ''false''. In Petras Kaffee ist weder Milch noch Zucker.

Diese Aussage ist äquivalent zu "Petras Kaffee enthält keine Milch und keinen Zucker." Das heißt bei gleicher Belegung der Variablen kommt das gleiche Ergebnis heraus:

¬''A'' &and; ¬''B'' = ¬''true'' &and; ¬''false'' = ''false'' &and; ''true'' = ''false''.

===Komplementärgesetze===

(9) ''A'' &and; ¬''A'' &equiv; ''false''

(9') ''A'' &or; ¬''A'' &equiv; ''true''

Es können nicht gleichzeitig ''A'' und die Negation von ''A'' gelten: Beispielsweise kann der Himmel nicht gleichzeitig blau und nicht-blau sein (9).
Allerdings ist der Himmel entweder blau oder nicht-blau gefärbt (9').

===Dualitätsgesetze===

(10) ¬false &equiv; true

(10') ¬true &equiv; false

Der Wert '''true''' ist das Komplement zu '''false'''. Ist eine Aussage nicht-wahr, so ist sie falsch. Umgekehrt gilt für eine nicht-falsche Aussage, dass sie wahr sein muss.

Boolesche Algebra

2016-09-07T19:35:08Z

Hauer: /* Disjunktion (OR) */

Die '''boolesche Algebra''' ist eine algebraische Struktur und beschreibt die Operationen '''UND''', '''ODER''' und '''NICHT''', die auf logische Aussagen angewendet werden können. Die Kenntnis dieser Struktur ist hilfreich für den Umgang mit dem [[Datentyp]] [[boolean]].

==Die booleschen Operatoren==

===Konjunktion (AND)===

Die '''Konjunktion''' ist eine der grundlegenden logischen Verknüpfungen der Aussagenlogik. Die Konjunktion zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn ''A'' '''und''' ''B'' (sowohl als auch) wahr sind. Das mathematische Symbol ist '''&and;'''. In [[Java]] wird das '''AND''' durch '''&&''' repräsentiert.
[[Datei:venn_and.png|right]]

{| class = "wikitable" width=50% align="center"
! A !! B !! A &and; B
|-
| ''false'' || ''false'' || ''false''
|-
| ''false'' || ''true'' || ''false''
|-
| ''true'' || ''false'' ||''false''
|-
| ''true'' ||''true'' || ''true''
|}

===Disjunktion (OR)===

Die '''Disjunktion''' ist eine der grundlegenden logischen Verknüpfungen der Aussagenlogik. Die Disjunktion zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn mindestens eine der Aussagen ''A'' '''oder''' ''B'' wahr ist. Das mathematische Symbol ist '''&or;'''. In [[Java]] wird das '''OR''' durch '''||''' repräsentiert.

[[Datei:OR_VENN.jpg]]

{| class = "wikitable" width=50% align="center"
! A !! B !! A &or; B
|-
| ''false'' || ''false'' || ''false''
|-
| ''false'' || ''true'' || ''true''
|-
| ''true'' || ''false'' ||''true''
|-
| ''true'' ||''true'' || ''true''
|}

''Venn-Diagramm?''

===Negation (NOT)===

Die '''Negation''' ist eine wichtige Operation in der Aussagenlogik. Die Negation einer Aussage ''A'' führt zur ihrer Verneinung. Das heißt aus einer wahren Aussage wird eine falsche Aussage und umgekehrt. Das mathematische Symbol ist '''¬'''. In [[Java]] wird das '''NOT''' durch '''!''' repräsentiert.

{| class = "wikitable" width=50% align="center"
! A !! ¬A
|-
| ''false'' || ''true''
|-
| ''true'' || ''false''
|}

===Kontravalenz (XOR)===

Die '''Kontravalenz''' ist eine erweiterte logische Verknüpfung in der Aussagenlogik. Die Kontravalenz zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn '''entweder''' ''A'' '''oder''' ''B'', aber nicht beide wahr sind. Das mathematische Symbol ist '''⊕'''. In [[Java]] wird das '''XOR''' durch '''^''' repräsentiert.

{| class = "wikitable" width=50% align="center"
! A !! B !! A ⊕ B
|-
| ''false'' || ''false'' || ''false''
|-
| ''false'' || ''true'' || ''true''
|-
| ''true'' || ''false'' ||''true''
|-
| ''true'' ||''true'' || ''false''
|}

''Venn-Diagramm?''

===Implikation===

Die '''Implikation''' ist eine erweiterte logische Verknüpfung in der Aussagenlogik. Die Implikation zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn ''A'' falsch oder ''B'' wahr ist. Das mathematische Symbol ist '''⇒'''. Die Implikation ist semantisch äquivalent zu ¬A &or; B. In [[Java]] gibt es keinen Implikationsoperator.

Eine Implikation wird im Deutschen meistens durch "'''wenn''' ''A'', '''dann''' ''B''" ausgedrückt. Es handelt sich hierbei um eine einfache Folgerung. Aus einer falschen Ausgangsaussage '''A''' lässt sich alles folgern, daher kann die Gesamtaussage nicht falsch werden.

{| class = "wikitable" width=50% align="center"
! A !! B !! A ⇒ B
|-
| ''false'' || ''false'' || ''true''
|-
| ''false'' || ''true'' || ''true''
|-
| ''true'' || ''false'' ||''false''
|-
| ''true'' ||''true'' || ''true''
|}

''Venn-Diagramm?''

===Äquivalenz (XNOR)===

Die '''Äquivalenz''' ist eine erweiterte logische Verknüpfung in der Aussagenlogik. Die Äquivalenz zweier Aussagen ''A'' und ''B'' ist genau dann wahr, wenn ''A'' und ''B'' wahr oder ''A'' und ''B'' falsch sind. Das mathematische Symbol ist '''⇔'''. Die Äquivalenz ist semantisch äquivalent zu A &and; B &or; ¬A &and; ¬B. In [[Java]] gibt es keinen Operator hierfür.

Die Äquivalenz wird im Deutschen meistens durch "'''genau dann''' ''A'', '''wenn''' ''B''" ausgedrückt. "Genau" heißt immer und nur unter dieser Bedingung. '''A''' gilt genau dann, wenn '''B''' gilt. '''A''' und '''B''' sind äquivalent, also austauschbar. Das heißt die vorherige Aussage gilt auch anders herum: '''B''' gilt genau dann, wenn '''A''' gilt.

{| class = "wikitable" width=50% align="center"
! A !! B !! A ⇔ B
|-
| ''false'' || ''false'' || ''true''
|-
| ''false'' || ''true'' || ''false''
|-
| ''true'' || ''false'' ||''false''
|-
| ''true'' ||''true'' || ''true''
|}

''Venn-Diagramm?''

==Peano-Axiome (erweitertes Wissen)==

===Kommutativgesetze===

(1) ''A'' &and; ''B'' &equiv; ''B'' &and; ''A''

(1') ''A'' &or; ''B'' &equiv; ''B'' &or; ''A''

Das Vertauschen der Argumente ''A'' und ''B'' ist hier möglich, ohne dass sich das Ergebnis der Operation ändert.

===Assoziativgesetze===

(2) (''A'' &and; ''B'') &and; ''C'' &equiv; ''A'' &and; (''B'' &and; ''C'')

(2') (''A'' &or; ''B'') &or; ''C'' &equiv; ''A'' &or; (''B'' &or; ''C'')

Die Klammerung der oben durchgeführten Operationen hat keinen Einfluss auf das Ergebnis.

===Idempotenzgesetze===

(3) ''A'' &and; ''A'' &equiv; ''A''

(3') ''A'' &or; ''A'' &equiv; ''A''

Die Eigenschaften des Arguments ''A'' bleiben bestehen, auch wenn dieses mit sich selbst verknüpft wird.

===Distributivgesetze===

(4) ''A'' &and; (''B'' &or; ''C'') &equiv; (''A'' &and; ''B'') &or; (''A'' &and; ''C'')

(4') ''A'' &or; (''B'' &and; ''C'') &equiv; (''A'' &or; ''B'') &and; (''A'' &or; ''C'')

Auswirkung des Auflösens von Klammern um Verknüpfungen von Operationen; ähnlich dem "Ausmultiplizieren" in der Schulmathematik.

===Neutralitätsgesetze===

(5) ''A'' &and; ''true'' &equiv; ''A''

(5') ''A'' &or; ''false'' &equiv; ''A''

Der Wert des Argumentes ''A'' wird durch die oben ausgeführten Operationen nicht verändert.

===Extremalgesetze===

(6) ''A'' &and; ''false'' &equiv; ''false''

(6') ''A'' &or; ''true'' &equiv; ''true''

Das Ergebnis der oben beschriebenen Operationen ist unabhängig vom Wert des Arguments ''A''.

===Doppelnegationsgesetz===

(7) ¬(¬''A'') &equiv; ''A''

"Doppelte Verneinung": Der Wert von ''A'' wird durch zweimaliges Ausführen des ¬ -Operators nicht beeinflusst.

===De Morgansche Gesetze===

(8) ¬(''A'' &and; ''B'') &equiv; ¬''A'' &or; ¬''B''

(8') ¬(''A'' &or; ''B'') &equiv; ¬''A'' &and; ¬''B''

Alltagsbeispiele:

(8) Peter hat sich einen Tee zubereitet, in dem nicht Zitronensaft und Zucker enthalten sind.
Beschreibe die Boolesche Variable '''A''' den Zustand, dass Zucker im Tee ist und '''B''' den Zustand, dass sich Zitronensaft im Tee befindet. Dann lautet die Antwort auf die Frage, ob Peters Tee Zucker und Zitronensaft (beides auf einmal) beinhaltet (also '''A''' = '''true''' und '''B''' = '''true''':

¬(''A'' &and; ''B'') = ¬(''true'' &and; ''true'') = ¬''true'' =''false''. In Peters Tee ist kein Zitronensaft und Zucker.

Diese Aussage ist äquivalent zu der Aussage "In Peters Tee ist kein Zitronensaft oder kein Zucker" (also mindestens eins von beiden ist nicht enthalten). Das heißt bei gleicher Belegung der Variablen erhält man das gleiche Ergebnis:

¬''A'' &or; ¬''B'' = ¬''true'' &or; ¬''true'' = ''false'' &or; ''false'' = false.

Damit die jeweilige Aussage wahr ist, muss mindestens eine der beiden Zutaten nicht in Peters Tee enthalten sein.

(8') Petras Kaffee enthält nicht Milch oder Zucker. Die Variable '''A''' beschreibe den Zustand, dass der Kaffee Milch enthält und '''B''', dass Zucker enthalten ist. Die Antwort auf die Frage, ob der Kaffee Milch aber keinen Zucker enthält (also '''A''' = '''true''' und '''B''' = '''false''') lautet dementsprechend:

¬(''A'' &or; ''B'') =¬(''true'' &or; ''false'') = ¬''true'' = ''false''. In Petras Kaffee ist weder Milch noch Zucker.

Diese Aussage ist äquivalent zu "Petras Kaffee enthält keine Milch und keinen Zucker." Das heißt bei gleicher Belegung der Variablen kommt das gleiche Ergebnis heraus:

¬''A'' &and; ¬''B'' = ¬''true'' &and; ¬''false'' = ''false'' &and; ''true'' = ''false''.

===Komplementärgesetze===

(9) ''A'' &and; ¬''A'' &equiv; ''false''

(9') ''A'' &or; ¬''A'' &equiv; ''true''

Es können nicht gleichzeitig ''A'' und die Negation von ''A'' gelten: Beispielsweise kann der Himmel nicht gleichzeitig blau und nicht-blau sein (9).
Allerdings ist der Himmel entweder blau oder nicht-blau gefärbt (9').

===Dualitätsgesetze===

(10) ¬false &equiv; true

(10') ¬true &equiv; false

Der Wert '''true''' ist das Komplement zu '''false'''. Ist eine Aussage nicht-wahr, so ist sie falsch. Umgekehrt gilt für eine nicht-falsche Aussage, dass sie wahr sein muss.

Pseudocode

2016-08-12T20:36:22Z

Hauer: Die Seite wurde neu angelegt: „'''Pseudocode''' nennt man die umgangssprachiche Formulierung von Algorithmen. Es ist eine willkürliche Art und Weise, angelehnt an die Syntax imperativer Pro…“

'''Pseudocode''' nennt man die umgangssprachiche Formulierung von Algorithmen. Es ist eine willkürliche Art und Weise, angelehnt an die Syntax imperativer Programmiersprachen wie C oder Java, eine Folge von Anweisungen zu formulieren. Er wird verwendet um komplexere Algorithmen einfach niederschreiben und erklären zu können.

= Beispiel =

<source>
Mittelwert einer Zahlenfolge berechnen:
Eingabe: Array von Zahlen
Ausgabe: Mittelwert
Algorithmus:
Für jede Zahl der Zahlenfolge:
Summe = Summe + Zahl
Gebe zurück: Summe / Anzahl der Zahlen
</source>

Eclipse

2016-08-12T19:02:51Z

Hauer: Die Seite wurde neu angelegt: „'''Eclipse''' ist eine frei verfügbare IDE zur Entwicklung von Java Programmen. = Download = Das Programm ist auf der Webseite der [http://www.eclipse.o…“

'''Eclipse''' ist eine frei verfügbare [[IDE]] zur Entwicklung von Java Programmen.

= Download =

Das Programm ist auf der Webseite der [http://www.eclipse.org Eclipse Foundation] verfügbar.

= Installation =

Es gibt sowohl einen auf der Webseite verfügbaren Insterllationsassistenten als auch herunterladbare Archive. Eclipse selbst muss in der Regel nicht installiert werden, sondern kann einfach in ein beliebiges Verzeichnis im Dateisysstem entpackt und gestartet werden. Vorraussetzung dafür ist nur eine bereits installierte JVM.

= Verwendung =

== Arbeitsverzeichnis ==

Beim ersten Start fragt Eclipse den Benutzer über die Angabe eines sogenannten "workspace"s. Dies ist das Verzeichnis, in welchem die Projekte und Java-Quelldateien gespeichert werden sollen.

== Willkommensbildschirm ==

Nach der Wahl des "workspace"s wird beim ersten Start vermutlich ein Willkommensbildschirm Sie begrüßen. Sie können diesen ganz einfach durch einen Klick auf den Button "Go to Workspace" verlassen.

== Arbeitsoberfläche ==

Die Arbeitsoberfläche von Eclipse ähnelt der vieler anderer Büroanwendungen. Sie bietet im oberen Bereich eine Werkzeugleiste für häufig verwendete Funktionen. Im Zentrum der Arbeitsoberfläche befindet sich der Bereich zum editieren von Dateien während am linken Rand eine Baumdarstellung der verwendeten Projekte zu finden ist.

Interpreter

2016-07-28T13:39:38Z

Hauer:

Ein '''Interpreter''' ist ein Programm, welches ein anderes Programm ausführen kann. Dies klingt erstmal sehr redundant, hat jedoch folgenden Hintergrund:

Für gewöhnlich wird ein menschenlesbares Programm von einem [[Compiler]] in ein von einer Maschine ausführbares Programm übersetzt. Dies limitiert die Ausführung des Programmes jedoch anschließend auf die Maschine, für die sie übersetzt wurde. Dies versucht man mit einem '''Interpreter''' zu umgehen. Ein '''Interpreter''' kann ein speziell für ihn geschriebenes Programm einlesen und die im Programm enthaltenen Befehle ausführen. Er dient quasi als Schnittstelle zwischen dem Programm und der eigentlichen Maschine. Dies nennt man dann auch ''ein Programm interpretieren''. Nun muss nur noch der Interpreter selbst auf verschiedene Maschinen ausgeliefert werden und alle für diesen Interpreter geschriebene Programme können auf jeder Maschine ausgeführt werden, für die ein passender Interpreter existiert.

Die Sprache, die ein Interpreter interpretiert, ist meistens direkt die menschenlesbare Quellsprache. Dies hat jedoch meistens zur Folge, dass ein Interpreter sehr langsam läuft und unter umständen große Sicherheitslücken aufweist, da ein Programm in der Quellsprache zu interpretieren meist involviert, den gesamten Quelltext und all seine Abhängigkeiten gleichzeitig analysieren zu müssen, als sich auf sehr einfache Maschineninstruktionen verlassen zu können.

Dieses Problem versuchen sogenannte '''Bytecodeinterpreter''', wie z.B. die [[JVM]], zu umgehen, indem sie nicht den Code der Quellsprache direkt interpretieren, sondern eine Zwischensprache interpretieren, die wesentlich effizienter und sicherer auszuführen ist und zuerst aus dem Quellcode der Quellsprache generiert werden muss. Dies reduziert jedoch nicht die portabilität des Programmes, da man das ein mal übersetzte Programm immernoch auf allen Maschinen ausführen kann, auf denen der passende Interpreter installiert ist.

Interpreter

2016-07-28T13:38:35Z

Hauer:

Ein '''Interpreter''' ist ein Programm, welches ein anderes Programm ausführen kann. Dies klingt erstmal sehr redundant, hat jedoch folgenden Hintergrund:

Für gewöhnlich wird ein menschenlesbares Programm von einem [[Compiler]] in ein von einer Maschine ausführbares Programm übersetzt. Dies limitiert die Ausführung des Programmes jedoch anschließend auf die Maschine, für die sie übersetzt wurde. Dies versucht man mit einem '''Interpreter''' zu umgehen. Ein '''Interpreter''' kann ein für ihn entwickelten Sprache geschriebenes Programm einlesen und die im Programm enthaltenen Befehle ausführen. Dies nennt man dann auch ''ein Programm interpretieren''. Nun muss nur noch der Interpreter selbst auf verschiedene Maschinen ausgeliefert werden und alle für diesen Interpreter geschriebene Programme können auf jeder Maschine ausgeführt werden, für die ein passender Interpreter existiert.

Die Sprache, die ein Interpreter interpretiert, ist meistens direkt die menschenlesbare Quellsprache. Dies hat jedoch meistens zur Folge, dass ein Interpreter sehr langsam läuft und unter umständen große Sicherheitslücken aufweist, da ein Programm in der Quellsprache zu interpretieren meist involviert, den gesamten Quelltext und all seine Abhängigkeiten gleichzeitig analysieren zu müssen, als sich auf sehr einfache Maschineninstruktionen verlassen zu können.

Dieses Problem versuchen sogenannte '''Bytecodeinterpreter''', wie z.B. die [[JVM]], zu umgehen, indem sie nicht den Code der Quellsprache direkt interpretieren, sondern eine Zwischensprache interpretieren, die wesentlich effizienter und sicherer auszuführen ist und zuerst aus dem Quellcode der Quellsprache generiert werden muss. Dies reduziert jedoch nicht die portabilität des Programmes, da man das ein mal übersetzte Programm immernoch auf allen Maschinen ausführen kann, auf denen der passende Interpreter installiert ist.

Terminierung

2016-07-24T00:41:19Z

Hauer: Die Seite wurde neu angelegt: „Unter '''Terminierung''' versteht man das Beenden eines Ablaufs. Dies kann der Ablauf eines Programmes sein, oder ''nur'' der Ablauf einer Funktion bzw. …“

Unter '''Terminierung''' versteht man das Beenden eines Ablaufs. Dies kann der Ablauf eines Programmes sein, oder ''nur'' der Ablauf einer [[Funktion]] bzw. [[Methode]].

Rechensysteme

2016-07-23T17:44:19Z

Hauer: Die Seite wurde neu angelegt: „Ein '''Rechensystem''' ist, wie der Name schon sagt, ein System zum rechnen. Dies kann sich sowohl auf das Zahlenystem (Dezimal- oder Binärsystem) beziehen, i…“

Ein '''Rechensystem''' ist, wie der Name schon sagt, ein System zum rechnen. Dies kann sich sowohl auf das Zahlenystem (Dezimal- oder Binärsystem) beziehen, in welchem gerechnet wird, als auch ein System, wie z.B. eine Maschine, bezeichnen, welche Berechnungen durchführt.

= Beispiele =

== Rechnen im Dezimalsystem ==

== Rechnen im Binärsystem ==

== Schaltsysteme im Rechner ==

Hauptseite

2016-07-23T13:57:03Z

Hauer:

<div id=mainpage_topbox>
<div id=mainpage_title>
<span>Willkommen im</span> EINI-Wiki
</div>
<div id=mainpage_title_text>
Eine Wiki zur Veranstaltung "Einführung in die Informatik für Logistiker, Wirtschaftsmathematiker und -ingenieure" der TU-Dortmund
</div>
</div>

<div style="display:flex">
<div style="border: solid 1px #AAA; width:100%; margin-top: 0.5em; margin-right: 0.5em;">
<div class="box_head">
Übersicht
</div>
<div class="box_content" style="margin:0 ; padding: 0;">
{| class = "wikitable" width=100%
|+ Themenübersicht
! Thema !! Vorlesung !! Inhalt
|-
| rowspan="2" | Rechensysteme & Datendarstellung
| Vorlesung 1 (Kapitel 0)
| Einführung und Organisation
|-
| Vorlesung 2 (Kapitel 1)
| Dezimal- und Binärzahlen, Darstellung von Zahlen, Darstellung von Zeichen, Darstellung logischer Werte, Umrechnung, Rechensysteme
|-
| Spezifikation - Algorithmus - Syntax & Semantik
| Vorlesung 3 (Kapitel 2)
| Entwurf, Spezifikation, [[Algorithmus]], [[Syntax und Semantik]]
|-
| rowspan="3" | Kern imperativer Programmiersprachen
| Vorlesung 4 (Kapitel 3.1)
| [[Variable | Variablen]], [[Zuweisung|Zuweisungen]], [[Datentyp|primitive Datentypen]], [[Operator|Operatoren]]
|-
| Vorlesung 5 (Kapitel 3.2)
| [[Kontrollstrukturen]]: [[Sequenz|Sequenzen]], [[Block|Blöcke]], [[Fallunterscheidung]], [[Schleife|Schleifen]]: [[while]], [[do-while]]
|-
| Vorlesung 6 (Kapitel 3.3)
| Schleifen: [[for]], [[continue]], [[break]]
|-
| Funktion - Prozedur - Methode - Rekursion
| Vorlesung 7 (Kapitel 4)
| [[Unterprogramm|Unterprogramme]], [[Funktion|Funktionen]], [[Funktion|Aufruf]], [[Rekursion]]
|-
| rowspan="2" | Arrays - Internes Sortieren - Rekursive Datenstrukturen
| Vorlesung 8 (Kapitel 5.1)
| [[Array|Arrays]], [[Sortieren|Internes Sortieren]], Rekursive Datenstrukturen ([[Baum|Binär-Baum]], [[Heap]])
|-
| Vorlesung 9 (Kapitel 5.2)
| Abstrakte Datentypen am Bsp. [[Heap]], Heapsort
|-
| rowspan="1" | Objektorientierte Programmierung - Einführung
| Vorlesung 10 (Kapitel 6)
| Aufbau eines Java-Programms, [[Klasse|Klassen]], [[Objekt|Objekte]], Details zu [[Konstruktor|Konstruktoren]], [[Referenz|Referenzen]], [[Garbage Collector|Garbage Collection]], Übergabe von [[Parameter|Parametern]], [[Attribut|Klassenattribute]]
|-
| rowspan="2" | Objektorientierte Programmierung - Vererbung
| Vorlesung 11 (Kapitel 7)
| rowspan="2" | [[Vererbung]], [[Attribut|Attribute]] & [[Methode|Methoden]]: [[Sichtbarkeit|Zugriffsrechte]], Überschreiben, Abstrakte Klassen/Methoden, Polymorphie
|-
| Vorlesung 12 (Kapitel 7)
|-
| rowspan="2" | Dynamische Datenstrukturen
| Vorlesung 13 (Kapitel 8.1)
| einfache [[Liste|Listen]], sortierte Liste, Doppelt verkettete Liste
|-
| Vorlesung 14 (Kapitel 8.2)
| Binärer Suchbaum, Vollständige Induktion, Operationen in einem binärem Suchbaum, Durchlaufstrategien für einen binären Suchbaum
|}
</div>
</div>
<div style="border: solid 1px #AAA; width:50%; margin-top: 0.5em; margin-left: 0.5em;">
<div class="box_head">
Glossar
</div>
<div class="box_content">
[[Glossar]]
[[Glossar_(alphabetisch)| Glossar (alphabetisch)]]
*[[Stack | Abarbeitung von Funktionsaufrufen]]
*[[Algorithmus]]
*[[Array]]
*[[Ausdruck]]
*[[Bit]]
*[[Dezimal-_und_Binärsystem | Binärzahlen]]
*[[Boolesche Algebra]]
*[[Boolean]]
*[[Block]]
*[[Alternative | Bedingte Anweisung]]
*[[Baum | binärer Baum]]
*[[Char]]
*[[call by value]]
*[[call by reference]]
*[[Darstellung natürlicher Zahlen]]
*[[Darstellung ganzer Zahlen]]
*[[Deklaration]]
*[[Datentyp]]
*[[do-while | do-while-Schleife]]
*[[Datenstruktur]]
*[[Dynamische Datenstruktur]]
*[[Ein- und Ausgabe]]
*[[Elementaroperationen]]
*[[Einfache Grundoperationen]]
*[[Festpunktzahlen]]
*[[Float]]
*[[for | for-Schleife]]
*[[Funktion]]
*[[Gleitpunktzahlen]]
*[[globale Variablen]]
*[[Hexadezimalzahlen]]
*[[Heap]]
*[[Initialisierung]]
*[[Integer]]
*[[Schleife | Iteration]]
*[[Objekt | Instanz]]
*[[Java]]
*[[Kurzformen]]
*[[Kontrollstruktur]]
*[[Klasse]]
*[[Liste | lineare Liste]]
*[[Methode]]
*[[main | main-Methode]]
*[[new | new-Operator]]
*[[null]]
*[[Objektorientierte Programmierung]]
*[[Operation]]
*[[Objekt]]
*[[Programmierung]]
*[[Primitive Datentypen]]
*[[Operatoren#Priotitäten von Operatoren | Priotitäten von Operatoren]]
*[[Parameter]]
*[[public]]
*[[private]]
*[[protected]]
*[[Punkt-Operator]]
*[[Rechensysteme]]
*[[Rückgabewert]]
*[[Rekursive Funktion]]
*[[Referenzen]]
*[[Syntax]]
*[[Semantik]]
*[[Sortieren]]
*[[Suchen]]
*[[Syntaxdiagramm]]
*[[switch]]
*[[Schleife]]
*[[static]]
*[[Schlüsselwörter]]
*[[Teile und herrsche]]
*[[Terminierung]]
*[[this]]
*[[Variable]]
*[[Vererbung]]
*[[while | while-Schleife]]
*[[Zweierkomplement]]
*[[Zuweisung]]

</div>
</div>
</div>

[[Glossar]]

Deklaration

2016-07-11T19:42:22Z

Hauer: /* Deklaration einer Variablen */

Unter '''Deklaration''' versteht man das Ankündigen von benötigtem Speicher im Quellcode.

[[Variablen]] müssen vor ihrer Verwendung '''deklariert''' werden. Wie viel Speicher für die entsprechende Variable benötigt wird, hängt von ihrem [[Datentyp]] ab.

Auch Datentypen, in [[Java]] durch [[Klassen]] repräsentiert, müssen durch ihre Definition deklariert werden. Primitive Datentypen sind davon ausgenommen. Alle Datentypen aus der Java-Standard[[bibliothek]] "java.lang" sind vordefiniert.

[[Methoden]] und Funktionen der jeweiligen Klasse müssen vor ihrer Verwendung zumindest über ihre [[Signatur]] deklariert werden. Dadurch soll erkannt werden, ob der Aufruf korrekt ist, auch wenn ihr Inhalt (Implementierung) noch unbekannt ist.

= Deklaration von Klassen =

siehe: [[Klasse]]

Eine einfache Klassendeklaration findet in einer .java-Datei mit dem gleichen Namen statt und sieht wie folgt aus:

<source lang="java">
public class Classname {
//Definition der Klasse
}
</source>

= Deklaration von Methoden =

siehe: [[Methode]]

Zur Deklaration einer Methode bzw. Funktion gehört zuerst nur ihre Signatur. Da jedoch nur in [[abstract|abstrakten]] Klassen auf eine Implementierung verzichtet werden kann, reicht dies in gewöhnlichen Klassen nicht aus:

<source lang="java">
public ReturnType methodName(Parameter variable, OtherParameter otherVariable) {
//Implementierung der Methode
}
</source>

= Deklaration einer Variablen =

siehe: [[Variable]]

Vor Verwendung einer Variablen muss diese durch Angabe ihres Datentyps deklariert werden. Der Datentyp einer Variablen kann sich innerhalb ihres [[Block]]es nicht ändern. Eine Variable ist nur in dem Block sichtbar, in dem sie deklariert wurde.

<source lang="java">
//Umgebender Block
{
VariableType variableName;
}
</source>

Codekonventionen

2016-07-09T00:01:31Z

Hauer: /* Konventionen für Einrückung und geschweifte Klammern in Java */

Eine '''Codekonvention''' ist eine Übereinkunft unter Programmierern, beim Schreiben ihrer [[Programm]]e einen gewissen Stil einzuhalten. Über die Jahre hinweg haben sich in fast allen [[Programmiersprachen]] eine oder mehrere solcher '''Standards''' gebildet.

= Verständlichkeit eines Algorithmus =

==Erläuterung==

Ein wichtiges Merkmal eines [[Algorithmus]] ist, dass ein menschlicher Leser ihn verstehen kann, obwohl er nicht in umgangssprachlicher Form vorliegt.

==Beispiel==

Als Beispiel sei folgender Algorithmus gegeben, der zwei Zahlen miteinander multipliziert, ohne explizit einen [[Operator|Multiplikationsoperator]] zu verwenden.

1. In '''[[Pseudocode]]''' sieht das ganze so aus:

Eingabe: Zwei ganze Zahlen a und b
Ausgabe: Produkt aus a und b
Vorgehensweise:
Initialisiere das Ergebnis mit 0
Addiere a mal b auf das Ergebnis
Gebe das Ergebnis zurück

2. Beispiel für eine '''schwer verständliche''' Formulierung des Algorithmus:

<source>
public static int berechnen2(int a, int b){int erg=0;for(int i=0;i<a;i++){erg+=b;}return erg;}
</source>

3. Das gleiche Beispiel, '''lesbarer''' und mit Syntaxhighlighting:
<source lang="java">public static int berechnen(int a, int b)
{
int erg = 0;
for(int i = 0; i<a ; i++)
{
erg += b;
}
return erg;
}</source>

Beide Programme führen dasselbe aus. Beide berechnen das Produkt von ''a'' und ''b'', ohne eine Multiplikation durchzuführen. Sie addieren ''b'' ''a''-mal auf eine Ergebnisvariablen <code>erg</code> auf. Diese [[Variable]] wird zum Schluss zurückgegeben.

Genaueres zur Funktionsweise des Algorithmus: siehe [[Schleife]]

= Bezeichner und Leerzeichen =

Da in [[Programmiersprachen]] der Text maschinell analysiert werden muss, um später vom [[Compiler]] übersetzt werden zu können, gilt es ''immer'' folgendes zu beachten:

Eine Zeichenkette, die als '''Bezeichner''' für ein Programmelement genutzt wird, darf '''keine Leerzeichen''' (engl. ''whitespaces'') beinhalten.

Mit Leerzeichen versehen werden Beginn und Ende des Bezeichners uneindeutig [[Deklaration|deklariert]]. Daher ist dies in fast allen Programmiersprachen verboten. Um trotzdem einen Bezeichner aus mehr als einem Wort bestehen zu lassen, verwenden Programmierer verschiedene Formen der '''Notation''', die im Folgenden erklärt werden.

= Notationsbegriffe =

Im Zusammenhang mit '''Codekonventionen''' haben sich verschiedene Begriffe etabliert:

'''Lower-Case''' (''engl.'' für "Kleinbuchstaben"): Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während alle Buchstaben klein geschrieben werden.
*z.B.: <code>nanosecondsinsecond</code>, <code>valueineuro</code>, <code>positionx</code>, <code>positiony</code>

'''Upper-Case'''(''engl.'' für "Großbuchstaben"): Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während alle Buchstaben groß geschrieben werden.
*z.B.: <code>NANOSECONDSINSECOND</code>, <code>VALUEINEURO</code>, <code>POSITIONX</code>, <code>POSITIONY</code>

'''Camel-Case''': Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während jeder Anfangsbuchstabe eines Wortes groß geschrieben wird.
*z.B.: <code>NanosecondsInSecond</code>, <code>ValueInEuro</code>, <code>PositionX</code>, <code>PositionY</code>

'''Mixed-Camel-Case''': Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während jeder Anfangsbuchstabe eines Wortes groß geschrieben wird, bis auf der erste.
*z.B.: <code>nanosecondsInSecond</code>, <code>valueInEuro</code>, <code>positionX</code>, <code>positionY</code>

'''Underscored''': Wörter in Bezeichnern werden durch einen Unterstrich '''_''' voneinander getrennt.
*z.B.: <code>nanoseconds_in_sekunde</code>, <code>value_in_euro</code>, <code>position_X</code>, <code>position_Y</code>.
Underscored kann in Kombination mit anderen Begriffen verwendet werden. Die ersten beiden Beispiele sind in der in C für Variablen verwendeten lower-case-underscored Schreibweise gehalten.

=Konventionen in Java=

Folgende Konventionen sind beim Programmieren von [[Java]] zwingend einzuhalten:

== Konventionen für Bezeichner in Java ==

1. '''Paketnamen''' werden im '''Lower-Case''' notiert und haben die Form einer "umgekehrten URL".
*z.B.: <code>de.tu-do.eini.blatt01</code>, <code>org.apache</code>, <code>com.jogamp.opengl</code>, <code>myproject.directory</code>

2. [[Klasse|'''Klassennamen''']] werden im '''Camel-Case''' notiert.
*z.B.: <code>String</code>, <code>MeinProgramm</code>, <code>AbstractSingletonFactoryBean</code>

3. [[Variable|'''Variablen- und Attributsnamen''']] werden im '''Mixed-Camel-Case''' notiert.
*z.B.: <code>x</code>, <code>result</code>, <code>processRunning</code>

4. [[Methode|'''Methodennamen''']] werden im ''''Mixed-Camel-Case''' notiert.
*z.B.: <code>calculate(int x, int y)</code>, <code>doSomething()</code>, <code>cleanupAtShutdown(String message)</code>

5. Klassenweite '''Konstanten'' werden im '''Underscored-Upper-Case''' notiert.
*z.B.: <code>PI</code>, <code>NANOSECONDS_IN_SECOND</code>, <code>ARRAY_SIZE</code>

Alles was einen '''Wert''' besitzt, kann so schnell durch den '''Kleinbuchstaben''' am Anfang erkannt werden kann, während von Typen mit Großbuchstaben unterschieden werden kann. Konstanten fallen schnell ins Auge.

Bei '''Paketnamen''' kann durch die Form der Notation bei Großprojekten insbesondere erkannt werden, in welcher Sprache das Projekt dokumentiert ist (Ländercode der "URL"). Für das Anlegen von Klassen zu den Übungsblättern reicht jedoch etwas wie <code>eini.blatt01</code> vollkommen aus.

== Konventionen für Einrückung und geschweifte Klammern in Java ==

In Java wird, wie auch in vielen anderen Programmiersprachen, '''blockebenenweise''' eingerückt. Eine Ebene wird dabei meist mit vier Leerzeichen oder einem Tab eingerückt. Das bedeutet, dass die Anzahl an umgebenden [[Block|Blöcken]] die Anzahl an Leerzeichen oder Tabs vor dem Beginn einer Zeile vorgibt. So stehen z.B. die Deklarationen von Attributen und Methoden immer im Block der sie beinhaltenden Klasse und werden deswegen um eine Ebene eingerückt:

<source lang="java">
public class Cube {
private int x,y,z; //Umgeben vom Block der Klasse: Einrückung um eine Ebene.

private int calculateVolume(){
/* Berechnung umgeben vom Block der Klasse und der Methode: Einrückung um zwei Ebenen. */
}
}
</source>

Ob Sie die öffnenden Klammern eines Blockes in die Zeile des ihn öffnenden Ausdruckes schreiben (wie im vorherigen Beispiel), oder die öffnende Klammer in die gleiche Ebene wie der den Block öffnende Ausdruck in einer einzelnen Zeile notieren (wie im lesbareren Beispiel unter Verständlichkeit eines Algorithmus) ist Ihnen überlassen. Sie sollten dabei aber auf jeden Fall konstant bleiben.

= Beispiele =

<source lang="java" title="Korrekte Vorgabe">
public class Classname {
private int variable;
private int another;
}
</source>

<source lang="java" title="Schlecht: Keine Einrückung">
public class Cube {
private int x,y,z;
private int calculateVolume(){
/* Berechnung */
}
}
</source>

<source lang="java" title="Schlecht: Klammern und Text geclustered">
public class Cube {
private int x,y,z;
private int calculateVolume(){
/* Berechnung */
}}
</source>

<source lang="java" title="Schlecht: Einrückung falsch formatiert, stimmt nicht mit Ebene überein">
public class Cube {
private int x,y,z;

private int calculateVolume(){
/* Berechnung */
}
}
</source>

<source lang="java" title="Schlecht: Uneinheitlich geklammert">
public class Calculator {
private int calculate(int x, int y){
for(int i = 0; i < y; i++)
{
/* Berechung */
}
}
}
</source>

<source lang="java" title="Alternative Klammerung">
public class Cube
{
private int x,y,z;

private int calculateVolume()
{
/* Berechnung */
}
}
</source>

Codekonventionen

2016-07-08T22:03:23Z

Hauer: /* Konventionen für Einrückung und geschweifte Klammern in Java */

Eine '''Codekonvention''' ist eine Übereinkunft unter Programmierern, beim Schreiben ihrer [[Programm]]e einen gewissen Stil einzuhalten. Über die Jahre hinweg haben sich in fast allen [[Programmiersprachen]] eine oder mehrere solcher '''Standards''' gebildet.

= Verständlichkeit eines Algorithmus =

==Erläuterung==

Ein wichtiges Merkmal eines [[Algorithmus]] ist, dass ein menschlicher Leser ihn verstehen kann, obwohl er nicht in umgangssprachlicher Form vorliegt.

==Beispiel==

Als Beispiel sei folgender Algorithmus gegeben, der zwei Zahlen miteinander multipliziert, ohne explizit einen [[Operator|Multiplikationsoperator]] zu verwenden.

1. In '''[[Pseudocode]]''' sieht das ganze so aus:

Eingabe: Zwei ganze Zahlen a und b
Ausgabe: Produkt aus a und b
Vorgehensweise:
Initialisiere das Ergebnis mit 0
Addiere a mal b auf das Ergebnis
Gebe das Ergebnis zurück

2. Beispiel für eine '''schwer verständliche''' Formulierung des Algorithmus:

<source>
public static int berechnen2(int a, int b){int erg=0;for(int i=0;i<a;i++){erg+=b;}return erg;}
</source>

3. Das gleiche Beispiel, '''lesbarer''' und mit Syntaxhighlighting:
<source lang="java">public static int berechnen(int a, int b)
{
int erg = 0;
for(int i = 0; i<a ; i++)
{
erg += b;
}
return erg;
}</source>

Beide Programme führen dasselbe aus. Beide berechnen das Produkt von ''a'' und ''b'', ohne eine Multiplikation durchzuführen. Sie addieren ''b'' ''a''-mal auf eine Ergebnisvariablen <code>erg</code> auf. Diese [[Variable]] wird zum Schluss zurückgegeben.

Genaueres zur Funktionsweise des Algorithmus: siehe [[Schleife]]

= Bezeichner und Leerzeichen =

Da in [[Programmiersprachen]] der Text maschinell analysiert werden muss, um später vom [[Compiler]] übersetzt werden zu können, gilt es ''immer'' folgendes zu beachten:

Eine Zeichenkette, die als '''Bezeichner''' für ein Programmelement genutzt wird, darf '''keine Leerzeichen''' (engl. ''whitespaces'') beinhalten.

Mit Leerzeichen versehen werden Beginn und Ende des Bezeichners uneindeutig [[Deklaration|deklariert]]. Daher ist dies in fast allen Programmiersprachen verboten. Um trotzdem einen Bezeichner aus mehr als einem Wort bestehen zu lassen, verwenden Programmierer verschiedene Formen der '''Notation''', die im Folgenden erklärt werden.

= Notationsbegriffe =

Im Zusammenhang mit '''Codekonventionen''' haben sich verschiedene Begriffe etabliert:

'''Lower-Case''' (''engl.'' für "Kleinbuchstaben"): Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während alle Buchstaben klein geschrieben werden.
*z.B.: <code>nanosecondsinsecond</code>, <code>valueineuro</code>, <code>positionx</code>, <code>positiony</code>

'''Upper-Case'''(''engl.'' für "Großbuchstaben"): Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während alle Buchstaben groß geschrieben werden.
*z.B.: <code>NANOSECONDSINSECOND</code>, <code>VALUEINEURO</code>, <code>POSITIONX</code>, <code>POSITIONY</code>

'''Camel-Case''': Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während jeder Anfangsbuchstabe eines Wortes groß geschrieben wird.
*z.B.: <code>NanosecondsInSecond</code>, <code>ValueInEuro</code>, <code>PositionX</code>, <code>PositionY</code>

'''Mixed-Camel-Case''': Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während jeder Anfangsbuchstabe eines Wortes groß geschrieben wird, bis auf der erste.
*z.B.: <code>nanosecondsInSecond</code>, <code>valueInEuro</code>, <code>positionX</code>, <code>positionY</code>

'''Underscored''': Wörter in Bezeichnern werden durch einen Unterstrich '''_''' voneinander getrennt.
*z.B.: <code>nanoseconds_in_sekunde</code>, <code>value_in_euro</code>, <code>position_X</code>, <code>position_Y</code>.
Underscored kann in Kombination mit anderen Begriffen verwendet werden. Die ersten beiden Beispiele sind in der in C für Variablen verwendeten lower-case-underscored Schreibweise gehalten.

=Konventionen in Java=

Folgende Konventionen sind beim Programmieren von [[Java]] zwingend einzuhalten:

== Konventionen für Bezeichner in Java ==

1. '''Paketnamen''' werden im '''Lower-Case''' notiert und haben die Form einer "umgekehrten URL".
*z.B.: <code>de.tu-do.eini.blatt01</code>, <code>org.apache</code>, <code>com.jogamp.opengl</code>, <code>myproject.directory</code>

2. [[Klasse|'''Klassennamen''']] werden im '''Camel-Case''' notiert.
*z.B.: <code>String</code>, <code>MeinProgramm</code>, <code>AbstractSingletonFactoryBean</code>

3. [[Variable|'''Variablen- und Attributsnamen''']] werden im '''Mixed-Camel-Case''' notiert.
*z.B.: <code>x</code>, <code>result</code>, <code>processRunning</code>

4. [[Methode|'''Methodennamen''']] werden im ''''Mixed-Camel-Case''' notiert.
*z.B.: <code>calculate(int x, int y)</code>, <code>doSomething()</code>, <code>cleanupAtShutdown(String message)</code>

5. Klassenweite '''Konstanten'' werden im '''Underscored-Upper-Case''' notiert.
*z.B.: <code>PI</code>, <code>NANOSECONDS_IN_SECOND</code>, <code>ARRAY_SIZE</code>

Alles was einen '''Wert''' besitzt, kann so schnell durch den '''Kleinbuchstaben''' am Anfang erkannt werden kann, während von Typen mit Großbuchstaben unterschieden werden kann. Konstanten fallen schnell ins Auge.

Bei '''Paketnamen''' kann durch die Form der Notation bei Großprojekten insbesondere erkannt werden, in welcher Sprache das Projekt dokumentiert ist (Ländercode der "URL"). Für das Anlegen von Klassen zu den Übungsblättern reicht jedoch etwas wie <code>eini.blatt01</code> vollkommen aus.

== Konventionen für Einrückung und geschweifte Klammern in Java ==

In Java wird, wie auch in vielen anderen Programmiersprachen, '''blockebenenweise''' eingerückt. Eine Ebene wird dabei meist mit vier Leerzeichen oder einem Tab eingerückt. Das bedeutet, dass die Anzahl an umgebenden [[Block|Blöcken]] von geschweiften Klammern die Anzahl an Leerzeichen oder Tabs vor dem Beginn einer Zeile vorgibt. So stehen z.B. die Deklarationen von Attributen und Methoden immer im Block der sie beinhaltenden Klasse und werden deswegen um eine Ebene eingerückt:

<source lang="java">
public class Cube {
private int x,y,z; //Umgeben vom Block der Klasse: Einrückung um eine Ebene.

private int calculateVolume(){
/* Berechnung umgeben vom Block der Klasse und der Methode: Einrückung um zwei Ebenen. */
}
}
</source>

Ob Sie die öffnenden Klammern eines Blockes in die Zeile des ihn öffnenden Ausdruckes schreiben (wie im vorherigen Beispiel), oder die öffnende Klammer in die gleiche Ebene wie der den Block öffnende Ausdruck in einer einzelnen Zeile notieren (wie im lesbareren Beispiel unter Verständlichkeit eines Algorithmus) ist Ihnen überlassen. Sie sollten dabei aber auf jeden Fall konstant bleiben.

= Beispiele =

<source lang="java" title="Korrekte Vorgabe">
public class Classname {
private int variable;
private int another;
}
</source>

<source lang="java" title="Schlecht: Keine Einrückung">
public class Cube {
private int x,y,z;
private int calculateVolume(){
/* Berechnung */
}
}
</source>

<source lang="java" title="Schlecht: Klammern und Text geclustered">
public class Cube {
private int x,y,z;
private int calculateVolume(){
/* Berechnung */
}}
</source>

<source lang="java" title="Schlecht: Einrückung falsch formatiert, stimmt nicht mit Ebene überein">
public class Cube {
private int x,y,z;

private int calculateVolume(){
/* Berechnung */
}
}
</source>

<source lang="java" title="Schlecht: Uneinheitlich geklammert">
public class Calculator {
private int calculate(int x, int y){
for(int i = 0; i < y; i++)
{
/* Berechung */
}
}
}
</source>

<source lang="java" title="Alternative Klammerung">
public class Cube
{
private int x,y,z;

private int calculateVolume()
{
/* Berechnung */
}
}
</source>

Codekonventionen

2016-07-08T21:57:13Z

Hauer:

Eine '''Codekonvention''' ist eine Übereinkunft unter Programmierern, beim Schreiben ihrer [[Programm]]e einen gewissen Stil einzuhalten. Über die Jahre hinweg haben sich in fast allen [[Programmiersprachen]] eine oder mehrere solcher '''Standards''' gebildet.

= Verständlichkeit eines Algorithmus =

==Erläuterung==

Ein wichtiges Merkmal eines [[Algorithmus]] ist, dass ein menschlicher Leser ihn verstehen kann, obwohl er nicht in umgangssprachlicher Form vorliegt.

==Beispiel==

Als Beispiel sei folgender Algorithmus gegeben, der zwei Zahlen miteinander multipliziert, ohne explizit einen [[Operator|Multiplikationsoperator]] zu verwenden.

1. In '''[[Pseudocode]]''' sieht das ganze so aus:

Eingabe: Zwei ganze Zahlen a und b
Ausgabe: Produkt aus a und b
Vorgehensweise:
Initialisiere das Ergebnis mit 0
Addiere a mal b auf das Ergebnis
Gebe das Ergebnis zurück

2. Beispiel für eine '''schwer verständliche''' Formulierung des Algorithmus:

<source>
public static int berechnen2(int a, int b){int erg=0;for(int i=0;i<a;i++){erg+=b;}return erg;}
</source>

3. Das gleiche Beispiel, '''lesbarer''' und mit Syntaxhighlighting:
<source lang="java">public static int berechnen(int a, int b)
{
int erg = 0;
for(int i = 0; i<a ; i++)
{
erg += b;
}
return erg;
}</source>

Beide Programme führen dasselbe aus. Beide berechnen das Produkt von ''a'' und ''b'', ohne eine Multiplikation durchzuführen. Sie addieren ''b'' ''a''-mal auf eine Ergebnisvariablen <code>erg</code> auf. Diese [[Variable]] wird zum Schluss zurückgegeben.

Genaueres zur Funktionsweise des Algorithmus: siehe [[Schleife]]

= Bezeichner und Leerzeichen =

Da in [[Programmiersprachen]] der Text maschinell analysiert werden muss, um später vom [[Compiler]] übersetzt werden zu können, gilt es ''immer'' folgendes zu beachten:

Eine Zeichenkette, die als '''Bezeichner''' für ein Programmelement genutzt wird, darf '''keine Leerzeichen''' (engl. ''whitespaces'') beinhalten.

Mit Leerzeichen versehen werden Beginn und Ende des Bezeichners uneindeutig [[Deklaration|deklariert]]. Daher ist dies in fast allen Programmiersprachen verboten. Um trotzdem einen Bezeichner aus mehr als einem Wort bestehen zu lassen, verwenden Programmierer verschiedene Formen der '''Notation''', die im Folgenden erklärt werden.

= Notationsbegriffe =

Im Zusammenhang mit '''Codekonventionen''' haben sich verschiedene Begriffe etabliert:

'''Lower-Case''' (''engl.'' für "Kleinbuchstaben"): Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während alle Buchstaben klein geschrieben werden.
*z.B.: <code>nanosecondsinsecond</code>, <code>valueineuro</code>, <code>positionx</code>, <code>positiony</code>

'''Upper-Case'''(''engl.'' für "Großbuchstaben"): Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während alle Buchstaben groß geschrieben werden.
*z.B.: <code>NANOSECONDSINSECOND</code>, <code>VALUEINEURO</code>, <code>POSITIONX</code>, <code>POSITIONY</code>

'''Camel-Case''': Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während jeder Anfangsbuchstabe eines Wortes groß geschrieben wird.
*z.B.: <code>NanosecondsInSecond</code>, <code>ValueInEuro</code>, <code>PositionX</code>, <code>PositionY</code>

'''Mixed-Camel-Case''': Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während jeder Anfangsbuchstabe eines Wortes groß geschrieben wird, bis auf der erste.
*z.B.: <code>nanosecondsInSecond</code>, <code>valueInEuro</code>, <code>positionX</code>, <code>positionY</code>

'''Underscored''': Wörter in Bezeichnern werden durch einen Unterstrich '''_''' voneinander getrennt.
*z.B.: <code>nanoseconds_in_sekunde</code>, <code>value_in_euro</code>, <code>position_X</code>, <code>position_Y</code>.
Underscored kann in Kombination mit anderen Begriffen verwendet werden. Die ersten beiden Beispiele sind in der in C für Variablen verwendeten lower-case-underscored Schreibweise gehalten.

=Konventionen in Java=

Folgende Konventionen sind beim Programmieren von [[Java]] zwingend einzuhalten:

== Konventionen für Bezeichner in Java ==

1. '''Paketnamen''' werden im '''Lower-Case''' notiert und haben die Form einer "umgekehrten URL".
*z.B.: <code>de.tu-do.eini.blatt01</code>, <code>org.apache</code>, <code>com.jogamp.opengl</code>, <code>myproject.directory</code>

2. [[Klasse|'''Klassennamen''']] werden im '''Camel-Case''' notiert.
*z.B.: <code>String</code>, <code>MeinProgramm</code>, <code>AbstractSingletonFactoryBean</code>

3. [[Variable|'''Variablen- und Attributsnamen''']] werden im '''Mixed-Camel-Case''' notiert.
*z.B.: <code>x</code>, <code>result</code>, <code>processRunning</code>

4. [[Methode|'''Methodennamen''']] werden im ''''Mixed-Camel-Case''' notiert.
*z.B.: <code>calculate(int x, int y)</code>, <code>doSomething()</code>, <code>cleanupAtShutdown(String message)</code>

5. Klassenweite '''Konstanten'' werden im '''Underscored-Upper-Case''' notiert.
*z.B.: <code>PI</code>, <code>NANOSECONDS_IN_SECOND</code>, <code>ARRAY_SIZE</code>

Alles was einen '''Wert''' besitzt, kann so schnell durch den '''Kleinbuchstaben''' am Anfang erkannt werden kann, während von Typen mit Großbuchstaben unterschieden werden kann. Konstanten fallen schnell ins Auge.

Bei '''Paketnamen''' kann durch die Form der Notation bei Großprojekten insbesondere erkannt werden, in welcher Sprache das Projekt dokumentiert ist (Ländercode der "URL"). Für das Anlegen von Klassen zu den Übungsblättern reicht jedoch etwas wie <code>eini.blatt01</code> vollkommen aus.

== Konventionen für Einrückung und geschweifte Klammern in Java ==

In Java wird, wie auch in vielen anderen Programmiersprachen, '''blockebenenweise''' eingerückt. Das bedeutet, dass die Anzahl an umgebenden [[Block|Blöcken]] von geschweiften Klammern die Anzahl an Leerzeichen oder Tabs vor dem Beginn einer Zeile angibt. So stehen z.B. die Deklarationen von Attributen und Methoden immer im Block der sie beinhaltenden Klasse und werden deswegen um eine Ebene eingerückt:

<source lang="java">
public class Cube {
private int x,y,z;

private int calculateVolume(){
/* Berechnung */
}
}
</source>

Ob Sie die öffnenden Klammern eines Blockes in die Zeile des ihn öffnenden Ausdruckes schreiben (wie im vorherigen Beispiel), oder die öffnende Klammer in die gleiche Ebene wie der den Block öffnende Ausdruck in einer einzelnen Zeile notieren (wie im lesbareren Beispiel unter Verständlichkeit eines Algorithmus) ist Ihnen überlassen. Sie sollten dabei aber auf jeden Fall konstant bleiben.

= Beispiele =

<source lang="java" title="Korrekte Vorgabe">
public class Classname {
private int variable;
private int another;
}
</source>

<source lang="java" title="Schlecht: Keine Einrückung">
public class Cube {
private int x,y,z;
private int calculateVolume(){
/* Berechnung */
}
}
</source>

<source lang="java" title="Schlecht: Klammern und Text geclustered">
public class Cube {
private int x,y,z;
private int calculateVolume(){
/* Berechnung */
}}
</source>

<source lang="java" title="Schlecht: Einrückung falsch formatiert, stimmt nicht mit Ebene überein">
public class Cube {
private int x,y,z;

private int calculateVolume(){
/* Berechnung */
}
}
</source>

<source lang="java" title="Schlecht: Uneinheitlich geklammert">
public class Calculator {
private int calculate(int x, int y){
for(int i = 0; i < y; i++)
{
/* Berechung */
}
}
}
</source>

<source lang="java" title="Alternative Klammerung">
public class Cube
{
private int x,y,z;

private int calculateVolume()
{
/* Berechnung */
}
}
</source>