Anweisungen und Programme

Algorithmus

Ein Algorithmus (algorithm) ist eine allgemeingültige endliche Folge von elementaren Operationen, die maschinell durchgeführt werden können. Die Folge enthält eine Beschreibung, wie diese elementaren Operationen nacheinander durchgeführt werden sollen. Insbesondere ist dabei eine Start- und Ende-Bedingung angegeben.
G. Büchel, Praktische Informatik

Typische Merkmale eines Algorithmus

• Eindeutigkeit
  jeder Schritt ist genau beschrieben
• Endlichkeit
  endet nach einer bestimmten Anzahl von Schritten
• Ausführbarkeit
  Schritte so formuliert, dass sie umsetzbar sind
• Determinismus
  gleiche Eingaben liefern gleiche Ausgaben

Es gibt Algorithmen, die absichtlich das Prinzip des Determinismus verletzen, z. B. wenn es darum geht Zufallszahlen zu generieren.

Es gibt verschiedene Möglichkeiten, Algorithmen zu formulieren.

• Formulierung von Algorithmen
• umgangssprachlich
• in einer Programmiersprache
• als Aktivitätsdiagramme
• Ausführung von Algorithmen durch einen Prozessor (Mensch / Computer)
  ⇒ Prozess (process)

Bei der umgangssprachlichen Formulierung muss man mit dem Problem umgehen, dass natürliche Sprache nicht eindeutig ist und immer einen Interpretationsspielraum lässt. Deswegen greift man bei der Programmierung auf klar definierte Programmiersprachen oder Aktivitätsdiagramme zurück. Beide besitzen eine eindeutigte Semantik und lassen keinen Raum für Interpretationen.

Algorithmus / Beispiel

Aufgabe: Berechne die Summe der Zahlen von 1 bis n

Umgangssprachliche Formulierung

Addiere für eine vorgegebene natürliche Zahl n
die Zahlen von 1 bis n. Dies ist das Resultat.

Programmiersprache

int n = readInt();
int erg = 0;
int aktZahl = 1;
while (aktZahl <= n) {
    erg = erg + aktZahl ;
    aktZahl = aktZahl + 1;
}
printInt(erg);

Hier sei kurz angemerkt, dass der Algorithmus an sich sinnlos ist, weil bereits Gaus als neunjähriger Schüler eine Formel (Gaußsche Summenformel) aufgestellt hat, mit der man die Summe der ersten n natürlichen Zahlen direkt brechnen kann:

\[ \begin{align*} 1+2+3+4+\dotsb +n=\sum_{k=1}^{n} k=\frac{n(n+1)}{2} = \frac{n^{2}+n}{2} \end{align*} \]

Programmiersprachen / Abstraktionsebenen

Bei jeder Programmiersprache muss man sich über deren grundlegende Eigenschaften verständigen. Diese muss man als Programmierer:in kennen, um korrekte Programme in der Sprache schreiben zu können.

• Lexikalik
  gültige Zeichen und Wörter der Sprache
• Syntax
  korrekter Aufbau von Sätzen der Sprache
• Semantik
  Bedeutung von Sätzen der Sprachen
• Pragmatik
  Einsatzbereich und Stil bei der Nutzung einer Sprache

Die Lexikalik legt fest, welche Zeichen überhaupt in einer Sprache vorkommen dürfen und welche Zeichenfolgen eine besondere Bedeutung haben. Ziel ist es, Zeichen zu erkennen, die zusammengehören. Diese zusammengehörigen Einheiten nennt man Token. Für einen deutschen Satz wären die möglichen Zeichen A–Z, a–z, äöüßÄÖÜ und die bekannten Satzzeichen. Die Token werden hier durch Leerzeichen getrennt. Der Satz „Peter liebt Schokolade.“ besteht somit aus drei Token: „Peter“, „liebt“ und „Schokolade“.

Die Syntaktik legt fest, wie die Sätze der Sprache aufgebaut werden dürfen, also wie die Token angeordnet werden können, damit ein gültiger Satz in der Sprache herauskommt. Für natürliche Sprachen gibt es z. B. Regeln, wie die einzelnen Satzbausteine aufeinanderfolgen müssen. Im Englischen z. B. üblicherweise nach der Form Subjekt, Prädikat, Objekt: „Peter likes chocolate.“. Ein ungültiger Satz wäre hier „Peter chocolate likes.“ (zumindest für alle außer Meister Yoda). Für Programmiersprachen verwendet man Syntax-Diagramme (s. u.), um die Syntax festzulegen.

Die Semantik bestimmt, welche Bedeutung ein syntaktisch korrekter Satz hat. Für Programmiersprachen ist genau festgelegt, was bei bestimmten Befehlen passiert. In natürlichen Sprachen ist dies etwas schwammiger und oft erst aus dem Kontext zu bestimmen.

Die Pragmatik ist nicht mehr Teil der Spezifikation einer Sprache, sondern ergibt sich aus der Erfahrung mit der Sprache und den Eigenschaften der Sprache. Sie legt fest, wo und wie man eine bestimmte Sprache sinnvollerweise einsetzt. Da es sich um einen Erfahrungswert handelt, ist die Pragmatik nicht fix und subjektiv.

Begriffe

Peter liebt Schokolade, deshalb ruft er "Juhu".

• Schlüsselworte (keywords): Wörter, die direkt in die Programmiersprache eingebaut sind
  (liebt, deshalb, ruft, er)
• Bezeichner (identifier) beziehen sich auf ein Objekt oder einen Wert
  (selbstdefiniert Peter, von außen vorgegeben Schokolade)
• Literale repräsentieren direkt einen Wert ("Juhu")
• Satzzeichen strukturieren den Text (, und .)
• Kommentare (comment) machen Aussagen über den Satz außerhalb des Satzes selbst

Beispiel in Java

// Ein erstes Programm
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

• Schlüsselworte: public, class, static, void
• Bezeichner: HelloWorld, main, args, System.out.println
• Literale: "Hello World"
• Satzzeichen: { } [ ] ( ) ;
• Kommentare: Ein erstes Programm

Lexikalik

• Java zugrundeliegender Zeichensatz: Unicode
• 16-Bit-Zeichensatz (2¹⁶ Zeichen)
• erste 128 Zeichen: ASCII (7-Bit-Zeichensatz)

Java unterscheidet zwischen Groß- und Kleinschreibung.

Schlüsselwörter

abstract     assert     boolean       break
byte         case       catch         char
class        const      continue      default
do           double     else          enum
extends      false      final         finally
float        for        goto          if
implements   import     instanceof    int
interface    long       native        new
null         package    private       protected
public       return     short         static
strictfp     super      switch        synchronized
this         throw      throws        transient
true         try        void          volatile
while

Java Schlüsselworte dürfen nicht für Bezeichner (identifier), d. h. Variablennamen, Klassennamen oder Methodennamen verwendet werden.

Das Schlüsselwort goto ist zwar reserviert, wird aber in der Sprache gar nicht verwendet. Vermutlich hat man es zum Schlüsselwort gemacht, weil in der Sprache C goto ebenfalls ein Schlüsselwort ist (mit dem man unbedingte Sprünge machen kann) und man sich die Möglichkeit offen halten wollte, später Sprünge in Java einführen zu können. Da goto aber zum sogenannten Spaghetticode führt, ist es als positiv zu werten, dass Java solche Sprünge nicht unterstützt.

Regeln für Bezeichner

Bezeichner in Java dienen dazu, Programmelemente eindeutig zu benennen, damit man sie im Code verwenden, referenzieren und wiederverwenden kann.

Bezeichner (identifier) dienen der Benennung von deklarierten Einheiten

• Klassen
• Variablen und Konstanten
• Parameter
• Prozeduren und Methoden
• Pakete
• …

Bezeichner geben Namen für

• Klassen, z. B. class Auto { ... } → Auto ist der Bezeichner für die Klasse
• Variablen und Konstanten, z. B. int alter = 25; → alter ist der Bezeichner für die Variable
• Parameter, z. B. void sagHallo(String name) → name ist der Bezeichner für den Parameter
• Methoden, z. B. public void druckeText() { ... } → druckeText ist der Methodenname
• Objekte, z. B. Auto meinAuto = new Auto(); → meinAuto ist der Bezeichner für die Referenz auf das Objekt

Bezeichner dürfen nicht so heissen wie Java-Schlüsselwörter (z. B. int, if, class) und müssen gewissen Namensregeln folgen (z. B. keine Leerzeichen, keine Sonderzeichen außer _ und $).

Ein gültiger Name für einen Bezeichner in Java

• entspricht nicht einem Schlüsselwort
• enthält beliebige Unicode-Buchstaben, Zahlen, $ oder _
• beginnt mit _, $ oder einem Buchstaben
• kann beliebig lang werden

Beispiele

• gültige Bezeichner:
  _hugo, peter__$$, antwort_42, meine7suenden, $rich$, haenselUndGretel
• ungültige Bezeichner:
  7zwerge, goto, km/h, -strich, haensel&gretel

Konvention für Bezeichner

In Java gibt es Konventionen für Bezeichner, also empfohlene Regeln zur Benennung von Variablen, Klassen, Methoden usw. Diese Konventionen machen den Code einheitlich, lesbar und wartbar – besonders in größeren Projekten oder Teams.

Bezeichner

• verwenden nur die Buchstaben A–Z, a–z und in bestimmten Fällen den Unterstrich (_)
• sind in camelCase: hanselUndGretel, patentAnmeldung, HelloWorld
• für Klassen beginnen mit einem Großbuchstaben
  TanzVeranstaltung, HundeKuchen
• für Variablen und Methoden beginnen mit einem Kleinbuchstaben
  tanzen, futterFressen
• für Konstanten in Großbuchstaben (Trennung mit _)
  PI, MOL_PRO_LITER

Variablen und Methoden: camelCase

• Erstes Wort klein, jedes weitere mit großem Anfangsbuchstaben.
• Keine Unterstriche (_).
• Vermeide Abkürzungen, außer sie sind allgemein verständlich.

int anzahlProdukte;
double bruttoPreis;
String getBenutzerName() { ... }

Klassen und Interfaces: PascalCase (auch UpperCamelCase genannt)

• Jedes Wort beginnt mit einem Großbuchstaben.
• Keine Unterstriche (_).
• Klassennamen sind oft Substantive.

class Fahrzeug { ... }
interface Druckbar { ... }
class KundenVerwaltung { ... }

Konstanten: UPPER_CASE_WITH_UNDERSCORES

• Alle Buchstaben groß.
• Wörter werden durch Unterstriche (_) getrennt.

final int MAX_WERT = 100;
final double PI = 3.14159;
final String STANDARD_FARBE = "Blau";

Pakete: Kleinbuchstaben, durch Punkte getrennt**

• Nur kleine Buchstaben, keine Unterstriche (_).
• Beginnt oft mit dem Domainnamen rückwärts (z. B. de.firma.projekt)

package com.meinunternehmen.meinprojekt.util;

Diese Konventionen sind nicht technisch zwingend, aber sie werden vom Java-Standard (z. B. von Oracle) und den meisten Entwickler:innen strikt empfohlen und erwartet. Wer sich daran hält, schreibt professionelleren und besser verständlichen Code.

Anweisungen und Kommentare

Programm besteht aus

• Anweisungen (statements)
• sagen dem Computer, was er tun soll
• enden in Java immer mit einem Semikolon ;
• Kommentaren (comment)
• erklären dem Menschen, was die Programmierer:innen erreichen wollte
• werden vom Compiler ignoriert

In einem Java-Programm sind die grundlegenden Bestandteile Anweisungen und Kommentaren.

Anweisungen sind ausführbare Befehle, die dem Computer sagen, was er tun soll. Sie werden immer durch ein Semikolon (;) beendet. Anweisungen werden vom Compiler verarbeitet und beim Programmstart ausgeführt. Beispiele sind Zuweisungen, Berechnungen, Methodenaufrufen, etc.

Kommentare sind Texte im Code, die der Erklärung und Dokumentation dienen. Sie werden vom Compiler ignoriert, beeinflussen also das Programm nicht.

• Zeilenkommentar (line comment)
• beginnt mit //
• endet am Ende der Zeile
• wird oft für kurze Hinweise verwendet
• Blockkommentar (block comment)
• beginnt mit /*
• endet mit */
• kann sich über mehrere Zeilen erstrecken
• gut für längere Erklärungen oder zum „Auskommentieren“ von Code

• JavaDoc-Kommentar (JavaDoc comment)
• spezieller Blockkommentar
• beginnt mit /**, endet mit */
• beschreibt die Funktion von Methoden und Klassen (s. u.)

JavaDoc-Kommentare sind eine besondere Art von Kommentaren in Java. Sie werden verwendet, um den Code automatisch zu dokumentieren, damit andere (oder man selbst) später schnell verstehen, was Klassen, Methoden oder Variablen machen. Aus JavaDoc-Kommentaren kann man automatisch HTML-Dokumentationen erzeugen und so eine Art Handbuch für das Verständnis des Codes erzeugen.

// dies ist ein Zeilenkommentar
vor();

/*
 Blockkommentar, der sich ueber
 mehrere Zeilen erstrecken kann.
*/
nimm();

/**
 * JavaDoc-Kommentar für eine Methode.
 * Er geht auch über mehrere Zeilen.
 */
void linksUm() {}