Beginner Java Programming Training Course | Code College


Beginner Java Programming Training Course

  • Learn the fundamentals of the Java programming language and prepare for the international exam : Part 1 of OCP Java 17 - 1Z0-829 Java Developer.
  • The course can be easily adapted for Java 11 - please enquire.



Duration

  • Full-time:
  • 5 Days (08h00-17h00, including an hour breaks) or
  • 10 Half-days(08h00-12h30, including 30 minute breaks)

What do I need?

  • Webinar : A laptop, and a stable internet connection. The recommended minimum speed is around 10 Mbps.
  • Classroom Training : A laptop, please notify us if you are not bringing your own laptop. Please see the calendar below for the schedule

Certification

  • Attendance : If you have attended 80% of the sessions and completed all the class work, you qualify for the Attendance Certificate. (Course Price : R14 500)
  • Competency : Only offered as part of a Coding Bootcamp

Alignment

  • Java Certified Foundations Associate 1Z0-811
  • Part 1 of OCP Java 17 - 1Z0-829 Java Developer
  • Exams are not included and has to be written at an international exam center or at home administered by remote proctoring

Delivery

  • Onsite (Woodmead Classroom) or your location (depending on the size of the group
  • Online (Discord Webinar)

Pre-requisites

Who will benefit

  • Any programmer at the right level that wants to start learning Java the right way
  • Any programmer with a goal to learn Java and prepare for the Java OCP Certification Exam
  • This course is a pre-requisite for the Java Advanced OCP Training Course

What you will learn

  • Use Java programming language constructs to create a Java technology application.
  • Use decision and looping constructs and methods to dictate program flow.
  • Understand basic object oriented concepts such as inheritance, encapsulation, and abstraction.
  • Use and manipulate object references, and to write simple error handling code.
  • Understand records, sealed classes, text blocks, dates, streams, controlling program flow, using the Java objectoriented approach, handling exceptions, working with arrays
  • This course constitutes the core subject portion of the corresponding module in the Java Bootcamp

Further Training

Content



Day 1

Building Blocks

  • Learning about the Environment
    • Major Components of Java
  • Downloading a JDK
  • Understanding the Class Structure
  • Fields and Methods
  • Comments
  • Classes and Source Files
  • Writing a main() Method
  • Creating a main() Method
  • Passing Parameters to a Java Program
  • Understanding Package Declarations and Imports
  • Packages
  • Wildcards
  • Redundant Imports
  • Naming Conflicts
  • Creating a New Package
  • Compiling and Running Code with Packages
  • Compiling to Another Directory
  • Compiling with JAR Files
  • Creating a JAR File
  • Ordering Elements in a Class
  • Creating Objects
  • Calling Constructors
  • Reading and Writing Member Fields
  • Executing Instance Initializer Blocks
  • Following the Order of Initialization
  • Understanding Data Types
  • Using Primitive Types
  • Using Reference Types
  • Distinguishing between Primitives and Reference Types
  • Creating Wrapper Classes
  • Defining Text Blocks
  • Declaring Variables
  • Identifying Identifiers
  • Declaring Multiple Variables
  • Initializing Variables
  • Creating Local Variables
  • Passing Constructor and Method Parameters
  • Defining Instance and Class Variables
  • Inferring the Type with var
  • Managing Variable Scope
  • Limiting Scope
  • Tracing Scope
  • Applying Scope to Classes
  • Reviewing Scope
  • Destroying Objects
  • Understanding Garbage Collection
  • Tracing Eligibility

Operators

  • Understanding Java Operators
  • Types of Operators
  • Operator Precedence
  • Applying Unary Operators
  • Complement and Negation Operators
  • Increment and Decrement Operators
  • Working with Binary Arithmetic Operators
  • Arithmetic Operators
  • Numeric Promotion
  • Assigning Values
  • Assignment Operator
  • Casting Values
  • Compound Assignment Operators
  • Return Value of Assignment Operators
  • Comparing Values
  • Equality Operators
  • Relational Operators
  • Logical Operators
  • Conditional Operators
  • Making Decisions with the Ternary Operator

Day 2

Making Decisions

  • Creating Decision- Making Statements
  • Statements and Blocks
  • The if Statement
  • The else Statement
  • Shortening Code with Pattern Matching
  • Applying switch Statements
  • The switch Statement
  • The switch Expression
  • Writing while Loops
  • The while Statement
  • The do/while Statement
  • Infinite Loops
  • Constructing for Loops
  • The for Loop
  • The for- each Loop
  • Controlling Flow with Branching
  • Nested Loops
  • Adding Optional Labels
  • The break Statement
  • The continue Statement
  • The return Statement
  • Unreachable Code
  • Reviewing Branching

Core API's

  • Creating and Manipulating Strings
  • Concatenating
  • Important String Methods
  • Method Chaining
  • Using the StringBuilder Class
  • Mutability and Chaining
  • Creating a StringBuilder
  • Important StringBuilder Methods
  • Understanding Equality
  • Comparing equals() and ==
  • The String Pool
  • Understanding Arrays
  • Creating an Array of Primitives
  • Creating an Array with Reference Variables
  • Using an Array
  • Sorting
  • Searching
  • Comparing
  • Using Methods with Varargs
  • Working with Multidimensional Arrays
  • Calculating with Math APIs
  • Finding the Minimum and Maximum
  • Rounding Numbers
  • Determining the Ceiling and Floor
  • Calculating Exponents
  • Generating Random Numbers
  • Working with Dates and Times
  • Creating Dates and Times
  • Manipulating Dates and Times
  • Working with Periods
  • Working with Durations
  • Period vs. Duration
  • Working with Instants
  • Accounting for Daylight Saving Time

Day 3

Methods

  • Designing Methods
  • Access Modifiers
  • Optional Specifiers
  • Return Type
  • Method Name
  • Parameter List
  • Method Signature
  • Exception List
  • Method Body
  • Declaring Local and Instance Variables
  • Local Variable Modifiers
  • Effectively Final Variables
  • Instance Variable Modifiers
  • Working with Varargs
  • Creating Methods with Varargs
  • Calling Methods with Varargs
  • Accessing Elements of a Vararg
  • Using Varargs with Other Method Parameters
  • Applying Access Modifiers
  • Private Access
  • Package Access
  • Protected Access
  • Public Access
  • Reviewing Access Modifiers
  • Accessing static Data
  • Designing static Methods and Variables
  • Accessing a static Variable or Method
  • Class vs. Instance Membership
  • Static Variable Modifiers
  • Static Initializers
  • Static Imports
  • Passing Data among Methods
  • Passing Objects
  • Returning Objects
  • Autoboxing and Unboxing Variables
  • Overloading Methods
  • Reference Types
  • Primitives
  • Autoboxing
  • Arrays
  • Varargs

Class Design

  • Understanding Inheritance
  • Declaring a Subclass
  • Class Modifiers
  • Single vs. Multiple Inheritance
  • Inheriting Object
  • Creating Classes
  • Extending a Class
  • Applying Class Access Modifiers
  • Accessing the this Reference
  • Calling the super Reference
  • Declaring Constructors
  • Creating a Constructor
  • The Default Constructor
  • Calling Overloaded Constructors with this()
  • Calling Parent Constructors with super()
  • Initializing Objects
  • Initializing Classes
  • Initializing final Fields
  • Initializing Instances
  • Inheriting Members
  • Overriding a Method
  • Redeclaring private Methods
  • Hiding Static Methods
  • Hiding Variables
  • Writing final Methods
  • Creating Abstract Classes
  • Introducing Abstract Classes
  • Declaring Abstract Methods
  • Creating a Concrete Class
  • Creating Constructors in Abstract Classes
  • Spotting Invalid Declarations
  • Creating Immutable Objects
  • Declaring an Immutable Class
  • Performing a Defensive Copy

Day 4

Beyond Classes

  • Implementing Interfaces
  • Declaring and Using an Interface
  • Extending an Interface
  • Inheriting an Interface
  • Inserting Implicit Modifiers
  • Declaring Concrete Interface Methods
  • Working with Enums
  • Creating Simple Enums
  • Using Enums in switch Statements
  • Adding Constructors, Fields, and Methods
  • Sealing Classes
  • Declaring a Sealed Class
  • Compiling Sealed Classes
  • Specifying the Subclass Modifier
  • Omitting the permits Clause
  • Sealing Interfaces
  • Reviewing Sealed Class Rules
  • Encapsulating Data with Records
  • Understanding Encapsulation
  • Applying Records
  • Understanding Record Immutability
  • Declaring Constructors
  • Customizing Records
  • Creating Nested Classes
  • Declaring an Inner Class
  • Creating a static Nested Class
  • Writing a Local Class
  • Defining an Anonymous Class
  • Reviewing Nested Classes
  • Understanding Polymorphism
  • Object vs. Reference
  • asting Objects
  • The instanceof Operator
  • Polymorphism and Method Overriding
  • Overriding vs. Hiding Members

Lambdas and Functional Interfaces

  • Writing Simple Lambdas
  • Looking at a Lambda Example
  • Learning Lambda Syntax
  • Coding Functional Interfaces
  • Defining a Functional Interface
  • Adding Object Methods
  • Using Method References
  • Calling static Methods
  • Calling Instance Methods on a Particular Object
  • Calling Instance Methods on a Parameter
  • Calling Constructors
  • Reviewing Method References
  • Working with Built- in Functional Interfaces
  • Implementing Supplier
  • Implementing Consumer and BiConsumer
  • Implementing Predicate and BiPredicate
  • Implementing Function and BiFunction
  • Implementing UnaryOperator and BinaryOperator
  • Checking Functional Interfaces
  • Using Convenience Methods on Functional Interfaces
  • Learning the Functional Interfaces for Primitives
  • Working with Variables in Lambdas
  • Listing Parameters
  • Using Local Variables inside a Lambda Body
  • Referencing Variables from the Lambda Body

Day 5

Mock Exams

  • Mock Exams

Calendar