Oreilly – Java Fundamentals with Paul Deitel, 3rd Edition 2025-3

Oreilly – Java Fundamentals with Paul Deitel, 3rd Edition 2025-3 Downloadly IRSpace

Super Admin Super Admin
Apr 22, 2025 - 14:42
0 0
Oreilly – Java Fundamentals with Paul Deitel, 3rd Edition 2025-3
Oreilly – Java Fundamentals with Paul Deitel, 3rd Edition 2025-3

Java Fundamentals with Paul Deitel, 3rd Edition. This comprehensive course is designed to teach the fundamentals and key concepts of the Java programming language and is based on the third edition of the valuable book “Java Fundamentals with Paul Deitel”. With a practical, step-by-step approach, this course starts you with installing and setting up the Java Development Environment (JDK) and familiarizing yourself with its command-line tools, and then goes on to cover basic programming concepts such as variables, data types, operators, and control structures (including conditional statements and loops).

The course then moves on to more advanced topics such as defining and using methods, arrays, and dynamic lists (ArrayLists), and teaches you how to work with the String class, natural language processing (NLP), and regular expressions (Regex). You will also learn the concept of real-world modeling using custom classes, inheritance, polymorphism, and interfaces. The final sections of the course delve into the important topic of Exception Handling and introduce you to different ways to deal with runtime errors. Throughout the course, many practical and applied examples are provided to help you better understand the concepts and strengthen your programming skills. The use of Generative AI in some sections to better understand the code and simplify it is also a feature of this course.

What you will learn in Java Fundamentals with Paul Deitel 3rd Edition

  • Install and configure the Java Development Kit (JDK) and become familiar with its command line tools.
  • Java programming basics including variables, data types, operators, and expressions.
  • Write your first Java program and understand its structure.
  • Use conditional control structures (if, if…else, switch) and loops (while, for, do…while) to control the flow of program execution.
  • Define and use methods to organize and reuse code.
  • Working with arrays and dynamic lists (ArrayLists) to store and manage a set of data.
  • Familiarity with the String class and its methods for working with text strings.
  • An introduction to natural language processing (NLP) and the use of regular expressions (Regex) for searching and manipulating text.
  • Model the real world using custom classes, defining instance variables, and accessor methods.
  • Understand object-oriented concepts including inheritance, polymorphism, and interfaces.
  • Managing errors and using the Exception Handling mechanism to write stable programs.
  • Familiarity with Java API Packages and how to use their documentation.
  • An introduction to record classes and pattern matching for switch statements.

This course is suitable for people who:

  • Are interested in programming and want to learn Java from scratch.
  • Have no or little prior programming experience and want to learn a powerful and widely used programming language.
  • Computer science and software engineering students who want to learn the fundamentals of Java.
  • Developers who are familiar with other programming languages ​​and want to add Java to their skill set.
  • People who plan to work in the fields of enterprise software development, Android applications, or other Java-related fields.
  • Those looking for a comprehensive educational resource based on a reputable book to learn Java.

Course details: Java Fundamentals with Paul Deitel, 3rd Edition

  • Publisher: Oreilly
  • Instructor: Paul Deitel
  • Training level: Beginner to advanced
  • Training duration: 10 hours and 17 minutes

Course headings

  1. Before You Begin
  2. Before You Begin Overview
  3. Our Corresponding Books and Videos
  4. Getting the Code Examples
  5. Structure of the examples folder
  6. Java Development Kit (JDK)
  7. Java Release Cadence
  8. Java Integrated Development Environments (IDEs)
  9. JavaFX SDK and Scene Builder
  10. Generative AIs
  11. Getting Your Questions Answered
  12. Keeping In Touch
  13. Lesson 1, Test-Driving the Java Development Kit
  14. Lesson 1 Overview, Test-Driving the Java Development Kit
  15. Java Development Kit Command-Line Tools
  16. Lesson 2, Intro to Java Programming
  17. Lesson 2 Overview, Intro to Java Programming
  18. Your First Program in Java: Printing a Line of Text
  19. Java Keywords
  20. Generative AI: What does this code display?
  21. Compiling and Running the Program
  22. Generative AI: What does this code display?
  23. Modifying Your First Program: Displaying a Single Line of Text with Multiple Statements
  24. Modifying Your First Program: Displaying Multiple Lines of Text with a Single Statement
  25. Escape Sequences
  26. Generative AI: Simplify this code
  27. Displaying Text with printf
  28. Generative AI: Displaying Text with printf
  29. Another Program: Adding Integers
  30. Generative AI: Adding Integers
  31. Arithmetic
  32. Decision Making: Equality and Relational Operators―Introducing the if Statement and boolean Expressions
  33. Generative AI: Adding Integers
  34. Objects-Natural Case Study: Creating and Using Objects of the Java API’s String Class
  35. Generative AI: Objects-Natural String Case Study
  36. Lesson 3, Control Statements: Part 1
  37. Lesson 3 Overview, Control Statements: Part 1
  38. if Single-Selection Statement
  39. if…else Double-Selection Statement and a JShell Demo
  40. GenAI: Finding Fixing a Syntax Error in an if…else
  41. GenAI: Finding and Fixing a Logical Error
  42. Nested if…else Statements
  43. Conditional Operator (?:) and a JShell Demo
  44. GenAI: Writing a line of Java code
  45. While Iteration Statement and a JShell Demo
  46. Counter-Controlled Iteration with the While Statement
  47. Sentinel-Controlled Iteration with the While Statement
  48. GenAI: Writing a Java Program to Determine the First Power of 2 Greater than One Million
  49. Nested Control Statements
  50. Compound Assignment Operators
  51. Increment and Decement Operators
  52. Primitive Types
  53. Objects-Natural Case Study: Super-Sized Integers
  54. Lesson 4, Control Statements: Part 2
  55. Lesson 4 Overview, Control Statements: Part 2
  56. Essentials of Counter-Controlled Iteration
  57. for Iteration Statement
  58. Summing the Even Integers from 2 to 20 with the for Statement
  59. Calculating Compound Interest with the for statement
  60. do…while Iteration Statement
  61. switch Multiple-Selection Statement
  62. switch Multiple-Selection Statement Activity Diagram
  63. break Statement
  64. continue Statement
  65. Logical Operators
  66. 4.12 Objects-Natural Case Study: Precise Monetary Calculations with Java API Class BigDecimal
  67. Lesson 5, Methods
  68. Lesson 5 Overview, Methods
  69. Declaring Methods
  70. Case Study: Die Rolling Simulation with Random-Number Generation—Rolling a Six-Sided Die 10 Times
  71. Case Study: Die Rolling Simulation with Random-Number Generation—Rolling a Six-Sided Die 60,000,000 Times
  72. Case Study: A Game of Chance; Introducing switch expressions
  73. Case Study: A Game of Chance; Introducing switch expressions—switch expressions yield values
  74. Scope of Declarations
  75. Method Overloading
  76. Class Math: Static Methods and Variables
  77. Why is method main declared static?
  78. Java API Packages; Introducing How to Use the Java API Docs
  79. Argument Promotion and Casting
  80. Objects-Natural Case Study: Java Date/Time API
  81. Lesson 6, Arrays and ArrayLists
  82. Lesson 6 Overview: Arrays and ArrayLists
  83. Primitive Types vs. Reference Types
  84. Arrays
  85. Declaring and Creating Arrays
  86. Creating and Initializing an Array
  87. Array Initializers
  88. Calculating Array Element Values
  89. Totaling Array Elements
  90. Intro to Visualization: Using a Bar Chart to Display Array Data Graphically
  91. Using Array Elements as Counters
  92. Analyzing Survey Results; Introduction to Exception Handling
  93. Enhanced for Statement: Totaling Array Elements
  94. Passing Arrays to Methods
  95. Multidimensional Arrays
  96. Variable-Length Argument Lists
  97. Command-Line Arguments
  98. Class Arrays
  99. Objects-Natural Case Study: Intro to Collections and Class ArrayList
  100. Objects-Natural Case Study: Intro to Collections and Class―Demonstrating an ArrayList
  101. Lesson 7, Strings, NLP and Regex
  102. Lesson 7 Overview: Strings, NLP and Regex
  103. Class String—Creating String Objects
  104. Class String—String Methods length, charAt and getChars
  105. Class String—Comparing Strings and Portions of Strings
  106. Class String—String Methods startsWith and endsWith
  107. Class String—Locating Characters and Substrings in Strings
  108. Class String—Extracting Substrings from Strings
  109. Class String—Concatenating Strings
  110. Class String—Miscellaneous String Methods
  111. Class String—String Method valueOf
  112. Class StringBuilder—Creating StringBuilder Objects
  113. Class StringBuilder—StringBuilder Methods length, capacity, setLength and ensureCapacity
  114. Class StringBuilder—Methods charAt, setCharAt, getChars and reverse
  115. Class StringBuilder—append Methods
  116. Class StringBuilder—Insertion and Deletion Methods
  117. Class Character—Character Testing and Case Conversion Methods
  118. Class Character—Character/Digit Conversions
  119. Class Character—Other Character Methods
  120. Tokenizing Strings
  121. Objects-Natural Case Study: Intro to Regular Expressions in NLP
  122. Objects-Natural Case Study: Intro to Regular Expressions in NLP—Matching Complete Strings to Patterns
  123. Objects-Natural Case Study: Intro to Regular Expressions in NLP—Replacing Substrings
  124. Objects-Natural Case Study: Intro to Regular Expressions in NLP—Searching for Matches with Classes Pattern and Matcher
  125. Objects-Natural Case Study: Intro to Regular Expressions in NLP—Simple Data Wrangling Steps Used to Prepare Text for Training NLP and Generative AI Models
  126. Objects-Natural Security Case Study: pMa5tfEKwk59dTvC04Ft1IFQz9mEXnkfYXZwxk4ujGE=
  127. Objects-Natural Security Case Study—Encrypting and Decrypting Text with AES
  128. Lesson 8, Real-World Modeling with Custom Classes
  129. Lesson 8 Overview: Real-World Modeling with Custom Classes
  130. Instance Variables, set Methods and get Methods―Account Class with an Instance Variable, and set and get Methods
  131. Instance Variables, set Methods and get Methods―AccountTest Class That Creates and Uses an Account Object
  132. Instance Variables, set Methods and get Methods―Compiling and Executing a Program with Multiple Classes
  133. Instance Variables, set Methods and get Methods―Notes on Class AccountTest
  134. Account Class: Initializing Objects with Constructors—Declaring an Account Constructor for Custom Object Initialization and Initializing New Account Objects
  135. Account Class with a Balance—Account Class with a BigDecimal balance Instance Variable
  136. Account Class with a Balance—AccountTest Class
  137. Case Study: Card Shuffling and Dealing Simulation—Class Card
  138. Case Study: Card Shuffling and Dealing Simulation—Class DeckOfCards
  139. Case Study: Card Shuffling and Dealing Simulation—Shuffling and Dealing Cards
  140. Case Study: Time Class—Time1 Class Declaration
  141. Case Study: Time Class—Using Time Class1
  142. Controlling Access to Members
  143. Referring to the current object’s members with this reference
  144. Case Study: Time Class Overloaded Constructors—Class Time2 with Overloaded Constructors
  145. Case Study: Time Class Overloaded Constructors—Using Class Time2’s Overloaded Constructors
  146. Composition—Class Date
  147. Composition—Class Employee
  148. Composition—Class EmployeeTest
  149. enum Types
  150. static Class Members
  151. static Import
  152. Package Access
  153. record Classes
  154. Pattern Matching for switch expressions
  155. Decomposing records in switch expressions
  156. Lesson 9, Real-World Modeling with Inheritance, Polymorphism Interfaces
  157. Lesson 9 Overview: Real-World Modeling with Inheritance, Polymorphism Interfaces
  158. Superclasses and Subclasses
  159. Relationship Between Superclasses and Subclasses
  160. Relationship Between Superclasses and Subclasses—Creating and Using a SalariedEmployee Class
  161. Relationship Between Superclasses and Subclasses—Creating and Using a SalariedEmployee Class—Class SalariedEmployeeTest
  162. Relationship Between Superclasses and Subclasses—Creating a SalariedEmployee/SalariedCommissionEmployee Inheritance Hierarchy
  163. Relationship Between Superclasses and Subclasses—Testing Class SalariedCommissionEmployee
  164. Class Object
  165. Demonstrating Polymorphic Behavior
  166. abstract Classes and Methods
  167. Case Study: Payroll System Using Polymorphism
  168. Case Study: Payroll System Using Polymorphism—Abstract Superclass Employee
  169. Case Study: Payroll System Using Polymorphism—Concrete Subclass SalariedEmployee
  170. Case Study: Payroll System Using Polymorphism—Concrete Subclass CommissionEmployee
  171. Case Study: Payroll System Using Polymorphism—Polymorphic Processing, Operator instanceof and Downcasting
  172. final Methods and Classes
  173. Creating and Using Interfaces
  174. Creating and Using Interfaces—Developing a Payable Hierarchy
  175. Creating and Using Interfaces—Interface Payable
  176. Creating and Using Interfaces—Class Invoice
  177. Creating and Using Interfaces—Modifying the Employee Class to Implement the Payable Interface
  178. Using Payable Interface to Process Invoices and Employees Polymorphically
  179. Some Common Java API Interfaces
  180. Other Interface Features
  181. Program to an Interface, Not an Implementation
  182. Program to an Interface, Not an Implementation—CompensationModel Interface
  183. Program to an Interface, Not an Implementation—An Employee Has a Compensation Model—Composition and Dependency Injection
  184. Program to an Interface, Not an Implementation—CompensationModel Implementations
  185. Program to an Interface, Not an Implementation—Testing the CompensationModel Hierarchy
  186. Program to an Interface, Not an Implementation—Dependency Injection Design Benefits
  187. Program to an Interface, Not an Implementation—interfaces vs. abstract classes
  188. sealed Classes and Interfaces
  189. Lesson 10, Exception Handling: A Deeper Look
  190. Lesson 10 Overview―Exception Handling: A Deeper Look
  191. Example: Divide by Zero without Exception Handling
  192. Example: Handling ArithmeticExceptions and InputMismatchExceptions
  193. Java Exception Hierarchy
  194. Checked vs. Unchecked Exceptions
  195. finally Block
  196. Stack Unwinding and Obtaining Information from an Exception
  197. Chained Exceptions
  198. Preconditions and Postconditions
  199. Assertions
  200. try-with-resources Statement
  201. Unnamed Variables in catch Handlers

Java Fundamentals with Paul Deitel 3rd Edition Course Images

Java Fundamentals with Paul Deitel 3rd Edition

Sample course video

Installation Guide

After Extract, view with your favorite player.

Subtitles: None

Quality: 720p

Download link

Download Part 1 – 1 GB

Download Part 2 – 507 MB

File(s) password: www.downloadly.ir

File size

1.5 GB

Tags: