Wie kann ich meine MAC-Adresse herausfinden?

Bevor man beginnt seine MAC-Adresse zu ändern, sollte man zunächst in Erfahrung bringen wie die eigene MAC-Adresse lautet. Am einfachsten lässt sich dies mit dem Terminal machen. Das Terminal ist auf OS X 1.6.x in Programme -> Dienstprogramme zu finden. Der Befehl um sich die MAC-Adresse der WLAN-Karte ausgeben zu lassen, könnt ihr hier entnehmen.

ifconfig en1 | grep ether

Die Ausgabe sollte dann in etwa so lauten

ether 00:26:ab:2b:af:39

Der Wert hinter “ether” ist eure MAC-Adresse. Hier kann man auch die gängige Syntax erkennen: Eine MAC-Adresse besteht aus sechs Hexadezimalzahlen, die durch Doppelpunkte getrennt sind.

Was ist vor der Änderung der MAC-Adresse zu beachten?

Bevor man die MAC-Adresse ändern kann, sollte man sich vergewissern, dass man mit keinem Netzwerk verbunden ist. Airport sollte jedoch aktiviert bleiben. Am einfachsten trennt man sich von einem verbundenen Netzwerk, indem man das Kommandozeilen-Tool “airport” nutzt. Leider ist es mit den Standardeinstellungen nicht einfach zu erreichen. Um sich lästiges Tippen zu ersparen, kann man sich eine Verknüpfung mit dieser Anweisung anlegen.

sudo ln -s /System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport /usr/sbin/airport

Einfach diesen Befehl kopieren, ins Terminal einfügen und ausführen. Der Aufruf von “sudo” erfordert eine Passworteingabe. Dafür tippt man sein Root-Passwort ein. Schon können wir uns damit von einem Netzwerk trennen

sudo airport -z

Dieser Befehl erledigt die ganze Arbeit für uns.

Wie ändere ich meine MAC-Adresse?

Nun können wir uns dem eigentlichen Thema widmen. Möchten wir beispielsweise unsere MAC-Adresse zu 00:11:22:33:44:55 ändern, nutzen wir diesen Befehl dafür

sudo ifconfig en1 ether 00:11:22:33:44:55

Nun sollten wir eine andere MAC-Adresse haben.

Wie prüfe ich die Änderung der MAC-Adresse?

Die Änderung der MAC-Adresse zu überprüfen ist gar nicht schwer. Man ruft einfach den bereits oben genutzten Befehl auf.

ifconfig en1 | grep ether

Und siehe da, unsere MAC-Adresse wurde erfolgreich geändert.

ether 00:11:22:33:44:55

War doch gar nicht so schwer oder?

IP-Adressen unterscheiden sich oft von Land zu Land. Manche IP-Adressen können sogar mit einer Stadt in Verbindung gebracht werden. So liefert uns beispielsweise die Seite http://utrace.de, dass sich die IP-Adresse 130.149.7.201 in Berlin befindet und zur TU-Berlin gehört.

Und so kann auch beispielsweise youtube herausfinden, dass wir uns in Deutschland befinden und uns den Zugriff auf ein Video verweigern. Probieren wir doch mal aus das Lied “The Catalyst” von Linkin Park anzusehen und freuen uns über eine Fehlermeldung.

Ich bin mir sicher, hätten wir eine IP aus den USA, könnten wir uns das Video problemlos ansehen. Dann sollten wir es doch mal probieren!

Zunächst brauchen wir die IP-Adresse eines Proxy-Servers aus den USA. Klingt kompliziert – ist es jedoch gar nicht. Im Internet finden sich eine Menge Seiten, die uns diese IP-Adressen kostenlos und auch noch legal zur Verfügung stellen. Sehen wir uns mal die Seite http://proxy-list.org an. Dort finden wir neben einem Haufen Werbung noch ein kleines Formular mit dem wir nach Proxy-Server suchen können. Den einzigen Wert den wir dabei ändern sollten, ist “country” da wir ja einen Proxy aus den USA haben wollen. Hier schnell auf “United States” gestellt und unten den korrekten Captcha-Code eingetippt, bekommen wir solch eine Liste zu sehen:

Nehmen wir doch gleich mal den ersten Eintrag in der Liste (209.136.113.151:808). Wir sehen, dass dieser aus zwei Teilen besteht: Alles was sich vor dem Doppelpunkt befindet, ist die IP-Adresse des Servers; Alles danach ist der Port auf dem der Server auf neue Verbindungen horcht.

Nun haben wir schon alles was wir brauchen. Jetzt müssen wir nur noch unserem Browser bzw. unserem Betriebssystem sagen, dass er den Internetverkehr über diesen Proxy leiten soll.  Ich werde hier nur ein Beispiel am Firefox 5.0 demonstrieren. Bei anderen Browser läuft dies ähnlich.

Den Browser geöffnet, gehen wir auf Einstellungen -> Erweitert -> Netzwerk.

Hier klicken wir auf Einstellungen und wählen den Punkt “Manuelle Proxy-Konfiguration” aus. Bei HTTP-Proxy tragen wir die IP-Adresse unseres Proxy-Servers ein (209.136.113.151) und bei Port den Port auf dem der Server horcht (808).

Nun klicken wir auf OK und schließen das Fenster. Nun können wir die Seite http://wieistmeineip.de aufrufen und vergewissern, dass wir uns in den USA befinden.

Jetzt brauchen wir nur noch das Youtube-Video aufrufen, das vorher nicht funktioniert hat und uns freuen.

/**
 * Klasse Programm soll die Verwendung von Methoden verdeutlichen.
 */
class Programm {
    /**
     * Methode add addiert zwei uebergebene Parameter und gibt die Summe zurueck
     * @param summand_1 Der erste Summand
     * @param summand_2 Der zweite Summand
     * @return Das Ergebnis der Addition beider  Summanden
     */
    public static int add(int summand_1, int summand_2){
        return summand_1 + summand_2;
    }
 
    /**
     * Methode hallo gibt ihren Namen aus. Welche weitere Methode sie aufgerufen hat und
     * welches Ergebnis sie von der anderen Methode erhalten hat.
     */
    public static void hallo(){
        System.out.println("Ich bin die Methode \"hallo\"");
        System.out.println("Ich rufe die Methode \"add\" mit den Parametern 3 und 4 auf");
        int summe = add(3, 4);
        System.out.println("Ich habe als Ergebnis die Summe " + summe + " von \"add\" erhalten");
    }
    /**
     * Main-Methode wird vom Compiler gesucht und automatisch aufgerufen
     */
    public static void main(String[] args) {
        System.out.println("Das ist ein Beispiel, das die Verwendung von Methoden erklaeren soll");
        hallo();
        System.out.println("Hier endet die main-Methode und damit das Programm");
    }
}

Dieses Programm enthält insgesamt drei Methoden, die wir definiert haben. Zunächst ist da die bereits bekannte main-Methode. Diese wird beim Kompilieren und beim Ausführen des Programms gesucht und automatisch aufgerufen. Sie ermöglicht also der JVM den Einstieg in unser Programm. Ohne ihr würde nichts funktionieren. Wichtig ist, dass ein Programm nur eine main-Methode haben darf, da sonst nicht klar ist, welche dieser Methoden ausgeführt werden sollen.
Die zweite Methode ist die Methode “hallo”. Sie ähnelt in ihrem Methodenkopf sehr stark der main-Methode. Der einzige Unterschied ist, dass unsere hallo-Methode keine Parameter übergeben bekommt. Parameter sind die Elemente, die von der runden öffnenden und schließenden Klammer, die hinter der Bezeichnung der Methode kommt, eingeschlossen werden. Zu erkennen ist, dass die main-Methode einen Parameter mit der Bezeichnung “args” übergeben bekommt. Dieser Parameter ist vom Typ ein String-Array.

Die Methode “hallo” ruft in Zeile 22 eine weitere Methode auf, die wir “add” genannt haben. Das Ergebnis, dass uns die Methode “add” liefert, wird der Variablen “summe” zugewiesen. Der Wert der Variablen wird dann in der drauf folgenden Zeile ausgegeben.
Die Methode “add” addiert die beiden übergebenen Parameter. Das Ergebnis der Addition wird dann zurückgegeben. Das Zurückgeben erfolgt stets mit dem Schlüsselwort “return”. Sobald wir etwas zurückgeben möchten, müssen wir im Methodenkopf notieren welchen Typ die Rückgabe haben wird. Deshalb steht vor der Bezeichnung der add-Methode das Schlüsselwort “int”. Zurückgegeben werden können alle erdenklichen Typen wie int, long, float, double, String, Arrays und Objekte. Da wird in der Methode “hallo” nichts zurückgeben wollen, sondern nur Ausgaben tätigen, muss vor dem Methodennamen das Schlüsselwort “void” stehen. Es heißt soviel wie “Ich geben nichts zurück”. Die main-Methode darf per Konvention nur void sein.

Was ist nun der Sinn hinter Methoden? Methoden dienen dazu, um Code durch Auslagern übersichtlicher und wartungsfreundlicher zu gestalten.

Methoden werden nacheinander wie sie im Programm aufgerufen werden abgearbeitet. Methoden, die andere Methoden aufrufen, werden unterbrochen und fahren erst nachdem die aufgerufene Methode beendet ist, in ihrem Programmfluss fort. In unserem Beispiel wird zunächst du die JVM die main-Methode ausgeführt. In dieser Methode rufen wir die Methode “hallo” auf. Somit wird die Methode main zunächst unterbrochen und die hallo-Methode ausgeführt. Methode “hallo” ruft wiederum die Methode “add” auf, der sie die zwei Parameter 3 und 4 übergibt, um dann den eigenen Programmfluss zu unterbrechen und den Weg für “add” frei zu machen. Nachdem “add” die beiden Parameter addiert hat, kann “hallo” fortfahren und ebenfalls beendet werden. Jetzt wird weiter die Methode “main” ausgeführt, bis diese abgearbeitet wurde und unser Programm schließlich beendet werden kann.
Den Programmfluss soll das nachfolgende Bild darstellen.

Programmfluss der Methoden

Der einfache Weg:

Im Internet findet man eine Menge kostenloser Video-Downloader, die man sich installieren kann. Auf http://www.dvdvideosoft.com/ kann man sich aus einem ganzen Haufen an Programmen aussuchen, die Youtube-Videos runterladen und diese eventuell in andere Video-Formate umwandeln können.

Die andere Möglichkeit ist es einen der zahlreichen Online-Dienste zu nutzen, die einem Youtube-Videos zum Download anbieten. Hier eine kleine Auswahl:

• http://www.filsh.net/
• http://www.mediaconverter.org/
• http://music-clips.net
• http://keepvid.com/
• http://www.clipconverter.cc/
• http://www.videoget.net/
• http://www.qtube.de
• http://getvids.de

Alle diese Dienste funktionieren relative gleich. Deswegen gebe ich hier nur ein Anleitung zu Filsh.net:

1. Ein cooles Video aufrufen und den Link aus der Browser-Adressleiste kopieren
   
2. Link bei Filsh.net einfügen, Nutzungsbestimmungen akzeptieren und auf “Weiter” klicken
3. Zugucken wie Filsh.net das Video von Youtube runterlädt
4. Auf “Download” klicken und Video von Filsh.net downloaden

In vielen Unix-Systemen sind die MD5-Bibliotheken bereits integriert und können über die Konsole genutzt werden.
Auf einem Mac sieht der Aufruf beispielsweise so aus:

md5 -s "ein string, den ich verschlüsseln will"

Mit dem Ergebnis:

MD5 ("ein string, den ich verschlüsseln will") = fbf50beb87218a44ed02a7cf4dca9868

Wie man erkennt entspricht der String “ein string, den ich verschlüsseln will” dem MD5-Hash fbf50beb87218a44ed02a7cf4dca9868.

Ein Merkmal der MD5-Funktion besteht darin, dass ein Hash-Wert nicht ohne Weiteres wieder entschlüsselt werden kann.
Deswegen wird MD5 oft genutzt um Passwörter verschlüsselt in Datenbanken zu speichern.

Was macht man nun, wenn man aber mal doch diesen Hash entschlüsselt haben möchte? Da das zurückrechnen nicht möglich ist, verwendet man eine besondere Datenstruktur, die sogenannten Rainbow Tables. Im Internet finden sich zahlreiche Seiten, die eine Entschlüsselung von Hashes mittels Rainbow Tables anbieten. Darunter findet man auch die Seite c0llision.net, die u.a mittels einer API ermöglicht auf ihre Dienste zuzugreifen. Wie man diese nutzt, will ich in den folgenden Textabschnitten erklären. Dabei stütze ich mich auf diese Dokumentation: http://www.c0llision.net/rest_api_documentation.

Der Zugriff auf die API erfolgt über die URL http://api.dev.c0llision.net/. Die API unterstützt drei verschiedene Formate, die einem als Ergebnis einer Anfrage geliefert werden. Zur Auswahl stehen dabei JSON, XML und YAML. Ich habe mich hier für JSON entschieden, da später der Zugriff über PHP bequemer ist. Als Algorithmen werden LM, NTLM und wie eingangs erwähnt MD5 unterstützt. Diese Angaben müssen der URL angehängt werden. Dabei erhält man folgendes Muster, um eine Anfrage an die c0llision API absetzen zu können:

http://api.dev.c0llision.net//crack//

Wollen wir nun den MD5-Hash fbf50beb87218a44ed02a7cf4dca9868 entschlüsselt haben und das Ergebnis als JSON zurückgeliefert bekommen, würden wir folgende Anfrage abschicken:

http://api.dev.c0llision.net/json/crack/md5/fbf50beb87218a44ed02a7cf4dca9868

Um diese Anfrage bequem per Skript verarbeiten zu können, habe ich folgendes kleines PHP-Programm geschrieben:

<!--?php
  function crack($algorithm, $hash){
    //Convert algorithm to lowercase
    $algorithm = strtolower($algorithm);
    $pattern = '';
    $url = 'http://api.dev.c0llision.net/json/crack/';
 
    //Check algorithm
    switch($algorithm){
      case 'md5':
        $pattern = '/^([0-9a-f]{32})$/';
        $url .= 'md5/';
      break;
 
      case 'lm':
        $pattern = '/^([0-9a-f]{32}:[0-9a-f]{32})$/';
        $url .= 'lm/';
      break;
 
      case 'ntlm':
        $pattern = '/^([0-9a-f]{32})$/';
        $url .= 'ntlm/';
      break;
 
      default:
        return FALSE;
      break;
    }
 
    //Check hash
    $check = preg_match($pattern, $hash);
    if(0 === $check || FALSE === $check){
      return FALSE;
    }
 
    //Build final URL
    $url .= $hash;
 
    //Initialize CURL and set options
    $curl_handle = curl_init();
    curl_setopt($curl_handle, CURLOPT_URL, $url);
    curl_setopt($curl_handle, CURLOPT_HEADER, 0);
    curl_setopt($curl_handle, CURLOPT_RETURNTRANSFER, TRUE);
    curl_setopt($curl_handle, CURLOPT_TIMEOUT, 4);
 
    //Execute CURL request
    $result = curl_exec($curl_handle);
    curl_close($curl_handle);
 
    return $result;
  }
 
  function crackMD5($hash){
    return crack('md5', $hash);
  }
 
  function crackLM($hash){
    return crack('lm', $hash);
  }
 
  function crackNTLM($hash){
    return crack('ntlm', $hash);
  }
?-->

Das Programm definiert eine Prozedur “crack”, welche die ganze Funktionalität liefert. In ihr wird zunächst ein Teil der URL gespeichert, auf die im weiteren Programmablauf mittels cURL zugegriffen wird. Nachdem die Variable “url” gesetzt wurde, wird überprüft ob ein korrekter Algorithmus gewählt wurde und das Muster des Hashs zum Algorithmus passt. Beispielsweise darf ein MD5-Hash lediglich aus 32 hexadezimalen Zahlen bestehen. Ist ein gültiger Hash übergeben, wird er an die URL gehängt. Diese ist nun vollständig zusammengebaut. Mittels cURL wird nun eine GET-Anfrage abgesetzt, die Antwort in die result-Variable gespeichert und zurückgegeben. Die weiteren Funktionen “crackMD5″, “crackLM” und “crackNTLM” nutzen lediglich “crack”, indem sie ihr die entsprechenden Parameter übergeben.
Die crackMD5-Funktion wollen wir nun nutzen, um den Hash 098f6bcd4621d373cade4e832627b4f6 zu entschlüsseln.
Ein PHP-Skript könnte zum Beispiel so aussehen:

<!--?php
  $hash = '098f6bcd4621d373cade4e832627b4f6';
  $result = crackMD5($hash);
  $json;
  if(FALSE !== $result){
    $json = json_decode($result, true);
 
    // HTTP 200 received
    if(200 !== $json['response']['status']['code']){
        echo 'Server response: ' . $json['response']['status']['code'];
    }
    // Hash already cracked
    elseif(TRUE !== $json['response']['result']['cracked']){
        echo 'Sorry, your hash has not been cracked yet';
    }
    else {
        echo $json['response']['result']['plaintext']['raw'];
    }
}
?-->

Es setzt eine Anfrage durch die Funktion “crackMD5″ an die c0llision API ab und speichert die Antwort in die Variable “result”. Hat “crackMD5″ eine gültige Antwort zurückgegeben, so dekodieren wir den JSON-String mittels der PHP-Funktion “json_decode“. Dann wird geprüft, ob der Server mit einem HTTP-200-Status geantwortet hat und der zu entschlüsselnde Hash bereits gecrackt wurde. Ist dies der Fall, wird der entsprechende Klartext des Hashs ausgegeben.

Dabei geht es darum mit dem Begriff Volksphone am 23.09.2009 um 22:00 Uhr auf Platz eins  der Google-Suche zu landen. Zu gewinnen gibt es wie letztes Jahr auch ein iPhone – diesmal handelt es sich dabei um das iPhone 3GS 32GB.

Trafficmaxx, der Gewinner des letztjährigen Wettbewerbs, versucht auch dieses Jahr seinen Platz zu verteidigen. Sollte sich Trafficmaxx wieder als Sieger behaupten können, so soll laut trafficmaxx Weblog das Volksphone zu einem guten Zweck öffentlich versteigert werden.

Also Leuts, jetzt ist Endspurt angesagt. Bloggt fleißig für den Volksphone – Contest!

cowsay 'Java rocks!'

Die Ausgabe dazu sollte so aussehen:

 _____________
< Java rocks! >
 -------------
           ^__^
           (oo)_______
           (__)       )/
              ||----w |
              ||     ||

Diese Funktionalität möchten wir nun nachbauen, dass wir unser cowsay mit diesem Befehl ausführen können und das Ergebnis genauso aussehen soll wie das original cowsay aus Unix.

java cowsay 'Java rocks!'

Der Vorteil dabei ist jedoch, dass wir dieses Programm auf Windows, Linux, Mac OSX und allen anderen Betriebssystemen nutzen können, die auch von dem Java Runtime Environment unterstützt werden.
Okay, fangen wir dann mal an. Zunächst erstellen wir uns eine Klasse cowsay, die auch die main-Methode enthält:

class cowsay
{
  public static void main(String[] args)
  {
  }
}

Zunächst sollten wir klären wie wir es schaffen, dass der Text, den wir beim Aufruf des cowsay-Programms mitgeben auch in unseren Java-Code kommt. Dazu ist dieses String[] args da! Wie wir in den letzten Tutorials gelernt haben, handelt es sich hierbei um ein Array des Typs String. Darin finden wir die Argumente, die wir an unser Programm in der Konsole übergeben haben. Bei unserem cowsay brauchen wir lediglich auf args[0] zuzugreifen, denn wir übergeben nur ein Argument. Sollten wir jedoch mehrere Argumente übergeben wollen, so trennen wir diese durch ein Leerzeichen im Programmaufruf und finden diese in args[0] … args[n] wieder. Je nachdem wie viele davon wir übergeben hatten.
Ein Problem auf das wir stoßen werden, ist dass wir die Fehlermeldung “ArrayIndexOutOfBoundException” erhalten, wenn wir beim Programmaufruf keine Nachricht übergeben. Dies werden wir mit einer bedingten Anweisung lösen und eine Standardnachricht angeben.
Deshalb waren mir auch die letzten Tutorials so wichtig, bevor wir dieses hier bearbeiten konnten.
Bauen wir uns dazu nun folgenden Code:

class cowsay
{
  public static void main(String[] args)
  {
    if(args.length == 0)
    {
      args = new String[1];
      args[0] = "Ich sage nix";
    }
    //Hier geht es noch weiter
  }
}

Hier prüfen wir mit args.length == 0, ob das args Array einen Wert zugewiesen bekommen hat. Ist dies der Fall, so ist die Länge des Arrays größer 0! Sollte es nun so sein, dass keine Nachricht eingegeben wurde, definieren wir args als ein String-Array-Objekt mit einer Länge von eins. Nun speichern wir die Standardnachricht “Ich sage nix” in das Array an der Stelle 0.

Wenden wir uns jetzt der Sprechblase zu. Wir müssen dabei darauf achten, dass die Größe dieser abhängig von der Länge der eingegeben Nachricht ist. Dieses Problem werden wir mit einer Schleife lösen können. Dies zeigt uns das folgende Code-Fragment:

class cowsay
{
  public static void main(String[] args)
  {
    if(args.length == 0)
    {
      args = new String[1];
      args[0] = "Ich sage nix";
    }
    String message = args[0];
    int messageLength = message.length();   //Laenge der Nachricht
 
    /*********************************************
    *           Sprechblase erzeugen
    *********************************************/
    String top = " ";                //Obere Linie der Sprechblase
    String bottom = " ";             //Untere Linie der Sprechblase
 
    //Linke und rechte Grenze mit Nachricht der Sprechblase
    String contentAndBorders = "< " + message + " >";
 
    //Gesamte Sprechblase
    String speechBubble;
 
    //Obere + untere Linie erzeugen
    for(int i = 1; i <= messageLength + 2; i++)
    {
      top += "_";
      bottom += "-";
    }
 
    speechBubble = top + "n";
    speechBubble += contentAndBorders + "n";
    speechBubble += bottom + "n";
 
    //Jetzt folgt noch die Kuh
  }
}

Die ersten Zeilen sind die gleichen wie im obigen Code. Wir weisen der Variablen message den Inhalt des Arrays an der Stelle 0 zu, damit wir uns das Schreiben der eckigen Klammern sparen können und diese Variable einfach sprechender ist, als ein args[0].
Die Variable messageLength bekommt die Länge unserer Nachricht zugewiesen, da wir diese für die Schleife brauchen werden. Als nächstes erzeugen wir uns die Variablen top und bottom, die die Zeichen für die obere bzw. untere Linie enthalten werden. Diese bekommen jeweils zunächst ein Leerzeichen zugewiesen. Damit stellen wir sicher, dass über / unter der öffnenden spitzen Klammer keine Striche stehen werden.
Die Variable messageAndBorders enthält die Nachricht und den linken und rechten Begrenzer gefolgt von einem Leerzeichen, damit links und rechts von der Nachricht etwas Platz bleibt. – Sieht einfach besser aus. Dadurch müssen wir aber auch die Schleife um zwei Durchläufe erweitern, um dies auszugleichen. In dieser Schleife werden die Variablen top und bottom mit den entsprechenden Zeichen “_” und “-” gefüllt. Es werden so viele Zeichen erstellt wie die Nachricht – verlängert um zwei – lang ist.
Die Variable speechBubble soll die gesamte Sprechblase enthalten und bekommt deshalb top, contentAndBorders und bottom – jeweils gefolgt von einer “newline” – zugewiesen.

Jetzt fehlt uns nur noch die Kuh. Eigentlich könnten wir einfach den Code aus dem CowSay-Tutorial verwenden, denn es ändert sich hierbei nichts. Um aber so viele System.out.println zu vermeiden, speichern wir die Kuh in die kuh Variable und erstellen uns eine Variable cowsay, die die Sprechblase und die Kuh enthält, die wir dann schließlich ausgeben werden.

class cowsay
{
  public static void main(String[] args)
  {
    if(args.length == 0)
    {
      args = new String[1];
      args[0] = "Ich sage nix";
    }
    String message = args[0];
    int messageLength = message.length();   //Laenge der Nachricht
 
    /*********************************************
    *           Sprechblase erzeugen
    **********************************************/
    String top = " ";                //Obere Linie der Sprechblase
    String bottom = " ";             //Untere Linie der Sprechblase
 
    //Linke und rechte Grenze mit Nachricht der Sprechblase
    String contentAndBorders = "< " + message + " >";
 
    //Gesamte Sprechblase
    String speechBubble;
 
    //Die Kuh
    String kuh;
 
    //Die gesamte Ausgabe
    String cowsay;
 
    //Obere + untere Linie erzeugen
    for(int i = 1; i <= messageLength + 2; i++)
    {
      top += "_";
      bottom += "-";
    }
 
    speechBubble = top + "n";
    speechBubble += contentAndBorders + "n";
    speechBubble += bottom + "n";
 
    //Die Kuh erzeugen
    kuh = "          ^__^" + "n";
    kuh += "          (oo)_______" + "n";
    kuh += "           (__)       )/" + "n";
    kuh += "               ||----w |" + "n";
    kuh += "               ||     ||";
 
    cowsay = speechBubble + kuh;
 
    System.out.println(cowsay);
  }
}

Jetzt ist unsere Kuh eigentlich fertig und kann auch verwendet werden. Wir werden sie aber noch in späteren Tutorials umbauen. Freut euch schon mal drauf.

int[] zahlArray = new int[4];
 
zahlArray[0] = 5;
zahlArray[1] = 2;
zahlArray[2] = 3;
zahlArray[3] = 4;

Mit den eckigen Klammern nach dem Typ sagen wir, dass wir ein Array erzeugen möchten. Die eckigen Klammern hinter die Bezeichnung des Arrays zu setzen ist auch möglich. Mit dem Schlüsselwort “new” erzeugen wir ein neues Array-Objekt, das Integer-Werte enthält und 4 Felder groß ist. Dabei können in einem Array nur Werte gespeichert werden, die auch zu dem angegebenen Typ passen. Würden wir nun versuchen einen String in unser Array zu speichern, bekämen wir eine Fehlermeldung.
Java bietet uns noch eine andere Möglichkeit Arrays zu erstellen:

int zahlArray[] = {5, 2, 3, 4};

Damit haben wir den obigen Code auf eine Zeile reduziert. Beides kann jedoch nicht kombiniert werden, sodass etwas wie dies nicht möglich ist und uns unweigerlich einen Compilerfehler bringt:

int[] zahlArray = new int[4];
zahlArray = {5, 2, 3, 4};

Dies können wir jedoch mit einem kleinen Trick umgehen:

int[] zahlArray = new int[4];
int[] zahlen = {5, 2, 3, 4};
 
zahlArray = zahlen;

Sowohl ist dies auch möglich:

int[] zahlArray = new int[]{5, 2, 3, 4};

Das größte Speichern von Arrays bringt uns nichts, wenn wir nicht auch auf die Werte darin zugreifen können. Dazu schreiben wir einfach hinter den Namen des Arrays in eckige Klammern den Indexwert, in denen unser gewünschter Wert gespeichert worden ist.

int[] zahlArray = {5, 2, 3, 4};
 
System.out.println(zahlArray[0]);

Mit zahlArray[0] greifen wir auf den Wert im Array zu, der unter dem Index 0 abgelegt worden ist. Da die Indizes bei Arrays mit 0 beginnen, erhalten wir als Ausgabe unsere 5.
Einige werden sich auch schon sicher Gedanken dazu machen wie man ein ganzes Array durchlaufen könnte, um auf alle Werte zugreifen zu können. Mit Array.length können wir bequem auf die Länge unseres Arrays zugreifen und somit mit Hilfe einer Schleife – zum Beispiel – alle Elemente ausgeben.

int[] zahlArray = {5, 2, 3, 4};
 
for(int i = 0; i < zahlArray.length; i++)
{
  System.out.println(zahlArray[i]);
}

Hierbei erzeugen wir wie in den obigen Beispielen das Array zahlArray und befüllen es mit den entsprechenden Werten. Mit der for-Schleife ist es uns nun möglich auf die Indizes von 0 bis 3 (zahlArray.length – 1) zuzugreifen.
Versuchen wir auf ein Element zuzugreifen, dass außerhalb des Arrays liegt – also wenn wir bei uns auf zahlArray[4] zugreifen würden – bekommen wir eine ArrayIndexOutOfBoundsException Fehlermeldung.

Wie in anderen Programmiersprachen ist es uns in Java auch möglich mehrdimensionale Arrays zu erstellen. Mehrdimensionale Arrays kann man sich als Arrays von Arrays vorstellen. Somit könnten wir beispielsweise Koordinaten speichern und auf diese zugreifen, oder uns eine Matrix simulieren.
Dies erfolgt folgendermaßen:

int[][] matrixEins = new int[2][3];
 
//Alternativen
int[] matrixZwei[] = new int[2][3];
int matrixDrei[][] = new int[2][3];

Mit diesem Code haben wir uns so gesehen drei Matrizen erzeugt, die jeweils aus zwei Zeilen und drei Spalten bestehen. Nun kommen wir zur Verwendung eines dieser mehrdimensionalen Arrays:

int[][] matrixEins = new int[2][3];
matrixEins[0][0] = 1;
matrixEins[0][1] = 1;
matrixEins[0][2] = 1;
matrixEins[1][0] = 2;
matrixEins[1][1] = 2;
matrixEins[1][2] = 2;
 
for(int i = 0; i < matrixEins.length; i++)
{
  int[] row = matrixEins[i];
 
  for(int j = 0; j < row.length; j++)
  {
    System.out.print(row[j]);
  }
  System.out.println();
}

Zunächst erzeugen wir uns wie schon weiter oben beschrieben ein zweidimensionales Array und befüllen es mit den Werten 1 und 2. Danach durchlaufen wir dieses Array mit zwei ineinander geschachtelten for-Schleifen, um auch alle Elemente zu erwischen. Dazu müssen wir uns ein neues Array anlegen, dass die jeweilige Zeile enthält und durchlaufen dieses neue Array mit der zweiten for-Schleife, um uns die Werte auszugeben, die in der aktuellen Zeile stecken. Ist diese Schleife abgearbeitet, wird dem row-Array die zweite Zeile des matrixEins-Arrays zugewiesen und die innere Schleife wird noch einmal abgearbeitet. Als Ausgabe wollten wir etwas sehen wie:

111
222

Ein letztes Thema in diesem Tutorial ist die erweiterte for-Schleife, die von den Java-Entwicklern erstellt worden ist, um uns ein wenig Tipparbeit abzunehmen.
Mit der erweiterten for-Schleife könnten wir unseren obigen Code in das umwandeln:

int[][] matrixEins = new int[2][3];
 
matrixEins[0][0] = 1;
matrixEins[0][1] = 1;
matrixEins[0][2] = 1;
matrixEins[1][0] = 2;
matrixEins[1][1] = 2;
matrixEins[1][2] = 2;
 
for(int[] row : matrixEins)
{
  for(int value : row)
  {
    System.out.print(value);
  }
 
  System.out.println();
}

Vom Prinzip her funktioniert die erweiterte for-Schleife wie die normale for-Schleife, unterscheidet sich jedoch in der Syntax:

for( Typ Bezeichner : Array )
{
…
}

Die erweiterte for-Schleife wird solange durchlaufen, bis das ganze Array abgearbeitet ist. Dabei wird der Variablen vor dem Doppelpunkt immer der aktuelle Wert aus dem Array übergeben, den wir zum Beispiel ausgeben können. Ist der Code im Rumpf abgearbeitet, wird der Variablen der nächste Wert, der im Array steckt übergeben, der dann wieder verarbeitet werden kann.

Somit hätten wir das Kapitel der Arrays in Java bearbeitet und können nun unsere Kuh vom Anfang endlich zum sprechen bringen. Dies jedoch im nächsten Tutorium.

Ansonsten bei Fragen fragen.

int i = 0;
System.out.println(i);    //Ausgabe: 0
i++;
System.out.println(i);    //Ausgabe: 1
i++;
System.out.println(i);    //Ausgabe: 2
i++;
System.out.println(i);    //Ausgabe: 3

Wie wir sehen, erzeugen wir uns zunächst eine Variable, die einen Wert von 0 zugewiesen bekommt und dann der Wert der Variablen ausgegeben wird. Danach wird der Wert der Variablen um eins erhöht und es erfolgt wieder eine Ausgabe … usw. Nun, da Programmierer schreibfaul sind und dieser Code einfach zu umständlich erscheint, gibt es in vielen Programmiersprachen Schleifen, die dazu dienen einen bestimmten Code mehrmals auszuführen. Programmiersprachen, die keine Schleifen unterstützen, verwenden oft das Konzept der Rekursion – dies unterstützt Java auch.

Java kennt hierbei drei Arten von Schleifen:

• while-Schleife
• do-while-Schleife
• for-Schleife

Schleifen bestehen immer aus einer Schleifenbedingung und dem Rumpf. In der Schleifenbedingung befindet sich ein boolescher Ausdruck, der der Schleife sagt wie lange der im Rumpf stehende Programmcode wiederholt werden soll.

Wenden wir uns zunächst der while-Schleife zu und betrachten dazu den oben abgewandelten Code in “Schleifen-Schreibweise”:

int i = 0;
while(i <= 3)
{
  System.out.println(i);
  i++;
}

Compilieren wir nun dieses Code-Fragment, so sollten wir das gleiche Ergebnis wie oben erhalten. Doch was passiert nun hier? Zunächst erstellen wir wie oben die Variable i und weisen ihr den Wert 0 zu. Danach sehen wir die while-Schleife in Gebrauch. In den runden Klammern finden wir die Bedingung, die der Schleife sagt, wie lange sie wiederholt werden soll – nämlich so lange wie unser i kleiner-gleich drei ist. Nun gelangen wir in den Rumpf der Schleife. Wie wir sehen findet dort lediglich die Ausgabe von i statt. Danach wird i um eins erhöht. Das Erhöhen der Variablen dürfen wir nicht vergessen, denn sonst bekämen wir eine Endlosschleife, die theoretisch unendlich lang ausgeführt wird. Naja, Theorie und Praxis sehen hierbei anders aus, denn entweder erkennt unser Betriebssystem, dass es sich hier um Code handelt, der nicht vorwärts kommt und bricht diesen ab, oder wir brechen ihn selber ab, weil es uns zu doof ist so lange zu warten, oder uns schmiert irgendwann das System ab und wir müssen den Rechner neu starten.
Schauen wir uns nun den obigen Code umgewandelt in eine for-Schleife an:

for(int i = 0; i <= 3; i++)
{
  System.out.println(i);
}

Was macht nun dieses Stück Code? In der for-Schleife deklarieren wir die Variable in den runden Klammern und weisen ihr den Wert 0 zu. Nach dem Semikolon folgt dann die Bedingung, die die gleiche ist wie bei der while-Schleife. Ein Semikolon weiter schreiben wir das rein, was mit unserer Zählvariablen i gemacht werden soll – sie wird um eins erhöht.
Die Syntax einer for-Schleife sieht folgendermaßen aus:

for(Zählvariable; Bedingung; Erhöhung der Zählvariablen)
{
Code im Rumpf
}

Der Code im Rumpf der Schleife wird so lange wiederholt, bis i den Wert von drei übersteigt.

Jetzt tun uns noch die do-while-Schleife und haben dieses Kapitel auch hinter uns
Zunächst einmal wenden wir uns wieder einem Code-Beispiel zu:

do
{
  System.out.println(i);
  i++;
}
while(i <= 3);

Okay, die do-while-Schleife unterscheidet sich von der while-Schleife einmal, dass da das “do” vor dem “while” steht und dadurch, dass eine do-while-Schleife mindestens einmal ausgeführt wird. Haben wir also eine Bedingung, die von vornherein “false” ist, so findet bei der while- und der for-Schleife keine Ausführung des Codes im Rumpf statt – jedoch bei der do-while-Schleife.

Nun sollte sich die Frage stellen wann man welche Schleife verwenden sollte. Bei der do-while-Schleife sollte es klar sein, dass man diese nutzt, um Code mindestens einmal ausgeführt zu haben. Bei der for- und while-Schleife ist es Wurschd, denn vom Aufwand her sollten beide gleich sein.

Also, noch ein fröhliches Coden … =)