Java Programming Masterclass Updated To Java 17

Last updated 8/2023
MP4 | Video: h264, 1920x1080 | Audio: AAC, 44.1 KHz
Language: English | Size: 70.41 GB | Duration: 126h 57m

Learn Java In This Course And Become a Computer Programmer. Obtain valuable Core Java Skills And Java Certification

What you'll learn
Learn the core Java skills needed to apply for Java developer positions in just 14 hours.
Be able to sit for and pass the Oracle Java Certificate exam if you choose.
Be able to demonstrate your understanding of Java to future employers.
Learn industry "best practices" in Java software development from a professional Java developer who has worked in the language for 18 years.
Acquire essential java basics for transitioning to the Spring Framework, Java EE, Android development and more.
Obtain proficiency in Java 8 and Java 11.

Requirements
A computer with either Windows, Mac or Linux to install all the free software and tools needed to build your new apps (I provide specific videos on installations for each platform).
A strong work ethic, willingness to learn, and plenty of excitement about the awesome new programs you're about to build.
Nothing else! It's just you, your computer and your hunger to get started today.

Description
December 24, 2022 UPDATE - SECOND PART OF THE MASSIVE NEW UPDATE FOR JAVA 17 IS LIVE TODAY. Read below to find out why you want to be learning Java 17 and not another version.This course has been constantly updated since it originally came out in 2016. All updates are included free. Buy the course once and get all future updates free.You've just stumbled upon the most complete, in-depth Java programming course online. With over 742,000 students enrolled and over one hundred and seventy four thousand reviews (with tens of thousands of those 5-star) to date, these comprehensive java tutorials cover everything you'll ever need. Whether you want to:- build the skills you need to get your first Java programming job- move to a more senior software developer position- pass the oracle java certification exam- or just learn java to be able to create your own java apps (desktop or web based) quickly....this complete Java Masterclass is the course you need to do all of this, and more. Why would you choose to learn Java?The reality is that there is a lot of computer languages out there. It's in the hundreds. Why would you choose the Java language?The number one reason is its popularity. According to many official websites that track the popularity of languages, Java is in the top 3 most popular languages worldwide in 2022. Popularity means more companies and their staff are using it, so there are more career opportunities available for you if you are skilled in the language.The last thing you want to do is pick a language that is not in mainstream use. Java came out in the 1990s and is still very popular today and continually updated by the owners, Oracle, over 30 years later.Are you aiming to get your first Java Programming job but struggling to find out what skills employers want and which course will give you those skills?This course is designed to give you the Java skills you need to get a job as a Java developer. By the end of the course, you will understand Java extremely well and be able to build your own Java apps and be productive as a software developer. Lots of students have been successful in getting their first job or promotion after going through the course.Here is just one example of a student who lost her job and despite having never coded in her life previously, got a full-time software developer position in just a few months after starting this course. She didn't even complete the course!"Three months ago I lost my job, came to a turning point in my life, and finally made the drastic decision to completely change course. I decided to switch career paths and go into coding. My husband found and gave me your Complete Java Masterclass at Udemy as a gift, and I wholeheartedly dove into it as a lifeline. Following your course has been absolutely enjoyable (still working on it, not yet finished), and has been a great way of keeping on course, dedicated and motivated. Yesterday, three months after starting the course, and honestly to my surprise, I received (and accepted!) a job offer as a full-time developer. I wanted to just drop you a line to say thank you for doing this work, for being such a dedicated teacher, and for putting all this knowledge available out there in such an approachable way. It has, literally, been life-changing. With gratitude, Laura"The course is a whopping 100 hours long. Perhaps you have looked at the size of the course and are feeling a little overwhelmed at the prospect of finding time to complete it. Maybe you are wondering if you need to go through it all?Firstly, Laura's story above shows that you do not have to complete the entire course - she was yet to complete the course when she accepted her developer job offer.Secondly, the course is designed as a one-stop shop for Java.The core java material you need to learn java development is covered in the first seven sections (around 14 hours in total). The Java Basics are covered in those sections. The rest of the course covers intermediate, advanced, and optional material you do not technically need to go through.For example section 13 is a whopping 10 hours just by itself and is aimed at those students who want to build desktop applications with graphical user interfaces. JavaFX (which is the technology used in this section) is something that most java developers will rarely or never need to work on. So you could skip that section entirely. But if you are one of the few that need to build user interfaces, then the content is there and ready for you. And there are other sections you can completely avoid if you wish.If you want to know absolutely everything about Java, then you can go through the entire course if you wish, but it's not necessary to do so if you are just looking to learn the essential information to get a java developer position.What version of Java should you learn?Generally speaking, you would want to learn the very latest version of a computer programming language, but that's not the case with Java.Oracle, the owner of Java release many versions of Java. Some are released and expire in six months, with no future updates or support. Other versions have long-term support, for many years.You can probably see why learning a version of Java that has expired makes no sense, and is likely a waste of time.A company using Java technology (big or small) is not going to use a version of Java that has no updates or support. They will stick to stable, well-supported versions of Java that get updates.Right now, in December 2022, the version of Java that offers this long-term support (LTS) is Java 17 - It's being fully supported until at least 2029 and likely will be extended from there.As such, you want to learn the version of Java that your future employer will use, and that's Java 17.The course will also be updated in the future as new LTS versions are announced by Oracle. BOTTOM LINE: You will learn the RIGHT VERSION of JAVA in this course! Right meaning the right version to maximize your future Java potential with clients or Employers.Will this course give me core java skills?Yes, it will. Core Java is the fundamental part of the Java JDK (the java development kit) that programmers need to learn to move onto other more advanced technologies.Why should you take this course?It's been a best-seller since its release on Udemy, you would be joining over 742,000 students who are already enrolled in the course.There are well over 174,000 reviews left by students. It's rated as the best course to learn Java for beginners.What makes this course a bestseller? Like you, thousands of others were frustrated and fed up with fragmented Youtube tutorials or incomplete or outdated courses which assume you already know a bunch of stuff, as well as thick, college-like textbooks able to send even the most caffeine-fuelled coder to sleep. Like you, they were tired of low-quality lessons, poorly explained topics, and confusing info presented in the wrong way. That's why so many find success in this complete Java developer course. It's designed with simplicity and seamless progression in mind through its content.This course assumes no previous coding experience and takes you from absolute beginner core concepts, like showing you the free tools you need to download and install, to writing your very first Java program. You will learn the core java skills you need to become employable in around 14 hours, and if you choose to, can take advantage of all the additional content in the course. It's a one-stop shop to learn java. If you want to go beyond the core content you can do so at any time.Here's just some of what you'll learn(It's okay if you don't understand all this yet, you will in the course)All the essential Java keywords, operators, statements, and expressions needed to fully understand exactly what you're coding and why - making programming easy to grasp and less frustratingYou will learn the answers to questions like What is a Java class, What is polymorphism and inheritance and to apply them to your java apps.How to safely download and install all necessary coding tools with less time and no frustrating installations or setupsComplete chapters on object-oriented programming and many aspects of the Java API (the protocols and tools for building applications) so you can code for all platforms and derestrict your program's user base (and potential sales)How to develop powerful Java applications using one of the most powerful Integrated Development Environments on the market, IntelliJ IDEA! - Meaning you can code functional programs easier. IntelliJ has both a FREE and PAID version, and you can use either in this course.(Don't worry if you're used to using Eclipse, NetBeans, or some other IDE. You're free to use any IDE and still get the most out of this course)Learn Java to a sufficient level to be a be to transition to core Java technologies like Android development, the Spring framework, Java EE (Enterprise edition) in general as well as and other technologies. In order to progress to these technologies, you need to first learn core Java - the fundamental building blocks. That's what this course will help you to achieve."AP-what?"Don't worry if none of that made sense. I go into great detail explaining each and every core concept, programming term, and buzzwords you need to create your own Java programs.This truly is Java for complete beginners. By the end of this comprehensive course, you'll master Java programming no matter what level of experience you're at right now. You'll understand what you are doing, and why you are doing it. This isn't a recipe book, you'll use your own creativity to make unique, intuitive programs. Not only do these HD videos show you how to become a programmer in great detail, but this course includes a unique challenge feature. Each time a core concept is taught, a video presents a challenge for you to help you understand what you have just learned in a real-world scenario.You'll go and complete the challenge on your own, then come back and see the answers which I then explain in detail in a video, allowing you to check your results and identify any areas you need to go back and work on.This is a proven way to help you understand Java faster and ensure you reach your goal of becoming a Java Developer in record time. Remember doing those old past exam papers in high school or college? It's the same concept, and it works. As your instructor, I have close to 40 years of experience as a software developer and teacher and have been using Java since the year 2000. Yes, over 22 years (I've taught students younger than that). Meaning not only can I teach this content with great simplicity, but I can make it fun too!It's no surprise my previous students have amazing results...See what your fellow students have to say:"This course was a guiding light in my "Becoming a developer" path from the first step. It helped me become a much more educated developer comparing to my friend who learned to code from trial/error. It's still a guide for me. every now and then I will come back to this course to learn something new or to improve what I've learned somewhere else. A BIG Thanks to "Tim Buchalka" my Master." - Sina Jz"I was an absolute beginner when I started this course, and now I can write some good small advanced clean codes. I wrote a code and showed it to a programmer, and he was shocked, he told me that I'm more than ready to start a programming career." - Amirreza Moeini"I am taking this class in conjunction with a Java 101 college class. I have learned more in one afternoon of videos from this class than I have in 4 weeks of a college class. Tim actually explains what things are and why they do what they do, as opposed to my college instructor that mainly said "go make a program that does *whatever*" and then I had to figure out a program that would meet those requirements but not actually learning why it worked." - Stacy HarrisIt's safe to say my students are thrilled with this course, and more importantly, their results, and you can be too.This complete Java course will teach you everything you need to know in order to code awesome, profitable projects, Is the course updated?As mentioned above, yes.It's no secret how technology is advancing at a rapid rate. New, more powerful hardware and software are being released every day, meaning it's crucial to stay on top with the latest knowledge.A lot of other courses on Udemy get released once, and never get updated. Learning an older version of Java can be counterproductive - you could be learning the "old way" of doing things, rather than using current technology.Make sure you check the last updated date on the page of any course you plan to buy - you will be shocked to see some have not been updated for years. That's why I'm always adding new, up-to-date content to this course at no extra charge. Buy this course once, and you'll have lifetime access to it and any future updates (which are on the way as we speak). And when I say updated, I also mean enhanced. With the recently released Java 17 update, a lot of the content has changed to actually include features included in Java 17. This is not just a "rebadged" update - the content is updated with new features of Java. Videos are actually re-recorded, etc.With this complete Java Masterclass, you will always have updated, relevant content.What if I have questions?As if this course wasn't complete enough, I offer full support, answering any questions you have 7 days a week (whereas many instructors answer just once per week, or not at all). This means you'll never find yourself stuck on one lesson for days on end. With my hand-holding guidance, you'll progress smoothly through this course without any major roadblocks. Student Quote: "This course is a great place to ask questions if you have them or find help if you become stuck in areas." - Blake S.There's no risk either!This course comes with a full 30-day money-back guarantee. Meaning if you are not completely satisfied with the course or your progress, simply let me know and I'll refund you 100%, every last penny no questions asked.You either end up with Java skills, go on to develop great programs and potentially make an awesome career for yourself, or you try the course and simply get all your money back if you don't like it. You literally can't lose. Ready to get started, developer?Enroll now using the "Add to Cart" button on the right, and get started on your way to creative, advanced Java brilliance. Or, take this course for a free spin using the preview feature, so you know you're 100% certain this course is for you. See you on the inside (hurry, Java class is waiting!)

Overview
Section 1: Getting Started

Lecture 1 Introduction To The Course

Lecture 2 Remaster in Progress

Lecture 3 Video Quality

Lecture 4 Subtitles

Lecture 5 How to Get Help

Lecture 6 Important Tip - Source Code

Lecture 7 Biggest Tip to Succeed as a Java Programmer

Lecture 8 Software Tools Introduction

Lecture 9 Which Version of Java?

Section 2: Programming Tools Setup

Lecture 10 Install JDK 17 for Windows

Lecture 11 Install JDK 17 for Mac

Lecture 12 Install JDK 17 for Linux

Lecture 13 Confirming installation and intro to JShell

Section 3: First Steps

Lecture 14 Hello World

Lecture 15 Variables

Lecture 16 Starting out with Expressions

Lecture 17 Primitive Types

Lecture 18 byte, short, long and width

Lecture 19 Casting in Java

Lecture 20 Primitive Types Challenge

Lecture 21 Float and Double Primitives

Lecture 22 Floating Point Precision and a Challenge

Lecture 23 The char and boolean Primitive Data Types

Lecture 24 Primitive Types Recap and the String Data Type

Lecture 25 Operators, Operands and Expressions

Lecture 26 Abbreviating Operators

Section 4: IntelliJ Basics

Lecture 27 From JShell to an IDE

Lecture 28 Installing IntelliJ IDEA for Windows

Lecture 29 Installing IntelliJ IDEA for Mac

Lecture 30 Installing IntelliJ IDEA for Linux

Lecture 31 Configuring IntelliJ IDEA - WINDOWS, MAC and LINUX

Lecture 32 Hello World in IntelliJ

Lecture 33 Hello World in IntelliJ

Lecture 34 if-then Statement

Lecture 35 Logical AND Operator

Lecture 36 Logical OR Operator

Lecture 37 Assignment Operator VS Equals to Operator

Lecture 38 Ternary Operator

Lecture 39 Operator Precedence and Operator Challenge

Section 5: Expressions, Statements & More

Lecture 40 Introduction

Lecture 41 Keywords and Expressions

Lecture 42 Statements, Whitespace and Indentation (Code Organization)

Lecture 43 Code Blocks And The If Then Else Control Statement

Lecture 44 if then else Challenge

Lecture 45 Methods in Java

Lecture 46 More on Methods

Lecture 47 Methods Recap

Lecture 48 Method Challenge

Lecture 49 Code Comparison in IntelliJ

Lecture 50 Coding Exercises

Lecture 51 Method Overloading

Lecture 52 Method Overloading Challenge

Lecture 53 Seconds And Minutes Challenge

Lecture 54 Bonus Challenge Solution

Section 6: Control Flow

Lecture 55 Introduction

Lecture 56 The switch statement

Lecture 57 More switch statement

Lecture 58 Traditional Switch Challenge

Lecture 59 A Switch Expression Challenge

Lecture 60 The for Statement

Lecture 61 The for Statement Challenge Exercise

Lecture 62 Sum 3 and 5 Challenge And Using IntelliJ's Debugger

Lecture 63 For Loop Recap

Lecture 64 The while and do while statements

Lecture 65 The while Loop Challenge Exercise

Lecture 66 Digit Sum Challenge

Lecture 67 While Loop and Do While Recap

Lecture 68 Local Variables and Scope

Lecture 69 The class, the object, static & instance fields and methods

Lecture 70 Parsing Values and Reading Input using System.console()

Lecture 71 Exception Handling, and Introduction to Scanner

Lecture 72 Reading Input with Scanner

Lecture 73 Reading User Input Challenge

Lecture 74 Min and Max Challenge

Section 7: OOP Part 1 - Inheritance

Lecture 75 Introduction

Lecture 76 Introduction to Classes and Objects

Lecture 77 Introduction to Classes, Using Getter Methods

Lecture 78 Classes, Using Setters, and Creating Objects

Lecture 79 Classes Challenge Exercise

Lecture 80 Constructors Part 1

Lecture 81 Constructors Part 2

Lecture 82 Constructor Challenge Exercise

Lecture 83 Reference vs Object vs Instance vs Class

Lecture 84 Static vs Instance Variables

Lecture 85 Static vs Instance Methods

Lecture 86 The POJO

Lecture 87 Java's Implicit POJO Type, The Record

Lecture 88 Inheritance - Part 1

Lecture 89 Inheritance - Part 2

Lecture 90 Inheritance - Part 3

Lecture 91 What is java.lang.Object?

Lecture 92 Inheritance Challenge - Part 1

Lecture 93 Inheritance Challenge Part 2

Lecture 94 this vs super

Lecture 95 Method Overloading vs Overriding Recap

Lecture 96 The Text Block and other Formatting Options

Lecture 97 Another Look at the String

Lecture 98 String Manipulation Methods

Lecture 99 The StringBuilder class

Section 8: OOP Part 2 - Polymorphism

Lecture 100 Introduction

Lecture 101 Composition Part 1

Lecture 102 Composition Part 2

Lecture 103 Composition Challenge

Lecture 104 Encapsulation, Part 1

Lecture 105 Encapsulation, Part 2

Lecture 106 Encapsulation Challenge

Lecture 107 Polymorphism, Part 1

Lecture 108 Polymorphism, Part 2

Lecture 109 Casting with classes, and using Object and var references

Lecture 110 Testing the runtime type using the instanceof operator

Lecture 111 Polymorphism Challenge Exercise

Lecture 112 Polymorphism Challenge Exercise, Part 2

Lecture 113 OOP Master Challenge Exercise, Part 1

Lecture 114 OOP Master Challenge Exercise, Part 2

Lecture 115 OOP Master Challenge Exercise, The Bonus

Lecture 116 Organizing Java Classes, Packages and Import Statements

Section 9: Arrays

Lecture 117 Introduction

Lecture 118 Arrays Part 1

Lecture 119 Arrays Part 2

Lecture 120 Using java.util.Arrays (sort, fill, copyOf )

Lecture 121 Finding a Match, Using a Binary Search and testing equality of arrays

Lecture 122 Arrays Challenge Exercise

Lecture 123 Arrays Recap

Lecture 124 References Types vs Value Types

Lecture 125 Variable Arguments (Varargs)

Lecture 126 Minimum Element Challenge

Lecture 127 Reverse Array Challenge

Lecture 128 Two-Dimensional Arrays

Lecture 129 Multi-dimensional Arrays

Section 10: List, ArrayList, LinkedList, Iterator, Autoboxing

Lecture 130 Introduction

Lecture 131 List and ArrayList Part 1

Lecture 132 ArrayList Part 2

Lecture 133 ArrayList Part 3

Lecture 134 Arrays vs. ArrayLists

Lecture 135 ArrayList Challenge Part 1

Lecture 136 Arrays, ArrayList & LinkedList - (Memory and Big O Notation)

Lecture 137 LinkedList Part 1

Lecture 138 LinkedList Part 2

Lecture 139 Iterators

Lecture 140 LinkedList Challenge

Lecture 141 LinkedList Challenge, Continued

Lecture 142 Introduction to Autoboxing and Unboxing

Lecture 143 Autoboxing and Unboxing related to Arrays & Lists

Lecture 144 Autoboxing & Unboxing Challenge

Lecture 145 Autoboxing & Unboxing Challenge

Lecture 146 Introduction to the enum type

Lecture 147 The enum type continued, with the switch statement

Section 11: Abstraction in Java

Lecture 148 Introduction

Lecture 149 Abstraction & Generalization (with overview of abstract and other modifiers)

Lecture 150 Abstract Classes Part 1

Lecture 151 Abstract Classes Part 2

Lecture 152 Abstract Classes Part 3

Lecture 153 Abstract Class Challenge Part 1

Lecture 154 Abstract Class Challenge Part 2

Lecture 155 Interfaces Part 1

Lecture 156 Interfaces Part 2

Lecture 157 Interfaces Part 3

Lecture 158 Interfaces, what's new since JDK 8 (default methods & public static methods)

Lecture 159 Interfaces, new since JDK8 (public static & private methods)

Lecture 160 Interface vs Abstract Class

Lecture 161 Interface Challenge Part 1

Lecture 162 Interface Challenge Part 2

Section 12: Generics

Lecture 163 Introduction to Generics

Lecture 164 Generics Part 1

Lecture 165 Generics Part 2

Lecture 166 Generics Part 3

Lecture 167 Generic Class Challenge

Lecture 168 Generic Class Challenge, Part 2

Lecture 169 Revisiting Comparable

Lecture 170 Comparable vs. Comparator

Lecture 171 Generic classes as reference types

Lecture 172 Generics methods, wildcards, and type erasure

Lecture 173 Static methods & multiple upper bounds

Lecture 174 Putting it all together, Final Section Challenge

Section 13: Nested Classes and Types

Lecture 175 Introduction

Lecture 176 Static Nested Classes

Lecture 177 Inner Classes

Lecture 178 Inner Classes, for Bills Burger Challenge

Lecture 179 Inner Classes Challenge

Lecture 180 Local Classes

Lecture 181 Anonymous Classes

Lecture 182 Local and Anonymous Class Challenge

Section 14: Lambda Expressions, Functional Interfaces, and Method References

Lecture 183 Introduction to Lambda Expressions

Lecture 184 Introduction to the Lambda Expression, and Functional Interfaces

Lecture 185 Lambda Expressions, syntax, and additional examples

Lecture 186 Lambda Expressions, Continued

Lecture 187 Java's Functional Interfaces, Consumer & Predicate

Lecture 188 Java's Functional Interfaces, Function & Supplier

Lecture 189 Lambda Mini Challenges

Lecture 190 Lambda Expression Challenge, Put it all together

Lecture 191 What's a Method Reference?

Lecture 192 The Most Confusing of the Method References

Lecture 193 Method Reference Challenge

Lecture 194 Convenience Methods on Functional Interfaces (Chaining lambdas)

Lecture 195 Convenience Methods, Continued, with the Comparator

Section 15: Java Collections

Lecture 196 Introduction to Java's Collections Framework

Lecture 197 Collections: Understanding the Big Picture

Lecture 198 Code Setup (Deck of Cards) for java.util.Collections methods

Lecture 199 Introduction to java.util.Collections

Lecture 200 java.util.Collections (shuffle, reverse, sort, indexOfSubList)

Lecture 201 java.util.Collections (binarySearch, frequency, min, max, rotate)

Lecture 202 Collections methods Challenge, Your own Card Game

Lecture 203 Collections methods Challenge, (Five Card Draw), continued

Lecture 204 Understanding the importance of the hash code

Lecture 205 Code Setup (Phone and Email Contacts) for Sets and Maps

Lecture 206 Introduction to Sets & HashSet

Lecture 207 Set Operations, Symmetric and Asymmetric results

Lecture 208 Code Setup (Tasks and TaskData)

Lecture 209 Set Operations Challenge

Lecture 210 LinkedHashSet and TreeSet

Lecture 211 TreeSet, Closest match and subset methods

Lecture 212 TreeSet Challenge (Theatre Seats)

Lecture 213 TreeSet Challenge (Theatre Seat Bonus)

Lecture 214 The Map Interface and functionality

Lecture 215 Map functionality, Continued (compute, replace, remove)

Lecture 216 Working with Map's view collections (keySet, values, entrySet)

Lecture 217 HashMap Challenge, A Text-Based Adventure Game

Lecture 218 Adventure Game, Continued

Lecture 219 LinkedHashMap and TreeMap

Lecture 220 Working with TreeMap (NavigableMap) methods

Lecture 221 Targeted Collections for enum types

Lecture 222 Collections Framework Final Challenge (The Setup)

Lecture 223 Final Challenge(Store Inventory)

Lecture 224 Final Challenge (Store Inventory)

Section 16: Using Final, Immutable classes, Constructors, Initializers, Sealed classes

Lecture 225 Introduction

Lecture 226 Revisiting the final modifier

Lecture 227 The final modifier applied to methods, and local variables

Lecture 228 When Change isn't good

Lecture 229 Declaring immutable classes to produce immutable objects, Part 1

Lecture 230 Declaring immutable classes to produce immutable objects

Lecture 231 Challenge: Write your own immutable classes

Lecture 232 Defensive Copies, Shallow and Deep Copies

Lecture 233 Immutable, Unmodifiable Collections and Views

Lecture 234 Challenge: Use unmodifiable collections

Lecture 235 Challenge, Continued: Using unmodifiable collections

Lecture 236 Constructor review, final field initializations, Introduction to Initializers

Lecture 237 Record Constructors (and javap)

Lecture 238 Enum Constructors

Lecture 239 Game Console Setup, Part 1

Lecture 240 Game Console Setup, Part 2

Lecture 241 Challenge: Initializers and Constructors, A Pirate Game

Lecture 242 Challenge: Pirate Game, continued

Lecture 243 Final Classes, Review of constructor access modifiers

Lecture 244 Sealed Classes

Lecture 245 Final Section Challenge

Lecture 246 Final Challenge (Pirates Continued, Part 2)

Section 17: Streams

Lecture 247 Introduction to Streams

Lecture 248 A first look at a stream in action

Lecture 249 The Structure of the Stream Pipeline

Lecture 250 Stream Sources

Lecture 251 Stream Source Challenge

Lecture 252 Intermediate Operations, distinct, filter, limit, skip, takeWhile, dropWhile

Lecture 253 Intermediate Operations, map, peek, sorted

Lecture 254 Terminal Operations for statistical information and matching

Lecture 255 Code Setup, Part 1 (Student Engagement Statistics)

Lecture 256 Code Setup, Part 2 (Student Engagement Statistics)

Lecture 257 Challenge: Terminal Operations

Lecture 258 Challenge, part 2: Terminal Operations

Lecture 259 Terminal operations for processing and transforming stream elements

Lecture 260 Using Stream's collect & reduce terminal operations

Lecture 261 Challenge: Terminal Operations, Part 2

Lecture 262 What's Optional?

Lecture 263 More Terminal Operations

Lecture 264 Streams to Maps

Lecture 265 Maps to Streams (using flatMap)

Lecture 266 Streams Challenge

Section 18: Back to a Few Nuts and Bolts

Lecture 267 Introduction

Lecture 268 Functionality on java.lang.Math

Lecture 269 Randomization in Java

Lecture 270 Randomization Challenge (Rolling Dice)

Lecture 271 Bonus Challenge (DiceGame with Scoring)

Lecture 272 Introduction to BigDecimal

Lecture 273 BigDecimal methods

Lecture 274 Overview: Date & Time (java.time)

Lecture 275 LocalDate

Lecture 276 LocalTime, LocalDateTime

Lecture 277 Overview: Instance, Period, Duration and Time Zones

Lecture 278 ZoneId (Time zones)

Lecture 279 Instant, ZonedDateTime, Duration, Period and ChronoUnit.between

Lecture 280 Localization, Introduction to Locale

Lecture 281 Localization, Continued

Lecture 282 DateTime and Localization Challenge

Lecture 283 Internationalization (ResourceBundle)

Lecture 284 Internationalization (ResourceBundle) Part 2

Section 19: Regular Expressions

Lecture 285 Introduction

Lecture 286 What's a Regular Expression?

Lecture 287 The Parts of a Regular Expression

Lecture 288 Methods that use Regular Expressions

Lecture 289 Mini Challenges -Regular Expressions

Lecture 290 Using Pattern and Matcher

Lecture 291 Matcher methods (find, group), Grouping and Capturing

Lecture 292 Matcher methods for replacing text

Lecture 293 Review of the Regular Expressions for Phone Number/HTML tags

Lecture 294 Matcher Challenge

Section 20: Naming Conventions and Packages. static and final keywords

Lecture 295 Naming Conventions

Lecture 296 Packages

Lecture 297 Packages Part 2

Lecture 298 Packages Part 3

Lecture 299 Packages (Challenge Exercise)

Lecture 300 Scope

Lecture 301 Scope Part 2 and Visibility

Lecture 302 Scope +(Challenge Exercise)

Lecture 303 Access Modifiers

Lecture 304 The static statement

Lecture 305 The final statement

Lecture 306 Final Part 2 and Static Initializers

Section 21: JavaFX

Lecture 307 JDK11 Global Library Configuration

Lecture 308 Create Your First JavaFX Project

Lecture 309 JavaFX Overview

Lecture 310 JavaFX Hello World Program

Lecture 311 GridPane Layout

Lecture 312 HBox Layout

Lecture 313 BorderPane Layout

Lecture 314 Other Layouts

Lecture 315 Controls

Lecture 316 RadioButton and CheckBox

Lecture 317 ComboBox and ChoiceBox

Lecture 318 Slider, Spinner, ColorPicker & DatePicker Controls

Lecture 319 TitledPane

Lecture 320 Events and Event Handlers

Lecture 321 Events Continued

Lecture 322 UI Thread

Lecture 323 Threads and Runnable

Lecture 324 Setup Sample Todo List Application

Lecture 325 Base Interface

Lecture 326 Add Change Listener

Lecture 327 Formatting Dates

Lecture 328 Singletons

Lecture 329 Load and Save ToDo Items from/to Disk

Lecture 330 Add DialogPane

Lecture 331 Show Dialog and Add Controller Code

Lecture 332 Bug Fix and Update List View

Lecture 333 Data Binding and Observable

Lecture 334 Cell Factories

Lecture 335 Context Menu

Lecture 336 KeyEvents and Toolbars

Lecture 337 SortedList

Lecture 338 FilteredList

Lecture 339 CSS With JavaFX

Lecture 340 Transforming Nodes and Choosers

Lecture 341 More on Choosers and Web Pages

Lecture 342 SceneBuilder

Lecture 343 Installing SceneBuilder for Windows

Lecture 344 Installing SceneBuilder for Mac

Lecture 345 Overview of SceneBuilder

Lecture 346 Building a UI with SceneBuilder

Lecture 347 More on SceneBuilder

Lecture 348 JavaFX Challenge

Lecture 349 JavaFX Challenge Part 2

Lecture 350 JavaFX Challenge Part 3

Lecture 351 JavaFX Challenge Part 4

Lecture 352 JavaFX Challenge Wrap up

Section 22: Basic Input & Output including java.util

Lecture 353 Exceptions

Lecture 354 Stack Trace and Call Stack

Lecture 355 Catching and throwing Exceptions

Lecture 356 Multi Catch Exceptions

Lecture 357 Introduction to I/O

Lecture 358 Writing content - FileWriter class and Finally block

Lecture 359 Try with Resources

Lecture 360 FileReader and Closeable

Lecture 361 BufferedReader

Lecture 362 Load Big Location and Exits Files

Lecture 363 Challenge

Lecture 364 Buffered Writer and Challenge

Lecture 365 Byte Streams

Lecture 366 Reading Binary Data and End of File Exceptions

Lecture 367 Object Input Output including Serialization

Lecture 368 Finish Object I/O and RandomAccessFile class

Lecture 369 Create Random Access File

Lecture 370 Update Static Initializer Block With Random File Access

Lecture 371 Update Adventure Game to Read Random Access File

Lecture 372 Java NIO

Lecture 373 Writing Objects With Java NIO

Lecture 374 Reading and Writing with Java NIO

Lecture 375 Writing Binary Files with Java NIO

Lecture 376 Reading Files with NIO

Lecture 377 Absolute and Relative Reads

Lecture 378 Chained Put Methods

Lecture 379 Writing Sequentially

Lecture 380 FileChannel to Copy Files and Pipes with Threads

Lecture 381 Filesystem

Lecture 382 More on Paths

Lecture 383 Exists and CopyFile

Lecture 384 Move, Rename and Delete

Lecture 385 File Attributes

Lecture 386 Read Existing Directory Contents

Lecture 387 Separators Temp Files and File Stores

Lecture 388 Walk File Tree

Lecture 389 Copy Entire Tree

Lecture 390 Mapping IO and NIO Methods

Section 23: Concurrency in Java

Lecture 391 Concurrency and Threads Introduction

Lecture 392 Threads

Lecture 393 Runnable and Thread

Lecture 394 Interrupt and Join

Lecture 395 Multiple Threads

Lecture 396 Thread Variables

Lecture 397 Synchronisation

Lecture 398 Producer and Consumer

Lecture 399 Deadlocks, wait, notify and notifyAll methods

Lecture 400 The Java Util Concurrent package

Lecture 401 Thread Interference

Lecture 402 Reentrant Lock and Unlock

Lecture 403 Using Try Finally With Threads

Lecture 404 Thread Pools

Lecture 405 ArrayBlockingQueue Class

Lecture 406 Deadlocks

Lecture 407 More on Deadlocks

Lecture 408 Thread Starvation

Lecture 409 Fair Locks and Live Locks

Lecture 410 Live Lock Example and Slipped Conditions

Lecture 411 Other Thread Issues

Lecture 412 JavaFX Background Tasks

Lecture 413 Data Binding

Lecture 414 Service

Lecture 415 Challenge 1 and 2

Lecture 416 Challenge 3,4 and 5

Lecture 417 Challenge 6 and 7

Lecture 418 Challenge 8

Lecture 419 Challenge 9

Section 24: Debugging and Unit Testing

Lecture 420 Introduction to Debugging

Lecture 421 More on Debugging

Lecture 422 Field Watch Points

Lecture 423 Advanced Debugging

Lecture 424 Introduction to Unit Testing with JUnit

Lecture 425 Asserts in Junit

Lecture 426 More Asserts and Exception Handling

Lecture 427 Parameterized Testing

Lecture 428 JUnit Challenge #1 and #2

Lecture 429 JUnit Challenges #3 to #7

Lecture 430 Junit Challenges #8 to #10

Section 25: Databases

Lecture 431 Section Introduction

Lecture 432 Database Terminology

Lecture 433 Install and Setup SQLite for Windows

Lecture 434 Install and Setup SQLite for Mac

Lecture 435 Install and Setup SQLite for Linux

Lecture 436 Introduction to SQLite

Lecture 437 More with SQLite

Lecture 438 Querying Data With SQL

Lecture 439 SQL Order by and Joins

Lecture 440 More Complex Joins

Lecture 441 Wildcards in Queries and Views

Lecture 442 Housekeeping and Final SQL Challenge

Lecture 443 JDBC and SQLite GUI Browser

Lecture 444 Creating Databases With JDBC in Java

Lecture 445 JDBC Insert, Update, Delete

Lecture 446 .executeQuery() and using Constants

Lecture 447 The Music SQLite Database

Lecture 448 Write Java Query for Artists

Lecture 449 Executing SQL in DB Browser

Lecture 450 Query Albums by Artist Method

Lecture 451 Query Artists for Song method

Lecture 452 Result Set Meta Data

Lecture 453 Functions and Views

Lecture 454 Write the Method to Query View

Lecture 455 SQL Injection Attacks and Prepared Statements

Lecture 456 Transactions

Lecture 457 Inserting Records With JDBC

Lecture 458 Insert Albums, Artists, and Songs

Lecture 459 Test Insert JDBC Code

Lecture 460 JDBC with a GUI Program

Lecture 461 Add Artists

Lecture 462 Fix Artist and Preload Records

Lecture 463 Implement Artist Query

Lecture 464 Add ProgressBar

Lecture 465 Handling Updates

Section 26: Java Networking Programming

Lecture 466 Networking Overview

Lecture 467 First Client and Server Apps

Lecture 468 Multi Threaded Server

Lecture 469 Multi-Threading and Timeouts

Lecture 470 UDP Server and Client

Lecture 471 High Level APIS

Lecture 472 URL Connections and Input Stream Reader

Lecture 473 HTTPUrlConnection

Lecture 474 Alternatives to HTTPUrlConnection

Section 27: Java 9 Module System

Lecture 475 Introduction to Modules

Lecture 476 Module Declarations and Statements

Lecture 477 Module Types

Section 28: Migrating Java Projects to Java 9

Lecture 478 Project Setup and Test

Lecture 479 Structuring the new project

Lecture 480 Creating the first module (Common)

Lecture 481 Creating the Module Descriptor file

Lecture 482 Creating the 2nd module (Database)

Lecture 483 Challenge - Create the final module (UI)

Lecture 484 Transitive Dependencies

Section 29: New Format Coding Exercises

Lecture 485 Instructions to use the new Coding exercises - Please Read

Section 30: Course Introduction - Old content for Java 11

Lecture 486 Introduction To The Course

Lecture 487 Remaster in Progress

Lecture 488 Video Quality

Lecture 489 Subtitles

Lecture 490 How to Get Help

Lecture 491 Important Tip - Source Code

Section 31: Software Tools Setup - Old content for Java 11

Lecture 492 Biggest Tip to Succeed as a Java Programmer

Lecture 493 The Four Stages of Becoming a Programmer

Lecture 494 Software Tools Introduction

Lecture 495 Java Development Kit Installation Overview

Lecture 496 Install JDK 11 for Windows

Lecture 497 Installing Intellij IDEA for Windows

Lecture 498 ** IMPORTANT ** - Configuring IntelliJ IDEA

Lecture 499 Install JDK 11 for Mac

Lecture 500 Installing Intellij IDEA for Mac

Lecture 501 Install JDK 11 for Linux

Lecture 502 Installing Intellij IDEA for Linux

Lecture 503 Configuring IntelliJ IDEA - WINDOWS, MAC and LINUX

Section 32: First Steps - Old content for Java 11

Lecture 504 Introduction

Lecture 505 Hello World Project

Lecture 506 Defining the Main Method

Lecture 507 Hello World Challenge and Common Errors

Lecture 508 Variables

Lecture 509 Starting out with Expressions

Lecture 510 Primitive Types

Lecture 511 byte, short, long and width

Lecture 512 Casting in Java

Lecture 513 Primitive Types Challenge

Lecture 514 float and double Primitive Types

Lecture 515 Floating Point Precision and a Challenge

Lecture 516 The char and boolean Primitive Data Types

Lecture 517 Primitive Types Recap and the String Data Type

Lecture 518 Operators, Operands and Expressions

Lecture 519 Abbreviating Operators

Lecture 520 if-then Statement

Lecture 521 Logical and Operator

Lecture 522 Logical OR Operator

Lecture 523 Assignment Operator VS Equals to Operator

Lecture 524 Ternary Operator

Lecture 525 Operator Precedence and Operator Challenge

Lecture 526 First Steps Summary

Lecture 527 End of Remaster

Section 33: Java Tutorial: Expressions, Statements, and More - Old content for Java 11

Lecture 528 Introduction

Lecture 529 Keywords And Expressions

Lecture 530 Statements, Whitespace and Indentation (Code Organization)

Lecture 531 Code Blocks And The If Then Else Control Statements

Lecture 532 if then else Recap

Lecture 533 Methods In Java

Lecture 534 More On Methods And A Challenge

Lecture 535 Method Challenge - Final Code Changes

Lecture 536 DiffMerge Tool Introduction

Lecture 537 Install DiffMerge

Lecture 538 Using DiffMerge

Lecture 539 Coding Exercises

Lecture 540 Coding Exercises Example Part 1

Lecture 541 Coding Exercises Example Part 2

Lecture 542 Coding Exercises Example Part 3

Lecture 543 Method Overloading

Lecture 544 Method Overloading Recap

Lecture 545 Seconds and Minutes Challenge

Lecture 546 Bonus Challenge Solution

Section 34: Control Flow Statements - Old content for Java 11

Lecture 547 Introduction

Lecture 548 The switch statement (+Challenge Exercise)

Lecture 549 Day of the Week Challenge

Lecture 550 The for Statement (+Challenge Exercise)

Lecture 551 For Loop Recap

Lecture 552 Sum 3 and 5 Challenge

Lecture 553 The while and do while statements (+Challenge Exercise)

Lecture 554 While and Do While Recap

Lecture 555 Digit Sum Challenge

Lecture 556 Parsing Values from a String

Lecture 557 Reading User Input

Lecture 558 Problems and Solutions

Lecture 559 Reading User Input Challenge

Lecture 560 Min and Max Challenge

Section 35: OOP Part 1 - Classes, Constructors and Inheritance - Old content for Java 11

Lecture 561 Introduction

Lecture 562 Classes Part 1

Lecture 563 Classes Part 2

Lecture 564 Constructors - Part 1 (+Challenge Exercise)

Lecture 565 Constructors - Part 2 (+Challenge Exercise)

Lecture 566 Inheritance - Part 1

Lecture 567 Inheritance - Part 2

Lecture 568 Reference vs Object vs Instance vs Class

Lecture 569 this vs super

Lecture 570 Method Overloading vs Overriding Recap

Lecture 571 Static vs Instance Methods

Lecture 572 Static vs Instance Variables

Lecture 573 Inheritance Challenge Part 1 (+Challenge Exercise)

Lecture 574 Inheritance Challenge Part 2

Section 36: OOP Part 2 - Composition, Encapsulation, and Polymorphism - Old content for Java

Lecture 575 Introduction

Lecture 576 Composition

Lecture 577 Composition Part 2 (+Challenge Exercise)

Lecture 578 Encapsulation

Lecture 579 Encapsulation (+Challenge Exercise)

Lecture 580 Polymorphism

Lecture 581 Polymorphism (+Challenge Exercise)

Lecture 582 OOP Master Challenge Exercise

Lecture 583 OOP Challenge - Solution

Section 37: Arrays, Java inbuilt Lists, Autoboxing and Unboxing - Old content for Java 11

Lecture 584 Arrays

Lecture 585 Arrays (Challenge Exercise)

Lecture 586 Arrays Recap

Lecture 587 References Types vs Value Types

Lecture 588 Minimum Element Challenge

Lecture 589 Reverse Array Challenge

Lecture 590 List and ArrayList Part 1

Lecture 591 ArrayList Part 2

Lecture 592 ArrayList Part 3

Lecture 593 ArrayList Challenge Part 1

Lecture 594 ArrayList Challenge Part 2

Lecture 595 ArrayList Challenge Part 3

Lecture 596 Bug Fix for ArrayList Challenge

Lecture 597 Autoboxing and Unboxing

Lecture 598 Autoboxing & Unboxing (Challenge Exercise) - Part 1

Lecture 599 Autoboxing & Unboxing (Challenge Exercise) - Part 2

Lecture 600 Autoboxing & Unboxing (Challenge Exercise) - Part 3

Lecture 601 LinkedList Part 1

Lecture 602 LinkedList Part 2

Lecture 603 LinkedList Part 3

Lecture 604 LinkedList Challenge Part 1

Lecture 605 Bug Fix for "Track 1" Error

Lecture 606 LinkedList Challenge Part 2

Lecture 607 LinkedList Challenge Part 3 (Final video)

Section 38: Inner and Abstract Classes & Interfaces - Old content for Java 11

Lecture 608 Interfaces

Lecture 609 Interfaces Part 2

Lecture 610 Interfaces Challenge Part 1

Lecture 611 Interfaces Challenge Part 2

Lecture 612 Inner classes Part 1

Lecture 613 Inner Classes Part 2

Lecture 614 Inner Classes Challenge

Lecture 615 Abstract Classes Part 1

Lecture 616 Abstract Classes Part 2

Lecture 617 Interface vs Abstract Class

Lecture 618 Abstract Class Challenge Part 1

Lecture 619 Abstract Class Challenge Part 2

Lecture 620 Abstract Class Challenge Part 3 (includes recursion).

Section 39: Java Generics - Old content for Java 11

Lecture 621 Generics Introduction

Lecture 622 Our Generics Class

Lecture 623 Our Generics Class Part 2

Lecture 624 Our Generics Class Part 3

Lecture 625 Generics Challenge

Section 40: Lambda Expressions - Old content for Java 11

Lecture 626 Lambda Expressions Introduction

Lecture 627 Lambda Expressions Continued

Lecture 628 Lambda Expressions Nested Blocks

Lecture 629 Scope and Functional Programming

Lecture 630 Functional Interfaces & Predicates

Lecture 631 More on Predicates & Suppliers

Lecture 632 Functions

Lecture 633 Chaining java.util.function Functions

Lecture 634 Lambda Challenge Part 1

Lecture 635 Lambda Challenge Part 2

Section 41: Streams - Old content for Java 11

Lecture 636 Streams

Lecture 637 Streams - Intermediate and Terminal Operations

Lecture 638 Streams - Flatmap & Lambda Best Practices

Section 42: Java Collections - Old content for Java 11

Lecture 639 Collections Overview

Lecture 640 Binary Search

Lecture 641 Collections List Methods

Lecture 642 Comparable and Comparator

Lecture 643 Maps

Lecture 644 Map Continued and Adventure Game

Lecture 645 Adding Exits to the Adventure game

Lecture 646 Adventure Game challenge

Lecture 647 Immutable Classes

Lecture 648 Immutable Class Challenge

Lecture 649 Sets & HashSet

Lecture 650 HashSet - equals() and hashCode()

Lecture 651 Finish off equals() and hashcode()

Lecture 652 Potential issue with equals() and sub-classing

Lecture 653 Sets - Symmetric & Asymmetric

Lecture 654 Finishing Off Sets

Lecture 655 Sets Challenge Part 1

Lecture 656 Sets Challenge Part 2

Lecture 657 Sets Challenge Part 3

Lecture 658 Sorted Collections

Lecture 659 StockList Class With Maps

Lecture 660 Add a Basket

Lecture 661 TreeMap and Unmodifiable Maps

Lecture 662 Challenge Part 1

Lecture 663 Challenge Part 2

Lecture 664 Challenge Part 3

Lecture 665 Challenge Part 4 (Final)

Section 43: Regular Expressions - Old content for Java 11

Lecture 666 Regular Expressions Introduction

Lecture 667 Character classes and Boundary Matchers

Lecture 668 Quantifiers and the Pattern and Matcher classes

Lecture 669 Matcher find and Group Methods

Lecture 670 And, Or & Not

Lecture 671 Regular Expressions Challenge Part 1

Lecture 672 Regular Expressions Challenge Part 2

Lecture 673 Regular Expressions Challenge Part 3

Section 44: Archived Videos

Lecture 674 Old JavaFX Introduction Video for JDK 8

Lecture 675 Old JavaFX Code Vs FXml Video for JDK 8

Section 45: Extra Information - Source code, and other stuff

Lecture 676 Source code for all Programs

Lecture 677 Bonus Lecture and Information

This course is perfect for absolute beginners with no previous coding experience, to intermediates looking to sharpen their skills to the expert level.,Those looking to build creative and advanced Java apps for either personal use or for high-paying clients as a self-employed contractor.,Those who love letting their own creative genius shine, whilst getting paid handsome amounts to do so.

Buy Premium Account From My Download Links & Get Fastest Speed.