Arrays

Ein Array, manchmal als Datenfeld bezeichnet, ist eine Datenstruktur in der mehrere Variablen gleichzeitig gespeichert werden können. Die Variablen die innerhalb eines Arrays gespeichert sind, werden mit Hilfe eines Indexes aufgerufen und identifiziert.

Deklaration eines Arrays (C#, Java und weitere..)

Im Folgenden Beispiel wird ein Array deklariert:

int [] zahlen;

Durch diese Anweisung wird ein Array vom Datentyp  integer mit dem Namen „zahlen“, deklariert. Als nächstes muss das Array initialisiert werden. Dafür muss auch die Anzahl der maximal im Array abzulegenden Variablen angegeben werden:

zahlen = new int[3];

Das Array wird als neues Objekt erzeugt, daher wird das Schlüsselwort „new“ benötigt. In den eckigen Klammern steht die Anzahl der im Array enthaltenen Elemente, nämlich 3.

Alternativ kann man das Array auch in einer Zeile deklarieren und initialisieren. Dafür muss man bei der Deklaration bereits wissen, wie viele Elemente das Array genau enthalten soll:

int[] zahlen = new int[3];

Wenn bereits bei der Deklaration klar ist, welche Werte im Array gespeichert werden sollen, kann man dies auch direkt mit angeben:

int[] zahlen = new int[] {1,3,2};

Es ist sogar möglich das Ganze noch kürzer zu gestalten, folgendes Beispiel erzeugt genau das Gleiche Array wie das vorherige Beispiel:

int[] zahlen = {1,3,2};

Arrayzugriff

Durch die Initialisierung eines Arrays werden die einzelnen Elemente eines Arrays erstellt und bekommen einen Index zugewiesen. Dieser Index startet bei 0, somit ist das 1. Element eines Arrays über den Index 0 aufrufbar, das 2. Element über den Index 1 und so weiter. Das weiter oben erstellte Array hat somit drei Elemente die folgendermaßen aufrufbar sind:

zahlen[0]
zahlen[1]
zahlen[2]

Wenn nun dem zweiten Element eine Zahl zugewiesen werden soll, kann das folgendermaßen realisiert werden:

zahlen[1] = 42;

Wenn nun der Wert eines, im Array enthaltenen, Elements einer Variablen zugewiesen werden soll, geht dies einfach mit der folgenden Zuweisung:

int element2 = zahlen[1];

Mit der Eigenschaft Length kann man außerdem die Länge eines Arrays zurückgeben.

int laengeMeinesArrays = zahlen.Length;

Im Folgenden Beispiel werden zwei Arrays, deklariert, initialisiert und dann auf dem Konsolenfenster wieder ausgegeben:

            int[] zahlen = new int[3];
            string[] woerter = new string[4] { "lerne-programmieren.com ", "sind die Besten!", "von ", "Die Beispiele " };

            zahlen[0] = 3;
            zahlen[1] = 1;
            zahlen[2] = 2;
            Console.WriteLine("Arrays\n =============================================================================\n");
            Console.WriteLine("zahlen[0]= " + zahlen[0]);
            Console.WriteLine("zahlen[1]= " + zahlen[1]);
            Console.WriteLine("zahlen[2]= " + zahlen[2]);
            Console.WriteLine();
            Console.WriteLine("zahlen.Length = " + zahlen.Length);
            Console.WriteLine();
            Console.WriteLine(woerter[3] + woerter[2] + woerter[0] + woerter[1]);
            Console.ReadKey();

Konsolenausgabe:

Wenn du Hilfe benötigst, Fragen oder Anmerkungen hast kannst du hierfür die Kommentarfunktion nutzen.

Vergleichsoperatoren

Claudi Hautumm / pixelio.de

In Bedingungsanweisungen zum Beispiel bei Schleifen, oder bei einer If Anweisung, werden häufig so genannte Vergleichsoperatoren genutzt. Dafür gibt es eine entsprechende Syntax die über einige Sprachen hinweg (zum Beispiel C#, Java, C …) einheitlich ist.

Bedingung Symbol Beispiel
Kleiner als < (x < y)
Größer als > (x > y)
Kleine oder gleich <= (x <= y)
Größer oder gleich >= (x >= y)
Gleich == (x == y)
Ungleich != (x != y)

Quelle: Eigene Darstellung

Die Funktion der meisten Operatoren kann man sich denken. Jedoch enthält der „Gleich“ Operator zwei Gleichheitszeichen. Dies gibt an, dass hier eine Überprüfung auf Gleichheit stattfindet, anstatt einer Zuweisung, die ein einzelnes Gleichheitszeichen nutzen würde. In dem Beispiel x == y wird also überprüft ob die beiden Variablen, x und y gleich sind. Das Ausrufezeichen ist eine Negierung. Das Beispiel x != y prüft also ob die Variablen ungleich sind.

Außerdem kann man die Vergleichsoperatoren mit ODER und UND Verknüpfen.

Logik Symbol Beispiel
ODER || ((x < y) || (x == z))
UND && ((x < y) && (x == z))

Quelle: Eigene Darstellung

Wenn eine der beiden Bedingungen des ersten Beispiels eintrifft, also wahr ist, dann wird, durch die ODER Verknüpfung, auch die Gesamtbedingung wahr. Im zweiten Beispiel wird die Gesamtbedingung nur erfüllt, wenn sowohl die erste, als auch die zweite Bedingung, gleichzeitig erfüllt werden. Ein abstraktes Einsatzbeispiel könnte sein:

if(aktuellerHelligkeitswert < schwellenWert && lichtAus == 1)
{
//Code um Licht einzuschalten
}

Der Code um das Licht einzuschalten würde nur ausgeführt werden, wenn es aktuell dunkler ist als der definierte Schwellenwert UND das Licht auch aus ist, also die lichtAus Variable den Wert 1 enthält. Wäre nur das Licht aus oder nur der aktuelle Helligkeitswert niedriger als der Schwellenwert, würde der Code um das Licht einzuschalten, nicht ausgeführt werden.

Angenommen die lichtAus Variable wäre vom Datentyp boolean, dann könnte man die Bedingung folgendermaßen noch vereinfachen:

if(aktuellerHelligkeitswert < schwellenWert && lichtAus)
{
//Code um Licht einzuschalten
}

Der Vergleich für die Variable lichtAus wird hier selbständig anhand des Wertes durchgeführt. Wenn die Variable den Wert 1 bzw. true enthält, ist die Bedingung wahr und wenn sie 0 bzw false enthält, ist die Bedingung nicht wahr. Das kann mit einem davorstehenden Ausrufezeichen zusätzlich negiert werden.

String

Rainer Sturm / pixelio.de

Ein String stellt eine beliebige Zeichenfolge, mit einer bestimmten Enkodierung, in C# ist es UTF 16,  dar. UTF 16 (Unicode Transformation Format) unterstützt sehr viele aber nicht alle Zeichen, hier findest du eine Auflistung aller unterstützten Zeichen.  Zurück zum String, man nutzt diesen Datentyp  um Zeichenketten oder Text in einer Variable abzulegen. Dies kann zum Beispiel der Fall sein, wenn ein Benutzer Eingaben auf einem Formular zu Registrierung auf einer Webseite gemacht hat. Dann werden diese Daten meist validiert, also auf ihre Gültigkeit geprüft, mit den Daten in der Datenbank abgeglichen und bei Erfolg in der Datenbank gespeichert. In Variablen vom Typ String werden also Zeichen abgelegt die sich mit den anderen Datentypen schlecht oder gar nicht realisieren lassen. Beispielsweise könnten Kundennummern auch Buchstaben enthalten, dadurch wären diese nicht für einen numerischen Datentypen, wie integer oder double geeignet. In C# und Java bieten die Frameworks eine Vielzahl von mächtigen Funktionen in der String Klasse an. Ein paar von mir häufig genutzte Beispiele:

  • „Replace“ zum Ersetzen von Zeichen, wenn ungewünschte oder verbotene Zeichen oder Zeichenfolgen vorhanden sind.
  • Substring“ ruft einen Teil des Strings, an einer bestimmten Stelle, für eine feste Länge, auf
  • Trim“ schneidet am Ende und Anfang leere Zeichen (spaces) oder ggf. auch andere Zeichen wie führende oder anhängende 0en ab
  • Split“ unterteilt die Zeichenkette in weitere Zeichenketten zum Beispiel anhand eines Trennzeichens. Dies könnte bei CSV Dateien zum Einsatz kommen
  • Join“ ist das Gegenstück zu Split es verkettet mehrere Strings zu einem und fügt ggf. Trennzeichen ein
  • Length“ ist eine Eigenschaft und gibt die Anzahl der Zeichen dieser Zeichenkette zurück
  • Contains“ überprüft ob eine Zeichenfolge in dem String vorhanden ist
  • Equals“ überprüft ob die Zeichenfolge den gleichen Wert wie eine andere Zeichenfolge hat

Es gibt noch viel mehr Funktionen die die String Klasse mit sich bringt, die man für C# in der Microsoft, bzw. für Java in der Oracle Dokumentation alle nachschlagen kann.

Oft werden auch zwei Strings aneinander gehangen, wie im folgenden C# Beispiel:

 string vorname;
 string nachname;
 
 Console.WriteLine("\t\t\tNamenseingabe lerne-programmieren.com\n");
 Console.Write("Bitte geben Sie ihren Vornamen ein:\t");
 vorname = Console.ReadLine();
 
 Console.Write("\nBitte geben Sie Ihren Nachname ein:\t");
 nachname = Console.ReadLine();
 
 Console.WriteLine("\nSie heißen:\t\t\t\t" + vorname + " " + nachname);
 Console.ReadKey();

Der Benutzer wird gebeten, erst seinen Vornamen, danach seinen Nachnamen einzugeben. Anschließend wird sein Name auf der Konsole ausgegeben. Dazu wurde der String „Sie heißen:“ mit der Variable strVorname, einem Leerzeichen und der Variable strNachname konkateniert, also verknüpft.

Das Ergebnis sieht folgendermaßen aus:

Empfohlene weiterführende Literatur:

Grundkurs C: C-Programmierung verständlich erklärt

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken

Programmieren lernen mit Java

 

Switch Case Anweisung

adel /pixelio.de

 

Die Switch Case Anweisung kann man nutzen, wenn man aus einer festen Menge von möglichen Kandidaten auswählt. Sie könnte zum Beispiel eingesetzt werden wenn auf einem Telefon eine entsprechende Taste gedrückt wurde. Wenn die 1 gedrückt wurde, könnte man zum Beispiel eine Weiterleitung an einen anderen Service implementieren. Wenn die 2 gedrückt wurde, könnte man die Weiterleitung mit einem Servicemitarbeiter umsetzen und so weiter.

Jede Switch Case Anweisung ließe sich auch mit einer „If elseif“ Anweisung umsetzen. Der Vorteil der Switch Case Anweisung ist, dass sie besser lesbar ist, da sie nicht so tief verschachtelt ist.

Der Aufbau ist recht einfach erklärt:

  1. Es startet mit dem Switch Keyword
  2. In den Klammern nach dem Keyword die Variable die überprüft wird
  3. In geschweiften Klammern, die Case Klausel gefolgt von
  4. Dem bedingten Wert und einem Doppelpunkt
  5. Dann kommt die eigentliche Anweisung die ausgeführt werden soll, wenn die Variable diesen Wert enthält.
  6. Am Ende eines Caseblocks steht das Schlüsselwort „break“. Es verhindert ein weiteres Ausführen des nachfolgenden Codes.
  7. Am Ende das optionale Schlüsselwort „default“ der hierauf folgende Code wird ausgeführt, wenn keiner der vorherigen Bedingungen wahr ist, oder bei der vorherigen Anweisung das Schlüsselwort „break“ nicht benutzt wurde.

Zum Beispiel C#, Java und weitere

Zum Beispiel C#, Java und weitere

      int number = 1;
      
      switch (number)
      {
          case 1:
              //Auszuführender Code wenn Number = 1 ist
              break;
          case 2:
              //Auszuführender Code wenn Number = 2 ist
              break;
          default:
              //Wird ausgeführt wenn andere Bedingungen nicht wahr sind
              break;
      }

VB:

Dim number As Integer = 8
 Select Case number
 Case 1
 //Auszuführender Code wenn die Number = 1 ist
 Case 2
 //Auszuführender Code wenn die Number = 2 ist
 Case Else
 //Wird ausgeführt wenn andere Bedingungen nicht wahr sind
End Select

In C# 7 wurde die Switch Anweisung weiterentwickelt. Es ist nun möglich auf jede Art von Typ ein Switch auszuführenden, zum Beispiel auf komplexe Objekte. Es können weiterführende Vergleiche (Pattern) in der Case Klausel benutzt werden. Hier findest du weiterführende Information von Microsoft. 

Um das Ganze noch ein bisschen greifbarer zu machen möchte ich gerne noch ein bisschen zusätzlichen Code mit euch teilen. Nachfolgend findet ihr Code für einen etwas erweiterten Taschenrechner, er kann auch Wurzeln ziehen und quadrieren (wenn W bzw. Q als Operator eingegeben wird). Auch Kommazahlen kann er verarbeiten, allerdings nur Zahlen zwischen -28000 und +28000. Wenn dich das stört, ändere es doch einfach ;). Wenn du Fragen hast nutze bitte die Kommentarfunktion.

using System;

namespace Rechnen
{

    class Program
    {


        static void Main(string[] args)
        {
            string strOperator;
            double dblZahl1;
            double dblZahl2;
            double dblErgebnis = 0;


            Console.WriteLine("\t\t*****\terweiterter Taschenrechner\t*****\n\n");
            Console.Write("Geben Sie die erste Zahl ein:\t\t\t\t\t");
            dblZahl1 = Convert.ToDouble(Console.ReadLine());

            if (dblZahl1 < -28000 | dblZahl1 > 28000)
            {
                Console.WriteLine("\n\nFehler: Bitte geben Sie eine Zahl zwischen -28.000 und 28.000 (achtundzwanzigtausend) ein.");
                Console.Read();
            }
            else
            {
                Console.Write("Geben Sie +, -, *, /, Q, oder W für die Rechenart ein:\t\t");
                strOperator = Console.ReadLine();

                if (strOperator == "+" || strOperator == "-" || strOperator == "*" || strOperator == "/" || strOperator == "W" || strOperator == "Q")
                {

                    switch (strOperator)
                    {
                        case "Q":

                            dblErgebnis = Math.Pow(dblZahl1, 2);
                            break;

                        case "W":

                            if (dblZahl1 < 0)
                            {
                                Console.WriteLine("\n\nFehler: Eine Wurzel aus einer negativen Zahl zu ziehen, ist leider nicht möglich, bitte geben Sie eine Zahl die <= 0 ist ein.");
                                Console.Read();
                            }
                            else
                            {
                                dblErgebnis = Math.Sqrt(dblZahl1);
                            }
                            break;

                        default:

                            Console.Write("Geben Sie die zweite Zahl ein:\t\t\t\t\t");
                            dblZahl2 = Convert.ToDouble(Console.ReadLine());

                            if (dblZahl2 < -28000 | dblZahl2 > 28000)
                            {
                                Console.WriteLine("\n\nFehler: Bitte geben Sie eine Zahl zwischen -28.000 und 28.000 (achtundzwanzigtausend) ein.");
                                Console.Read();
                            }
                            else
                            {
                                if (strOperator == "/" && dblZahl2 == 0)
                                {
                                    Console.WriteLine("------------------------------------------------------------------");
                                    Console.WriteLine("\nFehler: Eine Division durch Null ist mathematisch nicht möglich, nehmen Sie eine andere Zahl!");
                                    Console.WriteLine("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\t\t\t\t\t\t\"Development by Kai Fischer\"");
                                    Console.Read();
                                }
                                else
                                {

                                    switch (strOperator)
                                    {

                                        case "+":

                                            dblErgebnis = dblZahl1 + dblZahl2;
                                            break;

                                        case "-":

                                            dblErgebnis = dblZahl1 - dblZahl2;
                                            break;

                                        case "*":

                                            dblErgebnis = dblZahl1 * dblZahl2;
                                            break;

                                        case "/":

                                            dblErgebnis = dblZahl1 / dblZahl2;
                                            break;

                                    }
                                    if (strOperator == "+" | strOperator == "-" | strOperator == "*" | strOperator == "/" | strOperator == "W" | strOperator == "Q")
                                    {
                                        Console.WriteLine("------------------------------------------------------------------");
                                        Console.WriteLine("\nDas Ergebnis ihrer Rechnung lautet:\t\t\t\t{0}", Math.Round(dblErgebnis, 2));
                                        Console.WriteLine("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\t\t\t\t\t\t\"Development by https://lerne-programmieren.com/blog\"");
                                        Console.Read();
                                    }
                                }

                            }
                            break;

                    }
                }
                else
                {
                    Console.WriteLine("------------------------------------------------------------------");
                    Console.WriteLine("\nDies war keine gültige Eingabe für einen Operanden.\nBitte geben Sie +, -, *, /, Q oder W ein.");
                    Console.WriteLine("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\t\t\t\t\t\t\"Development by https://lerne-programmieren.com/blog\"");
                    Console.Read();
                }
            }
        }

    }
}



Empfohlene weiterführende Literatur:

Grundkurs C: C-Programmierung verständlich erklärt

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken

Programmieren lernen mit Java

For Schleife

Rainer Sturm / pixelio.de

For Schleifen sind eine der grundlegenden Kontrollstrukturen, die in so gut wie jeder Programmiersprache genutzt werden. In diesem Tutorial möchte ich euch zeigen wofür man eine For Schleife verwendet, wie sie aufgebaut ist, wie sie funktioniert, und natürlich auch entsprechenden Beispielcode mit euch teilen.

Schleifen werden zum Beispiel dafür genutzt um einen bestimmten Vorgang zu wiederholen. Das könnte der Fall sein, wenn man eine Sammlung von Daten, Datensatz für Datensatz, überprüft. Es könnte auch genutzt werden um zum Beispiel Daten in einer Listenansicht, Eintrag für Eintrag hinzuzufügen, die dem Benutzer dann angezeigt werden können. Forschleifen werden vor allem dann genutzt, wenn der Zähler der Schleife benötigt wird, zum Beispiel um auf ein Listenelement mit genau diesem Index zuzugreifen.

Aufbau C# & Java:

 for (int i = 0; i < anzahlDurchläufe; i++)
 {

 }

Die Syntax für eine Forschleife ist in den meisten Sprachen (z.B. Java, C#, JavaScript) sehr ähnlich:

  1. Es beginnt mit dem reservierten Wort „for“
  2. danach folgt eine Klammer,
  3. die Deklarierung (also Benennung der Laufvariable) und
  4. Initialisierung (Zuweisung) einer Variable, in dem Fall „i“, gefolgt von einem Semikolon.
  5. Dann kommt die Abbruchbedingung, bzw. um es genauer zu formulieren, ist es eigentlich die Weiterlaufbedingung. Solange diese Bedingung erfüllt ist wird die Schleife immer wieder neu durchlaufen, bis die Bedingung nicht mehr erfüllt ist.
  6. Zuletzt wird die Operation angegeben die bei jedem Durchlauf der Schleife einmal ausgeführt wird. In diesem Fall wird die Laufvariable i immer um 1 inkrementiert, also hochgezählt.

Alternativer Aufbau in VB:

 For i As Integer = 0 To anzahlDurchläufe
 
 
 Next

Jetzt zu dem praktischen Teil. Das folgende Beispiel gibt alle ganzen Zahlen von 1 bis inklusive 9 auf der Konsole aus:

C#:

 for (int i = 1; i < 10; i ++)
      Console.WriteLine(i);

Java:

for (int i = 1; i < 10; i ++)
     System.out.println(i)

Das Ganze ist auch umgekehrt ganz einfach möglich. Dieses Beispiel gibt alle ganzen Zahlen von 10 bis inklusive 2 aus.

C#:

for (int i = 10; i > 1; i--)
     Console.WriteLine(i);

Java:

 for (int i = 10; i > 1; i--)
      System.out.println(i)

Jetzt versuch doch mal mit mehreren, auch ineinander geschachtelten, For Schleifen in einem Konsolenprogramm das Haus von Nikolaus zu zeichnen. Oder eine Pyramide die auf dem Kopf steht. Falls du keine Idee hast wie das zu realisieren ist, hier ein Beispiel von mir für eine normale Pyramide, inklusive der Benutzereingabe, wie hoch die Pyramide sein soll. Wenn du noch Fragen hast, stelle diese bitte in den Kommentaren:

using System;


namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("\t\t\t\tPyramide\n\n");
            Console.Write("Bitte geben Sie die Höhe ein:\t\t\t");
            int hoehe = Convert.ToInt32(Console.ReadLine());

            for (int i = 1; i <= hoehe; i++)
            {
                for (int j = 0; j < hoehe - i; j++)
                {
                    Console.Write(" ");
                }

                for (int k = 0; k < i * 2 - 1; k++)
                {
                    Console.Write("x");
                }
                Console.WriteLine();


            }
            Console.ReadLine();
        }
    }
}

 

Empfohlene weiterführende Literatur:

Grundkurs C: C-Programmierung verständlich erklärt

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken

Programmieren lernen mit Java

Datenbanken

Rainer Sturm / pixelio.de

Jede Anwendung braucht irgendwelche Daten. Eine Wetterapp braucht die aktuellen Wetterdaten passend zu den Orten, eine Telefonbuchapp muss die Telefonnummern und Namen speichern, oder auch Webshops und so gut wie alle Webapplikationen greifen auf gespeicherte Daten zurück. Oft kommen dafür Datenbanken zum Einsatz. Sie verwalten die Daten und ermöglichen einen schnellen Zugriff auf selbige. Es gibt verschiedene Arten von Datenbanken zum Beispiel relationale, hierarchische, dokumentenorientiert und weitere. Oftmals wird für klassische Anwendungen im business, so wie im privaten Bereich, auf das relationale System gesetzt.

Die Daten einer Datenbank werden von einem Datenbankmanagementsystem (DBMS) verwaltet. Die Datenbanken, es können auch mehrere sein, zusammen mit dem DBMS werden als Datenbanksystem (DBS) bezeichnet. Möchte nun eine Anwendung auf den Inhalt der Datenbank zugreifen, so geschieht dies immer über das DBMS. Die folgende Abbildung veranschaulicht dieses System:

