Java In-Depth: Become a Complete Java Engineer!

Java In-Depth: Become a Complete Java Engineer!
Java In-Depth: Become a Complete Java Engineer!

English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 62 Hours | 12.5 GB
eLearning | Skill level: All Levels


Comprehensive Java programming course integrated with design principles, best practices & instructor-led Java EE project

Would you like to just acquire core Java skills or would you like to become a complete & professional Java engineer right at the end of this course. If it is the latter, then you should read on …

This comprehensive project-based course has been designed with following objectives:

  • To help you get an in-depth understanding of both core & advanced concepts in Java
  • To teach best practices & key design principles for writing effective Java programs
  • To help you gain truly practical experience in writing professional-level code via instructor-led implementation of a project, which is Java EE-based Web application that uses technologies like Servlets, JSP, and JSTL. Project is implemented in Eclipse using MVC pattern, TDD (Test-Driven Development) principles and other best practices. Project also incorporates few advanced multi-threading concepts and utilizes MySQL database as the back-end and Apache Tomcat as the Web server
  • Master Object-Oriented Programming concepts like Inheritance, Polymorphism, Interfaces & Abstract Classes via a real-world case-study
  • Learn about database designing, implementation (SQL), and how to interact interact with them from Java programs (via JDBC)
  • To help you understand the inner workings of Java platform (aka JVM)
  • Learn Functional-style programming via Java 8 features like lambda expressions & streams
  • Learn how to build Web applications using core Java EE technologies like Servlets, JSP, and JSTL
  • To teach how to effectively use Eclipse IDE to write, debug, and test Java programs

The motivation behind these objectives is to help you in becoming a complete & industry-ready Java engineer. Most Java courses focus only on teaching core fundamentals, which at the very best equip students with good basic skills to work on small-to-medium sized projects. Most of these students fall short when it comes to implementing more complex projects. To design elegant solutions for large, complex projects one needs to have a much deeper understanding of language features along with knowledge of the recommended best practices & design principles. More importantly one needs to know how to put all of these into practice. This comprehensive one-stop project-based course has been designed to equip students with these skills.

This course begins by giving a birds-eye view of Java covering everything from origin of Java to installing Java and writing your first Java program. Even the most fundamental concepts like compilation & interpretation are explained. All other topics are covered in-depth starting from language basics, object-oriented concepts & design (including Java 8 features like default & static methods in interfaces), JVM, exceptions, IO, data structures, generics, multi-threading, databases, nested classes, enums, functional-style programming via Java 8 constructs like lambda expressions & streams, and also gives a very good basic introduction to Java EE technologies like Servlets, JSP, and JSTL.

Each lecture has been very carefully crafted. Motivation behind every concept is clearly explained with well thought out examples and nice animations. Object-oriented concepts like inheritance & polymorphism are explained through a real-world case-study, which is also implemented as part of the course project. Every concept has been well-tested through ready-to-run, downloadable demo programs, which are implemented and executed in the course. Every chapter ends with a carefully crafted quiz to test what was learnt. Many chapters also include challenging coding exercises and student solutions are also auto-evaluated via JUnit scripts, i.e., students would instantly know whether their solution is right or wrong. One of the coding exercises is on Sentiment Analysis, which is a hot area in the industry.

The course project involves building a bookmarking Web application that helps users bookmark items like Books, Movies, and Web pages. The project is instructor-led and is implemented using professional coding conventions & best practices. It follows good object-oriented design, incorporates MVC architectural pattern and also uses Test-Driven Development (TDD) methodology. Java EE stack comprising technologies like Servlets, JSP, and JSTL are used for building the application. Parts of the project use advanced multi-threading capabilities. MySQL is used as the database and database designing is also explained in detail. Eclipse IDE is used for developing the entire project. There is also a separate dedicated chapter just for learning Eclipse IDE, which would give you a solid foundation in using Eclipse to effectively write, debug, and test Java programs. The chapter includes lessons to use Eclipse’s debugger & JUnit unit testing framework.

Finally, the course also discusses over half of the best practices/design rules outlined in the popular Effective Java book. Many rules are actually demonstrated in code. This is one of the highlights of the course and will make you truly complete!

What you’ll learn

  • Get an in-depth understanding of core & advanced Java
  • Master design principles, best practices and coding conventions for writing well-designed, professional Java code
  • Implement instructor-led, professional-grade Java EE-based Web application using TDD principles and MySQL as database
  • Set a firm foundation in Java for the rest of your career
  • Gain comprehensive understanding of JVM Internals ~ the incredible platform on which Java programs run
  • Set yourself up to become an Oracle Certified Associate, Java SE 8 Programmer (1Z0-808)
  • Master Object-Oriented Programming concepts by using a real-world application as a case study
  • Get a solid understanding of functional-style programming using Java 8 constructs like lambdas & streams
+ Table of Contents

Course Introduction
1 Why Yet Another Java Course?
2 Course Structure & UI Controls for Site Navigation
3 Terms of Service & Copyright

Java: A High-level Overview
4 Chapter Introduction
5 What is Java & Who is Using It?
6 Story behind Java’s Creation ~ A Brief History
7 Compilation
8 Platform Dependency + Demo
9 Interpreter
10 Platform Independence in Java + Demo
11 Java Virtual Machine
12 An Overview of Java SE
13 Installing JDK 10 on Windows
14 Installing JDK 10 on Mac
15 Installing JDK10 on Linux
16 Setting Classpath Environment Variable
17 Writing First Java Program + Demo
18 Conclusion
19 Important Q&A Discussions!

Classes, Objects and their Members
20 Chapter Introduction
21 Class & Objects
22 Demo: Absolute Java Basics
23 Variables: Introduction
24 Variable Kinds
25 Currency Converter – Creating a Class with Variables
26 Variables: Primitive Types
27 Primitive Variables: Integers + Demo
28 Primitive Variables: Floating-point Numbers + Item 48
29 Primitive Variables: Character Data Type + Demo
30 Primitive Variables: Boolean Data Type + Demo
31 Variables: Type Casting + Demo
32 Variables: Object References
33 Statements + Demo
34 Arrays + Demo
35 Methods: Introduction + Demo
36 Method Types + Demo
37 How Data is Passed to Methods in Java? + Demo
38 Method Overloading + Demo
39 Methods: varargs + Demo
40 Constructors + Demo
41 this Reference + Demo
42 Demo: Student Example
43 Demo: Reinitializing Object References ~ More Brainstorming!
44 Arrays with Object References
45 Review of Exercise 1 Solution with Best Practices
46 Conclusion
47 Important Q&A Discussions!

Method Building Blocks: Operators & Control-flow Statements
48 Chapter Introduction
49 Operators
50 Arithmetic Operators + Demo
51 Arithmetic Operation Rules + Demo
52 Demo: Comparison Operators
53 Logical Operators + Demo
54 Car Price Estimator ~ Coding Exercise for Comparison & Logical Operators
55 Car Price Estimator – Exercise Solution
56 Bitwise Operators + Demo
57 Bit Shift Operators
58 Control-flow: Demo: if-statement
59 Control-flow: switch + Demo
60 When is switch Preferred?
61 Control-flow: Ternary + Demo
62 Control-flow: for Statement + Demo
63 Demo: More for Statement …
64 Demo: for-each Statement (+ discussion on Item 46)
65 Variable Scope
66 Exercise
67 Control-flow: while Statement
68 Control-flow: break Statement + Demo
69 Control-flow: continue + Demo
70 Recursion + Demo
71 Conclusion

Packages, Strings and Information Hiding
72 Chapter Introduction
73 Java API + Item 47 (Know and use the libraries)
74 Accessing Packages + Demo
75 Creating Packages & Classpath Management + Demo
76 Naming Packages
77 Strings: Introduction
78 String Class + Demo
79 String Pool & Interning + Demo
80 String Immutability
81 String Concatenation + Demo
82 Item 51: String Concatenation Performance
83 Escape Sequences + Demo
84 Access Levels
85 Information Hiding – Item 14: Use accessor methods, not public fields + Demo
86 Information Hiding – Item 13: Minimize the accessibility of classes and members
87 Demo: Student Example with Information Hiding
88 Conclusion
89 Important Q&A Discussions!

static, final, and Coding Conventions
90 Chapter Introduction
91 Static Methods + Item 4: Enforce noninstantiability with a private constructor
92 Math Class + Demo
93 Static Variables + Demo
94 Initializers: Static & Instance + Demo
95 final Variable + Demo
96 Constant Variables + Demo
97 Boxed Primitives
98 Autoboxing + Demo
99 Item 49: Prefer Primitives to Boxed Primitives + Demo
100 Coding Conventions: Naming (Item 56: Use generally accepted naming conventions)
101 Coding Conventions: Structuring Programs (Item 45: Minimize the scope of local)
102 Coding Conventions: Stylistic + Demo
103 Coding Conventions: Comments + Demo
104 Conclusion
105 Important Q&A Discussions!

Case Study: A Social Bookmarking Application
106 thrill.io ~ A Social Polymarking App!
107 Case Study

Serious OOP: Inheritance & Polymorphism
108 Inheritance
109 Access Modifiers & Inheritance + Demo
110 IS-A Test
111 Polymorphism + Demo
112 Casting Objects & instanceof Operator + Demo
113 Type Safety
114 Method Overriding + Demo
115 Method Binding + Demo
116 What is Not Overridden? (final Method is one of them) + Demo
117 Demo: Fields are Not Overridden
118 Object Class + Demo + Item 10: Always override toString
119 Constructor Chaining + Demo
120 Preventing Inheritance
121 Conclusion

More Serious OOP: Abstract Classes & Interfaces
122 New Requirement: thrill.io for Kids
123 Abstract Classes & Methods + Demo
124 Item 20: Prefer class hierarchies to tagged classes
125 New Requirement: Sharing Bookmarks
126 Multiple Inheritance & Diamond Problem
127 Interfaces
128 More on Interfaces
129 Demo: Interfaces
130 Interfaces: A Conceptual View
131 Item 18: Prefer interfaces to abstract classes
132 Item 52: Refer to objects by their interfaces
133 Marker Interfaces
134 Cloneable Interface + Demo
135 default Methods (Java 8) + Demo
136 Recap of default Methods
137 default Methods: Other Benefits + Demo
138 Static Methods in Interfaces + Demo
139 Conclusion
140 Important Q&A Discussions!

Programming with Eclipse IDE
141 Introduction
142 Installing Eclipse
143 Writing a Java Program in Eclipse
144 Eclipse Build Process
145 Importing Demo Code
146 Source Code Navigation
147 Automatic Source Code Cleaning & Generation
148 Code Refactoring
149 Using Eclipse Debugger
150 JUnit & Debugging
151 Shortcuts Cheat Sheet
152 Conclusion

Project: Implementing a Social Bookmarking App
153 Project Introduction
154 MVC Architecture
155 Implementing Entities
156 Implementing Manager Classes – Demonstrates Singleton Pattern!!
157 Implementing Constant Exporting Classes
158 Implementing Data Store
159 Implementing Dao Classes
160 Launching the Application
161 Implementing User Bookmarking Feature
162 Implementing Kid-Friendly Eligibility Criteria Using TDD
163 Marking Bookmarks as Kid-Friendly
164 Implementing Sharing Feature: Part 1 (Implementing Shareable Interface)
165 Implementing Sharing Feature: Part 2 (View, Controller and Manager)

JVM Internals
166 Introduction
167 Lifetime of a Type
168 Lifetime of a Type: Class Loading
169 Lifetime of a Type: Linking
170 Demo: Lifetime of a Type
171 Reflection
172 Accessing Class Object
173 Demo: Reflection
174 Runtime Data Areas
175 Method Area & Heap
176 Method Table
177 Garbage Collection: Introduction
178 Garbage Collection Algorithms
179 GC: Generational Collections
180 Demo: Tuning Heap & Analyzing GC Cycles
181 Item 6: Eliminate Obsolete Object References
182 Stack
183 Stack Frame
184 Instruction Set: invokespecial & invokevirtual + Demo
185 Conclusion

