Java Novice to Javanista E-Learning

Java is one of the most in-demand programming languages in the world and one of the two official programming languages used in Android development. Though Java is a pure object-oriented language, it has developed into a multi-paradigm language making it highly compliant to any situation. Developers familiar with Java can build a wide range of applications, games, and tools.

If you are new to Java development, you may be a little apprehensive - how easy is Java to learn? This learning journey helps you get started with Java and it will take you all the way to becoming an accomplished Java developer. In this Journey, you will begin by exploring the roots and the significant features of Java and you will get a solid foundation with step-by-step hands-on code examples using JShell. In the second track, you will take a deep dive into the advanced features of Java - like exception handling, Generics, Lambdas, and Reflection.

The second track concludes with a focus on building jar files for Java Libraries. In the final track you will learn database connectivity with Java as well as how to build web applications and web services in Java.
In short, you will learn to write Java programs from scratch and become a confident Java developer.

Learning Kits are structured learning paths, mainly within the Emerging Tech area. A Learning Kit keeps
the student working toward an overall goal, helping them to achieve your career aspirations. Each part takes the student step by step through a diverse set of topic areas. Learning Kits are
made up of required tracks, which contain all of the learning resources available such as Assessments (Final Exams), Mentor, Practice Labs and of course E learning. And all resources with a 365 days access from first activation.

Course content

This learning path, with more than 70 hours of online content, is divided into the following tracks:
Track 1: Java Novice
Track 2: Java Apprentice
Track 3: Javanista

Track 1: Java Novice

In this track, the focus will be on Java fundamentals, control structures, modeling entities, mapping relationships, and interactive Java & JShell.

Content:
E-learning courses

Getting Started with Java: The Fundamentals of Java Programming

Course: 54 Minutes

• Course Overview
• How Java Works
• Running Java Programs
• The JVM and the Java Ecosystem
• Properties of Java
• Java's Class Library and Garbage Collector
• Applications of Java
• Course Summary

Getting Started with Java: Writing & Running Java Programs

Course: 1 Hour, 7 Minutes

• Course Overview
• Installing Java and IntelliJ on Windows
• Installing Java and IntelliJ on macOS
• Creating an IntelliJ Project
• Writing and Running a Java Program
• Examining Java's Syntax
• Comments in Java Source Files
• Course Summary

Getting Started with Java: Variables & Primitive Types

Course: 1 Hour, 7 Minutes

• Course Overview
• Declaring Variables in Java
• Printing Strings with the format Method in Java
• Exploring Primitive Data Types in Java
• Working with Integers, Floats, and Doubles in Java
• Working with Byte, Short, and Char Types in Java
• Strings and Arrays in Java
• Course Summary

Getting Started with Java: Operators

Course: 1 Hour, 23 Minutes

• Course Overview
• Doing Math with Arithmetic Operators in Java
• Recognizing Assignment Operator Use in Java
• Applying Logical Operators in Java
• Using Comparison Operators in Java
• Identifying Operator Precedence in Java
• Performing String Operations in Java
• Null Values in Java
• Casting Data in Java
• Course Summary

Control Structures in Java: Implementing Java Control Structures

Course: 1 Hour, 44 Minutes

• Course Overview
• Implementing a Basic if Statement
• Illustrating the if-else Statement
• Using Multiple if Statements
• Demonstrating a Basic for Loop
• Using the switch Statement
• Demonstrating Different Types of for Loops
• Illustrating continue and break Statements
• Using the while Loop
• Running Java from the Shell
• Supplying Arguments to Java Programs
• Course Summary

Modeling Entities in Java: Getting Started with Classes & Objects

Course: 39 Minutes

• Course Overview
• Understanding Java Classes
• The Relationship between Classes and Objects
• Contrasting Static and Instance Variables
• Setting up a Java Project on IntelliJ
• Creating Objects of Classes
• Course Summary

Modeling Entities in Java: Defining Custom Classes & Objects

Course: 1 Hour, 30 Minutes

• Course Overview
• Instantiating Objects of Built-in Java Classes
• Creating Objects and Viewing Data
• Performing Operations on Objects in Java
• Working with Member Variables in Java
• Creating and Using Constructors in Java
• Initializing Fields with Constructors
• Using Private Fields
• Creating and Using Private Methods in Java
• Exploring Getter and Setter Methods
• Course Summary

Modeling Entities in Java: Methods, Method Overloading, & Constructors

Course: 1 Hour, 33 Minutes

• Course Overview
• Using Return Statements
• Using Getters and Setters
• Defining Multiple Functions Using Method Overloading
• Working with Method Overloading and Code Reuse
• Understanding and Using Default Constructors
• Initializing Fields in Constructors
• Creating Parameterized Constructors
• Overloading Constructors
• Using 'this' Keyword in Field Initializations
• Reusing Code through Constructor Chaining
• Course Summary

Modeling Entities in Java: Static Members, Arguments, & Method Overriding

Course: 2 Hours, 1 Minute

• Course Overview
• Accessing Static Variables
• Using Static Variables and the final Keyword
• Working with Static and Instance Methods and Fields
• Using a Static Field for Auto-counting Objects
• Using a Class Reference to Invoke Static Methods
• Exploring Field Reassignments
• Understanding Pass-by-Value and Pass-by-Reference
• Pass-by-value/Pass-by-reference with Custom Objects
• Checking Object Equality with == and .equals()
• Understanding the HashCode Contract
• Overriding the .equals() Method
• Overriding the .hashCode() Method
• Course Summary

Mapping Relationships in Java: Modeling Is-a Relationships Using Inheritance

Course: 1 Hour, 40 Minutes

• Course Overview
• Accessing Static Variables
• Using Static Variables and the final Keyword
• Working with Static and Instance Methods and Fields
• Using a Static Field for Auto-counting Objects
• Using a Class Reference to Invoke Static Methods
• Exploring Field Reassignments
• Understanding Pass-by-Value and Pass-by-Reference
• Pass-by-value/Pass-by-reference with Custom Objects
• Checking Object Equality with == and .equals()
• Understanding the HashCode Contract
• Overriding the .equals() Method
• Overriding the .hashCode() Method
• Course Summary

Mapping Relationships in Java: Constructors & Polymorphism

Course: 1 Hour, 56 Minutes

• Course Overview
• Examining the Default, No-argument Constructor
• Using the Super Keyword
• Invoking Base Class Constructors via Derived Classes
• Investigating Nuances of Derived Class Constructors
• Reusing Constructors Using super() and this()
• Characterizing Runtime Polymorphism
• Invoking Methods Based on Runtime Types
• Understanding Dynamic Method Dispatch
• Investigating Compile-time Polymorphism
• Overloading Methods with Compile-time Polymorphism
• Invoking the Right Overloaded Method
• Performing Type Promotion and Coercion
• Course Summary

Mapping Relationships in Java: Overriding Methods and Using Access Modifiers

Course: 2 Hours, 1 Minute

• Course Overview
• Overriding Methods in Derived Classes
• Invoking Base Class Methods Using super()
• Identifying Method Hiding
• Using the Final Modifier with Fields
• Using the Final Modifier with Methods and Classes
• Characterizing Abstract Classes
• Using Abstract Classes in Inheritance Hierarchies
• Using the Private Access Modifier
• Using the Public and Private Modifiers
• Using Factory Methods to Instantiate Objects
• Using the Protected Access Modifier
• Investigating Protected Access Modifier Nuances
• Using the Default Access Modifier
• Course Summary

Mapping Relationships in Java: Working with Interfaces & Class Loaders

Course: 1 Hour, 46 Minutes

• Course Overview
• Characterizing Interfaces and Interface Methods
• Implementing Interface Methods
• Creating Fields in Interfaces
• Enforcing Method Implementations for Interfaces
• Specifying Interface Method Default Implementations
• Defining Variables of Interface Types
• Identifying Class Loader Use Cases and Hierarchy
• Using Class Loaders
• Manually Loading Classes
• Creating Custom Class Loaders
• Loading Classes Using a Custom Class Loader
• Course Summary

Interactive Java & JShell: Writing Java Programs with the Interactive JShell

Course: 1 Hour, 57 Minutes

• Course Overview
• Running Commands and Snippets on JShell
• Defining and Calling Functions in JShell
• Defining Functions Referencing External Variables
• Adjusting Feedback Modes in JShell
• Using the Auto-complete Feature in JShell
• Working with Different JShell Features
• Working with User-defined Types in JShell
• Updating User-defined Types in JShell
• Loading Data from a File into JShell
• Writing Data to a File Using JShell
• Building and Running JShell Scripts
• Course Summary

Final Exam assessment
Estimated duration: 90 minutes.

Track 2: Java Apprentice

In this track, the focus will be on handling errors, arrays and the Java collection framework, nested classes and lambda expressions, reflection for runtime inspections, and building Jar files.

Content:
E-learning courses

Handling Errors: An Introduction to Exceptions

Course: 54 Minutes

• Course Overview
• Exceptions in Java
• The Java Exception Stack
• Identifying Compile Errors in Java
• Defining Unchecked Exceptions in Java
• Working with Checked Exceptions in Java
• Course Summary

Handling Errors: Handling Exceptions in Java

Course: 1 Hour, 10 Minutes

• Course Overview
• Getting familiar with Exceptions and Program Flow
• Handling Java Exceptions
• Tackling Multiple Exceptions in Java
• Using the finally Block in Java
• Working with the throws Keyword in Java
• Implementing the try-with-resource Block in Java
• Course Summary

Handling Errors: Advanced Topics in Exceptions

Course: 44 Minutes

• Course Overview
• Throwing Exceptions Proactively
• Throwing Multiple Exceptions
• Chaining Exceptions
• Defining Custom Exceptions and Errors
• Course Summary

Collections in Java: Arrays & Non-parameterized ArrayLists

Course: 1 Hour, 18 Minutes

• Course Overview
• Creating Arrays of Primitive Types and Objects
• Examining Fixed-length Characteristics of Arrays
• Iterating over Arrays Using For Loops
• Working with Arrays as Collection Containers
• Using Multidimensional and Jagged Arrays
• Working with Non-parameterized Collections
• Accessing Elements in Non-parameterized Collections
• Course Summary

Collections in Java: Lists & List Operations

Course: 42 Minutes

• Course Overview
• Creating and Using Parameterized Lists
• Comparing Parameterized and Non-parameterized Lists
• Performing Collection Operations
• Working with List Operations
• Working with Iterator Operations
• Course Summary

Collections in Java: Sets & Maps

Course: 1 Hour, 39 Minutes

• Course Overview
• Conducting Set Operations
• Identifying Duplicates in a HashSet
• Ordering Elements in Set Implementations
• Using Comparators in Tree Sets
• Using Comparables and Comparators in Tree Sets
• Carrying Out Map Operations
• Working with Collection Views on a Map
• Using Custom Objects as Keys and Values
• Ordering Entries in Map Implementations
• Implementing an LRU Cache Using LinkedHashMap
• Using TreeMaps and Comparators
• Using TreeMaps and Comparables
• Performing Sorted Map Operations
• Course Summary

Generics in Java: Creating Classes and Methods Using Generics

Course: 1 Hour, 40 Minutes

• Course Overview
• Recognizing Generic and Environment Setup Advantages
• Identifying Non-generic Code Reuse Limitations
• Using Raw Objects to Store Data: The Limitations
• Implementing Classes with Generic Type Parameters
• Using Generic Types for Parameters and Return Types
• Constructing Raw Objects from Generic Classes
• Identifying the Limitations of Non-generic Methods
• Parameterizing Classes to Call Parameterized Methods
• Using Parameterized Methods
• Identifying Type Inference for Parameterized Methods
• Course Summary

Generics in Java: Bounded Type Parameters & Wildcards

Course: 1 Hour, 58 Minutes

• Course Overview
• Recognizing Unbounded Type Parameter Disadvantages
• Specifying Bounded Type Parameters
• Defining Classes with Bounded Type Parameters
• Using Bounded Types with Custom Objects
• Using Multiple Bound Specification for Bounded Types
• Constraining Types Using Upper-bounded Wildcards
• Comparing Bounded Types and Upper-bounded Wildcards
• Using Unconstrained Variables & Unbounded Wildcards
• Using Unbounded Wildcards in Class Objects
• Constraining Types Using Lower-bounded Wildcards
• Recognizing Java's Use of Wildcard Capture
• Identifying Valid and Invalid Type Parameter Names
• Recognizing Java Compiler's Use of Type Erasure
• Course Summary

Classes in Java: Working with Static Nested, Inner, & Local Classes

Course: 1 Hour, 49 Minutes

• Course Overview
• Working with Static Nested Classes in Java
• Instantiating Static Nested Classes in Java
• Using Multiple Nested Classes within an Outer Class
• Navigating the Drawbacks of Static Nested Classes
• Using and Characterizing Inner Classes in Java
• Accessing Variables from Inner Classes in Java
• Working with Iterators Implemented as an Inner Class
• Using and Characterizing Local Classes in Java
• Accessing Final and Local Fields from Outer Classes
• Using Access Modifiers and Scopes for Local Classes
• Using Local Classes Defined in Initialization Blocks
• Course Summary