Um den Zugriff auf die Daten zu ermöglichen wird meist eine Datenbankabfragesprache, zum Beispiel die structured query language (SQL) genutzt. Bekannte DBMS sind zum Beispiel MSSQL, MySQL, Oracle, Sybase usw. Diese DBMS nutzen alle SQL, aber mit einer leicht unterschiedlichen Syntax dem sogenannten SQL Dialekt. Wenn man eine eigene relationale Datenbank erstellen möchte, sollte man sich mit dem Thema Normalisierung auseinandersetzen. Man erstellt dafür Tabellen die keine Redundanzen enthalten, das heißt das die Daten so gut es geht zusammengefasst werden sollen, um das unnötige Sammeln von Daten zu vermeiden und die Performance zu verbessern.

Wenn du mehr über Datenbanken wissen willst empfehle ich dir folgendes Fachbuch: Datenbanken: Grundlagen und Design

Einfache Programmiersprache

Thommy Weiss / pixelio.de

Mit welche Programmiersprache fange ich an? Diese Frage stellt sich oftmals für einen Anfänger der nicht grade selbst in seinem Studium oder Ausbildung programmiert. Die Antwort auf die Frage ist ein ganz klares „kommt darauf an“ es kommt darauf an was du erreichen möchtest. Folgende Tabelle gibt erstmal Aufschluss darüber, welche Sprache für welchen Anwendungsbereich empfohlen werden kann und enthält besonders gute Literaturempfehlungen zu jeder Sprache. Natürlich ist das nur ein kleiner Auszug der existierenden Sprachen:

Anwendungsbereich Empfohlene Sprache inklusive Literaturtipp
Hardwarenahes programmieren Assembler, C, C++
Webdesign Erst HTML, dann CSS, dann JavaScript
Webserver und Webapplikationen programmieren für einen Windows Server C# (ASP.NET)
Webserver und Webapplikationen programmieren für einen Linux Server C# ASP.NET core, Java
Anwendungsprogramme für Windows C# (WinForms oder WPF)
Anwendungsprogramme für Linux Java
Crossplatform App (Android, iOS, Windows Phone) C# mit Xamarin, oder Apache Codova Framework mit HTML, CSS und JavaScript
iOS App Entwicklung Swift
Android Apps Java, Android SDK
Windows Phone Apps C#
Zugriff auf relationale Datenbanken SQL: z.B. TSQL, oder Oracle SQL usw.
Makros für Word und Exceldokumente Entweder VBA oder C# (interop Schnittstelle)
Automatische Word Dokumentengenerierung OpenXMLSDK (zB C#)

Quelle: Eigene Darstellung

Wenn du noch keinen bestimmten Anwendungsbereich hast, sondern nur programmieren lernen möchtest und das möglichst einfach, dann würde ich C# empfehlen. Schau dir die Beiträge im Programmierlexikon an und folge meinen Tutorials auf dieser Seite, beginne am besten mit dem Programm aus dem Beitrag HelloWorld.

Generell empfehle ich außerdem sich mit mehreren Sprachen auseinander zu setzen, JavaScript ist in dutzenden von Frameworks sehr verbreitet. Kenntnisse hierin werden in der Webentwicklung bei so gut wie jeder Anwendung benötigt.

Außerdem macht es Sinn sich mit SQL auseinander zu setzen damit du lernst wie du Daten aus einer relationalen DB abfragst, änderst, abspeicherst und löschst.

Wenn du noch nie programmiert hast sind Sprachen wie C# und Java sicher einfacher für den Einstieg als Assembler oder C++. Wenn du aber erstmal in einer Programmiersprache fortgeschrittene Kenntnisse besitzt und grundlegende Kontrollstrukturen wie zum Beispiel Schleifen, Bedingungen,   Switch Case Anweisungen und Datenstrukturen zum Beispiel Listen, Arrays und Datensätze verstanden hast. Ist dies der Fall, ist das Erlernen einer weiteren Programmiersprache keine große Hürde mehr. Hier kommt es dann in  hauptsächlich darauf an die Syntax und die zugehörigen Frameworks kennen zu lernen.

Syntax

Rainer Sturm / pixelio.de

Jede Programmiersprache hat eine eigene formale Syntax. Diese kann sich zwischen den Programmiersprachen erheblich unterscheiden. Es handelt sich hierbei um ein System von Regeln das definiert wie zum Beispiel Ausdrücke, Anweisungen, Bedingungen usw. syntaktisch korrekt realisiert werden. In diesem System sind auch alle zulässigen Wörter für die entsprechende Sprache festgelegt.

Zum Beispiel in der Programmiersprache C# beginnt in der Regel jedes Programm mit einem „using“, dieses Wort ist so in der C# Syntax definiert. Dahinter folgt der Name eines Namensraums (namespace) der in diesem Programm genutzt werden darf.

Der Begriff „class“ nutzt die C# Syntax zum deklarieren einer neuen Klasse. Einzeilige Kommentare beginnen in C# immer mit „//“ daran erkennt der Kompiler dass die Zeichen in dieser Zeile nicht verarbeitet werden sollen. In XML und HTML beginnen Kommentare mit <!– und enden mit –> das gibt die Syntax so vor.

Es gibt in jeder Programmiersprache sogenannte reservierte Keywords, also zum Beispiel das oben genutzte „using“ Keyword fällt darunter. Diese keywords darf man nicht für die Benennung von eigenen Variablen und Objekten nutzen, da sie durch die Syntax der entsprechenden Programmiersprache vorbelegt sind.

Hier ein Überblick über die Keywords in C#:

abstract as base bool
break byte case catch
char checked class const
continue decimal default delegate
do double else enum
event explicit extern false
finally fixed float for
foreach goto if implicit
in in (generic modifier) int interface
internal is lock long
namespace new null object
operator out out (generic modifier) override
params private protected public
readonly ref return sbyte
sealed short sizeof stackalloc
static string struct switch
this throw true try
typeof uint ulong unchecked
unsafe ushort using using static
void volatile while

Quelle: Microsoft Dokumentation

 

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

Quelle: Java ist auch eine Insel von Christian Ullenboom
Das umfassende Handbuch Kapitel 2.1.5

Ich würde empfehlen sich erst einmal auf eine Programmiersprache zu konzentrieren, bevor man die Syntax von mehreren Programmiersprachen erlernt. Mit der Zeit gewöhnt man sich an die Syntax einer Programmiersprache und braucht nicht ständig in der Dokumentation nachzuschauen wie der eine oder andere Befehl lautet, wie eine Schleife umgesetzt wird, oder die Vergleichsoperatoren definiert wurden.

Empfohlene weiterführende Literatur:

Grundkurs C: C-Programmierung verständlich erklärt

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken

Programmieren lernen mit Java

Taschenrechner

Konstantin Gastmann / pixelio.de

eine erste C# consolenapplication (Konsolenanwendung) habt ihr bereits erstellt, wenn ihr meinem Beitrag HelloWorld gefolgt seid. Außerdem habe ich euch gezeigt, wo ihr die Entwicklungsumgebung Visual Studio kostenlos bekommt und wie ihr eine erste Konsolenanwendung schreibt.
Dieser Beitrag soll euch zeigen wie ihr nun die nächste Konsolenapplikation erstellt. Diese Anwendung soll 2 ganzahlige Zahlen, einen Operator der Grundrechenarten: Addition (+), Subtraktion (-), Division (/), oder Multiplikation (x) einlesen Und das zugehörige Ergebnis ausgeben. Wenn du sowas noch nie gemacht hast, wirst du eine ganze Menge dabei lernen.
Als erstes musst du in Visual Studio wieder ein neues Projekt, vom Typ „Konsolenanwendung“ anlegen.
Deine Entwicklungsumgebung sollte jetzt wie folgt aussehen:

Jetzt gibst du der Anwendung einen Titel dazu rufst du wieder das Console Objekt auf und weißt der Eigenschaft Title einen Wert vom Datentyp string  zu, nämlich den Titel den dein Programm haben soll.

Console.Title = "Grundrechenarten";

Danach rufst du die Methode WriteLine auf um eine Zeile in die Konsole zu schreiben. Du schreibst jetzt am besten die Überschrift und Namen des Programms in die Konsole und ggf. kannst du die Ausgabe auch ein bisschen formatieren zum Beispiel so:

Console.WriteLine("Mein einfacher Taschenrechner von https://lerne-programmieren.com");          Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------\n");

Als nächstes wollen wir dem Benutzer deiner Anwendung ermöglichen Zahlen einzugeben. Dazu fordern wir den Benutzer auf, damit er weiß wie er dein Programm zu bedienen hat dies geschieht mit der Write Methode auf dem Console Objekt:

Console.Write("Bitte gib die erste ganzzahlige Zahl ein:\t\t ");

Vielleicht fällt dir auf dass sich die Methode/Funktion von der zuvor genutzten etwas unterscheidet. Sie heißt jetzt Write anstatt WriteLine. Bei WriteLine springt der Cursor nach dem Ausführen des Befehls in eine neue Zeile. Bei Write bleibt er in der gleichen Zeile.

Jetzt brauchen wir noch eine Variable in der wir die Benutzereingabe speichern können. Wir werden der Einfachheit halber den Datentyp integer nutzen mit dem nur ganze Zahlen gespeichert werden können. Ihr könnt es aber auch mit einem Datentyp der Kommazahlen zulässt probieren, wie zum Beispiel double.

int ersteEingabe = 0;

Im nächsten Schritt wollen wir die Benutzereingabe auslesen. Dazu dient der Befehl ReadLine, der auf dem Console Objekt ausgeführt wird. Allerdings könnte man ja auch ungültige Zeichen wie Buchstaben oder Sonderzeichen eingeben, das würde zu einem Fehler führen. Um das zu verhindern, gibt es die Methode Int32.TryParse diese versucht einen Wert vom Datentyp string (in diesem Fall die Eingabe des Benutzers) in den Datentyp integer zu konvertieren, das bedeutet umzuwandeln. Als Parameter muss dieser Methode die Quelle, also in diesem Fall die Eingabe des Benutzers, und ein Ziel, in diesem Fall unsere grade erstellte Variable ersteEingabe angegeben werden.

Das sieht dann so aus:

Int32.TryParse(Console.ReadLine(), out ersteEingabe);

Durch den Befehl Console.ReadLine() wird außerdem die Anwendung solange gestoppt bis der Benutzer die Enter Taste betätigt und die Eingabe zurückgegeben.

Das Gleiche wollen wir für eine 2. Zahl tun:

Console.Write("Bitte gib die zweite ganzzahlige Zahl ein:\t\t ");
 int zweiteEingabe = 0;
 Int32.TryParse(Console.ReadLine(), out zweiteEingabe);

Man könnte jetzt noch den Rückgabewert der TryParse Methode abfragen um dann eine Fehlermeldung auszugeben, falls ein Wert eingegeben wurde der keine Zahl ist, aber der Einfachheit halber sehen wir hier davon ab.

Jetzt haben wir 2 Zahlen aber das Programm weiß noch nicht was es damit anfangen soll, der Operator fehlt noch, also wird dieser auch eingelesen:

Console.Write("Bitte gib einen gültigen Operator ein (+,-,*,/):\t ");
char numerischerOperator;
char.TryParse(Console.ReadLine(), out numerischerOperator);

Als Datentyp wurde hier character gewählt, also ein einzelnes Zeichen, der der Operator immer nur ein Zeichen hat.

Jetzt haben wir 2 Zahlen und einen Operator im Speicher, wir müssen also als nächstes das Ergebnis berechnen, dazu braucht man natürlich wieder eine Variable, gut verständliche Namen sind übrigens sehr wichtig beim Programmieren, also gewöhne es dir direkt an:

double ergebnis = 0;

Jetzt müssen wir entscheiden welche Rechenoperation ausgeführt werden muss. Hierzu müssen wir den Wert abfragen und dann entscheiden ob wir entweder die eine oder die andere Rechenoperation ausführen.

Der Befehl dazu heißt

if(Bedingung)
 {
 //Code der ausgeführt wird, wenn Bedingung erfüllt
 }
Else
 {
 //Code der ausgeführt wird, wenn Bedingung nicht erfüllt
 }

Ich habe es folgendermaßen umgesetzt:

if (numerischerOperator.Equals('+'))
{
     ergebnis = ersteEingabe + zweiteEingabe;
}
else if (numerischerOperator.Equals('-'))
{
    ergebnis = ersteEingabe - zweiteEingabe;
}
else if (numerischerOperator.Equals('*'))
{
   ergebnis = ersteEingabe * zweiteEingabe;
}
else if (numerischerOperator.Equals('/'))
{
  ergebnis = ersteEingabe / zweiteEingabe;
}
else
{                Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------");
Console.WriteLine("Fehler, du hast keinen gültigen Operanden eingegeben!");
Console.WriteLine("Beliebige Taste zum Beenden drücken!");                Console.ReadKey();
Environment.Exit(0);
}

 

Die Rechenoperation wird ausgeführt und das Ergebnis in die ergebnisvariable geschrieben. Der letzte Elseblock wird ausgeführt wenn keine der vorherigen Bedingungen erfüllt wurde, also wenn im Operator ein Zeichen steht das weder +,-,* noch / ist. Der Befehl Environment.Exit(0); beendet das Programm und die 0 als Parameter teilt dem Betriebssystem mit, dass das Programm ordnungsgemäß heruntergefahren wurde.

Danach kommt der Code um das Ergebnis in der Konsole auszugeben:

Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------");
Console.WriteLine("Das Ergebnis ist:\t\t\t\t\t {0}", ergebnis);
Console.WriteLine("Beliebige Taste zum Beenden drücken!");            Console.ReadKey();

Die Zeichenfolge {0} ist ein Platzhalter für den Wert einer Varibale, der dort ausgegeben werden soll. In diesem Fall das Ergebnis. Man gibt diese Variable nach einem Komma an. Man könnte auch mehrere Platzhalter einfügen dies kann man dann durchnummerieren {0}{1} {2} usw. und die Variablenwerte werden in der angegebenen Reihenfolge eingesetzt. Hast du noch Fragen, dann lass es mich in den Kommentaren wissen?!

Übrigens, wenn ihr Visual Studio nutzt eine Klasse, Methode, oder Objekt markiert und dann F1 drückt öffnet sich die Microsoft Dokumentation dazu.

Hier der gesamte Quellcode:

using System;

namespace Grundrechenarten
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "Grundrechenarten";
            Console.WriteLine("Mein einfacher Taschenrechner von https://lerne-programmieren.com");
            Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------\n");

            Console.Write("Bitte gib die erste ganzzahlige Zahl ein:\t\t ");
            int ersteEingabe = 0;
            Int32.TryParse(Console.ReadLine(), out ersteEingabe);

            Console.Write("Bitte gib die zweite ganzzahlige Zahl ein:\t\t ");
            int zweiteEingabe = 0;
            Int32.TryParse(Console.ReadLine(), out zweiteEingabe);

            Console.Write("Bitte gib einen gültigen Operator ein (+,-,*,/):\t ");
            char numerischerOperator;
            char.TryParse(Console.ReadLine(), out numerischerOperator);

            double ergebnis = 0;
            if (numerischerOperator.Equals('+'))
            {
                ergebnis = ersteEingabe + zweiteEingabe;
            }
            else if (numerischerOperator.Equals('-'))
            {
                ergebnis = ersteEingabe - zweiteEingabe;
            }
            else if (numerischerOperator.Equals('*'))
            {
                ergebnis = ersteEingabe * zweiteEingabe;
            }
            else if (numerischerOperator.Equals('/'))
            {
                ergebnis = ersteEingabe / zweiteEingabe;
            }
            else
            {
                Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------");
                Console.WriteLine("Fehler, du hast keinen gültigen Operator eingegeben!");
                Console.WriteLine("Beliebige Taste zum Beenden drücken!");
                Console.ReadKey();
                Environment.Exit(0);
            }
            Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------");
            Console.WriteLine("Das Ergebnis ist:\t\t\t\t\t {0}", ergebnis);
            Console.WriteLine("Beliebige Taste zum Beenden drücken!");
            Console.ReadKey();
        }
    }
}

 

Weiterführende Literatur, für Anfänger gut geeignet in C# oder in C:

Grundkurs C: C-Programmierung verständlich erklärt

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken

Datentypen

 

Markus Vogelbacher / pixelio.de

Was sind Datentypen?

Die Definition von Datentypen „Der Datentyp beschreibt den Wertebereich von Variablen […] Es gibt numerische Datentypen und boolesche, alphanumerische, abstrakte elementare und benutzerdefinierte“ klingt für einen Anfänger wahrscheinlich ziemlich unverständlich.

Einfacher:

Datentypen bestimmen welche Art von Daten ich in einer Variablen  speichern darf.

Ein sehr häufig genutzter Datentyp ist integer, meist als int abgekürzt. Der unten stehenden Tabelle der in C# integrierten Datentypen, kann man entnehmen, dass der Datentyp int Werte zwischen – 2,147 und 2,147 Milliarden zulässt. Außerdem können nur ganze Zahlen und keine Kommawerte in diesem Datentyp abgelegt werden.

Weitere oft genutzte Datentypen sind bool wenn es eine entweder/oder Entscheidung gibt, double/float für Kommawerte, char für ein einzelnes Zeichen oder string für eine Zeichenkette, also eine beliebige Folge von Zeichen.

Datentyp Wertebereich
byte 0 .. 255
sbyte -128 .. 127
short -32,768 .. 32,767
ushort 0 .. 65,535
int -2,147,483,648 .. 2,147,483,647
uint 0 .. 4,294,967,295
long -9,223,372,036,854,775,808 .. 9,223,372,036,854,775,807
ulong 0 .. 18,446,744,073,709,551,615
float -3.402823e38 .. 3.402823e38
double -1.79769313486232e308 .. 1.79769313486232e308
decimal -79228162514264337593543950335 .. 79228162514264337593543950335
char Ein Unicode-Zeichen.
string Eine Unicode-Zeichenfolge.
bool True oder False.
object Ein Objekt.

Quelle der Tabelle

Übrigens, wenn man das „const“ Schlüsselwort nutzt kann man eine Konstante, statt einer Variablen definieren.

Empfohlene Literatur, für Anfänger geeignet in C# oder in C:

Grundkurs C: C-Programmierung verständlich erklärt

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken