Cover image for Job Ready Java

Job Ready Java

Release Date: 2021/03/01
ISBN: 9781119775645
Topic:
0%
57
Chapters
0-1
Hours read
0k
Total Words
    Start Reading Now    
       Add to Wishlist       
View table of contents

Prepare yourself to take on new and exciting Java programming challenges with this one-stop resource 

Job Ready Java delivers a comprehensive and foundational approach to Java that is immediately applicable to real-world environments. Based on the highly regarded and effective Software Guild Java Bootcamp: Object Oriented Programming course, this book teaches you the basic and advanced Java concepts you will need at any entry-level Java position. 

With the “Pulling It Together” sections, you’ll combine and integrate the concepts and lessons taught by the book, while also benefiting from: 

  • A thorough introduction to getting set up with Java, including how to write, compile, and run Java programs with or without a Java IDE 
  • Practical discussions of the basics of the Java language, including syntax, program flow, and code organization 
  • A walk through the fundamentals of Object-Oriented Programming including Classes, Objects, Interfaces, and Inheritance, and how to leverage OOP in Java to create elegant code.  
  • Explorations of intermediate and advanced Java concepts, including Maven , unit testing, Lambdas, Streams, and the Spring Framework  

Perfect for Java novices seeking to make a career transition, Job Ready Java will also earn a place in the libraries of Java developers wanting to brush up on the fundamentals of their craft with an accessible and up-to-date resource. 

Table of Contents

  1. Cover
  2. Title Page
  3. Introduction
    1. WHAT DOES THIS BOOK COVER?
    2. READER SUPPORT FOR THIS BOOK
  4. PART I: Getting Set Up
    1. Lesson 1: Installing Java
    2. THE JAVA UNIVERSE
    3. INSTALLING OpenJDK
    4. CREATING YOUR FIRST JAVA PROGRAM
    5. USING THE COMPILER AND JAVA VIRTUAL MACHINE
    6. SUMMARY
    7. Lesson 2: Installing a Development Environment: NetBeans
    8. GETTING STARTED
    9. UNDERSTANDING THE VALUE OF AN IDE
    10. INSTALLING NETBEANS
    11. RUNNING NETBEANS
    12. SUMMARY
    13. Lesson 3: Using an Integrated Development Environment
    14. USING AN IDE
    15. USING THE DEBUGGING TOOLS
    16. UNDERSTANDING SOURCE CONTROL
    17. SUMMARY
  5. PART II: Basics of Object Oriented Programming
    1. Lesson 4: Using Program Statements and Variables
    2. APPROACH
    3. CONCEPTS
    4. LANGUAGE BUILDING BLOCKS
    5. SUMMARY
    6. EXERCISES
    7. Lesson 5: Collecting and Parsing Input from the User
    8. CONSOLE INPUT AND OUTPUT
    9. PARSING DATA
    10. DEALING WITH BAD NUMBERS: NumberFormatException
    11. SCANNER PROBLEMS
    12. SUMMARY
    13. EXERCISES
    14. Lesson 6: Pulling It All Together: Building a Useful Program
    15. PLANNING THE PROGRAM
    16. CREATING THE CODE
    17. RUNNING THE PROGRAM
    18. SUMMARY
    19. EXERCISES
    20. Lesson 7: Controlling Program Flow
    21. WHAT CAN OUR CODE DO?
    22. DECISIONS AND BOOLEAN EXPRESSIONS
    23. TERNARY OR CONDITIONAL OPERATOR
    24. SWITCH STATEMENT
    25. COMPARING FOR EQUAL STRINGS
    26. SUMMARY
    27. EXERCISES
    28. Lesson 8: Looping Program Flow
    29. LOOPS
    30. USING WHILE LOOPS
    31. USING DO-WHILE LOOPS
    32. USING FOR LOOPS
    33. SUMMARY
    34. EXERCISES
    35. Lesson 9: Understanding Flowcharts and Algorithms
    36. FLOWCHART BASICS
    37. FLOWCHARTING
    38. FLOWCHART EXAMPLE
    39. SUMMARY
    40. EXERCISES
    41. Lesson 10: Adding Randomness to Your Programs
    42. INITIALIZING THE RANDOM OBJECT
    43. GENERATING RANDOM INTEGERS
    44. GENERATING RANDOM DOUBLES
    45. REVISITING THE NUMBER GUESSING GAME
    46. OTHER RANDOM OPTIONS
    47. SUMMARY
    48. EXERCISES
    49. Lesson 11: Debugging
    50. CREATING A FILE TO DEBUG
    51. SETTING BREAKPOINTS
    52. SUMMARY
    53. EXERCISES
    54. Lesson 12: Adding Methods
    55. WHY METHODS?
    56. DEFINING METHODS
    57. METHOD FORMS
    58. PULLING IT ALL TOGETHER
    59. SCOPE
    60. DEBUGGING AND STEP INTO
    61. SUMMARY
    62. EXERCISES
    63. Lesson 13: Organizing with Arrays
    64. WHAT IS AN ARRAY?
    65. DECLARING ARRAYS
    66. INITIALIZING ARRAYS
    67. ACCESSING ARRAY ELEMENTS
    68. ITERATING THROUGH ARRAYS
    69. CHANGING THE SIZE OF AN ARRAY
    70. DEALING WITH ERRORS
    71. SUMMARY
    72. EXERCISES
  6. PART III: Fundamentals of Classes and Objects
    1. Lesson 14: Object-Oriented Concepts
    2. ABSTRACTION
    3. OBJECT ORIENTATION
    4. TYPES
    5. PUBLIC INTERFACE/PRIVATE IMPLEMENTATION
    6. ENCAPSULATION AND DATA HIDING
    7. SINGLE RESPONSIBILITY PRINCIPLE AND COHESION
    8. DELEGATION
    9. SUMMARY
    10. Lesson 15: Creating Classes and Types
    11. CREATING NEW TYPES
    12. CLASSES VS. OBJECTS
    13. PROPERTIES, ACCESSORS, AND MUTATORS
    14. DOT OPERATOR
    15. this KEYWORD
    16. METHODS/BEHAVIORS
    17. CONSTRUCTORS
    18. OBJECT INSTANTIATION AND METHOD INVOCATION
    19. static KEYWORD
    20. PULLING IT ALL TOGETHER
    21. SUMMARY
    22. EXERCISES
    23. Lesson 16: Managing Storage and Memory
    24. PROGRAMS AND MEMORY
    25. GARBAGE COLLECTION
    26. REFERENCE AND NULL VALUES
    27. SUMMARY
    28. Lesson 17: Exploring Interfaces, Composition, and Inheritance
    29. HOW DO THESE TOOLS HELP?
    30. INTERFACES
    31. COMPOSITION AND INHERITANCE
    32. USING INTERFACES, COMPOSITION, AND INHERITANCE
    33. SUMMARY
    34. Lesson 18: Diving into Interfaces
    35. WHAT IS AN INTERFACE?
    36. DECLARING AN INTERFACE
    37. IMPLEMENTING AN INTERFACE
    38. INTERFACE RESTRICTIONS
    39. IMPLEMENTING MULTIPLE INTERFACES
    40. EXTENDING AN INTERFACE
    41. INTERFACES AND POLYMORPHISM
    42. SUMMARY
    43. Lesson 19: Diving into Composition
    44. WHAT IS COMPOSITION?
    45. SUMMARY
    46. EXERCISES
    47. Lesson 20: Diving into Inheritance
    48. EVERYTHING EXTENDS OBJECT
    49. TERMINOLOGY
    50. ACCESS CONTROL
    51. INHERITANCE
    52. CODE REUSE THROUGH INHERITANCE
    53. METHOD OVERLOADING
    54. METHOD OVERRIDING
    55. CONSTRUCTORS
    56. POLYMORPHISM
    57. CALLING METHODS POLYMORPHICALLY
    58. ABSTRACT BASE CLASSES
    59. SUMMARY
    60. EXERCISES
    61. Lesson 21: Understanding Collections
    62. COLLECTIONS IN JAVA
    63. JAVADOC
    64. COLLECTIONS FRAMEWORK STRUCTURE
    65. INTERFACE VS. IMPLEMENTATION
    66. ITERATOR
    67. COMMONLY USED INTERFACES IN THE COLLECTIONS FRAMEWORK
    68. SUMMARY
    69. Lesson 22: Introduction to Lists
    70. LIST
    71. TYPES OF LISTS
    72. UNDERSTANDING GENERICS
    73. USING LISTS
    74. ENHANCED APPROACHES TO ACCESS LIST ITEMS
    75. SUMMARY
    76. EXERCISES
    77. Lesson 23: Exploring Maps
    78. MAP INTERFACE
    79. HashMap
    80. CREATING AND ADDING ENTRIES TO A MAP
    81. MANIPULATING WITH ENTRIES IN A MAP
    82. GETTING KEYS AND LISTING MAPPED VALUES IN A MAP
    83. SUMMARY
    84. EXERCISES
    85. Lesson 24: Using Simple File Input and Output
    86. DATA STORAGE AND REPRESENTATION
    87. FILE FORMAT, MARSHALING, AND UNMARSHALING
    88. SIMPLE FILE I/O
    89. SUMMARY
    90. EXERCISES
    91. Lesson 25: Applying Application Design
    92. CRUD APPLICATIONS
    93. THE MODEL-VIEW-CONTROLLER PATTERN
    94. PACKAGES
    95. SOFTWARE DEVELOPMENT LIFECYCLEOVERVIEW
    96. AGILE DEVELOPMENT
    97. SUMMARY
    98. Lesson 26: Handling Exceptions
    99. EXCEPTION HANDLING
    100. CATCH OR SPECIFY REQUIREMENT
    101. EXCEPTION TYPES
    102. HANDLING (CATCHING) EXCEPTIONS
    103. SPECIFYING AND THROWING EXCEPTIONS
    104. EXCEPTION TRANSLATION AND ENCAPSULATION
    105. SUMMARY
    106. EXERCISES
    107. NOTE
    108. Lesson 27: Pulling It All Together: Building the Class Roster App
    109. APPLICATION REQUIREMENTS AND USE CASES
    110. UNDERSTANDING THE APPLICATION STRUCTURE
    111. SETTING UP THE CLASS ROSTER APPLICATION SHELL
    112. CREATING THE MENU SYSTEM
    113. ADDING A STUDENT USE CASE
    114. VIEWING ALL STUDENTS USE CASE
    115. GETTING A STUDENT USE CASE
    116. REMOVING A STUDENT USE CASE
    117. HANDLING UNKNOWN COMMAND AND EXITING
    118. WORKING WITH DEPENDENCY INJECTION
    119. HANDLING APPLICATION EXCEPTIONS
    120. ADDING FILE PERSISTENCE
    121. SUMMARY
    122. EXERCISES
  7. PART IV: Intermediate Java
    1. Lesson 28: Exploring the Service Layer
    2. THE ROLE OF THE SERVICE LAYER
    3. SERVICE LAYER EXCEPTIONS
    4. SERVICE LAYER API DESIGN
    5. NEW BUSINESS RULES
    6. CREATE A STUDENT
    7. SERVICE LAYER METHODS FOR GETTING STUDENTS
    8. SUMMARY
    9. Lesson 29: Pulling It All Together: Coding the Class Roster Service Layer
    10. CREATE A SERVICE LAYER INTERFACE
    11. CREATE NEW EXCEPTIONS
    12. CREATE THE SERVICE LAYER IMPLEMENTATION
    13. MODIFY THE CONTROLLER
    14. MODIFY THE APP
    15. ADD THE AUDIT LOG FEATURE
    16. SUMMARY
    17. Lesson 30: Doing Unit Testing
    18. UNIT TESTING
    19. TYPES OF UNIT TESTING
    20. JUnit
    21. GIVEN/WHEN/THEN
    22. STATELESS UNIT TESTING
    23. IMPLEMENTING UNIT TESTS
    24. SUMMARY
    25. Lesson 31: Testing Stateful Code
    26. UNIT TESTING STATEFUL CODE
    27. SEPARATING PRODUCTION AND TEST DATA
    28. CLASS ROSTER DAO TEST DESIGN
    29. UNIT TESTING THE SERVICE LAYER
    30. SUMMARY
    31. EXERCISES
    32. Lesson 32: Including Magic Numbers and Enums
    33. MAGIC NUMBERS
    34. ENUMS
    35. ENUM MEMBERS
    36. SUMMARY
    37. EXERCISES
    38. Lesson 33: Manipulating Dates and Times
    39. ISO CALENDAR
    40. HUMAN TIME AND MACHINE TIME
    41. LOCAL AND ZONED CLASSES
    42. PERIODS AND DURATION
    43. WORKING WITH LocalDate OBJECTS
    44. GETTING THE TIME WITH LocalDateTime
    45. WORKING WITH DATE CALCULATIONS
    46. WORKING WITH LEGACY DATES
    47. SUMMARY
    48. EXERCISES
    49. Lesson 34: Using the BigDecimal Class
    50. EXPLORING BIGDECIMAL
    51. WORKING WITH BIGDECIMAL
    52. DOING CALCULATIONS WITH BigDecimals
    53. SUMMARY
    54. EXERCISES
    55. Lesson 35: Working with Lambdas and Streams
    56. USING AGGREGATE OPERATIONS
    57. UNDERSTANDING PIPELINES AND STREAMS
    58. STREAMS VS. ITERATION
    59. EXPLORING LAMBDAS
    60. WORKING WITH STREAM AND LAMBDA SYNTAX
    61. SUMMARY
    62. EXERCISES
  8. PART V: Advanced Java
    1. Lesson 36: Working with the Spring Framework
    2. DEPENDENCY INJECTION AND PROGRAMMING TO INTERFACES
    3. WHY SPRING?
    4. UNDERSTANDING THE SPRING APPROACH
    5. PULLING IT ALL TOGETHER: SPRING DI IN ACTION
    6. SUMMARY
    7. Lesson 37: Introducing Maven
    8. WHAT IS MAVEN?
    9. PROJECT OBJECT MODEL
    10. DEPENDENCY MANAGEMENT
    11. MAVEN LIFECYCLE
    12. SUMMARY
    13. Lesson 38: Pulling It All Together: Building the Class Roster with Spring
    14. INCLUDE THE SPRING LIBRARIES
    15. ADD SPRING CONFIGURATION FILES
    16. CONVERT THE APP CLASS TO USE SPRING
    17. CONVERT THE UNIT TESTS TO USE SPRING
    18. EXCEPTION CONDITIONS
    19. SUMMARY
    20. EXERCISES
  9. PART VI: Appendices
    1. Appendix A: Code Checklist
    2. FUNCTIONALITY
    3. STYLE
    4. Appendix B: Java Concepts Study List
    5. VARIABLES
    6. METHODS
    7. ARRAYS
    8. MAKING DECISIONS
    9. LOOPS
    10. JAVA/JVM
    11. OBJECTS
    12. INTERFACES
    13. INHERITANCE
    14. N-TIER DESIGN
    15. COLLECTIONS
    16. EXCEPTIONS
    17. LAMBDAS/STREAMS
    18. SPRING CORE
    19. Appendix C: Agile Approach Checklist for Console CRUD Applications
    20. ASSUMPTIONS
    21. REQUIREMENT STEPS
    22. DESIGN STEPS
    23. CONSTRUCTION STEPS
  10. Index
  11. Copyright
  12. About the Authors
  13. About the Technical Writer
  14. About the Technical Editors
  15. Acknowledgments
  16. End User License Agreement
3.15.226.173