Programmieren lernen - Band 1 (Prozedural)

Das allumfassende Tutorial für Einsteiger mit Praxistipps und viel Hintergrund Infos.
5.0 (2 ratings) Instead of using a simple lifetime average, Udemy calculates a
course's star rating by considering a number of different factors
such as the number of ratings, the age of ratings, and the
likelihood of fraudulent ratings.
4 students enrolled
$20
Take This Course
  • Lectures 48
  • Length 9 hours
  • Skill Level All Levels
  • Languages German
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion
Wishlisted Wishlist

How taking a course works

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

Learn and practice real-world skills and achieve your goals.

About This Course

Published 9/2016 German

Course Description

WILLKOMMEN

beim allumfassenden Programmieren lernen Tutorial von Tom Wendel. Anders als typische Tutorials ist zum jetzigen Zeitpunkt keineswegs alles von Anfang bis Ende geplant, sondern lebt vom Feedback und den Themenwünschen der beteiligten Zuschauer. Ebenso bewegt sich das Tutorial nicht in linearer Form – es folgt also nicht eine Folge nach der anderen – sondern besteht aus einem Netz aus zusammenhängenden Folgen, die man je nach Interesse in unterschiedlicher Reihenfolge anschauen kann. Dadurch wird das Tutorial nicht nur interessant für blutige Einsteiger, sondern dient auch als Nachschlagewerk und Weiterbildung für langjährige Profis.

FUNKTIONSWEISE

Das Tutorial besteht aus mehreren unabhängigen Kapiteln die in unterschiedliche Programmier-Paradigmen unterteilt sind, bauen aber vom Wissensstand her aufeinander auf. In jedem Kapitel werden jeweils 3-4 Themenschwerpunkte behandelt, die für das entsprechende Paradigma besonders wichtig sind. So beginnen wir beispielsweise im ersten Kapitel damit, uns mit der Prozeduralen Programmierung auseinander zu setzen und lernen dort alle notwendigen Dinge rund um die Werkzeuge, die Programmiersprache und die Grundlagen der Standard-Bibliotheken.

LEVEL & THEMEN

Kapitel haben keinen konstanten linearen Ablauf. Beginnend mit einem zusammenhängenden Strang an Videos, in denen eine vollwertige Applikation mit einfachen Mitteln erstellt wird, gibt es zu einzelnen Themen weitere Vertiefungsvideos in 4 unterschiedlichen Schwierigkeitslevels. Beginnend beim pragmatischen Nutzen von Funktionen (Level 1), über die erweiterten Möglichkeiten (Level 2) gibt es auch wissenswerte Hintergründe (Level 3) bis hin zu den theoretischen Konzepten (Level 4) die man sonst üblicherweise nur im Informatik-Studium erfährt.

KOSTEN

Die ersten Videos werden jetzt erst mal kostenfrei online gehen. Sollte sich das Format bewähren und der Aufwand für die Produktion steigen, werden Videos mit höherem Schwierigkeitslevel kostenpflichtig werden. Es entstehen dabei einmalig Kosten und der Käufer profitiert auch von den nach dem Kauf produzierten Folgen. Mit steigender Video-Anzahl steigt aber auch der Einstiegspreis. Je eher du also einsteigst, umso günstiger wird das Ganze für dich und umso eher kannst du Einfluss auf den Verlauf des Tutorials nehmen.

What are the requirements?

  • Null Vorkenntnisse - man braucht aber einen Computer

What am I going to get from this course?

  • Umfassendes Wissen der Software Entwicklung
  • Inklusive Hintergrundwissen und Theorie
  • Sicherer Umgang mit den typischen Werkzeugen

What is the target audience?

  • Interessant für alle, die von 0 bis 100 alles lernen wollen
  • Interessant für vollkommene Einsteiger, da der Kurs bei null anfängt
  • Interessant für Profis, weil in Vertiefungen auch Details und Hintergründe beleuchtet werden
  • NICHT Interessant für Leute, die schnell vorhandene Probleme lösen wollen

What you get with this course?

Not for you? No problem.
30 day money back guarantee.

Forever yours.
Lifetime access.

Learn on the go.
Desktop, iOS and Android.

Get rewarded.
Certificate of completion.

Curriculum

Section 1: Intro
02:02

Lasst mich euch kurz willkommen heißen in Band 1 des umfangreichen und allumfassenden Programmier Tutorial.

Section 2: Die ersten Schritte
00:40

Willkommen im Training. Worum soll es in diesem Kapitel gehen?

14:39

Bevor es losgehen kann, sollte man auf jeden Fall die richtigen Tools installiert haben. Ein kurzer Rundgang zu den möglichen Tools installieren wir Visual Studio Community.

12:06

Nach der Installation schauen wir uns mal ein bisschen um und lernen die IDE kennen, schauen uns die verschiedenen Projekt-Templates an (nicht im Detail, nur in der Unterscheidung)

14:34

Als erstes Projekt legen wir eine Konsolen Anwendung an und schauen uns mal um. Zunächst im Projektmappen Explorer, dann vielleicht auch auf Ordner-Ebene wo wir eine ähnliche Struktur wieder finden. Außerdem versuchen wir schon mal grundlegend die Struktur des vorhandenen „Programms“ zu verstehen.

12:41

Die Grundkonzepte einer Applikation beruhen darauf, dass man Befehle an den Computer richtet und dabei auf bestimmte Umstände reagiert. Neben dem Kernkonzept von komplexen Berechnungen geht es in Programmen meist um die Interaktion zwischen User und dem Computer.

Diese Lektion zeigt, wie man direkte Befehle an den Computer richtet. Wir geben die ersten Zeilen an der Konsole aus.

14:06

Zwar sind wir noch nicht an einem Punkt an dem viele Fehler entstehen, allerdings ist gerade die erste Zeit beim Umgang mit Visual Studio oft sehr frustrierend, da man den Quellcode immer sehr exakt schreiben muss um Erfolg zu haben. Es kommt also nicht nur darauf an die Befehle zu kennen, sondern sie auch korrekt in das Text-Fenster einzutragen. Wir schauen uns an welche Fehler so passieren können und wie man ihnen schnell auf die Schliche kommt.

07:33

Bei der Eingabe von Text an die Konsole stellt sich raus, dass der Computer irgendwie unterschiedliche Eingabeformate unterscheidet. Im Groben scheint es eine Unterscheidung zwischen Text und Zahlen zu geben. In Wirklichkeit sind es noch ein paar mehr. Wir schauen uns die wichtigsten (int, double, string) an.

14:19

Aktuell behandeln wir all unsere Informationen direkt im Quellcode. Das ist recht unpraktisch – vorallem, wenn man mache Sachen öfter braucht. Vielleicht für eine weitere Ausgabe oder zum Durchführen von Berechnungen.

Aus diesem Grund kommen weitere Schlüsselworte ins Spiel mit dessen Hilfe wir unsere Daten zwischen speichern können – Die Möglichkeiten (Arithmetische Ausdrücke) bleiben gleich.

07:18

All das macht noch wenig Sinn solange man nicht auf die Eingabe des Users reagieren kann. Wir fügen in diesem Kapitel eine Möglichkeit ein Informationen vom User einzuholen und mit diesen Daten weiter zu arbeiten.

14:38

Mit den Eingaben des Users können wir jetzt natürlich unmittelbare Ausgaben durchführen. Viel spannender wäre es aber doch auf unterschiedliche Eingaben auch unterschiedlich zu reagieren. Dazu benötigen wir eine der wichtigsten Strukturen der Software-Entwicklung: Die Fallunterscheidung / Bedingung

10:08

