Course Overview

1. Intro
2. Practice Practice Practice
3. Textbook
4. Discord
5. What is Java
6. What can you build with Java
7. Java Usages
8. Compliled vs Interpreted Languages
9. Static vs Dynamic Type Checking
10. Java version history
11. IntelliJ IDEA
12. jetbrains.com/idea
13. Jetbrains ToolBox
14. Quick Word Before We Begin
Getting started
15. Create Project - Part 1
16. Create Project - Part 2
17. Your First Java Program
18. Compiling and Running via Terminal
19. Fixing Compilation Errors
20. View ByteCode
21. Public Static Void Main
22. Understanding Java Code

The Basics
23. SOUT Keyboard Shortcut
24. Reserved Keywords
25. Comments
26. Variables
27. Primitives Data Types Difference
28. Numeric Literals with Underscore
29. Arithmetic Operators
30. Increment and Decrement Operators
31. Comparison Operators
32. Short hand re-assignment
33. Naming Variables
34. Strings
35. String API Documentation
36. Reference Types and Objects
37. Reference Types and Objects Diferences
38. Pass py value with Primitives
39. Pass py value with Reference Types
40. Arrays
41. 0 and Null Values for Arrays
42. Quick word on Arrays
43. TextBook and Exercises
44. How To Attempt Exercises
45. Quick word on the CLI Project

Loops and iteration

46. For Loop
47. Loops and Arrays
48. Enhanced For Loop
49. For i vs Enhanced For Loop
50. While Loop
51. Do While

Control Flow
52. If Statements
53. If Statements with Conditions
54. Else If
55. AND Logical Operators
56. OR Logical Operators
57. Logical Operators Recap
58. ! on ifs
59. Dont do this with if statements
60. Switch Statement
61. Data Types for Enums
62. New Switch Expression

Packages
63. Packages
64. Creating Packages
65. Exploring Packages
66. Import keyword
67. Optmizing imports
68. Import with fully qualified name
69. No Import for java lang
Access Modifiers
70. Access Modifiers Intro
71. Public Access Modifier
72. Private
73. Default
74. Recap
75. When To Use Each Access Modifier
Static Keyword
76. Static Keyword
Methods
77. Methods
78. Method that add 2 numbers
79. Parameters and Arguments
80. Void methods
81. Naming Convention
82. Exercise
83. Exercise Solution
Beyond the basics
84. Understanding public static void main
85. Program Arguments
86. Type Inference with Var
87. Break Keyword and Loops
88. Continue
89. Return Keyword and Void Methods
90. Final Keyword
91. Enums
92. Enums Methods
93. Implicit and Explicit Type Casting
94. Global and Local Variables
95. Wrapper Classes
Strings
96. Working With Strings
97. How Strings are stored in memory
98. Strings are Immutable
99. String Literal vs String Object
100. Comparing Strings with ==
101. Comparing Strings with .equals
102. Useful String static Methods
Dates
103. LocalDateTime
104. LocalDate and LocalTime
105. Creating Specif Dates
106. ZoneIds
107. Other Date Classes
108. The Problem With double
Big Decimal
109. BigDecimal
110. Exploring BigDecimal Methods
Scanner
111. Scanner
112. NextInt and other data types
113. Outro

Exception Handling and Errors

114. Intro
115. What is an exception
116. Try Catch
117. Multiple Catch Blocks
118. Using Or Within Catch
119. The Exception Class
120. Finally Keyword
121. Exception Hierarchy
122. Uncheck Exceptions
123. Checked Exceptions
124. Throw and Throws
125. Throwing Exceptions
126. When To Use Checked VS Unchecked Exeptions
127. Creating Custom Exceptions
Working with Files

128. Creating Files

129. Writing To Files
130. Reading from Files
131. Try with Resources

Classes and Objects

132. Intro
133. Your first class
134. Setters
135. Getters
136. Constructors
137. Default Constructors
138. Multiple Contructors
139. ToString
140. The Inside Constructors
141. The This Keyword
142. Everything in Java is an Object
143. @Override
144. Comparing Objects with ==
145. Comparing Obects with .equals
146. Generating Equals method
147. Equals Explained
148. Generating Code
149. Person and Cats Example
150. POJOS
151. Java Bean
152. Exercise
153. Exercise Solution
Static Keyword

154. Static Keyword

155. When to use Static
156. Static Initlaization Block
157. Instance Block Initializer
158. Static Import
159. Intro
160. Packages
161. Models
162. Service Classes
163. Data Access Object
164. Connecting DAO and Service
165. N Tier Architecture
166. Utitlity Classes
167. Intro
168. The first CLI project task
169. Demo
170. Upcoming Section Intro
171. Encapsulation
172. Encapsulation in Action
173. The Problem With Non Private Fields
174. Data Hiding
175. String Class Encapsulation Example
176. What is Inheritance
177. Implementing Inheritance
178. Create an instance of Programmer
179. Super Keyword
180. Protected Access Modifier
181. Override
182. Single and Multi Level Inheritance
183. Abstract Keyword on Classes
184. Abstract Methods
185. A Quick Word Before we move on
186. Abstract Classes Example
187. What is Polymorphism
188. Car Bicycle Electric Scooter Example
189. Create Your First Interface
190. Implementing Interfaces
191. Putting it all together
192. Constants
193. Default Methods
194. CLI Project Exercise
195. Don't Do This
196. Dependecy Injection
197. Dependency Injection In Action
198. Singletons and @Inject_@Autowire
199. CLI Project Exercise
200. SOLID Principles
201. Single Responsibitiy
202. Open Close
203. Liskov
204. Interface Segragation
205. Dependecy Inversion
206. Null Pointer Exception
207. The Wrong Way Of Dealing with Null
208. Optionals
209. Intro
210. Overview
211. Arrays
212. Working With Arrays
213. 2D Arrays
214. Working with 2D Arrays
215. Lists
216. Working With Lists and ArrayList
217. Stack
218. Working With Stacks
219. Queue
220. Working With Queues
221. Linked List
222. Working with LinkedList
223. Sets
224. Working with Sets
225. Map Interface Hierarchy
226. Maps
227. Working With Maps
228. HashCode
229. Working HashCode and HashFunction
230. Outro
231. HackerRank Big Notation
232. CLI Project Exercise
233. Intro
234. Class Cast Exception
235. ClassCastException Example 2
236. Type Parameter and Type Argument
237. Generic Type Naming Convention
238. Generic and Classes
239. Generic and Classes Part 2
240. Generics and Methods
241. Bounded Type Parameters
242. Multiple Bounds
243. Unbounded Wildcard
244. Upper Bounded Wildcards
245. Lower Bounded Wildcards
246. Difference Between Bounded Type Parameters and Wildcards
247. Type Erasure
248. Outro
249. Intro
250. Java Streams
251. How Streams Work
252. Getting Started With Streams
253. Exercise
254. Declarative Solution
255. Imperative Solution
256. Visualise Streams
257. Outro
258. CLI Exercise
259. Maven
260. Installing Maven
261. Verifying Maven Installation
262. Creating a Maven Project
263. Maven Folder Structure
264. Project Object Model (pom.xml)
265. Target Folder
266. Installing Maven Dependencies
267. Using Java Faker
268. .m2 Folder
269. Maven Lifecycles
270. Running Maven Commands
271. Packaging and Jar Files
272. CLI Project Exercise
273. Intro
274. JUnit
275. Installing JUNIT
276. Launching Your First Test
277. Calculator and CalculatorTest Classes
278. Writing Your First Unit Test
279. Assertions
280. Test Scenarios
281. Other JUnit Features
282. CLI Exercise
283. Section Intro
284. Intro Spring Boot
285. Spring Initializr
286. Open the project with IntelliJ
287. The pom.xml
288. Cleanup Few Things
289. JDK
290. Your first Spring Boot Application
291. Embedded Web Serve
292. Configuring Embedded Web Server
293. Your first API
294. @SpringBootApplication
295. Spring Web MVC
296. JSON For Java
297. Java Objects to JSON Objects
298. Introduction to HTTP
299. The Evolution of HTTP
300. HTTP Request and Response Messages
301. HTTP Methods
302. HTTP Status Codes
303. URL
304. API and REST API
305. Public APIs and Other Types
306. Why build APIs
307. Chrome Developer Tools
308. Exploring XHR for our API
309. Inspecting Instagram Network Activity
310. REST Client & Postman
311. IntelliJ REST Clients
312. CRUD and Section Overview
313. Customer Model
314. Fake Database
315. API Endpoint
316. @PathVariable
317. N Tier Architecture
318. Refactor - Controller Service and DAO
319. @RestController @Service @Repository @Component
320. Application Context
321. Inspecting beans
322. Bean Scopes
323. Creating Beans
324. We are not handling error the right way
325. Custom Exception
326. @ResponseStatus
327. Include error Message to Responses
328. Section Intro
329. Postgres and Docker
330. Verifying Docker Installation
331. Postgres DB with Docker compose
332. Connecting to Database
333. Connecting to DB using IntelliJ IDEA
334. Data Source & JPA
335. Installing PostgreSQL Driver and Spring Data JPA Dependencies
336. Configuring Datasource Properties
337. Create Customer Table
338. Entity
339. Inspecting The Database
340. Column Contraints
341. CustomerRepository
342. CustomerJPADataAccessService class
343. @Qualifier
344. Saving Entities
345. Exploring JPA Methods
346. The Problem
347. Exercise Solution
348. Intro
349. Chasing Interface
350. Override insert customer
351. Business Logic for Adding new Customer
352. Controller @RequestMapping and @RequestBody
353. Testing POST Request
354. Exercise
355. Exercise Solution
356. Exercise
357. Exercise Solution
358.