Course Details
Full Stack Java Developer
Programming
Created On
July 01, 2023Description
Java is a versatile and widely adopted programming language renowned for its platform independence, strong typing, and robustness. Developed by Sun Microsystems (now owned by Oracle Corporation), Java debuted in 1995 and has since become one of the world's most favored programming languages. It boasts several key characteristics, including platform independence through bytecode execution, a pure object-oriented structure, rigorous type checking, built-in garbage collection for memory management, support for multithreading, an extensive standard library, robust security features, and a thriving developer community. Java's adaptability extends to a wide array of application domains, such as web development, mobile app development (notably for Android), desktop software, and enterprise-level applications, all while upholding a strong commitment to backward compatibility, ensuring the compatibility of older Java applications with newer language versions.
Overview
This Full Stack Java Developer course provides a comprehensive understanding of the skills needed to become a full-stack Java developer. Students learn core Java concepts, object-oriented programming, data structures, and algorithms. **They gain hands-on experience with popular Java development tools like IntelliJ IDEA, Eclipse, and NetBeans**. **The course covers front-end and back-end frameworks**, equipping students to build robust web applications from start to finish.
Features
- Blended Learning Experience with Live Online Instruction and Access to Pre-recorded Video Content
- Doubt clearing session.
- Internal Hiring
- Course Certification (Full stack)
- Lifetime Dashboard access
- Addressing Questions and Clarifications via Email and Online Discussion Platforms
- live project with real-time implementation
- Crafting a Professional Resume
- Guidance for Advancing Your Career
- Preparing for Job Interviews
- Ongoing Evaluation
- Mock Interview
- Course resources
- Practical exercises
- Course completion certification
- Quizzes & Assignments
What you'll learn
- Fundamentals of Programming: Code Foundations
- Database Connectivity in Java
- Java Web Development
- Spring Framework Fundamentals
- Rapid Application Development with Spring Boot
- Data Access with Spring JDBC
- Object-Relational Mapping with Spring
- Building Web Applications with Spring MVC
- RESTful Web Services with Spring
- Microservices Architecture and Tooling
- Containerization with Docker and Kubernetes
- Agile Development Methodologies
- Version Control with Git and Github
- HTML and CSS: Web Development Fundamentals: HTML and CSS
- Introduction to Javascript
- React.js: Building Web Applications with React.js
- Database Management with MySQL
- Introduction to NoSQL with MongoDB
Prerequisites
Curriculum
- 42 modules
Git Fundamentals
Setting, Maintaining, and Tracking Git Repos
Git : Managing Code Snapshots
Git for Team Management:
Git : Advanced Branching Strategies
Git Merging: Seamless Code Integration
Exploring the Git and Github Integration
Java Environment Setup
Eclipse IDE Installation
Visual Studio Code Setup
Introduction to Programming
Computing Basics
Core Java Features
Main method: Java's Entry Point
Object-Oriented Fundamentals
Statically typed vs. Dynamically typed Programming Language: Type System Comparison
Variables and Data type in Java
Naming Best Practices
Identifiers: Java Naming Entities
Demystifying Java Operators
Incrementation and Decrementation: Fine-tuning Variables
Conditional Statement: Decision Making in Java
Ternary Operator: Compact Conditional Expression
Switch Case: Multi-Way Decision Making
Loops Intro: Iteration Basics
for - while - do while: Exploring Looping Constructs
More on Loops: Advanced Iteration Techniques
Scanner Class and User Input in Java: Interactive Input Handling
Pattern Programs: Art of Design with Loops
Nested Loops: Looping within Looping
Building Java Objects
Instance Variable vs. Local Variables: Memory Allocation in Java
Methods with Memory Maps (JVM Data Areas): Under the Hood of Java Methods
Method Overloading: Polymorphism in Action
The Java Array Chronicles
Unraveling the Array Mystery
Array Unveiled
Array Creation Demystified
1D, 2D, 3D and Regular Array & Jagged Array with Memory Map: Array Dimensions Explored
Buffer Overrun and
Adventures in Array Bounds
The Dark Side of Arrays
Bubble Sort: The Bubbling World of Sorting
Selection Sort: Sorting Selections Made Easy
Merge Sort: Merging Paths to Sorted Arrays
Linear Search: Hunting for Values in Arrays
Binary Search: Binary Quest for Array Values
String Introduction
Types of String: The String Spectrum
The Immutable Charm of Strings
Ways to Compare and Memory Map String Constant Pool: String Equality Explored
Inbuilt Methods in String Class: Harnessing the String Arsenal
Concatenation: String Fusion Techniques
Mutable String: The Mutable Side of Strings
String Buffer vs. String Builder: Battle of the String Mutable
Inbuilt Methods: Exploring the String Toolbox
Class Loading: Behind the Scenes of Class Initialization
Journey into Java Execution
Static Variables, Static Methods, Static Block: Unleashing the Power of Static
Differences between Non-Static and Static: Dynamic vs. Static Unveiled
Need of Encapsulation: Safeguarding Data Integrity
What is Encapsulation? Unveiling Encapsulated Objects
The Hidden Gems of Encapsulation
Shadowing Problem and "this" Keyword: Unmasking the Shadows
Setters & Getters: Controlling Access with Accessors and Mutators
Constructor: Building Objects with Constructors
Navigating Constructor Overload with "this()"
Unleashing the Power of Inheritance
Extending the Java Inheritance Realm
Exploring the Inheritance Patterns & Types
Important Key Points : Inheritance Nuggets Unveiled
Inherited Methods, Overridden Methods, Specialized Methods: Method Inheritance Demystified
Rules to Override Method: Mastering Method Overriding Guidelines
Unveiling the Power of Polymorphism
Harnessing the Magic of Polymorphic Behavior
Runtime vs. Compile Time Polymorphism: Dynamic vs. Static Polymorphism
Embracing the Abstract Realm
Exploring the World of Abstraction
Final Class: The Ultimate Immutable Class
Final Variable: The Unchanging Data Realm
Final Method: The Ultimate Method Lockdown
Unveiling the Power of Interface
Bridging the Gap in Java Development
Different Use Cases of Interface: Versatility in Interface Implementations
Abstract vs Interface: The Battle of Abstraction Approaches
Additional Features of Interface: Expanding the Interface Horizons.
Functional Interface: The Blueprint for Lambda Expressions
Unveiling the Expressive Functions
Different Ways to Create Lambda Expression: Crafting Functions in Style
Putting Your Lambda Skills to the Test
Unraveling the World of Java Exceptions
How to Handle Exception (try-catch): Taming the Unexpected
Multiple Catch Block: Targeted Exception Handling
Handling vs. Ducking an Exception: Dealing with Errors Head-On
Understanding the Exception Family Tree
Unleashing Custom Error Handling
Efficient Resource Management with try
Assignment with mentor guidance - Food Delivery App
What is Thread & Need of Multiple Threads: Embracing Parallelism in Java
How to Create Multiple Threads: Spawning Thread Warriors
The Heartbeat of Thread Execution run() Method
Race Condition
Exploring the Thread Lifecycle
Deadlock: Unlocking the Mysteries of Thread Synchronization
Unlocking the Power of Data Organization
The Dynamic Array Marvel
LinkedList: Navigating the Linked World of Data
PriorityQueue: Prioritizing Data in Java
ArrayDeque: Exploring the Array-Based Double-Ended Queue
TreeSet: The Sorted Set Wonderland
HashSet: Embracing Uniqueness with Hashing
LinkedHashSet: Ordered Uniqueness with Linked Structures
Collection Hierarchy: Mapping the Collections Universe
Map: The Key-Value Pair Marvel
Map Hierarchy: Navigating the Map World
Stream API in Java: Streamlining Data Manipulation with Java Streams
Enums: Embracing Type-Safe Constants
What is Annotation: Unveiling the Power of Metadata
In-Built Annotation: Exploring Java's Built-In Annotations
Custom Annotation: Crafting Personalized Annotations
Input Stream: Reading Data from Files
Output Stream: Writing Data to Files
Manipulating Files with Java
Serialization: Preserving Object State in Files
Deserialization: Restoring Object State from Files
DBMS: Unveiling the Power of Database Management
Navigating the Relational Database Realm
E-R Modeling and Diagram: Visualizing Relationships in Databases
Normalization: Optimizing Data Structure in Databases
Introduction to SQL: The Language of Databases
DDL and DML Statements: Crafting and Manipulating Database Objects
Working with Queries (DQL): Unleashing the Power of Data Retrieval
CRUD Operations: Mastering Database Manipulation
Aggregate Functions: Analyzing Data with SQL Aggregates
Joins and Set Operations: Connecting Data across Tables
Working with Constraints: Enforcing Data Integrity in Databases
Exploring the NoSQL Database Revolution
Unraveling the Inner Workings of MongoDB
What is Mocha and the Need for Mocha in MongoDB:
The Big Umbrella of MongoDB: The Ecosystem and Beyond
How to Install MongoDB on macOS: Setting Up Your MongoDB Environment
How to Install MongoDB on Windows: Creating Your MongoDB Playground
Create and Read Operations in MongoDB: Building and Fetching Data
ObjectID and BSON in MongoDB: Unveiling the MongoDB Data Types
CRUD Operations in MongoDB: Mastering Data Manipulation
UpdateOne and DeleteOne in MongoDB: Modifying and Removing Single Documents
UpdateMany and DeleteMany in MongoDB: Updating and Deleting Multiple Documents
Database Issues with Update in MongoDB: Handling Challenges and Pitfalls
Getting More Data in MongoDB: Exploring Advanced Querying and Aggregation
Understanding Object Structure in MongoDB: Modeling Data in Document Format
What is Schema in MongoDB: Defining Structure and Validation
Steps followed to write JDBC Code
Usage of Statement Object
Usage of Prepared Statement
Types of Driver available
Application using Statement and Prepared Statement
CRUD operation application in layered approach of Student table using Factory Design Pattern
Collecting and installing developer’s tool
Structuring the files and creating first file
Text tags
List items
Divisions and Spans
Images and links
Challenge for links on images and solution
Tables in HTML
More about forms in HTML
Comparing HTML 4 semantics with HTML 5
Introduction to CSS and where to write it
Solving the color selection problem
Coming soon template and backgrounds
Box model and centering text
Google fonts and font awesome
Styling the links
Classes and ID in CSS
Designing a navigation bar from scratch
Color pallets and Canva for design
Gradients in CSS
Check through CSS
Box sizing in CSS
What are JavaScript Engines?
What ES version of JavaScript is good for us
Variable and data types in JavaScript
Operators in JavaScript
What are conditionals in JavaScript
Logical conditional Login in JavaScript
Ternary operator in JavaScript
Switch for role-based access in JavaScript
Basics of functions in JavaScript
Functions in variable User Role in JavaScript
Understand the context in JavaScript
Code hoisting in JavaScript
Scope chaining in JavaScript
Light intro to THIS in JavaScript
Maps in JavaScript
Classes and module exports in JavaScript
Private props getters and setters in JavaScript
Inheritance in JavaScript
Event loop Will JavaScript wait
Promise async and await in JavaScript
Debunking Misconceptions about React
Essential Tools for React Development
Optimizing Performance with Virtual DOM
Difference Between JS and JSX:
Building Blocks of React Applications
Containers and Components:
Child Components: Creating and Nesting Components
Organizing Components with Namespaces
Leveraging JSX's Power
Node Setup
How to Use NPM:
How to Create package.json and Purpose of It: Configuring Your React Project
Best IDE for React JS and How to Write Optimized Code in React JS: Boosting Productivity and Performance
React JS Browser Plugins Overview:
Create a React Component with JSX Template: Building Your First React Component
How to Create Nested Components: Nesting Components for Complex UIs
What is React JS Render: Understanding the Render Method in React
React Props Overview: Passing and Handling Data with Props
Introduction of Props Validation with Data Types: Ensuring Data Integrity with PropTypes
Flow of States, Initialize States and Update States: Managing State in React Components
Lists of Form Components: Building Interactive Forms in React
Setup Controlled and Uncontrolled Form Components: Handling Form Input in React
Control Input Elements: Managing User Input in React Forms
How to Set Default Values on All Formats of Input Elements: Pre-filling Input Elements in React Forms
React JS Form Validations: Validating User Input in React Forms
How to Write Styles: Styling React Components
Initial Render: Understanding the React Component Lifecycle
Props Change: Handling Changes in Props
Stage Change: Reacting to State Changes
Component willMount: Executing Code Before Rendering
Component DidMount: Executing Code After Rendering
Component Unmount: Cleaning Up Before Component Removal
Overview of a Single-Page Application: Building Dynamic Web Applications with React
How is React Router Configured: Navigating and Routing in React Applications
Background of Router: Understanding the Importance of Routing in React
How Should Conditional Statements Be Handled in JSX: Conditional Rendering in React
onBlur, onKeyUp, onChange, and Other Useful Primary Events in React JS: Handling User Events in React
How to Share Events Between Components: Communicating Between React Components
Introduction to Styled Components: Styling React Components with Styled Components
Styling the Application Using Styled Component: Building Stylish and Reusable UI Components
How to Load the Router Library: Incorporating React Router into Your Project
Configure the React Router: Setting Up Routes and Navigation
How to Pass and Receive Parameters: Handling Route Parameters in React Router
Understanding Hooks: Simplifying State and Side Effects in React
The useState Hook: Managing State with Hooks
Side Effects Using the useEffect Hook: Handling Side Effects in React
The useContext Hook: Simplifying Context Usage in React
The useReducer Hook: Managing Complex State with useReducer
Writing Your Own Hook: Creating Custom Hooks in React
The React Ecosystem: Exploring the Richness
Types of application
Client Server Architecture
Different types of Server a. web server b. application server
Need of Servlet and Different ways of Creating a Servlet
Configuring Servlet in
XML and Annotation support
Difference b/w Servlet Config vs Servlet Context object
HttpServlet Request, HttpServlet Response, Request Dispatching
Session Tracking Mechanism
HttpSession Tracking
Cookie
URL ReWriting
Hidden form Field
Filters, Listeners and One CRUD app using MVC Design pattern
Need of JSP, Usage of JSP, Implicit Objects
Type of Directives
Expression Language, JSTL Tags
MVC CRUD APP using Servlet, JSP
Building Customer Relationship manager System using JDBC, Servlets and JSP and JSTL
Limitations of JDBC for Database Operations
Mastering Hibernate for Database Integration
Harnessing the Power of Hibernate over JDBC
Introduction: Getting Started with Hibernate
ORM (Object Relational Mapping): Mapping Objects to Relational Databases
Configuration XML File and Mapping XML File along with DTDs: Configuring Hibernate with XML
Understanding the Internal Structure of Hibernate
Installation and Directory Structure: Setting Up Hibernate and Organizing Project Files
Hibernate Data Types: Handling Different Data Types in Hibernate
First Application Using Hibernate: Building Your First Hibernate Application
Exploring the Hibernate API for Database Operations
CRUD Operations: Performing Create, Read, Update, and Delete Operations with Hibernate
Primary Key Generators: Generating Primary Keys in Hibernate
Hibernate Query Language (HQL): Executing Powerful Queries with HQL
Native SQL: Interacting with the Database Using Native SQL Queries
Criteria API: Querying the Database with Criteria API
Inheritance in Hibernate: Managing Inheritance Hierarchies in Hibernate
Relations (One-to-One, One-to-Many, Many-to-One, Many-to-Many): Handling Relationships in Hibernate
Optimizing Performance with Hibernate Caching
Connecting with Multiple Databases: Working with Multiple Databases in Hibernate
Integrating Hibernate with Servlets, JSP, and with Spring: Incorporating Hibernate into Web Applications
Hibernate Annotations: Simplifying Mapping with Hibernate Annotations
Performing BLOB/CLOB Operations, Insertion of Date and Time to Database: Working with Binary and Text Data in Hibernate
Performing Object Versioning, Timestamping, and Lifecycle Events of Hibernate: Managing Object Versions and Lifecycle in Hibernate
Connection Pooling in Hibernate: Maximizing Database Connection Efficiency with Connection Pooling
Building Customer Relationship manager System using ORM, Servlets and JSP and JSTL
What is Spring Frame Work?
What is Spring Boot?
Differences between Spring & Spring Boot
IOC container
Dependency Injection a) Setter Injection b) Constructor Injection c) Field Injection
Stereotype Annotations a) @Component b) @Service c) @Repository d) @Controller e) @Indexed
Spring Boot Overview
Pros & Cons of Spring Boot
Approaches to create Spring Boot Application
Spring Initializer (start.spring.io)
Spring Starter Wizard in STS IDE
Introduction to Spring Boot Starters
Spring Boot Parent Starter
Spring-boot-starter
Spring-boot-starter-web
Spring-boot-starter-webflux
Spring-boot-starter-data-jpa
Spring-boot-devtools
Spring-boot-starter-mail
Spring-boot-actuator
Spring-boot-starter-test etc.
What is Start Class in Spring Boot
@SpringBootApplication annotation internals
Spring Application.run(..) method internals
Spring Boot Application Boot strapping
Auto Configuration in Spring Boot
What is Persistence Layer?
Best practices to follow in persistence layer
ORM Basics
Spring Data JPA Introduction
Differences between Spring ORM and Spring Data
Curd Repository introduction
Curd Repository methods for DB operations
Custom findByXXX method syntax
Custom Queries Execution in Data JPA
JpaRepository introduction
JpaRepository methods for DB operations
Pagination Using Data JPA methods
Sorting Using Data JPA Methods
Query by Example Executor
Generators
Custom Generators in Spring Data
Embedded Database Introduction
Embedded Database vs. External Database
Application Development using Embedded Database (H2)
Application Development Using MYSQL Database
Application Development Using PostGreSQL Database
Application Development Using MongoDB
Profiles in springboot
Spring Web MVC Introduction
Spring Web MVC Advantages
Spring MVC Architecture
Introduction to Front Controller
Controllers
Handler Mappers
View Resolvers
Web Application development using Spring Boot
Embedded HTTP Servers Introduction
Embedded Tomcat Server b) Embedded Jetty Server c) Embedded Undertow Server
Making Jetty as Default server
Web Application Deployment in External Server
Sending Data from UI to Controller
Query Param b) Path Param
Sending Data from Controller to UI a) Model b) ModelAndView
@RequestBody annotation 38) @ResponseBody annotation
Introduction to Spring MVC Form Tag library
Form Based application development using Spring Boot
Thymeleaf Introduction
Web Application with Thymeleaf
Sending Email using Spring Boot
Exception Handling in Spring Boot Web Application
Spring Boot Actuators
Health b) Info c) Heapdump d) Theaddump
e) Beans f) Httptrace g) Mappings h) Shutdown etc
Unit Testing for Spring Boot Application using Junit with Mocking
Code Coverage using Jacocco
Distributed Applications
Distributed Technologies
SOAP vs. REST
RESTful Services Introduction
REST principles
XML
One Time operations
Run Time Operations a) Marshaling b) Un Marshaling
JAX-B Introduction JAX-B Architecture
Applications development with JAX-B
JSON Introduction
XML vs JSON
JACKSON API
Converting Java object to JSON and vice versa using Jackson API
GSON API
Converting Java Object to JSON and Vice Versa using GSON API
HTTP Protocol Details
HTTP Methods a) GET b) POST c) PUT d) DELETE
HTTP Status Codes
@RestController
@RequestBody
@ResponseBody
@RequestParam
@PathVariable
MediaTypes
Consumes
Produces
Accept Header
Content-Type head
REST API Development using Spring Boot
POSTMAN
SWAGGER & SWAGGER UI
Exception Handling in REST API
REST Security
HTTP Basic Auth
JWT
OAuth2.0
Mono Objects
Flux Objects
REST Client Introduction
Rest Template
WebClient
RestTemplate vs WebClient
Reactive Programming
Synchronous vs. Asynchronous Calls
Apache Kafka Integration with Spring Boot
Redis Cache Integration with Spring Boot
Building Student management System using Spring Boot
Building Customer Relationship manager System using SpringMVC and Thymleaf
Working with Ticket Management application using Spring datajpa and Spring ReSt with swagger integration
Docker & its architecture
Docker as a service
Docker CLI
Docker Volumes
Dockerizing a web application
Monolith Architecture case study
Monolith Application Deployment Process
Load balancer (Cluster) case study
Load Balancing Algorithms
Round Robin
IP Hashing
Sticky Session
Monolith Architecture Drawbacks
Micro services Introduction
Micro Services Advantages
Micro Services Dis-Advantages
Micro Services case study
Identifying Micro services boundaries
Micro services Architecture
Micro services Development
What is Agile?
What is Scrum?
Benefits of Agile
Scrum Artifacts
Building Stock Market API integration with Eureka Client and hosting in PCF
Building Book Stock AP integration with MongoDB and making it as Eureka Client with swagger integration
Capstone project of Insurance application which holds micro services and React integration
Instructors
Skoliko Faculty
₹17500.00
- 42 Modules
- 190 Hours
- Programming
Login to Purchase the Course