Montag, 13. Februar 2017

Schleifen in Java Teil 3


Schleifen in Java Teil 3

Die dritte und somit die letzte der Schleifen in Java ist die sogenannte do Schleife auch bekannt als Do-While Schleife. Die Do-While Schleife ist im gegensatz zu while und for Schleife Fuß gesteuert. Das heißt, dass die Ausführungsbedingung nach dem Durchlaufen der Anweisung überprüft wird. Dadurch wird die Anweisungsfolge immer mindestens einmal ausgeführt.

Die für die do-while Schleife dazugehörige Syntax lautet:

do {
Anweisung(sfolge);
} while (Bedingung);

Als Beispiel können wir eine do-while Schleife angeben der die Ganzzahligen werte von 1 bis 100 in der Konsole aufschreiben wird.

01 package java2enterprise;
02
03 public class BeispielDo_While {
04
05      public static void main(String[] args) {
06
07         int zahl = 1;
08         do {
09            System.out.println(zahl);
10            zahl++;
11         } while ( zahl <= 100);
12      }
13 }
14

Wir müssen natürlich bei dieser Schleife vorsichtig sein. Denn diese Schleife zeigt den Wert als erstes und danach wird das gezeigte Wert überprüft.

Wir haben unsere Variable zahl mit dem Wert 1 und mit dem primitiven Datentyp int initialisiert und deklariert. Dann beginnt, wie Sie es durch den obigen Syntax erkennen können, die do-while Schleife. Als Anweisung haben wir eine Ausgabe (System.out.println()) angegeben mit dem wert zahl. Danach also nach dem das Wert beim ersten durchlauf in die Konsole eingetragen worden ist wird die Variable mit dem Postfix (zahl++) um eins vergrößert. Nach dem Anweisungsblock wird die Bedingung geprüft. Die Bedingung hier dient als Grenze. In unserem Fall ist unsere untere Grenze der Schleife 1 und Obere Grenze die 100. Wenn in der Konsole zuletzt ein Wert ausgegeben wurde die, kleiner als 100 ist dann wird die Schleife wieder von neu Ausgeführt. Die Schleife endet erst dann, wenn unten in der Konsole die Zahl 100 als letzte eingabe steht. Doch da bei der do-while Schleife zuerst die Ausgabe danach das überprüfen erfolgt wird hier als letzte Ausgabe die 101 erfolgen. Da wir eine Obere Grenze mit 100 gewählt haben lässt der Compiler die Schleife wieder von anfang Ausführen. Bei der letzten Ausführung steht ganz unten auf der Konsole 101 stehen. Dann beginnt die prüfung der Bedingung. Da 101 größer ist als 100 wird die Schleife nicht mehr ausgeführt. Um das zu verhindern könnten wir die Obere Grenze als zahl <= 99 angeben und wir würden stattdessen als Maximalwert die 100 bekommen.

Als Eselsbrücke können Sie sich vorstellen, dass wenn eine Grenze oder besser gesagt eine Bedingung 1000 gegeben ist, wird in der Konsole das Ziffer 1001 ausgegeben. Versuchen Sie es selber. Übung macht ja schließlich den Meister.

Für weitere Fragen steht die Kommentarzeile für euch zu verfügung.

Sonntag, 5. Februar 2017

Schleifen in Java Teil 2


Schleifen in Java Teil 2



Neben for Schleife habe wir noch weitere Schleifen. Die zweite dieser Schleifengruppe ist die while Schleife.

Unter Schleifen in Java Teil 1 habe ich ihnen erklärt wozu eine Schleife nützlich bzw. vorteilhaft ist.



Die while Schleife ist eine abweisende Schleife oder unter Informatiker auch eine Kopfgesteuerte Schleife genannt. Die zugehörige Ausführungsbedingung wird also vor dem Eintritt in die Schleife überprüft.



Die Java Syntax für die while Schleife lautet deshalb:



while (Bedingung) {

Anweisung(sfolge);

                       }



Wie im Quellcode sie erkennen können, wird als erstes die Bedingung überprüft und danach die dazugehörige Anweisung ausgeführt.



Das folgende Quellcode stellt ein Programm dar, welches eine Zahlenreihe von 1 bis 100 in die Konsole anzeigen lässt.

package java2enterprise;


public class BeispielWhile {

      public static void main(String[] args) {

           int i = 1;



           while (i <= 100) {

                System.out.println(i);

                i++;

           }

      }

}



Wie Sie an der dritten Zeile es sehen können, initialisieren wir unsere Variable i mit dem Datentyp int und deklarieren diese mit dem Mathematischen Wert 1. Damit teilen wir die untere Grenze der Schleife dem Compiler mit. Erst nach dem deklarieren und initialisieren der Variable i beginnt die while schleife. In der fünften Zeile des Quellcodes können Sie noch die Bedingung der schleife im Klammern erkennen. Diese besagt, dass wenn die Variable i kleiner ist gleich 100 ist die Schleife mit System.out.println(i); und i++ ausgeführt werden soll.
Somit dient bei der While Scheile die Bedingung als die Obere Grenze der Schleife. Danach wird in einem Postfix nach der System.out.... Statement die Schrittweite der Aufzählung festgelegt.



>>Konsole



1

2

3

.

.

.

.

98

99

100

Für weitere Fragen steht die Kommentarzeile für euch zu verfügung.

Samstag, 4. Februar 2017

Schleifen in Java Teil 1


Schleifen in Java Teil 1


Sowie in Java aber auch in den anderen Programmiersprachen gibt es Schleifen.

Wozu dienen die Schleifen?
Schleifen sind dazu da, wenn eine berechnung oder eine Anwendung mehrmals ausgeführt werden soll. Ein Beispiel aus dem Alltag. Ein Rauchmelder kontrolliert 50 mal in der Sekunde ob der Sensor, der dazu dient das Rauch zu erkennen, ein Signal gib oder nicht. Das heißt die Anwendung oder das Programm stellt 50 mal in der Sekunde die Frage ob es Rauch gibt oder nicht. Wenn dies der Fall ist, reagiert der Sensor und somit werden wir mit einem akkustischen Signal gewarnt. Diese und Programme führen im Hintergrund eine Schleife aus.

Welche Arten von schleifen gibt es?
In Java gibt es drei Schleifen. Das sind die sogenannten for, while und do while schleifen.
Der unterschied zwischen den Schleifen ist, welches die Kontrolle oder Ausführung als erstes unternimmt.

/** Ich werde als beispiel für jede Schleife den darauf folgenden Quellcode aufschreiben * * und die Funktion erklären.
**/

For Schleife

Die meiner Meinung nach übersichtlichste Schleife ist die For Schleife. Diese ist wie folgt dargestellt:

for ( int i = 0 ; i <= 10 ; i++ ){
[anweisung] ←
                               }

Wie Sie sehen, haben wir die For Schleife in einer Zeile aufgeschrieben. Die Schleife beginnt immer mit dem Schlüsselwort “for“ und endet mit einem geschlossenen schleiften Klammer. Damit geben wir dem Compiler beim übersetzen die Information, dass es sich hierbei um eine for Schleife handelt und wo es beginnt “{“ und wo die Schleife in dem Code endet “}“ . Die Funktion der Schleife entscheiden nur die Informationen welches in dem runden Klammer stehenden Eingaben.
Als erstes deklarieren wir unsere Variable “i“ mit einem Ganzzahligen Datentyp int und initialisieren diese mit dem Wert 0. Damit deuten wir den Compiler, wo diese anfangen soll zu zählen. Also definiert der erste Abschnitt der Schleife wo diese beginnen soll zu zählen.

Als zweites definieren wir in unsere Schleife, wo diese enden soll. Somit geben wir in dem ersten zwei eingaben nur die Grenzen. Wie es in dem Quellcode erkennbar ist beginnt unsere Schleife von 0 an bis 10 zu zählen. Natürlich ist auch wichtig dem Compiler zu sagen, wie in welche Schrittweite diese zählen soll. Dies geschieht mit dem Teil drei. Wir sagen somit dem Compiler, mit welcher Schrittweite es von 0 bis 10 zählen soll.

i++ = i = i + 1 → Postfix
++i = i + 1 = i → Präfix

Es ist wichtig zu wissen, was Postfix und Präfix. Im vorherigen Quellcode ist diese deutlich dargestellt. In Unserem Beispiel beinhaltet die for Schleife eine Schrittweite die in Postfix geschrieben ist. Den funktionalen Unterschied werde ich Später erörtern. Mit i++ als Schrittweite wird der Compiler in einser Schritten von 0 bis 10 Zählen. Somit kann unsere fertiges Quellcode wie folgt aussehen.

package java2enterprise;

public class ForSchleife {
      public static void main(String[] args) {
           for ( int i = 0 ; i <= 10 ; i++ ) {
                System.out.println(i);
           }
      }
}


Wie Sie im Quellcode sehen, haben wir dem Compiler die for Schleife als erstes angegeben. Danach die Grenzwerte und schließlich am Ende die Schrittweite. Mit System.out.println(i); teilen wir dem Compiler mit, dass er bei jedem Schleifenübergang das Ergebnis auf der Konsole aufschreiben soll.

>>Konsole

0
1
2
3
4
5
6
7
8
9
10



Für weitere Fragen steht die Kommentarzeile für euch zu verfügung.

Dienstag, 31. Januar 2017

Umrechnung von Grad Celsius nach Grad Fahrenheit

Wir können eine Übungsaufgabe mit den bisher gelernten Methoden bearbeiten.

Umrechnung von Grad Celsius nach Grad Fahrenheit


Erstellen Sie eine Klasse Temperatur mit einer main-Methode, um eine Temperatur gegeben in Grad Celsius in Grad Fahrenheit umzurechnen. Die Umrechungsformel lautet:

Fahrenheit = 9/5 * Celsius + 32


Die beiden Temperaturen sollen jeweils in lokale Variablen celsius und fahrenheit vom Typ double gespeichert werden. Das Ergebnis der Berechnung – für irgendeinen Temperaturwert celsius – soll in der Form „10.0 Grad Celsius sind 50.0 Grad Fahrenheit.“ auf dem Bildschirm ausgegeben werden.


----------------------------------------------------------------------------------------------------





package java2enterprise;

import java.util.Scanner;

public class GradInFahrenheit {

      public static void main(String[] args) {

           double celsius, fahrenheit;

           Scanner scannerVariable = new Scanner(System.in);
           System.
out.println("Geben Sie eine Temperatur in °C ein: ");
           celsius = scannerVariable.nextDouble();

           fahrenheit = (9/5) * celsius + 32;

           System.
out.println(celsius+ " Grad Celsius sind "+ fahrenheit + " Grad Fahrenheit");     

      }

}



Console >> 

Geben Sie eine Temperatur in °C ein: 0

0 Grad Celsius sind 32 Grad Fahrenheit



Montag, 30. Januar 2017

Mathematische Funktionen in Java


Mathematische Funktionen in Java

Alle Objektorientierten Sprachen wie C#, Java, C++, Objective C etc. können nicht nur anhand der Mathematik den Quellcode in die Maschinensprache, die in Binärcode geschrieben worden ist, umwandeln sondern diese Sprachen können selbst mit mathematischen Funktionen wie zum Beispiel den Winkelmaß von Sinus oder Kosinus berechnen. Natürlich gibt es dafür wie auch speziell für Mathematische Berechnungen geeignete Befehle.

Java5 und höhere Java Versionen erlaubt den statischen Import von java.lang.Math alle mathematischen Methoden ohne Vorstellen von Math zu verwenden.

z.B.: Wenn Sie eine Version von Java5 oder höhere auf ihrem Rechner installiert haben, brauchen Sie beim eingeben der Mathematischen Funktionen nicht den Befehl “Math“ davor zu schreiben.

double variableEins = Math.PI;


Einige Methoden der Klasse Math sind wie folgt:

abs(int a) , abs(double a) → Liefert den Positiven wert der Variable a ein. Also den Betrag

ceil(double a) → Rundet den Gleitkomma Zahl nach oben

floor(double a) → Rundet den Gleitkomma Zahl nach unten

sin(double x) → Liefert den Sinus Wert der Variable x ein

cos(double x) → Liefert den Kosinus Wert der Variable x ein

tan(double x) → Liefert den Tangens Wert der Variable x ein

