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 44KHz 2ch | 53.5 Hours | 8.14 GB
eLearning | Skill level: All Levels

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

Would you like to just acquire core Java skills or would you like to become a complete and a professional Java engineer right at the end of the 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 practical experience in writing professional-level code via instructor-led implementation of a project. Project is implemented in Eclipse using MVC design 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
  • 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
  • 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 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 and even functional-style programming via Java 8 constructs like lambda expressions & streams.

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 simulates a real-world product that is based on bookmarking concept. The project is instructor-led and is implemented using professional coding conventions & best practices. It follows good object-oriented design, incorporates MVC design pattern and also uses Test-Driven Development (TDD) methodology. 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 Will I 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, industry-strength database-backed, multi-threaded project in Eclipse using TDD principles & MVC design pattern
  • 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 Javas Creation ~ A Brief History
7 Compilation
8 Platform Dependency
9 Interpreter
10 Platform Independence in Java
11 Java Virtual Machine
12 An Overview of Java SE
13 Installing Java
14 Setting Classpath Environment Variable
15 Writing First Java Program Demo
16 Conclusion

Classes Objects and their Members
17 Chapter Introduction
18 Class Objects
19 Absolute Java Basics Demo
20 Variables Introduction
21 Variable Kinds
22 Variables Primitive Types
23 Primitive Variables Integers Demo
24 Primitive Variables Floating-point Numbers Item 48
25 Primitive Variables Character Boolean Types Demo
26 Variables Type Casting Demo
27 Variables Object References
28 Statements Demo
29 Arrays Demo
30 D Arrays
31 D Arrays Demo
32 Methods Introduction
33 Method Types
34 Methods How Data is Passed to Methods in Java
35 Method Overloading
36 Demo Lets Test it All ~ Defining Methods Pass Data and Method Overloading
37 Methods varargs Demo
38 Constructors Demo
39 this Reference Demo
40 Demo Student Example
41 Demo Reinitializing Object References ~ More Brainstorming
42 Conclusion
43 Important QA Discussions

Method Building Blocks Operators Control-flow Statements
44 Chapter Introduction
45 Operators
46 Arithmetic Operators
47 Arithmetic Operation Rules Demo
48 Comparison Operators
49 Logical Operators
50 Demo Comparison Logical Operators
51 Bitwise Operators Demo
52 Bit Shift Operators
53 Control-flow if-statement
54 Control-flow switch Demo
55 When is switch Preferred
56 Control-flow Ternary Demo
57 Control-flow for Statement Demo
58 Item 46 Prefer for-each loops to traditional for loops
59 Control-flow while Statement
60 Control-flow break Statement Demo
61 Control-flow continue Demo
62 Variable Scope
63 Exercise
64 Conclusion

Packages Strings and Information Hiding
65 Chapter Introduction
66 Java API Item 47 (Know and use the libraries)
67 Accessing Packages Demo
68 Creating Packages Demo
69 Naming Packages
70 A Brief Note on Path Classpath Environment Variables
71 Strings Introduction
72 String Class Demo
73 String Pool Interning Demo
74 String Immutability
75 String Concatenation Demo
76 Item 51 String Concatenation Performance
77 Escape Sequences Demo
78 Access Levels
79 Information Hiding – Item 14 Use accessor methods not public fields Demo
80 Information Hiding – Item 13 Minimize the accessibility of classes and members
81 Demo Student Example with Information Hiding
82 Conclusion

static final and Coding Conventions
83 Chapter Introduction
84 Static Methods Item 4 Enforce noninstantiability with a private constructor
85 Math Class Demo
86 Static Variables Demo
87 Initializers Static Instance Demo
88 final Variable Demo
89 Constant Variables Demo
90 Boxed Primitives
91 Autoboxing Demo
92 Item 49 Prefer Primitives to Boxed Primitives Demo
93 Coding Conventions Naming (Item 56 Use generally accepted naming conventions)
94 Coding Conventions Structuring Programs (Item 45 Minimize the scope of local)
95 Coding Conventions Stylistic Demo
96 Coding Conventions Comments Demo
97 Conclusion

Case Study A Social Bookmarking Application
98 ~ A Social Polymarking App
99 Case Study

Serious OOP Inheritance Polymorphism
100 Inheritance
101 Access Modifiers Inheritance Demo
102 IS-A Test
103 Polymorphism Demo
104 Casting Objects instanceof Operator Demo
105 Type Safety
106 Method Overriding Demo
107 Method Binding Demo
108 What is Not Overridden (final Method is one of them) Demo
109 Demo Fields are Not Overridden
110 Object Class Demo Item 10 Always override toString
111 Constructor Chaining Demo
112 Preventing Inheritance
113 Conclusion

More Serious OOP Abstract Classes Interfaces
114 New Requirement for Kids
115 Abstract Classes Methods Demo
116 Item 20 Prefer class hierarchies to tagged classes
117 New Requirement Sharing Bookmarks
118 Multiple Inheritance Diamond Problem
119 Interfaces
120 Demo Interfaces
121 Interfaces A Conceptual View
122 Item 18 Prefer interfaces to abstract classes
123 Item 52 Refer to objects by their interfaces
124 Marker Interfaces
125 Cloneable Interface Demo
126 default Methods (Java 8) Demo
127 Recap of default Methods
128 default Methods Other Benefits Demo
129 Static Methods in Interfaces Demo
130 Conclusion

Programming with Eclipse IDE
131 Introduction
132 Installing Eclipse
133 Writing a Java Program in Eclipse
134 Eclipse Build Process
135 Importing Demo Code
136 Source Code Navigation
137 Automatic Source Code Cleaning Generation
138 Code Refactoring
139 Using Eclipse Debugger
140 JUnit Debugging
141 Shortcuts Cheat Sheet
142 Conclusion

Project Implementing a Social Bookmarking App
143 Project Introduction
144 MVC Architecture
145 Implementing Entities
146 Implementing Manager Classes – Demonstrates Singleton Pattern
147 Implementing Constant Exporting Classes
148 Implementing Data Store
149 Implementing Dao Classes
150 Launching the Application
151 Implementing User Bookmarking Feature
152 Implementing Kid-Friendly Eligibility Criteria Using TDD
153 Marking Bookmarks as Kid-Friendly
154 Implementing Sharing Feature Part 1 (Implementing Shareable Interface)
155 Implementing Sharing Feature Part 2 (View Controller and Manager)

JVM Internals
156 Introduction
157 Lifetime of a Type
158 Lifetime of a Type Class Loading
159 Lifetime of a Type Linking
160 Demo Lifetime of a Type
161 Reflection
162 Accessing Class Object
163 Demo Reflection
164 Runtime Data Areas
165 Method Area Heap
166 Method Table
167 Garbage Collection Introduction
168 Garbage Collection Algorithms
169 GC Generational Collections
170 Demo Tuning Heap Analyzing GC Cycles
171 Item 6 Eliminate Obsolete Object References
172 Stack
173 Stack Frame
174 Instruction Set invokespecial invokevirtual Demo
175 Conclusion

Exceptions with Best Practices
176 Chapter Introduction
177 Demo Exceptions Exception Handling
178 Demo Multiple Exceptions Polymorphically Referencing Exceptions
179 Checked Unchecked Exceptions Demo
180 Exceptions Method Overriding
181 finally Block Demo
182 try-with-resources Statement Demo
183 Demo Suppressed Exceptions
184 Demo – Best Practices Creating New Exceptions (Items 58 65)
185 Demo – Best Practices for Capturing Failure Information (Item 63)
186 Demo – Item 61 Throw exceptions appropriate to the abstraction
187 Exceptions More Advice … (Items 57 59 60 62 and 38)
188 Assertions
189 Demo Assertions
190 Conclusion

191 Chapter Introduction
192 Character Encoding Demo (Prerequisite)
193 Stream IO
194 Byte Streams
195 Reading Byte-Oriented Files Efficiently Decorator Pattern Demo
196 Character Streams
197 Reading Writing Text Efficiently
198 Project Extension Reading User Bookmark Data from Text Files (Demo)
199 Project Extension Downloading WebLinks Writing to Disk (Demo)
200 Demo Reading User Input from Console using BufferedReader Scanner
201 The File Class Demo
202 Serializing Java Objects Demo
203 Deserialization Versioning Demo
204 Demo Decoding with Compatible Encoding Scheme
205 Conclusion

Collections Framework (aka Data Structures)
206 Chapter Introduction
207 Collection Interface
208 List Interface
209 ArrayList – Introduction
210 Demo ArrayList
211 Iterator Demo
212 List Iterator Demo
213 LinkedList
214 Queue Deque Interfaces
215 ArrayDeque Demo
216 Hash Table
217 Set Interface HashSet Demo Overriding hashCode Equals (Item 9) Item 52
218 LinkedHashSet Demo
219 SortedSet NavigableSet
220 TreeSet (Comparable Comparator) Demo
221 Demo More TreeSet ~ Exploring NavigableSet Methods
222 Map Interface
223 Demo HashMap Excercise
224 Demo Beware of Creating Mutable Keys
225 LinkedHashMap Demo
226 SortedMap NavigableMap and TreeMap Demo
227 Demo Arrays Class
228 Demo Arrays Class (Part 2) ~ Parallelized Operations from Java 8
229 Demo Collections Class
230 Best Practice Return empty arrays or collections instead of nulls (Item 43)
231 Conclusion – A Quick Summary
232 Collections ~ Important QA Discussions

