Java training
Java training courses provide a comprehensive understanding of Core Java Programming language features like Object-oriented Programming, Inheritance, Interfaces, Exception Handling, Reflection, Standard I/O programming, File Handling, Generics, GUI programming with Swing, Applets, Multi-Threading, Socket Programming, JDBC. Students learn how to develop Java applications.
Java is the most popular programming language and the platform for developing desktop, web, enterprise and mobile-based applications. Real-world scenarios and case studies will demonstrate the key functioning of Java. This Java training course provides you with an understanding of Java programming fundamentals and makes you proficient in programming basics, building a strong foundation for your programming career.
Benefits of Java Training:
At the end of this course, you will be able to:
- Build robust console and GUI applications using Java’s Object-Oriented Features
- Design flexible object models using Object Oriented Principles
- Create robust applications using Java class libraries
- Organize complex data using Java collections
- Develop platform-independent GUIs
Audience:
Java certification courses should be taken up by people with basic programming experience. The advanced Java training classes are designed for application programmers and designers who need to develop applications using Java Virtual Machine.
Click here for more information – Java Course Content.pdf
Declarations and Access Control
- Identifiers & JavaBeans
- Legal Identifiers
- Sun’s Java Code Conventions
- JavaBeans Standards
- Declare Classes
- Source File Declaration Rules
- Class Declarations and Modifiers
- Concrete Subclass
- Declaring an Interface
- Declaring Interface Constants
- Declare Class Members
- Access Modifiers
- Nonaccess Member Modifiers
- Constructor Declarations
- Variable Declarations
- Declaring Enums
Object Orientation
- Encapsulation
- Inheritance, Is-A, Has-A
- Polymorphism
- Overridden Methods
- Overloaded Methods
- Reference Variable Casting
- Implementing an Interface
- Legal Return Types
- Return Type Declarations
- Returning a Value
- Constructors and Instantiation
- Default Constructor
- Overloaded Constructors
- Statics
- Static Variables and Methods
- Coupling and Cohesion
Assignments
- Stack and Heap—Quick Review
- Literals, Assignments, and Variables
- Literal Values for All Primitive Types
- Assignment Operators
- Casting Primitives
- Using a Variable or Array Element That Is Uninitialized and Unassigned
- Local (Stack, Automatic) Primitives and Objects
- Passing Variables into Methods
- Passing Object Reference Variables
- Does Java Use Pass-By-Value Semantics?
- Passing Primitive Variables
- Array Declaration, Construction, and Initialization
- Declaring an Array
- Constructing an Array
- Initializing an Array
- Initialization Blocks
- Using Wrapper Classes and Boxing
- An Overview of the Wrapper Classes
- Creating Wrapper Objects
- Using Wrapper Conversion Utilities
- Autoboxing
- Overloading
- Garbage Collection
- Overview of Memory Management and Garbage Collection
- Overview of Java’s Garbage Collector
- Writing Code That Explicitly Makes Objects Eligible for Garbage Collection
Operators
Flow Control, Exceptions
- Using do Loops
- Using for Loops
- Using break and continue
- Unlabeled Statements
- Labeled Statements
- Handling Exceptions
- Catching an Exception Using try and catch
- Using finally
- Propagating Uncaught Exceptions
- Defining Exceptions
- Exception Hierarchy
- Handling an Entire Class Hierarchy of Exceptions
- Exception Matching
- Exception Declaration and the Public Interface
- Rethrowing the Same Exception
- Common Exceptions and Errors
Maven Fundamental
TDD with Junit 5
- Setting up JUnit with Maven
- Lifecycle Methods
- Test Hierarchies
- Assertion
- Disabling Tests
- Assumptions
- Test Interfaces and Default Methods
- Repeating Tests
- Dynamic Tests
- Parameterized Tests
- Argument Sources
- Argument Conversion
- What Is TDD?
- History of TDD
- Why Practice TDD?
- Types of Testing
- Testing Frameworks and Tools
- Testing Concepts
- Insights from Testing
- Mocking Concepts
- Mockito Overview
- Mockito Demo
- Creating Mock Instances
- Stubbing Method Calls
Strings, I/O, Formatting, and Parsing
- String, StringBuilder, and StringBuffer
- The String Class
- Important Facts About Strings and Memory
- Important Methods in the String Class
- The StringBuffer and StringBuilder Classes
- Important Methods in the StringBuffer and StringBuilder Classes
- Types of Streams
- The Byte-stream I/O hierarchy
- Character Stream Hierarchy
- RandomAccessFile class
- The java.io.Console Class
- Serialization
- Dates, Numbers, and Currency
- Working with Dates, Numbers, and Currencies
- Parsing, Tokenizing, and Formatting
- Locating Data via Pattern Matching
- Tokenizing
Generics and Collection
- Overriding hashCode() and equals()
- Overriding equals()
- Overriding hashCode()
- Collections
- So What Do You Do with a Collection?
- List Interface
- Set Interface
- Map Interface
- Queue Interface
- Using the Collections Framework
- ArrayList Basics
- Autoboxing with Collections
- Sorting Collections and Arrays
- Navigating (Searching) TreeSets and TreeMaps
- Other Navigation Methods
- Backed Collections
- Generic Types
- Generics and Legacy Code
- Mixing Generic and Non-generic Collections
- Polymorphism and Generics
Threads
- Defining, Instantiating, and Starting Threads
- Defining a Thread
- Instantiating a Thread
- Starting a Thread
- Thread States and Transitions
- Thread States
- Preventing Thread Execution
- Sleeping
- Thread Priorities and yield( )
- Synchronizing Code
- Synchronization and Locks
- Thread Deadlock
- Thread Interaction
- Using notifyAll( ) When Many Threads May Be Waiting
Introduction to JDBC
Getting Started with JDBC
Performing Basic CRUD operations using JDB
Servlets
JPA with Hibernate
Spring
Course Features
- Course Duration : 40 Hours
- Life Time Access to Recordings
- Resume preparation / Mock Interviews
- Real time Assignments and projects
- On Job Support for the 1st Project