Classes in Java: Creating & Using Anonymous Classes

Course: 1 Hour

• Course Overview
• Using Anonymous Classes in Java
• Defining Why Anonymous Class Instances Are Objects
• Exploring Nuances of Anonymous Classes in Java
• Implementing Interfaces with Anonymous Classes in Java
• Using Local and Anonymous Classes to Filter Data in Java
• Course Summary

Classes in Java: Implementing Functional Interfaces Using Lambdas

Course: 1 Hour, 29 Minutes

• Course Overview
• Introducing Lambda Expressions
• Creating Lambda Statements and Lambda Expressions
• Implementing Functional Interfaces Using Lambdas
• Implementing Generic Interfaces Using Lambdas
• Using the @FunctionalInterface Annotation
• Exploring Nuances of Functional Interfaces
• Predicate, Consumer, Function, and Supplier
• Method References: Static and Instance Methods
• Method References: Type Methods and Constructors
• Course Summary

Java: Getting Started with Reflection

Course: 1 Hour, 56 Minutes

• Course Overview
• Creating an IntelliJ Project
• Creating Classes and Instantiating Objects
• Extracting Class Information from Objects
• Viewing Class Fields, Methods, and Their Modifiers
• Examining Class Objects for Different Data Types
• Identifying Classes Using Objects
• Viewing Fully Qualified Class Names
• Creating Class Handles from Class Names
• Viewing Modifiers of Class Members
• Anonymous, Local, Member Classes, and Interfaces
• Identifying Enums, Arrays, and Primitives
• Viewing Class Package, Superclass, Declaring Class
• Course Summary

Java: Accessing Constructors, Methods, & Fields Using Reflection

Course: 1 Hour, 39 Minutes

• Course Overview
• Accessing Constructors Using Reflection
• Creating Objects Using Constructor Handles
• Accessing Field Metadata
• Getting and Setting Field Values
• Accessing and Updating Private and Protected Fields
• Accessing Public, Private, and Protected Methods
• Viewing Method Parameters, Annotations, and More
• Accessing Annotations on Methods
• Recognizing Annotation Runtime Policy Implications
• Identifying Getters and Setters Using Heuristics
• Invoking Functions Using Reflection
• Course Summary

Java: Working with Annotations, Generics, & Arrays Using Reflection

Course: 1 Hour, 27 Minutes

• Course Overview
• Accessing Annotations on Fields and Methods
• Configuring Custom Annotations for Reflective Access
• Scenario: Accessing Annotations to Perform Checks
• Scenario: Checking Objects for Validity
• Using Reflection with Generics Classes and Methods
• Exploring Limitations of Reflection and Generics
• Working with Arrays Using Reflection
• Exploring Array Types and Component Types
• Course Summary

Java: Leveraging Reflection to Build Dynamic Proxies & Unit Tests

Course: 55 Minutes

• Course Overview
• Working with Dynamic Proxies
• Invoking Interface and Object Functions on Proxies
• Constructing Proxies to Pass Method Invocations
• Creating Annotations for a Unit Testing Framework
• Using Annotations to Write Test Cases
• Running Test Cases Using a Custom Test Harness
• Course Summary

Java Archive (JAR): Building Java Archives

Course: 1 Hour, 40 Minutes

• Course Overview
• Creating the Contents of a JAR File
• Building and Running an Executable JAR
• Viewing the Contents of a JAR File
• Creating a JAR without an Input Manifest
• Defining a Detailed Manifest File
• Adding Dependencies to a Project
• Building a JAR File with Dependencies
• Constructing JAR Files with Multiple Main Classes
• Creating JARs with Multiple Packages
• Using JAR Files as an External Library
• Course Summary

Java Archive (JAR): Packaging Java Apps Using Maven

Course: 1 Hour, 29 Minutes

• Course Overview
• Installing and Configuring Maven
• Creating a Maven Project
• Building a JAR File with Maven
• Running and Examining a JAR File
• Building a JAR File with Dependencies
• Examining the Local Maven Repository
• Building an Uber JAR Using the Maven Assembly Plugin
• Exploring JARs with Dependencies
• Building an Uber JAR Using the Maven Shade Plugin
• Course Summary

Final Exam assessment
Estimated duration: 90 minutes.

Track 3: Javanista

In this track, the focus will be on object serialization and JSON parsing, HTTP requests, connecting to and querying databases with JDBC, building web applications with JSP, and building web services.

Content:
E-learning collections

Serialization in Java: Getting Started with Object Serialization

Course: 1 Hour, 25 Minutes

• Course Overview
• Setting up the Environment
• Exploring Serialization and Deserialization
• Serializing and Deserializing Custom Objects
• Understanding serialVersionUID
• Changing Serializable Class Definitions
• Using Transient Fields
• Serializing Nested Object References
• Sending Serialized Data over Sockets
• Using the Externalizable Interface
• Course Summary

Serialization in Java: Using JSON Simple for Serialization & Parsing

Course: 1 Hour, 17 Minutes

• Course Overview
• Understanding the JSON Structure
• Setting up an Apache Maven Project
• Writing and Reading JSON Objects
• Writing and Reading JSON Arrays
• Writing and Reading Complex JSON Structures
• Parsing Exceptions in JSON
• Parsing JSON Using the SAX Interface
• String Encoding and Stream Encoding
• Implementing JSONAware and JSONStreamAware
• Course Summary

Serialization in Java: Using JSON in Java for Serialization & Parsing

Course: 1 Hour, 18 Minutes

• Course Overview
• Serializing a JSON Object
• Reading and Writing JSON Objects
• Reading and Writing JSON Arrays
• Inserting Arrays into JSON Structures
• Tokenizing Strings
• Serializing Custom Classes to JSON
• Working with Nested Object Arrays
• Using @JSONPropertyName and @JSONPropertyIgnore
• Using the CDL Class to Parse Comma-delimited Values
• Parsing CSV Files and Converting to JSON Format
• Course Summary

HTTP Requests in Java: Sending Simple HTTP Requests

Course: 1 Hour, 19 Minutes

• Course Overview
• Creating an HTTP Client Project with Maven
• Sending a Simple GET Request
• Exploring the Response to a GET Request
• Processing JSON Data in a Response
• Sending Parameters in an HTTP Request
• HttpURLConnection and POST Requests
• PUT and DELETE Requests
• The HEAD Request
• Setting Timeouts with HttpURLConnection
• Course Summary

HTTP Requests in Java: HTTP Requests with Java's HttpClient

Course: 1 Hour, 17 Minutes

• Course Overview
• Sending GET Requests with HttpClient
• Handling HttpResponses
• Configuring Timeouts
• Handling Redirects
• Sending Asynchronous Requests
• Sending Multiple Asynchronous Requests
• Implementing POST, PUT, and DELETE Requests
• Course Summary

Java Database Connectivity (JDBC): An Introduction to JDBC

Course: 1 Hour, 30 Minutes

• Course Overview
• Installing MySQL Server and MySQL Workbench
• Creating a Maven Project
• Connecting to a Database Using JDBC
• Applying a DataSource Instance for Connections
• Running Queries with a Statement Object
• Processing Query Results with a ResultSet
• Parametrizing Queries with a PreparedStatement
• Executing Inserts with a PreparedStatement
• Updating and Deleting Queries Using JDBC
• Course Summary

Java Database Connectivity (JDBC): Interacting with Databases using RowSets

Course: 1 Hour, 38 Minutes

• Course Overview
• Using the Connected JdbcRowSet
• Exploring the Properties of a JdbcRowSet
• Navigating the Rows in a JdbcRowSet
• Picking Up Updates with a JdbcRowSet
• Updating Table Data with a JdbcRowSet
• Adding and Deleting Rows with a JdbcRowSet
• Using the Disconnected CachedRowSet
• Contrasting CachedRowSets and JdbcRowSets
• Updating Table Data with a CachedRowSet
• Inserting and Deleting with a CachedRowSet
• Course Summary

Java Database Connectivity (JDBC): Joining & Filtering Data with RowSets

Course: 1 Hour, 10 Minutes

• Course Overview
• Creating Tables for Join Operations
• Joining Tables with a JDBC JoinRowSet
• Exploring Join Types in a JoinRowSet
• Joining Three Tables with a JoinRowSet
• Defining a Filter with a Predicate
• Applying a Predicate on a FilteredRowSet
• Configuring Multiple Conditions in a FilteredRowSet
• Course Summary

Java Database Connectivity (JDBC): Batch Executions & Transactions with JDBC

ourse: 56 Minutes

• Course Overview
• Running Insert Queries in a Batch
• Parameterized Batch Inserts
• Errors in Batch Inserts
• Running Inserts in a Sequence
• Implementing a Transaction
• Using Savepoints in Transactions
• Applying Savepoints in Batch Operations
• Course Summary

Building Web Applications with JSP: An Introduction to JSP

Course: 1 Hour, 28 Minutes

• Course Overview
• Installing and Setting up Apache Maven
• Creating a Web Application Using Maven
• Downloading and Installing Apache Tomcat
• Packaging and Deploying a Web App
• Writing and Deploying a JSP App
• Declaring and Invoking Functions
• Accessing the request Object
• Exploring the WAR File
• Referencing Other JSP Pages
• Course Summary

Building Web Applications with JSP: Handling Errors

Course: 49 Minutes

• Course Overview
• Integrating an Error Page
• Using the JSP Expression Language
• Setting an Application-level Error Page
• Handling Exceptions with Java's try-catch Block
• Course Summary

Building Web Applications with JSP: Customizing Responses with Servlets

Course: 1 Hour, 21 Minutes

• Course Overview
• Building a Java Servlet
• Deploying and Testing a Servlet
• Processing Inputs in a Servlet
• Using the RequestDispatcher
• Forwarding a Request from a Servlet to a JSP Page
• Working with ServletConfig and ServletContext
• Setting Attributes at Different Scopes
• Retrieving Attributes from Different Scopes
• Course Summary

Building Web Applications with JSP: Integrating a JSP App with a Database

Course: 1 Hour, 42 Minutes

• Course Overview
• Downloading and Installing MySQL Server
• Creating and Populating a Database Table
• Connecting a JSP App to a SQL Database
• Testing a JSP App's Connectivity to the Database
• Working with a Model Class
• Retrieving Single and Multiple Rows from a Table
• Displaying Data Using JSTL
• Adding New Data to a SQL Table
• Working with jsp:useBean and jsp:setProperty Tags
• Updating a Database Table via a JSP App
• Deleting Rows from a Database Table
• Course Summary

Java Web Services: Getting Started with SOAP-based Web Services

Course: 1 Hour, 8 Minutes

• Course Overview
• Setting Up Apache Maven
• Configuring a Web Service Project
• Defining a Web Service
• Identifying WSDL File Properties
• Creating a Web Service Client
• Setting Up a Service Endpoint Interface
• Course Summary

Java Web Services: Integrating Web Services with a Database

Course: 1 Hour, 57 Minutes

• Course Overview
• Building a Book Store Project
• Defining Web Services That Return Java Objects
• Writing a Client App to Retrieve Java Objects
• Setting Up a Database for a Web Service
• Integrating a Web Service with a Database
• Web Methods with Parameters
• Adding Operations Using Web Services
• Deleting Operations with a Web Service
• Updating a Database with a Web Service
• Setting up Apache Tomcat
• Deploying the Web Services App to Tomcat
• Testing the Deployed Web Service
• Course Summary

Java Web Services: Building REST APIs

Course: 1 Hour, 7 Minutes

• Course Overview
• Configuring a RESTful Application
• Defining a REST API Method
• Testing the RESTful Application
• Building Responses to HTTP Requests
• Transmitting Java Objects Over HTTP
• Examining the JSON Version of Java Objects
• Course Summary

Java Web Services: Enabling CRUD Operations with REST APIs

Course: 1 Hour, 1 Minute

• Course Overview
• Integrating a RESTful App with a Database
• Submitting Parameters in a GET Request
• Processing POST Requests
• Handling PUT Requests
• Working with DELETE Requests
• Course Summary

Final Exam assessment
Estimated duration: 90 minutes.
Practice Labs: Javanista (estimated duration: 8 hours)
In this lab, the focus will be on object serialization and JSON parsing, HTTP requests, connecting to and querying databases with JDBC, building web applications with JSP, and building web services. The following exercises will be performed:

• implement serialization, deserialization, and externalizable interface
• implement JSON operations with Objects
• implement a simple HTTP request with Maven
• connect to a database using MySQL
• implement data joins with tables using Rowset in MySQL
• build a web application using JSP
• implementing a web service in JSP with MySQL database
• building a RESTful API-based application
• In the lab, you will have access to the following:
• Java (JDK14)
• Eclipse
• MySQL