233 Chapter Introduction ~ Motivation Agenda
234 Generic Parameterized Types
235 Demo Creating Generic Types
236 Project Extension Replacing Arrays with ArrayLists (Part 1)
237 Project Extension Replacing Arrays with ArrayLists (Part 2)
238 Bounded Type Parameter Demo
239 Item 23 Dont use raw types in new code Demo
240 Unbounded Wildcard Demo
241 Invariance Demo Item 25 Prefer lists to arrays
242 Generic Methods (Items 26 27 Favor generic typesmethods)
243 Demo Generic Methods Generic Constructors
244 Bounded Wildcards Motivation Demo
245 Bounded Wildcards Item 28 Use bounded wildcards to increase API flexibility
246 Demo Bounded Wildcards
247 Generics Restrictions
248 Conclusion – A Quick Summary

Nested Classes
249 Chapter Introduction
250 Nonstatic Member Classes Demo
251 Anonymous Classes Demo Item 21 ~ About Function objects
252 Local Classes Demo
253 Static Member Classes Demo Item 22 Favor Static Member Classes
254 Variable Scope with Nested Classes
255 Conclusion – A Quick Summary

256 enums Motivation Introduction Item 30 Use enums instead of int constants
257 Enum Class Demo
258 enums with State Behavior Demo
259 Nested enums Demo
260 Project Extension Converting Constant Exporting Classes to Enums
261 enums with Constant-specific Behavior Demo

Concurrency (aka Multi-threading)
262 Chapter Introduction ~ Motivation Agenda
263 Threads Introduction
264 Demo Launching Threads and Making them to Sleep
265 Demo Thread Naming Prioritization and Joining Item 73 (Avoid thread groups)
266 Race Condition Demo
267 Synchronization Demo Item 66 Synchronize access to shared mutable data
268 Java Memory Model (JMM)
269 Volatile Variables Demo
270 Atomic Variables Demo
271 Synchronization Best Practices ( Item 67 Avoid excessive synchronization)
272 Thread Cooperation Management Demo
273 Demo wait notify
274 Thread Interruption Demo
275 Explicit Locks (Reentrant Lock) Demo
276 Item 69 Prefer concurrency utilities to wait and notify
277 Executor Framework Demo (Item 68 Prefer executors and tasks to threads)
278 Executor Service Future
279 Demo ExecutorService Future
280 Tasks with Time Limits Demo
281 Project Extension Downloading Web Links Concurrently
282 Project Extension Implementing Background Job to Download Web Links

Functional-style Programming ~ Lambdas Streams
283 Functional-style Programming Motivation Chapter Agenda
284 Lambdas ~ Introduction
285 Demo Lambdas
286 Demo Capturing Variables from Lambdas ~ Closures
287 Predicate (Bi) Function and Unary Operator Interfaces Demo
288 Demo Consumer Supplier and Primitive Functional Interfaces
289 Demo Method References
290 Demo Constructor References
291 Streams Demo
292 Stream Operations An Overview
293 Demo Slicing a Stream
294 Demo Stream Matching Operations
295 Demo Stream Finding Operations Optional Class
296 Stream Reduction Operations Demo
297 Mutable Reduction with Collection Operations Demo
298 collect() with Collector
299 Demo Collecting Stream into List Set
300 Demo Grouping Stream Elements
301 Demo Summarizing Groups Generating Multi-level Groups

Date Time API ~ Covers Java 8 also Legacy API
302 Agenda
303 Background ~ epoch UTC Timezone …
304 Legacy API ~ Date Calendar Classes Demo
305 New Date Time API ~ Introduction
306 Demo New Date Time API

Database Implementation JDBC API
307 Database Introduction Chapter Agenda
308 Installing MySQL Database MySQL Workbench
309 Database Design Normalization
310 Database Design using MySQL Workbench
311 Project Ext. Creating Database via CREATE INSERT Queries Storage Engines
312 Installing JDBC Driver
313 Writing SELECT Queries with Multiple Tables GROUP BY ORDER BY etc.
314 Project Extension Loading Data from Database via JDBC API
315 Project Extension Saving Bookmarking Data via INSERT Queries
316 Project Extension ALTER Query Saving Kid-Friendly Details via UPDATE Queries
317 Useful Links to Some Tutorials

Bonus Lessons
318 Big O Notation
319 Java on Web Websites Social Media Groups to Follow
320 Follow-up Steps Towards Becoming a Full-Stack Java Developer

Download from Turbobit

Download from DepositFiles

Download from Rapidgator