java a course for beginners
1.0.0
Eclipse – https://courses.in28minutes.com/p/eclipse-tutorial-for-beginners
Maven – https://courses.in28minutes.com/p/maven-tutorial-for-beginners-in-5-steps
JUnit – https://courses.in28minutes.com/p/junit-tutorial-for-beginners
PDF: https://github.com/in28minutes/java-a-course-for-beginners/blob/master/InstallingJavaAndEclipse.pdf
Wir lieben Programmieren. Unser Ziel mit diesem Kurs ist es, die Liebe zum Programmieren zu wecken.
Java ist eine der beliebtesten Programmiersprachen. Java bietet sowohl objektorientierte als auch funktionale Programmierfunktionen.
Wir verfolgen einen praktischen Ansatz und verwenden eine Kombination aus JShell (eine tolle neue Funktion in Java 9) und Eclipse als IDE, um mehr als 200 Java-Codierungsübungen, Rätsel und Codebeispiele zu veranschaulichen.
In mehr als 250 Schritten erkunden wir die wichtigsten Funktionen der Java-Programmiersprache
Grundlagen der Java-Programmierung – Ausdrücke, Variablen und Druckausgabe
Java-Operatoren – Java-Zuweisungsoperator, relationale und logische Operatoren, Kurzschlussoperatoren
Java-Bedingungen und If-Anweisung
Methoden – Parameter, Argumente und Rückgabewerte
Ein Überblick über die Java-Plattform – Java, Javac, Bytecode, JVM und Plattformunabhängigkeit – JDK vs. JRE vs. JVM
Objektorientierte Programmierung – Klasse, Objekt, Zustand und Verhalten
Grundlagen von OOPS – Kapselung, Abstraktion, Vererbung und Polymorphismus
Grundlagen zu Java-Datentypen – Casting, Operatoren und mehr
Integrierte Java-Klassen – BigDecimal-, String- und Java-Wrapper-Klassen
Bedingungen mit Java – If-Else-Anweisung, verschachteltes If-Else, Java-Switch-Anweisung, ternärer Java-Operator
Schleifen – For-Schleife, While-Schleife in Java, Do While-Schleife, Break und Continue
Unveränderlichkeit der Java-Wrapper-Klassen String und BigDecimal
Java Dates – Einführung in LocalDate, LocalTime und LocalDateTime
Java Array und ArrayList – Java-String-Arrays, Arrays von Objekten, primitive Datentypen, toString und Ausnahmen
Einführung in variable Argumente
Grundlagen zum Entwerfen einer Klasse – Klasse, Objekt, Zustand und Verhalten. Entscheidender Staat und Konstrukteure.
Objektzusammensetzung und Vererbung verstehen
Abstrakte Java-Klasse und Schnittstellen. Einführung in den Polymorphismus.
Java-Sammlungen – Listenschnittstelle (ArrayList, LinkedList und Vector), Set-Schnittstelle (HashSet, LinkedHashSet und TreeSet), Warteschlangenschnittstelle (PriorityQueue) und Kartenschnittstelle (HashMap, HashTable, LinkedHashMap und TreeMap() – Vergleichen, Kontrastieren und Auswählen).
Generika – Warum brauchen wir Generika? Einschränkungen bei Extends und generischen Methoden, WildCards – Obergrenze und Untergrenze.
Funktionale Programmierung – Lambda-Ausdruck, Stream und Operationen auf einem Stream (Zwischenoperationen – Sortieren, Unterscheiden, Filtern, Zuordnen und Terminaloperationen – max, min, in Liste sammeln), funktionale Schnittstellen – Prädikatschnittstelle, Verbraucherschnittstelle, Funktionsschnittstelle für die Zuordnung, Methodenreferenzen – statische und Instanzmethoden
Einführung in Threads und MultiThreading – Need for Threads
Threads implementieren – Thread-Klasse erweitern und ausführbare Schnittstelle implementieren
Zustände eines Threads und Kommunikation zwischen Threads
Einführung in den Executor Service – Anpassen der Anzahl aktiver Threads. Gibt eine Zukunft zurück, invokeAll und invokeAny
Einführung in die Ausnahmebehandlung – Ihr Denkprozess während der Ausnahmebehandlung. versuchen, fangen und endlich. Ausnahmehierarchie – aktivierte Ausnahmen vs. ungeprüfte Ausnahmen. Eine Ausnahme auslösen. Erstellen und Auslösen einer benutzerdefinierten Ausnahme – CurrenciesDoNotMatchException. Versuchen Sie es mit Ressourcen – Neue Funktion in Java 7.
Listen Sie Dateien und Ordner im Verzeichnis mit der Dateilistenmethode, der Dateidurchlaufmethode und den Suchmethoden auf. Lesen und schreiben Sie aus einer Datei.
Sie lernen, wie man als Java-Programmierer denkt
Sie erfahren, wie Sie Ihre Reise als Java-Programmierer beginnen
Sie erlernen die Grundlagen von Eclipse IDE und JShell
Sie lernen, mit Java fantastische objektorientierte Programme zu entwickeln
Sie lösen vielfältige praktische Übungen zu den unten besprochenen Themen
Sie lernen die Grundlagen der Programmierung kennen – Variablen, Auswahl eines Datentyps, bedingte Ausführung, Schleifen, das Schreiben großartiger Methoden, das Aufteilen von Problemen in Unterprobleme und die Implementierung einer großartigen Ausnahmebehandlung.
Sie erlernen die Grundlagen der objektorientierten Programmierung – Schnittstellen, Vererbung, abstrakte Klasse und Konstruktoren
Sie lernen die wichtigen Konzepte der objektorientierten Programmierung kennen – Abstraktion, Vererbung, Kapselung und Polymorphismus
Sie erlernen die grundlegende funktionale Programmierung mit Java
Sie erlernen die Grundlagen von MultiThreading – mit Executor Service
Sie lernen eine Vielzahl von Sammlungen kennen – Listen-, Karten-, Set- und Warteschlangenschnittstellen
Konnektivität zum Internet zum Herunterladen von Java 9 und Eclipse.
Wir helfen Ihnen bei der Installation von Java9 mit JShell und Eclipse.
Kursbeginn
Kursende
Schritt 00 – Wie nutzt man den Kursführer optimal?
Schritt 01 – Installation von JDK 9 – mit Installationsanleitung im PDF-Format
Schritt 02 – Überprüfen von Java und Jshell
Schritt 03 – Fehlerbehebung bei der Java-Installation
Schritt 04 – Umgebungsvariable „Pfad“ in Windows festlegen
Schritt 00 – Erste Schritte mit der Programmierung
Schritt 01 – Einführung in die Multiplikationstabellen-Herausforderung
Schritt 02 – Starten Sie JShell
Schritt 03 – Die Multiplikationstabellen-Herausforderung aufschlüsseln
Schritt 04 – Java-Ausdruck – Eine Einführung
Schritt 05 – Java-Ausdruck – Übungen
Schritt 06 – Java-Ausdruck – Rätsel
Schritt 07 – Ausgabe auf der Konsole mit Java drucken
Schritt 08 – Ausgabe an die Konsole mit Java drucken – Übungsanweisungen
Schritt 09 – Ausgabe auf der Konsole mit Java drucken – Übungslösungen
Schritt 10 – Ausgabe auf der Konsole mit Java – Puzzles drucken
Schritt 11 – Erweiterte Druckausgabe an die Konsole mit Java
Schritt 12 – Erweiterte Druckausgabe auf der Konsole mit Java – Übungen und Rätsel
Schritt 13 – Einführung in Variablen in Java
Schritt 14 – Einführung in Variablen in Java – Übungen und Rätsel
Schritt 15 – 4 Wichtige Dinge, die Sie über Variablen in Java wissen sollten
Schritt 16 – Wie werden Variablen im Speicher gespeichert?
Schritt 17 – Wie benenne ich eine Variable?
Schritt 18 – Grundlegende Variablentypen in Java verstehen
Schritt 19 – Grundlegende Variablentypen in Java – Auswählen eines Typs
Schritt 20 – Java-Zuweisungsoperator
Schritt 21 – Java-Zuweisungsoperator – Rätsel zu Inkrementierung, Dekrementierung und zusammengesetzter Zuweisung
Schritt 23 – Java-Bedingungen und If-Anweisung – Einführung
Schritt 24 – Java-Bedingungen und If-Anweisung – Übungsanweisungen
Schritt 25 – Java-Bedingungen und If-Anweisung – Übungslösungen
Schritt 26 – Java-Bedingungen und If-Anweisung – Rätsel
Schritt 27 – Java For-Schleife zum Drucken der Multiplikationstabelle – Einführung
Schritt 28 – Java For-Schleife zum Drucken der Multiplikationstabelle – Übungsanweisungen
Schritt 29 – Java For-Schleife zum Drucken der Multiplikationstabelle – Übungslösungen
Schritt 30 – Java For-Schleife zum Drucken der Multiplikationstabelle – Rätsel
Schritt 31 – Programmiertipps: JShell – Verknüpfungen, mehrere Zeilen und Variablen TODO Nach oben verschieben
Schritt 32 – Erste Schritte mit der Programmierung – Überarbeiten Sie die gesamte Terminologie
Schritt 00 – Abschnitt 02 – Methoden – Eine Einführung
Schritt 01 – Ihre erste Java-Methode – Hello World Twice und Übungsanweisungen
Schritt 02 – Einführung in Java-Methoden – Übungen und Rätsel
Schritt 03 – Programmiertipp – Methoden mit JShell bearbeiten
Schritt 04 – Einführung in Java-Methoden – Argumente und Parameter
Schritt 05 – Einführung in Java-Methodenargumente – Übungen
Schritt 06 – Einführung in Java-Methodenargumente – Rätsel und Tipps
Schritt 07 – Zurück zur Multiplikationstabelle – Erstellen einer Methode
Schritt 08 – Drucken Sie die Multiplikationstabelle mit einer Parameter- und Methodenüberladung
Schritt 09 – Übergeben mehrerer Parameter an eine Java-Methode
Schritt 10 – Rückkehr von einer Java-Methode – Eine Einführung
Schritt 11 – Rückkehr von einer Java-Methode – Übungen
Schritt 99 – Methoden – Abschnittsüberprüfung
Schritt 00 – Abschnitt 03 – Überblick über die Java-Plattform – Abschnittsübersicht
Schritt 01 – Überblick über die Java-Plattform – Eine Einführung – Java, Javac, Bytecode und JVM
Schritt 02 – Java-Klasse und -Objekt – Erster Blick
Schritt 03 – Erstellen Sie eine Methode in einer Java-Klasse
Schritt 04 – Erstellen und kompilieren Sie die Planet.java-Klasse
Schritt 05 – Planet calss mit Java ausführen – Verwendung einer Hauptmethode
Schritt 06 – Spielen und Lernen mit Planet Class
Schritt 07 – JDK vs. JRE vs. JVM
Schritt 00 – Eclipse installieren
Schritt 01 – Erstellen eines neuen Java-Projekts mit Eclipse
Schritt 02 – Ihre erste Java-Klasse mit Eclipse
Schritt 03 – Schreiben eines Multiplikationstabellen-Java-Programms mit Eclipse
Schritt 04 – Hinzufügen weiterer Methoden für das Multiplikationstabellenprogramm
Schritt 05 – Programmiertipp 1: Refactoring mit Eclipse
Schritt 06 – Programmiertipp 2: Debuggen mit Eclipse
Schritt 07 – Programmiertipp 3: Eclipse vs. JShell – Wie wählt man aus?
Schritt 00 – Einführung in die objektorientierte Programmierung – Abschnittsübersicht
Schritt 01 – Einführung in die objektorientierte Programmierung – Grundlagen
Schritt 02 – Einführung in die objektorientierte Programmierung – Terminologie – Klasse, Objekt, Zustand und Verhalten
Schritt 03 – Einführung in die objektorientierte Programmierung – Übung – Online-Shopping-System und Person
Schritt 04 – Erstellen Sie die Motor Bike Java-Klasse und einige Objekte
Schritt 05 – Übungslösungen – Buchklasse und drei Beispiele
Schritt 06 – Eingeben des Zustands eines Objekts mit Geschwindigkeitsvariable
Schritt 07 – Grundlagen der Kapselung mit Setter-Methoden verstehen
Schritt 08 – Übungen und Tipps – Getter und Generieren von Gettern und Settern mit Eclipse
Schritt 09 – Rätsel dazu und Initialisierung der Mitgliedsvariablen
Schritt 10 – Erster Vorteil der Kapselung
Schritt 11 – Einführung in die Kapselung – Ebene 2
Schritt 12 – Kapselungsübungen – Bessere Validierung und Buchklasse
Schritt 13 – Einführung in die Abstraktion
Schritt 14 – Einführung in Java-Konstruktoren
Schritt 15 – Einführung in Java-Konstruktoren – Übungen und Rätsel
Schritt 16 – Einführung in die objektorientierte Programmierung – Fazit
Schritt 00 – Primitive Datentypen im Detail – Abschnittsübersicht
Schritt 01 – Grundlagen zu Java-Ganzzahldatentypen – Umwandlung, Operatoren und mehr
Schritt 02 – Java-Integer-Datentypen – Rätsel – Oktal, Hexadezimal, Post- und Pre-Inkrement
Schritt 03 – Java-Integer-Datentypen – Übungen – BiNumber – Addieren, Multiplizieren und Verdoppeln
Schritt 04 – Java-Gleitkomma-Datentypen – Umwandlung, Konvertierung und Genauigkeit
Schritt 05 – Einführung in die BigDecimal Java-Klasse
Schritt 06 – BigDecimal-Rätsel – Ganzzahlen hinzufügen
Schritt 07 – BigDecimal-Übungen – Einfache Zinsberechnung
Schritt 08 – Java Boolescher Datentyp – Relationale und logische Operatoren
Schritt 09 – Java Boolescher Datentyp – Rätsel – Kurzschlussoperatoren
Schritt 10 – Java-Zeichendatentyp char – Darstellung und Konvertierung
Schritt 11 – Java-Char-Datentyp – Übungen 1 – isVowel
Schritt 12 – Java-Char-Datentyp – Übungen 2 – isDigit
Schritt 13 – Java char-Datentyp – Übungen 3 – isConsonant, Auflisten von Groß- und Kleinbuchstaben
Schritt 14 – Primitive Datentypen im Detail – Fazit
Schritt 00 – Bedingungen mit Java – Abschnittsübersicht
Schritt 01 – Einführung in die If Else-Anweisung
Schritt 02 – Einführung in Nested If Else
Schritt 03 – If Else-Anweisung – Rätsel
Schritt 04 – Wenn sonst ein Problem besteht – Wie erhalte ich Benutzereingaben in Java?
Schritt 05 – Wenn sonst Problem – Wie bekomme ich Nummer 2 und eine Auswahl vom Benutzer?
Schritt 06 – If Else-Problem – Implementierung mit Nested If Else
Schritt 07 – Java Switch-Anweisung – Eine Einführung
Schritt 08 – Java Switch-Anweisung – Rätsel – Standard, Break und Fall Through
Schritt 09 – Java Switch-Anweisung – Übungen – isWeekDay, nameOfMonth, nameOfDay
Schritt 10 – Ternärer Java-Betrieb – Eine Einführung
Schritt 11 – Bedingungen mit Java – Fazit
Schritt 00 – Java-Schleifen – Abschnitt Einführung
Schritt 01 – Java For-Schleife – Syntax und Rätsel
Schritt 02 – Java For-Schleife – Übersicht über die Übungen und erste Übung: Primzahlen
Schritt 03 – Java For-Schleife – Übung – Summiere bis zu N Zahlen und Summe der Teiler
Schritt 04 – Java For-Schleife – Übung – Drucken Sie ein Zahlendreieck
Schritt 05 – While-Schleife in Java – Eine Einführung
Schritt 06 – While-Schleife – Übungen – Würfel und Quadrate bis zum Limit
Schritt 07 – While-Schleife in Java ausführen – Eine Einführung
Schritt 08 – Ausführen einer While-Schleife in Java – Ein Beispiel – Cube, während der Benutzer positive Zahlen eingibt
Schritt 09 – Einführung in Break and Continue
Schritt 10 – Auswählen einer Schleife in Java – For vs While vs Do While
Schritt 00 – Java-Referenztypen – Abschnitt Einführung
Schritt 01 – Referenztypen – Wie werden sie im Speicher gespeichert?
Schritt 02 – Java-Referenztypen – Rätsel
Schritt 03 – String-Klasse – Einführung und Übung – Geben Sie jedes Wort und Zeichen in einer neuen Zeile aus
Schritt 04 – String-Klasse – Übungslösung und einige weitere wichtige Methoden
Schritt 05 – Verstehen, dass String unveränderlich ist und die Methoden String Concat, Upper Case, Lower Case, Trim verwenden
Schritt 06 – String-Verkettung und Join-/Replace-Methoden
Schritt 07 – Java-String-Alternativen – StringBuffer und StringBuilder
Schritt 08 – Java-Wrapper-Klassen – Eine Einführung – Warum und was?
Schritt 09 – Java-Wrapper-Klassen – Erstellung – Konstruktor und valueOf
Schritt 10 – Java-Wrapper-Klassen – Auto-Boxing und ein paar Wrapper-Konstanten – SIZE, BYTES, MAX_VALUE und MIN_VALUE
Schritt 11 – Java Dates – Einführung in LocalDate, LocalTime und LocalDateTime
Schritt 12 – Java Dates – LocalDate erkunden – Erstellung und Methoden zum Spielen mit Date
Schritt 13 – Java-Daten – LocalDate erkunden – Daten vergleichen und spezifische Daten erstellen
Schritt 14 – Java-Referenztypen – Fazit
Schritt 00 – Einführung in Array und ArrayList – Abschnitt Einführung mit einer Herausforderung
Schritt 01 – Verständnis der Notwendigkeit und Grundlagen eines Arrays
Schritt 02 – Java-Arrays – Werte erstellen und darauf zugreifen – Einführung
Schritt 03 – Java-Arrays – Rätsel – Arrays von Objekten, primitiven Datentypen, toString und Ausnahmen
Schritt 04 – Java-Arrays – Vergleichen, Sortieren und Füllen
Schritt 05 – Java-Arrays – Übung – Schülerklasse erstellen – Teil 1 – Gesamt- und Durchschnittsnoten
Schritt 06 – Java-Arrays – Übung – Schülerklasse erstellen – Teil 2 – Höchst- und Mindestpunktzahl
Schritt 07 – Einführung in variable Argumente – Bedarf
Schritt 08 – Einführung in variable Argumente – Grundlagen
Schritt 09 – Einführung in variable Argumente – Verbesserung der Schülerklasse
Schritt 10 – Java-Arrays – Verwendung von Personenobjekten und String-Elementen mit Übungen
Schritt 11 – Java-String-Arrays – Übungslösungen – Geben Sie den Wochentag mit der höchsten Anzahl an Buchstaben und mehr aus
Schritt 12 – Markierungen hinzufügen und entfernen – Problem mit Arrays
Schritt 13 – Erster Blick auf ArrayList – Eine Einführung
Schritt 14 – Erster Blick auf ArrayList – Umgestaltung der Studentenklasse zur Verwendung von ArrayList
Schritt 15 – Erster Blick auf ArrayList – Erweitern der Schülerklasse durch Hinzufügen und Entfernen von Markierungen
Schritt 16 – Einführung in Array und ArrayList – Fazit
Schritt 00 – Objektorientierte Programmierung – Ebene 2 – Abschnitt Einführung
Schritt 01 – Grundlagen des Klassenentwurfs – Klasse, Objekt, Zustand und Verhalten
Schritt 02 – OOPS-Beispiel – Fan-Klasse – Entscheidungsstatus und Konstruktoren
Schritt 03 – OOPS-Beispiel – Fan-Klasse – Verhaltensentscheidung mit Methoden
Schritt 04 – OOPS-Übung – Rechteckklasse
Schritt 05 – Verstehen der Objektzusammensetzung am Beispiel einer Kundenadresse
Schritt 06 – Objektzusammensetzung verstehen – Eine Übung – Bücher und Rezensionen
Schritt 07 – Vererbung verstehen – Warum brauchen wir sie?
Schritt 08 – Das Objekt steht an der Spitze der Vererbungshierarchie
Schritt 09 – Vererbung und Überschreibung – mit der toString()-Methode
Schritt 10 – Java-Vererbung – Übung – Studenten- und Mitarbeiterklassen
Schritt 11 – Java-Vererbung – Standardkonstruktoren und super()-Methodenaufruf
Schritt 12 – Java-Vererbung – Rätsel – Mehrfachvererbung, Referenzvariablen und Instanz von
Schritt 13 – Java Abstract Class – Einführung
Schritt 14 – Java Abstract Class – Erstes Beispiel – Erstellen von Rezepten mit der Template-Methode
Schritt 15 – Java Abstract Class – Rätsel
Schritt 16 – Java-Schnittstelle – Beispiel 1 – Spielekonsole – Wie denken Sie über Schnittstellen nach?
Schritt 17 – Java-Schnittstelle – Beispiel 2 – Komplexer Algorithmus – API definiert durch externes Team
Schritt 18 – Java-Schnittstelle – Rätsel – Nicht implementierte Methoden, abstrakte Klassen, Variablen, Standardmethoden und mehr
Schritt 19 – Java-Schnittstelle vs. abstrakte Klasse – ein Vergleich
Schritt 20 – Java-Schnittstelle Flyable und Abstract Class Animal – Eine Übung
Schritt 21 – Polymorphismus – Eine Einführung
Schritt 01 – Java-Sammlungen – Abschnittsübersicht mit Need For Collections
Schritt 02 – Listenschnittstelle – Einführung – Position ist König
Schritt 03 – Listenschnittstelle – Unveränderlichkeit und Einführung von Implementierungen – ArrayList, LinkedList und Vector
Schritt 04 – Schnittstellenimplementierungen auflisten – ArrayList vs. LinkedList
Schritt 05 – Schnittstellenimplementierungen auflisten – ArrayList vs. Vector
Schritt 06 – Listenschnittstelle – Methoden zum Hinzufügen, Entfernen und Ändern von Elementen und Listen
Schritt 07 – Liste und ArrayList – Durchlaufen von Elementen
Schritt 08 – Liste und ArrayList – Auswahl des Iterationsansatzes zum Drucken und Löschen von Elementen
Schritt 09 – Liste und ArrayList – Rätsel – Typsicherheit und Entfernen von Ganzzahlen
Schritt 10 – Liste und ArrayList – Sortieren – Einführung in die statische Sortiermethode für Sammlungen
Schritt 11 – Liste und ArrayList – Sortierung – Implementierung einer vergleichbaren Schnittstelle in der Schülerklasse
Schritt 12 – Liste und ArrayList – Sortierung – Bereitstellung von Flexibilität durch Implementierung der Comparator-Schnittstelle
Schritt 13 – Liste und ArrayList – Eine Zusammenfassung
Schritt 14 – Schnittstelle festlegen – Einführung – Keine Duplizierung
Schritt 15 – Datenstrukturen verstehen – Array, LinkedList und Hashing
Schritt 16 – Datenstrukturen verstehen – Baum – sortierte Reihenfolge
Schritt 17 – Schnittstelle festlegen – Hands on – HashSet, LinkedHashSet und TreeSet
Schritt 18 – Schnittstelle festlegen – Übung – Eindeutige Zeichen in einer Liste suchen
Schritt 19 – TreeSet – Methoden von NavigableSet – floor,lower,upper, subSet, head und tailSet
Schritt 20 – Warteschlangenschnittstelle – Elemente in der richtigen Reihenfolge verarbeiten
Schritt 21 – Einführung in PriorityQueue – Grundlegende Methoden und benutzerdefinierte Priorität
Schritt 22 – Kartenschnittstelle – Eine Einführung – Schlüssel und Wert
Schritt 23 – Kartenschnittstelle – Implementierungen – HashMap, HashTable, LinkedHashMap und TreeMap
Schritt 24 – Kartenschnittstelle – Grundfunktionen
Schritt 25 – Kartenschnittstelle – Vergleich – HashMap vs. LinkedHashMap vs. TreeMap
Schritt 26 – Kartenschnittstelle – Übung – Zählen Sie das Vorkommen von Zeichen und Wörtern in einem Text
Schritt 27 – TreeMap – Methoden von NavigableMap – floorKey, higherKey, firstEntry, subMap und mehr
Schritt 28 – Java-Sammlungen – Fazit mit drei Tipps
Schritt 01 – Einführung in Generika – Warum brauchen wir Generika?
Schritt 02 – Generika für die benutzerdefinierte Liste implementieren
Schritt 03 – Erweitern der benutzerdefinierten Liste mit einer generischen Rückgabemethode
Schritt 04 – Generische Rätsel – Einschränkungen bei Erweiterungen und generischen Methoden
Schritt 05 – Generics und WildCards – Obergrenze und Untergrenze
Schritt 01 – Einführung in die funktionale Programmierung – Funktionen sind erstklassige Bürger
Schritt 02 – Funktionale Programmierung – Erstes Beispiel mit Funktion als Parameter
Schritt 03 – Funktionale Programmierung – Übung – Schleife eine Liste von Zahlen
Schritt 04 – Funktionale Programmierung – Filtern – Übungen zum Drucken ungerader und gerader Zahlen aus der Liste
Schritt 05 – Funktionale Programmierung – Sammeln – Summe der Zahlen in einer Liste
Schritt 06 – Funktionale Programmierung vs. Strukturelle Programmierung – Ein kurzer Vergleich
Schritt 07 – Terminologie der funktionalen Programmierung – Lambda-Ausdruck, Stream und Operationen in einem Stream
Schritt 08 – Zwischenoperationen streamen – Sortieren, Unterscheiden, Filtern und Zuordnen
Schritt 09 – Zwischenoperationen streamen – Übungen – Quadrate der ersten 10, Zuordnung der Zeichenfolgenliste zu Kleinbuchstaben und Länge der Zeichenfolge
Schritt 10 – Stream-Terminal-Vorgänge – 1 – maximaler Betrieb mit Komparator
Schritt 11 – Terminalvorgänge streamen – 2 – Min., in Liste sammeln,
Schritt 12 – Optionale Klasse in Java – Eine Einführung
Schritt 13 – Hinter den Kulissen mit funktionalen Schnittstellen – Prädikatschnittstelle implementieren
Schritt 14 – Hinter den Kulissen mit funktionalen Schnittstellen – Verbraucherschnittstelle implementieren
Schritt 15 – Hinter den Kulissen mit funktionalen Schnittstellen – Funktionsschnittstelle für die Zuordnung implementieren
Schritt 16 – Vereinfachen Sie den funktionalen Programmiercode mit Methodenreferenzen – statische Methoden und Instanzmethoden
Schritt 17 – Funktionen sind erstklassige Bürger
Schritt 18 – Einführung in die funktionale Programmierung – Fazit
Schritt 01 – Einführung in Threads und MultiThreading – Bedarf an Threads
Schritt 02 – Erstellen eines Threads für Aufgabe 1 – Erweitern der Thread-Klasse
Schritt 03 – Erstellen eines Threads für Task2 – Implementieren einer ausführbaren Schnittstelle
Schritt 04 – Theorie – Zustände eines Threads
Schritt 05 – Prioritätsanfragen für Threads stellen
Schritt 06 – Kommunikation zwischen Threads – Join-Methode
Schritt 07 – Thread-Dienstprogrammmethoden und synchronisiertes Schlüsselwort – Sleep, Yield
Schritt 08 – Notwendigkeit der Steuerung der Ausführung von Threads
Schritt 09 – Einführung in den Executor-Service
Schritt 10 – Executor-Dienst – Anpassen der Anzahl der Threads
Schritt 11 – Executor-Dienst – Zurückgeben eines Futures aus einem Thread mithilfe von Callable
Schritt 12 – Executor-Dienst – Warten auf den Abschluss mehrerer Aufgaben mit invokeAll
Schritt 13 – Executor-Dienst – Warten Sie mit invokeAny nur auf die schnellste Aufgabe
Schritt 14 – Threads und MultiThreading – Fazit
Schritt 01 – Einführung in die Ausnahmebehandlung – Ihr Denkprozess während der Ausnahmebehandlung
Schritt 02 – Grundlagen von Ausnahmen – NullPointerException und StackTrace
Schritt 03 – Grundlagen der Ausnahmebehandlung – Ausprobieren und Abfangen
Schritt 04 – Grundlagen der Ausnahmebehandlung – Ausnahmehierarchie, Zuordnung und Abfangen mehrerer Ausnahmen
Schritt 05 – Grundlagen der Ausnahmebehandlung – Need for Finally
Schritt 06 – Grundlagen der Ausnahmebehandlung – Rätsel
Schritt 07 – Geprüfte Ausnahmen vs. ungeprüfte Ausnahmen – Ein Beispiel
Schritt 08 – Hierarchie der Fehler und Ausnahmen – geprüft und zur Laufzeit
Schritt 09 – Auslösen einer Ausnahme – Währungen stimmen nicht mit der Laufzeitausnahme überein
Schritt 10 – Auslösen einer geprüften Ausnahme – Wirft Methodensignatur und -behandlung ein
Schritt 11 – Auslösen einer benutzerdefinierten Ausnahme – CurrenciesDoNotMatchException
Schritt 12 – Weniger Code schreiben mit Try with Resources – Neue Funktion in Java 7
Schritt 13 – Grundlagen der Ausnahmebehandlung – Rätsel 2
Schritt 14 – Ausnahmebehandlung – Abschluss mit Best Practices
Schritt 01 – Listen Sie Dateien und Ordner im Verzeichnis mit der Dateilistenmethode auf
Schritt 02 – Rekursives Auflisten und Filtern aller Dateien und Ordner im Verzeichnis mit der Walk-Methode „Step Files“ und Suchen mit der Find-Methode
Schritt 03 – Inhalt aus einer Datei lesen – Dateien readAllLines und Zeilenmethoden
Schritt 04 – Inhalte in eine Datei schreiben – Methode zum Schreiben von Dateien
Schritt 05 – Dateien – Fazit
Schritt 01 – Erste Schritte mit Synchronized
Schritt 02 – Problem mit Synchronisiert – Weniger Parallelität
Schritt 03 – Sperren mit ReEntrantLock eingeben
Schritt 04 – Einführung in Atomklassen – AtomicInteger
Schritt 05 – Bedarf an ConcurrentMap
Schritt 06 – Implementierung eines Beispiels mit ConcurrentHashMap
Schritt 07 – ConcurrentHashMap verwendet unterschiedliche Sperren für unterschiedliche Regionen
Schritt 08 – Gleichzeitige CopyOnWrite-Sammlungen – Wenn es mehr Lesevorgänge als Schreibvorgänge gibt
Schritt 09 – Fazit
Java-Tipp 01 – Importe und statische Importe
Java-Tipp 02 – Blöcke
Java-Tipp 03 – Equals-Methode
Java-Tipp 04 – Hashcode-Methode
Java-Tipp 05 – Klassenzugriffsmodifikatoren – öffentlich und standardmäßig
Java-Tipp 06 – Methodenzugriffsmodifikatoren – öffentlich, geschützt, privat und Standard
Java-Tipp 07 – Final-Klassen und Final-Methoden
Java-Tipp 08 – Schlussvariablen und Schlussargumente
Java-Tipp 09 – Warum brauchen wir statische Variablen?
Java-Tipp 09 – Warum brauchen wir statische Methoden?
Java-Tipp 10 – Statische Methoden können keine Instanzmethoden oder Variablen verwenden
Java-Tipp 11 – öffentliches statisches Finale – Konstanten
Java-Tipp 12 – Verschachtelte Klassen – Innere Klasse vs. statische verschachtelte Klasse
Java-Tipp 13 – Anonyme Klassen
Java-Tipp 14 – Warum Enum und Enum-Grundlagen – Ordinalzahlen und Werte
Java-Tipp 15 – Enum – Konstruktor, Variablen und Methoden
Java-Tipp 16 – Kurzer Blick auf Inbuild-Enums – Monat, DayOfWeek
Weitere Informationen finden Sie in unserem Leitfaden zur Fehlerbehebung – https://github.com/in28minutes/in28minutes-initiatives/tree/master/The-in28Minutes-TroubleshootingGuide-And-FAQ
Klicken Sie hier – über 30 Playlists mit über 500 Videos zu Spring, Spring Boot, REST, Microservices und der Cloud
in28Minutes erstellt erstaunliche Lösungen für Sie, um Spring Boot, Full Stack und die Cloud zu erlernen – Docker, Kubernetes, AWS, React, Angular usw. – Schauen Sie sich hier alle unsere Kurse an
Einführung in neue Abschnitte – https://www.udemy.com/course/java-programming-tutorial-for-beginners/learn/lecture/25694200
Vielen Dank, dass Sie sich entschieden haben, von in28Minutes zu lernen.
Laden Sie das Kursmaterial (Präsentation und Downloads) zum Kurs herunter – HIER KLICKEN
Wir sehen uns im nächsten Schritt!
Für die nächsten Abschnitte ist die neueste Version von Java und Eclipse Enterprise Edition erforderlich.
Wenn Sie auf Probleme stoßen:
Installieren der neuesten Java-Version
Fehlerbehebung bei Java und Eclipse
Windows: C:ProgrammeJavajdk-{version}
Beispiel für JDK 16 – C:Program FilesJavajdk-16
Beispiel für JDK 17 – C:Program FilesJavajdk-17
Mac: /Library/Java/JavaVirtualMachines/jdk-{version}.jdk/Contents/Home
Beispiel für JDK 16 – /Library/Java/JavaVirtualMachines/jdk-16.jdk/Contents/Home
Beispiel für JDK 17 – /Library/Java/JavaVirtualMachines/jdk-17.jdk/Contents/Home
Windows: C:ProgrammeJavajdk-{version}bin
Beispiel für JDK 16 – C:Program FilesJavajdk-16bin
Mac: /Library/Java/JavaVirtualMachines/jdk-{version}.jdk/Contents/Home/bin
Beispiel für JDK 16 – /Library/Java/JavaVirtualMachines/jdk-16.jdk/Contents/Home/bin
Paket com.in28minutes.learnspringframework.sample.enterprise.flow.web;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind. annotation.RestController;import com.in28minutes.learnspringframework.sample.enterprise.flow.business.BusinessService;//Antwort im richtigen Format senden@RestControllerpublic class Controller { @Autowiredprivate BusinessService businessService;
//"/sum" => 100@GetMapping("/sum") public long displaySum() { return businessService.calculateSum();
}
} //Business Logicpackage com.in28minutes.learnspringframework.sample.enterprise.flow.business;import java.util.List;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Component;import com.in28minutes.learnspringframework.sample.enterprise.flow.data.DataService;@Componentpublic class BusinessService {
@Autowiredprivate DataService dataService;
public long berechneSum() { List<Integer> data = dataService.retrieveData(); return data.stream().reduce(Integer::sum).get();
}
} package com.in28minutes.learnspringframework.sample.enterprise.flow.data;import java.util.Arrays;import java.util.List;import org.springframework.stereotype.Component;@Componentpublic class DataService { public List<Integer> restartData( ) { return Arrays.asList(12,34,56,78,90);
}
}Starten Sie MySQL mit Docker
docker run --detach --env MYSQL_ROOT_PASSWORD=dummypassword --env MYSQL_USER=courses-user --env MYSQL_PASSWORD=dummycourses --env MYSQL_DATABASE=courses --name mysql --publish 3306:3306 mysql:5.7
application.properties-Konfiguration
#spring.datasource.url=jdbc:h2:mem:testdb spring.jpa.hibernate.ddl-auto=update spring.datasource.url=jdbc:mysql://localhost:3306/courses spring.datasource.username=courses-user spring.datasource.password=dummycourses spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL57Dialect #courses-user@localhost:3306
MySQL-Befehle
mysqlsh connect courses-user@localhost:3306 sql use courses select * from course; quit
Docker-Befehle
docker container ls docker container stop ID
Vielen Dank, dass Sie diesem Kurs geholfen haben, 100.000 Lernende zu erreichen. Jeden Tag absolvieren Tausende von Lernenden diesen Kurs! Danke für all deine Liebe.
Java entwickelt sich kontinuierlich weiter. Ich freue mich wirklich, tolle Updates für den Kurs ankündigen zu können! Wir fügen dem Kurs ein Real-World-Projekt mit Spring und Spring Boot hinzu!
Der Kurs wurde aktualisiert, um JDK 16 zu verwenden (letzte Woche veröffentlicht).
Neuer Inhalt hinzugefügt
Java-Modularisierung
Aufzeichnungen
Textblöcke
Ausdruck wechseln
Lokale Variablentypinferenz
Neue Java-API in Dateien, Listen, Mengen, Karten und Zeichenfolgen
Es wurde ein neuer Abschnitt zum Erstellen einer realen Java-Rest-API hinzugefügt mit:
Frühlingsrahmen
Frühlingsstiefel
JPA
Daten-JPA
H2/MySQL
Docker
Worauf warten Sie noch?
Ich bin wirklich begeistert von diesen Veränderungen. Ich hoffe, Sie sind es auch!
Viel Glück.
Gerne können Sie Ihre Fragen hier posten!
Ranga
Lernen Sie jeden Tag weiter!
Letzte Woche haben wir tolle Aktualisierungen des Kurses angekündigt.
Wir erhalten wunderbares Feedback von unseren Lernenden.
Alle Aktualisierungen sind für bestehende Kursteilnehmer KOSTENLOS.
Beginnen Sie jetzt mit den neuen Java-Funktionen, Spring und Spring Boot!
Viel Glück
Docker und Kubernetes sind heutzutage in der Welt der Microservices unverzichtbar. Da wir den Bedarf erkannten, kündigten wir im Januar 2021 erstaunliche Aktualisierungen des Kurses an:
Abschnitt 6 – Microservices mit Spring Cloud – V2 Abschnitt 7 – Docker mit Microservices mit Spring Boot und Spring Cloud – V2 Abschnitt 8: Kubernetes mit Microservices mit Docker, Spring Boot und Spring Cloud – V2 Wir erhalten wunderbares Feedback von unseren Lernenden.
Alle Aktualisierungen sind für bestehende Kursteilnehmer KOSTENLOS.
