The Java Platform- Java Platforms
- Lifecycle of a Java Program
- Responsibilities of JVM
- Documentation and Code Reuse
Using the JDK- Setting Up Environment
- Locating Class Files
- Compiling Package Classes
- Source and Class Files
- Java Applications
The Eclipse Paradigm- Workbench and Workspace
- Views
- Editors
- Perspectives
- Projects
Writing a Simple Class- Classes in Java
- Class Modifiers and Types
- Class Instance Variables
- Primitives vs. Object References
- Creating Objects
Adding Methods to the Class- Passing Parameters into Methods
- Returning a Value from a Method
- Overloaded Methods
- Constructors
- Optimizing Constructor Usage
Language Statements- Operators
- Comparison and Logical Operators
- Looping
- Continue and Break Statements
- The switch Statement
- The for-each() Loop
Using Strings- Create an instance of the String class
- Test if two strings are equal
- Get the length of a string Parse a string for its token components
- Perform a case-insensitive equality test
- Build up a string using StringBuffer
- Contrast String, StringBuffer, and StringBuilder
Specializing in a Subclass- Extending a Class
- Casting
- The Object Class
- Default Constructor
- Implicit Constructor Chaining
Fields and Variables- Instance vs. Local Variables:
- Usage Differences
- Data Types
- Default Values
- Block Scoping Rules
- Final and Static Fields
- Static Methods
Using Arrays- Arrays
- Accessing the Array
- Multidimensional Arrays
- Copying Arrays
- Variable Arguments
Local-Variable Type Inference- Type inference
- Infering Types of Local Variables
- The var Reserved Type name
- Benefits of Using var
- Backward Compatibility
Java Packages and Visibility- Class Location of Packages
- The Package Keyword
- Importing Classes
- Executing Programs
- Visibility in the Modular System
- Java Naming Conventions
Inheritance and Polymorphism- Polymorphism: The Subclasses
- Upcasting vs. Downcasting
- Calling Superclass Methods from Subclass
- The final Keyword
Interfaces and Abstract Classes- Separating Capability from Implementation
- Abstract Classes
- Implementing an Interface
- Abstract Classes vs. Interfaces
Introduction to Exception Handling- Exception Architecture
- Throwing Exceptions
- Checked vs. Unchecked Exceptions
Exceptions- Handling Multiple Exceptions
- Automatic Closure of Resources
- Creating Your Own Exceptions
Utility Classes- Wrapper Classes
- Autoboxing/Unboxing
- Enumeration Syntax
- Using Static imports
Introduction to Generics- Generics and Subtyping
- Bounded Wildcards
- Generic Methods
- Legacy Calls to Generics
- When Generics Should Be Used
Lambda Expressions and Functional Interface- Lambda Expression Syntax
- Functional Interfaces
- Type Inference in Java 8
- Method references
Collections- Characterizing Collections
- Collection Interface Hierarchy
- The Set, List and Queue Interfaces
- Map Interfaces
Using Collections- Collection Sorting
- Comparators
- Using the Right Collection
- Lambda expressions in Collections
Streams- Processing Collections of data
- The Stream interface
- Reduction and Parallelism
- Filtering collection data
- Sorting Collection data
- Map collection data
- Find elements in Stream
- Numeric Streams
- Create infinite Streams
- Sources for using Streams
Collectors- Creating Collections from a Stream
- Group elements in the Stream
- Multi-level grouping of elements
- Partitioning Streams
Introduction to the Module System- Introduce Project Jigsaw
- Classpath and Encapsulation
- The JDK internal APIs
- Java 9 Platform modules
- Defining application modules
- Define module dependencies
- Implicit dependencies
- Implied Readability
- Exporting packages
Java Date/Time- The Date and Calendar classes
- Introduce the new Date/Time API
- LocalDate, LocalDateTime, etc.
- Formatting Dates
- Working with time zones
- Manipulate date/time values
Java 12 and beyond- Provide an overview of changes since Java 11
- Introduce Preview Features
- Records (Java 14)
- Switch Expressions (Java 12, Java 13, Java 14)
- Text Blocks (Java 13, Java 14)
- Helpful NullPointerExceptions (Java 14)
- Pattern Matching for instanceof (Java 14)
, 1. The Java Platform
¢ Introduce the Java Platform
¢ Explore the Java Standard Edition
¢ Discuss the lifecycle of a Java Program
¢ Explain the responsibilities of the JVM
¢ Executing Java programs
¢ Garbage Collection
¢ Documentation and Code Reuse
2. Using the JDK
¢ Explain the JDK's file structure
¢ Use the command line compiler to compile a Java class
¢ Use the command line Java interpreter to run a Java application class
3. Using the IntelliJ IDE
¢ Introduce the IntelliJ IDE
¢ The Basics of the IntelliJ interface
¢ IntelliJ Projects and Modules
¢ Creating and running Java applications
¢ Tutorial: Exploring your IDE ( with IntelliJ 2023.2 (Community Edition) or Eclipse IDE
4. Writing a Simple Class
¢ Write a Java class that does not explicitly extend another class
¢ Define instance variables for a Java class
¢ Create object instances
¢ Primitives vs Object References
¢ Implement a main method to create an instance of the defined class
¢ Java keywords and reserved words
5. Adding Methods to the Class
¢ Write a class with accessor methods to read and write instance variables
¢ Write a constructor to initialize an instance with data
¢ Write a constructor that calls other constructors of the class to benefit from code reuse
¢ Use the this keyword to distinguish local variables from instance variables
6. Language Statements
¢ Arithmetic operators
¢ Operators to increment and decrement numbers
¢ Comparison operators
¢ Logical operators
¢ Return type of comparison and logical operators
¢ Use for loops
¢ Switch Expressions
¢ Switch Expressions and yield
7. Using Strings and Text Blocks
¢ Create an instance of the String class
¢ Test if two strings are equal
¢ Perform a case-insensitive equality test
¢ Contrast String, and StringBuilder
¢ Compact Strings
¢ Text Blocks
¢ Unicode support
¢ Lab: Fun with Strings
¢ Lab: Using StringBuffers and StringBuilders
8. Fields and Variables
¢ Discuss Block Scoping Rules
¢ Distinguish between instance variables and method variables within a method
¢ Explain the difference between the terms field and variable
¢ List the default values for instance variables
¢ Final and Static fields and methods
9. Specializing in a Subclass
¢ Constructing a class that extends another class
¢ Implementing equals and toString
¢ Writing constructors that pass initialization data to parent constructor
¢ Using instanceof to verify type of an object reference
¢ Overriding subclass methods
¢ Pattern matching for instanceof
¢ Safely casting references to a more refined type
10. Using Arrays
¢ Declaring an array reference
¢ Allocating an array
¢ Initializing the entries in an array
¢ Writing methods with a variable number of arguments
11. Records
¢ Data objects in Java
¢ Introduce records as carrier of immutable data
¢ Defining records
¢ The Canonical constructor
¢ Compact constructors
12. Java Packages and Visibility
¢ Use the package keyword to define a class within a specific package
¢ Discuss levels of accessibility/visibility
¢ Using the import keyword to declare references to classes in a specific package
¢ Using the standard type naming conventions
¢ Introduce the Java Modular System
¢ Visibility in the Java Modular System
13. Utility Classes
¢ Introduce the wrapper classes
¢ Explain Autoboxing and Unboxing
¢ Converting String representations of primitive numbers into their primitive types
¢ Defining Enumerations
¢ Using static imports
¢ Introduce the Date/Time API
¢ LocalDate / LocalDateTime etc.
¢ Apply text formatting
¢ Using System.out.printf
14. Inheritance and Polymorphism
¢ Write a subclass with a method that overrides a method in the superclass
¢ Group objects by their common supertype
¢ Utilize polymorphism
¢ Cast a supertype reference to a valid subtype reference
¢ Use the final keyword on methods and classes to prevent overriding
15. Interfaces and Abstract Classes
¢ Define supertype contracts using abstract classes
¢ Implement concrete classes based on abstract classes
¢ Define supertype contracts using interfaces
¢ Implement concrete classes based on interfaces
¢ Explain advantage of interfaces over abstract classes
¢ Explain advantage of abstract classes over interfaces
16. Sealed Classes
¢ Introduce sealed classes
¢ The sealed and permits modifier
¢ Sealed interfaces
¢ Sealed classes and pattern matching
17. Pattern Matching
¢ Pattern Matching in switch statements
¢ Pattern Matching and sealed classes
¢ Record Patterns
18. Introduction to Exception Handling
¢ Introduce the Exception architecture
¢ Defining a try/catch blocks
¢ Checked vs Unchecked exceptions
19. Exceptions
¢ Defining your own application exceptions
¢ Automatic closure of resources
¢ Suppressed exceptions
¢ Handling multiple exceptions in one catch
¢ Enhanced try-with-resources
¢ Helpful NullPointerException(s)
20. Building Java Applications
¢ Explain the steps involved in building applications
¢ Define the build process
¢ Introduce build scripts
¢ Explain the standard folder layout
¢ Resolving project dependencies
¢ Tutorial: Importing code Using Maven
21. Introduction to Generics
¢ Generics and Subtyping
¢ Bounded Wildcards
¢ Generic Methods
22. Introducing Lambda Expressions and Functional Interfaces
¢ Understanding the concept of functional programming
¢ Understanding functional interfaces
¢ Lambda's and type inference
23. Collections
¢ Provide an overview of the Collection API
¢ Review the different collection implementations (Set, List and Queue)
¢ Explore how generics are used with collections
¢ Examine iterators for working with collections
24. Using Collections
¢ Collection Sorting
¢ Comparators
¢ Using the Right Collection
¢ Lambda expressions in Collections
¢ Sequenced Collections
Bonus Topics / Time Permitting
Streams
¢ Understanding the problem with collections in Java
¢ Thinking of program solutions in a declarative way
¢ Use the Stream API to process collections of data
¢ Understand the difference between intermediate and terminal stream operations
¢ Filtering elements from a Stream
¢ Finding element(s) within a Stream
¢ Collecting the elements from a Stream into a List
Collectors
¢ Using different ways to collect the items from a Stream
¢ Grouping elements within a stream
¢ Gathering statistics about numeric property of elements in a stream
Download Overview