Exceptions with Best Practices
186 Chapter Introduction
187 Demo: Exceptions & Exception Handling
188 Demo: Multiple Exceptions & Polymorphically Referencing Exceptions!!
189 Checked & Unchecked Exceptions + Demo
190 Exceptions & Method Overriding
191 finally Block + Demo
192 try-with-resources Statement + Demo
193 Demo: Suppressed Exceptions
194 Demo – Best Practices: Creating New Exceptions (Items 58 & 65)
195 Demo – Best Practices for Capturing Failure Information (Item 63)
196 Demo – Item 61: Throw exceptions appropriate to the abstraction
197 Exceptions: More Advice … (Items 57, 59, 60, 62, and 38)
198 Assertions
199 Demo: Assertions
200 Conclusion

Input-Output
201 Chapter Introduction
202 Character Encoding + Demo (Prerequisite)
203 Stream IO
204 Byte Streams
205 Reading Byte-Oriented Files Efficiently + Decorator Pattern + Demo
206 Character Streams
207 Reading & Writing Text Efficiently
208 Project Extension: Reading User & Bookmark Data from Text Files (Demo)
209 Project Extension: Downloading WebLinks & Writing to Disk (Demo)
210 Demo: Reading User Input from Console using BufferedReader & Scanner
211 The File Class + Demo
212 Serializing Java Objects + Demo
213 Deserialization & Versioning + Demo
214 Demo: Decoding with Compatible Encoding Scheme
215 Conclusion
216 Input-Output ~ Important Q&A Discussions!

Collections Framework (aka Data Structures)
217 Chapter Introduction
218 Collection Interface
219 List Interface
220 ArrayList – Introduction
221 Demo: ArrayList
222 Iterator + Demo
223 List Iterator + Demo
224 LinkedList
225 Queue & Deque Interfaces
226 ArrayDeque + Demo
227 Hash Table
228 Set Interface & HashSet + Demo + Overriding hashCode & Equals (Item 9) + Item 52
229 LinkedHashSet + Demo
230 SortedSet & NavigableSet
231 TreeSet (Comparable & Comparator) + Demo
232 Demo: More TreeSet ~ Exploring NavigableSet Methods
233 Map Interface
234 Demo: HashMap + Excercise
235 Demo: Beware of Creating Mutable Keys
236 LinkedHashMap + Demo
237 SortedMap, NavigableMap and TreeMap + Demo
238 Demo: Arrays Class
239 Demo: Arrays Class (Part 2) ~ Parallelized Operations from Java 8
240 Demo: Collections Class
241 Best Practice: Return empty arrays or collections instead of nulls (Item 43)
242 Conclusion – A Quick Summary
243 Collections ~ Important Q&A Discussions!

Generics
244 Chapter Introduction ~ Motivation & Agenda
245 Generic & Parameterized Types
246 Demo: Creating Generic Types
247 Project Extension: Replacing Arrays with ArrayLists (Part 1)
248 Project Extension: Replacing Arrays with ArrayLists (Part 2)
249 Bounded Type Parameter + Demo
250 Item 23: Don’t use raw types in new code + Demo
251 Unbounded Wildcard + Demo
252 Invariance + Demo + Item 25: Prefer lists to arrays
253 Generic Methods (Items 26 & 27: Favor generic types/methods)
254 Demo: Generic Methods & Generic Constructors
255 Bounded Wildcards: Motivation + Demo
256 Bounded Wildcards + Item 28: Use bounded wildcards to increase API flexibility
257 Demo: Bounded Wildcards
258 Generics Restrictions
259 Conclusion – A Quick Summary
260 Important Q&A Discussions!

Nested Classes
261 Chapter Introduction
262 Nonstatic Member Classes + Demo
263 Anonymous Classes + Demo & Item 21 ~ About Function objects
264 Local Classes + Demo
265 Static Member Classes + Demo + Item 22: Favor Static Member Classes
266 Variable Scope with Nested Classes
267 Conclusion – A Quick Summary

enums
268 enums: Motivation & Introduction + Item 30: Use enums instead of int constants
269 Enum Class + Demo
270 enums with State & Behavior + Demo
271 Nested enums + Demo
272 Project Extension: Converting Constant Exporting Classes to Enums
273 enums with Constant-specific Behavior + Demo

Concurrency (aka Multi-threading)
274 Chapter Introduction ~ Motivation & Agenda
275 Threads: Introduction
276 Demo: Launching Threads and Making them to Sleep!
277 Demo: Thread Naming, Prioritization and Joining + Item 73 (Avoid thread groups)
278 Race Condition + Demo
279 Synchronization + Demo + Item 66: Synchronize access to shared mutable data
280 Java Memory Model (JMM)
281 Volatile Variables + Demo
282 Atomic Variables + Demo
283 Synchronization Best Practices (+ Item 67: Avoid excessive synchronization)
284 Thread Cooperation & Management + Demo
285 Demo: wait & notify
286 Thread Interruption + Demo
287 Explicit Locks (Reentrant Lock) + Demo
288 Item 69: Prefer concurrency utilities to wait and notify
289 Executor Framework + Demo (Item 68: Prefer executors and tasks to threads)
290 Executor Service & Future
291 Demo: ExecutorService & Future
292 Tasks with Time Limits + Demo
293 Project Extension: Downloading Web Links Concurrently
294 Project Extension: Implementing Background Job to Download Web Links

Date & Time API ~ Covers Java 8 & also Legacy API
295 Agenda
296 Background ~ epoch, UTC, Timezone …
297 Legacy API ~ Date & Calendar Classes + Demo
298 New Date & Time API ~ Introduction
299 Demo: New Date & Time API

Database Implementation & JDBC API
300 Database Introduction & Chapter Agenda
301 Installing MySQL Database & MySQL Workbench
302 Database Design & Normalization
303 Database Design using MySQL Workbench
304 Project Ext.: Creating Database via CREATE & INSERT Queries + Storage Engines
305 Installing JDBC Driver
306 Writing SELECT Queries with Multiple Tables, GROUP BY, ORDER BY, etc.
307 Project Extension: Loading Data from Database via JDBC API
308 Project Extension: Saving Bookmarking Data via INSERT Queries
309 Project Extension: ALTER Query & Saving Kid-Friendly Details via UPDATE Queries
310 Useful Links to Some Tutorials

Functional-style Programming ~ Lambdas & Streams (Java 8)
311 Functional-style Programming: Motivation & Chapter Agenda
312 Lambdas ~ Introduction
313 Demo: Lambdas
314 Demo: Capturing Variables from Lambdas ~ Closures!
315 Predicate, (Bi) Function, and Unary Operator Interfaces + Demo
316 Demo: Consumer, Supplier, and Primitive Functional Interfaces
317 Demo: Method References
318 Demo: Constructor References
319 Streams + Demo
320 Stream Operations: An Overview
321 Demo: Slicing a Stream
322 Demo: Stream Matching Operations
323 Demo: Stream Finding Operations & Optional Class
324 Stream Reduction Operations + Demo
325 Mutable Reduction with Collection Operations + Demo
326 collect() with Collector
327 Demo: Collecting Stream into List & Set
328 Demo: Grouping Stream Elements
329 Demo: Summarizing Groups & Generating Multi-level Groups
330 Important Q&A Discussions!

Introduction to Java EE & Web-enabling Project
331 Motivation & Agenda
332 Web Basics
333 Java EE & Servlet Containers
334 Installing Tomcat
335 BooksAloha! ~ Creating & Deploying a Web Application using Servlets
336 Servlet Life Cycle
337 Implementing BooksAloha! as MVC using JSP
338 Using JSTL to Improve Presentation Layer
339 Project Extension: Web-enabling thrill.io Project
340 Project Extension: Implementing Browse Functionality
341 Project Extension: Implementing Bookmarking & MyBooks Functionality
342 Project Extension: Implementing Login Functionality with Session

Bonus Lessons
343 Big O Notation
344 Java on Web: Websites & Social Media Groups to Follow
345 Follow-up Steps Towards Becoming a Full-Stack Java Developer!