Bei der Fallunterscheidung haben wir insgeheim einen weiteren Datentypen kennen gelernt: Den Bool. Es handelt sich dabei um den „kleinsten“ Datentypen des Computers. 1 oder 0. Bzw. Wahr oder falsch. Er wird dazu verwendet grundlegende Entscheidungen zu treffen. Mit diversen boolschen Ausdrücken und Boolschen Operatoren lassen sich Ausdrücke formulieren, die entweder wahr oder falsch sind und damit klare Aussagen über das weitere Vorgehen treffen.

10:08

Dank unterschiedlichen Datentypen haben wir gerade bei der Verarbeitung der User-Eingaben jetzt ein kleines Problem. Wollen wir mit Zahlen rechnen, können wir mit dem String aber leider nichts anfangen. Das Framework gibt uns da aber ein paar Möglichkeiten.

14:22

Zum ersten Mal begegnen uns bei der Software Entwicklung jetzt sogenannte Exceptions. Ein Konzept, das auf unerwartete Umstände beim Ablauf des Programms hindeuten. Behandelt man diese Exceptions nicht, führen sie zu einem Fehler und zum Absturz des Programms. Mit Hilfe vom try/catch Konstrukt lässt sich zum Glück aber damit umgehen.

11:15

Um zu sehen ob unser Code funktioniert können wir natürlich nach der Änderung des Codes das Projekt neu starten und sehen, ob das Ergebnis stimmt. Das klappt bei einfachen Projekten noch recht zuverlässig, wird aber bei komplexeren Projekten zu einer anstrengenden Angelegenheit. Unsere Tools helfen uns aber dabei.

09:08

Nach dem Taschenrechner wird’s Zeit für etwas Cooleres. Wie versprochen möchte ich gerne im Laufe des Tutorials ein Snake-Spiel erstellen, weshalb wir uns mal über die Möglichkeiten der Console informieren und dabei auch was über die Hilfe Funktionen kennen lernen.

Section 3: Snake 2.0
01:47

Es wird Zeit mit den ersten Infos was sinnvolles anzufangen. Wir starten mit unserem eigentlichen Projekt: Snake 2.0!

14:29

Neben den Debugger-Tools die wir bisher kennen gelernt haben gibt’s auch noch die Möglichkeit einer Realtime Watch auf Variablen und Inhalte. Wir gehen sogar noch einen Schritt weiter und nutzen die Quickwatch für eine Echtzeit-Manipulation unserer Daten und fangen so das Design unserer Konsole an.

14:01

Um ein passendes Spielfeld für unser Snake-Spiel zu erstellen müssen wir unser Spielfeld ordentlich aufbauen und einrichten. Um das zu tun setzen wir die Spielfeldgröße, legen den Titel fest und die verwendeten Farben.

14:07

Alleine schon die ganzen Fenster-Begrenzungen zu zeichnen ist ganz schon mühsam. Dabei machen wir ständig das Gleiche. Mit Hilfe von Schleifen können wir das Ganze auch automatisieren und sparen uns damit nicht nur Tipp-Arbeit, sondern sorgen auch noch für einen wesentlich besser lesbaren Code. 

11:49

Mit der Raute das Spielfeld zu malen ist ja ganz nett, aber irgendwie macht das Ärger, sobald man alles verschiebt und vollflächige Anzeige wäre schon toll. Außerdem gibt’s ein Problem beim letzten Zeichen. Zeichnet man das, bricht alles um. Neuer Ansatz: Hintergrundfarbe.

12:13

Neben dem Spielfeld soll nun eine Schlange auf dem Spielfeld laufen. Damit das passieren kann, muss neben der Aktualisierung des Spielfeldes auch die Position der Schlange immer wieder aktualisiert werden. Dinge, die immer wieder passieren müssen, führt man innerhalb von Schleifen aus. For haben wir schon kennen gelernt, aber da wir die Anzahl Schleifendurchläufe im Vorfeld noch nicht kennen, verwenden wir eine andere Lösung.