max(double x, double y) → Liefert das Maximum x, y

min(double x, double y) → Liefert das Minimum x, y

round(double x) → Rundet die Variable x auf eine Ganze Zahl

random(double x) → Liefert eine Zufallszahl zwischen 0 und 1

sqrt(double x) → Liefert den Quadratwurzel des Zahlen x

toDegrees(double a) → Konvertiert den Winkel in Radiant zum Winkel in Grad


Wenn Sie eine Java Version kleiner als fünf besitzen, dann müssen Sie vor jedem Mathematischen Befehl eine “Math.“ eingeben. 


package java2enterprise;

public class MathematikFunktionen {

          public static void main(String[] args) {

                   // Wenn Sie kleiner als Java5 Versionen besitzen dann Wie folgt eingeben
                   // Das folgende Befehl liefert den Quadratwurzel von wert1.
                   double wert1 = 10.3333333;
                   ergebnis1 = Math.sqrt(wert1);


                   // Wenn Sie größer als Java5 Versionen besitzen, dann können Sie wie folgt vorgehen
                   // Das folgende Befehl rechnet den Sinuswert der variable b.
                   double wert2 = 25.5;
                   ergebnis2 = sin(wert2);

          }

}

Samstag, 28. Januar 2017

If und else Abfragen


Hallo meine sehr verehrten Freunde, 

heute möchte ich euch die if und else abfragen in Java vorstellen. Neben if und else gibt es auch try und catch die wir aber erst das nächste mal besprechen werden. 

Was ist if und else abfrage? 

Wie im letzten Post "DatenTypen in Java" ich euch präsentiert habe gibt es Acht verschiedene DatenTypen in Java. Einer dieser Datentypen kontrolliert den Wahrheitswert, was der Variable zugewiesen wurde. Es handelt sich hierbei um den DatenTyp boolean. Dieser DatenTyp kann zwischen der gegebenen Bedingungen überprüfen, ob der Wert der Variable übereinstimmt. Dies kann wie folgt aussehen:

if ( Bedingung ) {
          System.out.println("Die Bedingung ist erfüllt. ");
}

else {
          System.out.println("Die Bedingung ist nicht erfüllt.");
}


Wie sie es sehen, haben wir eine if abfrage und eine else. Der Compiler führt den Quellcode aus und kontrolliert mit dem DatenTyp boolean (if, else) ob das Wert der Variable mit dem Bedingung übereinstimmt. Wenn diese der Fall ist, wird "Die Bedingung ist erfüllt" Ausgegeben. Mit else sagen wir dem Compiler, dass wenn Bedingung nicht erfüllt ist soll der Folgende Text ausgegeben werden. Also in diesem Fall wird "Die Bedingung ist nicht erfüllt." ausgegeben werden. Sie können es am unteren Beispielanwendung sehen.
Wir ermöglichen mit Scanner dem Anwender sein Alter in die Konsole einzugeben. Die Bedingung hier ist die Altersabfrage. Tippt der Anwender ein Wert kleiner als 18 ein, so wird auf der Konsole "Nein du bist nicht Volljährig."  ausgegeben. Doch gibt der Anwender eine Eingabe die, größer als 18 beträgt so meldet der Compiler eine Ausgabe "Aha du siehst aber nicht so alt aus."
Wir wollten es genauer haben und haben daher das Programm so aufgebaut, sodass es noch persönlichere Antworten dem Anwender zurück gibt. 
Wie zum Beispiel am ende des Programms. Die else Bedingung wird erst dann ausgeführt, wenn die vorherigen Bedingungen nicht mit der Variable "Alter" übereinstimmen. 

Gibt der Anwender für das Alter = 17 -> "Nein du bist nicht Volljährig."
Gibt der Anwender für das Alter = 20 -> "Aha du siehst aber nicht so alt aus."
Gibt der Anwender für das Alter = 18 ->
"Wow du bist dieses Jahr 18 geworden Glückwunsch."


package java2enterprise;

import java.util.Scanner;

public class if_Und_else_Abfrage {
   
    public static void main(String[] args) {
       
        Scanner scannerVariable1 =
new Scanner(System.in);
        System.
out.println("Geben Sie ihr Alter ein: ");
        byte alter = scannerVariable1.nextByte();
       
        if ( alter < 18 ) {
            System.out.print(
"Nein du bist nicht Volljährig.");
        }

        else if ( alter > 18 ) {
            System.
out.println("Aha du siehst aber nicht so alt aus.");
        }

        else {
            System.
out.println("Wow du bist dieses Jahr 18 geworden Glückwunsch.");
        }
    }
}

Freitag, 27. Januar 2017

DatenTypen in Java

Datentypen in Java

Hallo, heute möchte ich euch die einer der wichtigsten Werkzeuge in Java präsentieren. Wie Sie womöglich unten in dem Quellcode es schon gesehen haben, haben wir lauter Variablen die, mit Zahlen voneinander unterschieden sind (Zahlen als Wörter). Variablen in Java sind fast die selben wie in der Mathematik. Es sind Platzhalter für bestimmte Berechnungen oder Zwischenlösungen sowie Endergebnisse. Der einzige unterschied zwischen Variablen in Java oder in den anderen Programmiersprachen und der Mathematik ist, dass die Variablen in Java etc. initialisiert und deklariert werden muss. Das heißt, dass wir dem Compiler (also der, der das ganze Quellcode am Ende in die Maschinensprache übersetzen wird) sagen müssen, was für eine Zahl es sich hierbei handelt und mit welche Genauigkeit wir diese Zahl behandeln möchten. Es gibt zwei arten von Zahlen. Diese sind Gleitkommazahlen und Ganze Zahlen.
Gleitkommazahlen sind z.B.: 1,5 ; 2,7 ; -1000000,09192 etc...
Ganze Zahlen sind z.b.: 1 ; 2 ; 900000 ; -1651165 etc...

Wenn es zwei arten von Zahlen Initialisierung gibt, warum haben wir acht Datentypen?

Wer sich diese Frage stellt, wird es früher oder Später bemerken, dass wir nicht nur Variablen denen Werte als Zahl deklarieren können sondern Zeichen, Ganze Wörter (die wir Später mit String näher behandeln werden) und Wahrheitsergebnisse wie true oder false

Als nächstes möchte ich Sie auf das folgende Quellcode aufmerksam machen. Wie Sie es sehen, haben alle Schlüsselwörter in Java die Schriftfarbe "ROT". Somit wird dem Entwickler mitgeteilt, dass diese Variable schon für bestimmte Aufgabe/Funktion initialisiert worden ist. Sie können dies in ihrem Entwicklungsumgebungen (IDEs) wie Eclipse, Netbeans, IntelliJ etc. kontrollieren. Der Unterschied liegt daran, dass die IDEs für Schlüsselwörter unterschiedliche Schriftfarbe verwenden. Dies ändert aber weder die Bedeutung noch die Funktion des Schlüsselwortes. Wir können deshalb diese Schlüsselwörter nicht als Variablen initialisieren noch deklarieren. Wenn wir aber dies Versuchen z.B. double static, wird der Compiler eine Fehlermeldung bringen. Doch wir können ein Zeichen oder eine Zahl nach dem static wort eintragen und Sie werden schließlich merken, dass der Compiler die Fehlermeldung nicht mehr anzeigt. 


Alle Datentypen haben Arten, die ich ihnen als nächstes zeigen möchten.

Datentypen unterscheiden sich zwischen ihr Verwendung, Größe in Byte und Bit sowie ihrer Wertebereich.

Der Datentyp boolean ist ebenfalls wie alle anderen Datentypen ein Schlüsselwort und hat eine Bestimmte Funktion nämlich die Kontrolle des Wahrheitswertes. Die Größe dieses Datentyps ist 1Byte und in Bit beträgt ihre Größe 8Bit. Der Wertebereich liegt zwischen true oder false. Also boolean kontrolliert ob etwas richtig oder falsch ist.

Der Datentyp char kann nur, wie das Kürzel schon sagt "char", Zeichen speichern. Dieser Datentyp hat die Größe 2Byte und in Bit beträgt es 16Bit. Ihr Wertebereich liegt bei 0 bis 65.535. Sie werden sich natürlich Fragen, warum es nur Reelle Zahlen inklusive die Zahl "NULL" als Wertebereich definiert wird. Dies werde ich in einem anderen Beispiel mit euch behandeln. 

Da ich schreibarbeit sparen möchte, stelle ich die Folgenden Datentypen in einer Tabelle dar.

Der Datentyp byte ist ein Ganz Zahl Datentyp mit der Größe 1Byte und in Bit 8Bit großes Schlüsselwort. Ihr Wertebereich liegt bei -128 bis 127.
  
short ist ebenfalls eine Ganz Zahl Datentyp jedoch unterscheidet diese sich zwischen Wertebereich und der Größe. Größen: 2Byte und 16Bit. Wertebereich ist -32768 bis 32767

int ist eine Ganz Zahl Datentyp wie short und byte jedoch ist diese 4Byte und 32 Bit Groß. Ihr wertebereich liegt bei -2147483648 - 2147483647

long -> Ganz Zahl. Es ist 8Byte und 64Bit groß. Der Wertebereich liegt -9223372036854775808 bis 9223372036854775807

float -> Kommazahl. Es ist 4Byte und 32Bit groß. Der Wertebereich liegt  (1.4 * 10^-45)    bis (3,4 * 10^38)

double -> Kommazahl. Es ist 8Byte und 64Bit groß. Der Wertebereich liegt (4,9 * 10^-324)   bis (1,7 * 10^308)


Wir könne in Java Kommentare mit doppelten Slash setzen // oder
mit /** wort **/ setzten.

Wir initialisieren in diesem Beispiel folgende Variablen als Kommentar.




package java2enterprise;

public class javaDatentypen {
   
    public static void main(String[] args) {
       
        boolean variableEins;

        // variableEins = true;
        // variableEins = false;
       
        char variableZwei;

        // variableZwei = 20;
       
        byte variableDrei;

        // variableDrei = -150;
       
        short variableVier;

        // variableVier = 24021;
       
        int variableFünf;

        // variableFünf = 150;
       
        long variableSechs;

        // variableSechs = 90005463;
       
        float variableSieben;

        // variableSieben = 15.12141f;
        /**
        * Wie sie es sehen könne haben wir am Ende des Werts eine
        * f eingesetzt. Dies ist eine Regel in Java um die Zahlen
        * als Double darstellen zu können. Dies kann mit einem 
        * f, F eingestellt werden.
        **/
       
        double variableAcht;

        // variableAcht = -46410;
       
    }
}

Donnerstag, 26. Januar 2017

Einfacher Additionsrechner



Als zweites möchte ich mit euch ein einfaches Additionrechner Programmieren. Das Programm besitzt eine einfache Operation. 
Dazu importieren wir die Scanner Einstellung damit wir den Rechner für Allgemeine Addition Aufgaben verwenden können.
Der Scanner ermöglicht und das eintragen der Werte in die Console.
Davor stellt das Programm und zwei Fragen:

1. Geben Sie eine Zahl ein: >> Sie können hier eine Zahl eingeben <<

2. Geben Sie eine zweite Zahl ein: >> Sie können hier ein zweites Zahl eingeben << 

3. Alle eingaben bestätigen Sie mit ENTER und das Programm wird auf der Console das Ergebnis liefern.

long ist der Datentyp für Gleitkommazahlen. Warum haben wir kein double verwendet?
double ist ein 64 Bit Datentyp und long ein 32 Bit Datentyp. Da wir eine ganz einfache Addition durchführen entscheiden wir uns für das (kleine) Datentyp long. Damit wir bisschen speicher sparen können.


package java2enterprise;

import java.util.Scanner;

public class Rechner {
   
    public static void main(String[] args) {
       
        Scanner scannerVariable1 = new Scanner(System.in);
        System.out.println("Geben Sie eine Zahl ein: ");
        long zahl1 = scannerVariable1.nextLong();
       
        Scanner scannerVariable2 = new Scanner(System.in);
        System.out.println("Geben Sie eine zweite Zahl ein: ");
        long zahl2 = scannerVariable2.nextLong();
       
        long ergebnis = zahl1 + zahl2;
       
        System.out.println("Das Ergebnis der Addition lautet: " + ergebnis);
       
    }

}