10:57

Die Schlange hat in Zukunft die Möglichkeit sich in unterschiedliche Richtungen zu bewegen. Um das abzubilden braucht es eine weitere Variable die das angibt. Eine Kette von Abfragen soll dann entscheiden, wie genau die Schlange sich weiter bewegen soll.

16:07

Wie man mit simplen Abfragen Wahrheit oder Nichtwahrheit abprüft, haben wir schon herausgefunden und bereits ein bisschen damit herum gespielt. Manchmal kommt es aber vor, dass man mehrere Dinge gleichzeitig prüfen will. Dann ergibt sich die Möglichkeit mit Hilfe von Boolschen Operatoren die einzelnen Prüfungen miteinander zu verrechnen

13:29

Das Spiel ist bisher wenig interaktiv, weil der Spieler noch nichts tun kann. Das soll sich jetzt ändern. Wir lernen Console.ReadKey und KeyAvailable kennen und verarbeiten die Eingabe in die richtigen Bewegungsabläufe.

12:06

Oft, wenn man verschiedene Zustände oder limitierte Listen verwendet, kommt es zu einem Index-System, das von 0 bis x läuft. Manchmal möchte man, dass eine fortlaufende Zählung wieder bei 0 beginnt, wenn es das letzte Element erreicht hat. Mathematisch betrachtet braucht man dafür den Restwert einer Division. Aus 7 wird bei einer Listenlänge von 6 wieder eine 1.

12:45

Möchte man einer Variable den Wert aus einer festen Liste von Möglichkeiten verpassen, bleibt einem mit den bisherigen Möglichkeiten eigentlich nur das codieren als Zahl. 1 bedeutet Möglichkeit 1, 2 steht für den zweiten Eintrag in der Liste,… Das funktioniert zwar, macht den Code aber unnötig kryptisch. Mit Hilfe einer Enumeration lassen sich solche Listen erstellen und erlauben auf diesem Weg eine sprechende Codierung im Code.

09:07

Zwischendrin lohnt es sich auch mal einen Blick auf das eigentliche Spielprinzip zu werfen. In dieser Lektion kümmern wir uns darum, dass die Schlange aus mehr als nur ihrem Kopf besteht. Es kommen neue Schlangen-Zellen hinzu, sodass die Schlange später aus 3 Teilstücken besteht, die sich durch das Spielfeld schlängeln.

17:38

Braucht man von einer Sorte Variable unter Umständen mal mehrere – im schlimmsten Fall sogar ohne im Vorfeld zu wissen, wie viele am Ende benötigt werden – steht man mit dem bisherigen Variablen-Konzept vor einer ganzen Menge Tipparbeit. Eine dynamische Anzahl Variablen lassen sich auf diesem Weg überhaupt nicht abbilden. Um dieses Problem zu lösen gibt es Arrays. Das sind Ketten/Listen von Variablen des selben Datentyps, die anschließend per Arraynamen und Index angesprochen werden.

10:10

Wird Zeit, dass das Spiel auch einen ordentlichen Spielinhalt bekommt. Es braucht nun auch die Spielelemente, für die der Spieler auf dem Spielfeld umher grabbelt und was das Spiel voran treibt. Wir fügen Früchte ins Spiel ein und sehen, wie wir die vernünftig auf dem Spielfeld platziert bekommen.

13:49

Mit einer steigenden Komplexität des Spiels steigt auch die Komplexität der Daten, die wir speichern wollen. Oft kommt es vor, dass Dateneinheiten nicht nur aus den Datentypen bestehen, die über die Sprache zur Verfügung stehen. Oft bestehen die gewünschten Strukturen aus einer Kombination dieser primitiven Datentypen. Ein Beispiel dafür ist die Zellenkoordinaten, die ja aus einem X- und einem Y-Anteil bestehen. Das wird über Structs abgebildet.

10:36

Nachdem die Schlange nun die Frucht fressen kann, muss sie nun auch wirklich länger werden. Mit unserer bisherigen Array-Lösung funktioniert das leider nicht, da Arrays prinzipiell eine feste Länge haben. Wir erzeugen also einen zweiten Array, kopieren alle Infos und ersetzen die alte Liste damit.

13:57

Um das ganze Thema etwas besser zu verdeutlichen, malen wir uns die verschiedenen Tabellen mal auf Papier auf und schauen uns an, was im Speicher so passiert.

08:42

Zufällige Werte innerhalb eines Computerprogrammes zu schreiben, ist gar nicht so einfach. Alles was der Computer macht, ist berechenbar und wiederholbar. Um also wirklichen Zufall zu bekommen, sind ein paar Tricks notwendig. Zum Glück bietet uns das .NET Framework ein paar Hilfsmittel an um das zu vereinfachen. Die Klasse Random.

12:46

Die naive Herangehensweise der letzten Lektion (einfach Random Werte in den Apfel zu schreiben) bringt leider ein paar potentielle Probleme mit. Die Wahrscheinlichkeit ist zwar gering, aber der Apfel könnte sich nach der Neuplatzierung potentiell innerhalb der Schlange befinden, was unsere Spielregeln etwas aus der Bahn werfen würde. Aus diesem Grund brauchen wir einen Prüfungsmechanismus der sicher stellt, dass neu gefundene Punkte sich nicht in der Schlange befinden und gegebenenfalls wieder einen neuen Wert suchen.

13:30

Der inzwischen doch recht umfangreiche Quellcode beginnt unübersichtlich zu werden. Außerdem haben wir gerade eine Stelle gefunden, bei der wir ein relativ kompliziertes Codefragment grundsätzlich an zwei verschiedenen Stellen brauchen. Das schreit nach Wiederverwendbarkeit und somit nach dem Konzept von eigenen Methoden.

09:31

Damit Methoden auch sinnvolle Arbeit leisten können, brauchen sie Informationen. Da aber unsere neuen Methoden keine Chance haben auf die internen Variablen unserer Hauptmethode zuzugreifen, müssen wir eine Möglichkeit finden Informationen zu übergeben mit denen die Methode arbeiten kann. Wir lernen Parameter kennen.

12:31

Wie versprochen schauen wir uns auf jeden Fall auch noch die Möglichkeit an kompliziertere Aufgaben mit Hilfe von Methoden zu erledigen und schauen mal, was denn noch so alles an doppeltem Quellcode finden. Es existieren z.B. mehrere Kollisionsprüfungen die identischen Code enthalten.

11:58

Es gibt in C# die Möglichkeit Methoden zu definieren, die den selben Namen tragen wie andere Methoden. Die Unterscheidung, welche der beiden Methoden aufgerufen wird, hängt dann von den unterschiedlichen Datentypen der Parameter ab. Oft macht das Sinn, wenn man Methoden hat, die sinngemäß die selbe Aufgabe übernehmen, allerdings mit unterschiedlichen Datentypen arbeiten.

10:43

Die kleine Kür am Ende des Kapitels ist die Implementierung dessen, weswegen wir das Thema eigener Methoden überhaupt erst angeschnitten haben: Das komplizierte Auffinden eines freien Punktes auf dem Spielfeld, um dort einen Apfel platzieren zu können. Wir erstellen also eine Methode die auf Basis der Spielfeld-Bedingungen eine freie Stelle findest – ungeachtet der ursprünglichen Apfel-bezogenen Aufgabe.

Section 4: Exkursion zum Speicher
Intro
Preview
01:22
10:47

Was wir bisher eher implizit gemacht haben, ist die Deklaration und Initialisierung von Variablen – ganz ohne zu wissen, was eigentlich wirklich passiert. Variablen sind nämlich im Grunde kleine Speicherstellen im Arbeitsspeicher des Computers.

07:46

Im Praxisbereich haben wir bereits darüber gesprochen, dass Variablen nicht von überall zugreifbar sind. Hier war aber hauptsächlich die Rede von Sichtbarkeit – also von wo aus Variablen zugreifbar bleiben. Wir erweitern die Sichtweise nun auf die Frage wie lange Variablen existieren und dadurch ihre Gültigkeit behalten.

07:46

Da der Computer ja nur 0 und 1 versteht, muss man ein bisschen umdenken, wenn man verstehen will, wie Computer unsere Daten speichern und mit ihnen umgehen. Wir schauen uns also mal an was es mit dem Binärsystem, Bits und Bytes auf sich hat.

15:45

Grundsätzlich wissen wir schon, dass der Datentyp die Sorte Daten angibt, die sich darin befindet. Int waren Ganzzahlen, String Zeichenketten und Double beinhaltete Kommazahlen. Aber was gibt es noch für Typen und warum ist es so wichtig das im Vorfeld zu definieren?

07:26

Neben den primitiven Datentypen haben wir ja auch noch andere Datentypen verwendet. Beispielsweise den Enum und sogar unseren eigenen Struct. Wir schauen uns an wie sich diese Datentypen bei der Reservierung von Speicher verhalten.

11:37

Im Spezialfall der Integer Liste funktioniert das ganze Konzept der Speicher-Reservierung leider nicht mehr. Das Konzept der festen Speicherzuweisung funktioniert nämlich nur mit Variablen, von denen wir bereits zum Zeitpunkt des Programmierens die endgültige Größe kennen. Im Falle des Arrays war es aber so, dass wir das ja im Laufe des Spiels ändern wollen

12:44

Wir haben jetzt herausgefunden, dass unterschiedliche Datentypen sich nicht nur in der Größe unterscheiden, sondern sich auch grundlegend anders verhalten. Man unterscheidet da zwischen den sogenannten Value-Types die ihren Inhalt unmittelbar in einem Speicherbereich namens „Stack“ halten. Andere wiederum, wie der Array, halten nur einen Zeiger auf einen weiteren Speicherbereich der ganz woanders, nämlich im „Heap“ liegt.

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

Tom Wendel, Lets Coder, Ameisen-Dompteur und Sprecher der ersten Stunde

Tom Wendel, aufgewachsen in einem kleinen, beschaulichen Dörfchen im nahen Westen der Republik, studierte Informatik an der Hochschule zu Karlsruhe und war eine ganze Weile freischaffender Software-Schmied für die unterschiedlichsten Projekte.

Schon früh war die Begeisterung für Spiele - das Bauen, nicht das Spielen - klar. Das Abenteuer begann bereits mit den ersten bitverarbeitenden Geräten und mündete in dem bislang verbreitetsten seiner Titel "AntMe!", einem allseits beliebten Lernspiel für Programmierer. Dies führte ihn bereits nach Ausbildungsende in die entlegensten Regionen Deutschlands, um ehrenamtliche Schulungen für junge Programmierer durchzuführen.

Später war Tom als Developer Evangelist bei Microsoft unterwegs. Mit hunderten Vorträgen, Fach-Artikeln und Büchern hat er Entwickler jeglicher Ausrichtung über die aktuellsten Technologien informiert, wo er seine Liebe zu Spielen mit dem Schwerpunkt Gaming und Multimedia ausleben konnte. Zwischenzeitlich war Tom Community Manager für die Bayerische Spiele Entwickler Community und half dort bei der Vernetzung der coolen Leute und Organisation von Veranstaltungen und Messen.

Seine seit Jahren aufrechterhaltene Behauptung, im Jahr 1972 Weltmeister in Super Mario Kart gewesen zu sein, konnte ihm bislang nicht widerlegt werden.

Ready to start learning?
Take This Course