9007116752

c3creativedomain@gmail.com

C-Cube

Centre of Computer Education

1) Get hands-on Java skills and accelerate your career
as a Software Developer.
2) The course includes all the important aspects of Java
programming like Core Java, Advanced java , J2EE , JDBC
, JSP, Servlet , Spring Frameworks.
3)Course has been designed according to the current &
the most effective ways of the Java programming , software
development, testing industry, market demands

Full Stack Development Training in Kolkata

Training Partners

C-Cube Centre of Computer Education , best java training institute in kolkata provides training on latest Java technologies like Spring , Hibernate , Struts , J2EE , Servlets , Jave SE , Maven , Netbeans , Eclipse IDE where students can learn the core concepts from scratch to the very advance technologies.

Here students get hands-on training on practical projects and certification directly from IIT Bombay Spoken Tutorial and National Board of Computer Education(NBCE).

Core Java Training For Beginners- Level 1

  • Java Introduction
  • Java Installation
  • JVM architecture
  • Class & Object Concept
  • Java Data types
  • Variables
  • Keywords
  • Identifiers
  • Java Operators
  • Expressions
  • If Condition
  • Loops
  • Arrays 1 & 2D
  • Methods & Overloading
  • Constructors & Overloading
  • String Handling
  • Object Oriented Programming in Java
  • Inheritance
  • Interface
  • Overriding
  • Polymorphism
  • Abstraction
  • Encapsulation
  • Abstract class
  • Java Packages
  • Exceptional Handling
  • Multi-Threading
  • Applet in Java

Quick Contact Form


    Minimum Eligibility         10 + 2 Pass
    Course Duration               3 Months
    Mode of Training             Online & Offline (Both Available )

    Core Java Training For Beginners- Level 2

    JDBC

    • JDBC Introduction
    • Understanding what JDBC is and its role in Java applications.
    • Knowing the architecture of JDBC and how it works.
    • Overview of core components: DriverManager, Driver, Connection, Statement, PreparedStatement, CallableStatement, and ResultSet.
    • Types of JDBC drivers.
    • Differences between the driver types and when to use each.
    • How to configure and load JDBC drivers in Java applications.
    • Using DriverManager to establish a database connection.
    • Understanding the JDBC connection URL format for different databases (e.g., MySQL, Oracle, PostgreSQL).
    • Connection properties like username, password, and database-specific options.
    • Types of SQL statements (SELECT, INSERT, UPDATE, DELETE, DDL, etc.).
    • Using Statement for executing SQL queries.
    • Differences between Statement, PreparedStatement, and CallableStatement.
    • Executing DDL commands (e.g., creating tables) via JDBC.
    • Benefits of PreparedStatement (security, performance).
    • How to use PreparedStatement for parameterized queries.
    • Executing batch updates using PreparedStatement.
    • Using ResultSet to retrieve and navigate query results.
    • Methods to retrieve data from ResultSet (e.g., getInt(), getString(), etc.).
    • Insert Records
    • Update Records
    • Delete Records
    • Creating Log-in Form.
    • What JSP is and how it fits into the Java EE (Jakarta EE) ecosystem.
    • Differences between JSP, Servlets, and other Java web technologies.
    • Basic understanding of how JSP is converted into a servlet at runtime.
    • Translation: The JSP file is converted into a Servlet.
    • Compilation: The Servlet class is compiled.
    • Initialization: The jspInit() method is called.
    • Request Processing: The service() method is executed for each request.
    • Destruction: The jspDestroy() method is called when the JSP is destroyed.
    • JSP Scriptlet Tags
    • JSP Expression Tags
    • JSP Declaration Tags
    • JSP Requests
    • JSP Response
    • JSP Config
    • JSP Application
    • JSP Session
    • JSP PageContext
    • JSP Page
    • JSP Exception
    • JSP Page Direct

    Servlet

    . Introduction to Java Servlets:

    • What a Servlet is and its role in Java web applications.
    • Understanding how Servlets extend the capabilities of servers and handle HTTP requests and responses.
    • Differences between Servlets, JSP, and other web technologies.
      1. init(): Called once when the servlet is initialized.
      2. service(HttpServletRequest req, HttpServletResponse res): Called for each request; handles the core processing.
      3. destroy(): Called once when the servlet is destroyed by the server.
    • Servlet, GenericServlet, and HttpServlet.
    • ServletRequest and ServletResponse for handling request and response data.
    • HttpServletRequest and HttpServletResponse for HTTP-specific request and response handling.
    • ServletConfig and ServletContext for configuration and application-wide parameters.
    • Understanding HTTP request methods (GET, POST, PUT, DELETE, etc.) and how to handle them in a Servlet.
    • Methods like doGet(), doPost(), doPut(), doDelete(), and how to override them for specific request types.
    • Working with request parameters (getParameter(), getParameterMap()), headers (getHeader()), and cookies.
    • Generating and sending responses using HttpServletResponse (setContentType(), getWriter(), sendRedirect(), etc.).
    • Using Request Dispatcher for forwarding requests within the server (request.getRequestDispatcher().forward()).
    • Difference between forward and sendRedirect methods:
    • forward: Keeps the request within the server.
    • sendRedirect: Sends a new request to the client.
    • Using the web.xml deployment descriptor to configure servlets:
    • Defining servlets and servlet mappings.
    • Setting initialization parameters.
    • Configuring error pages and security constraints.
    • Using @WebServlet annotation for servlet configuration in Java EE 6 and later.
    • Understanding HTTP sessions and their purpose.
    • Techniques for session management: cookies, URL rewriting, and hidden form fields.
    • Working with HttpSession object to create, retrieve, store, and manage session attributes.
    • Understanding session timeout, session tracking, and invalidation.
    • Understanding the ServletContext object for sharing data across servlets within a web application.
    • Using getServletContext() to access context parameters, resources, and log messages.
    • Context attributes vs. request/session attributes.
    • Using annotations (@WebServlet, @WebFilter, @WebListener) to simplify servlet configuration.
    • Benefits of annotations over web.xml configuration.

    Minimum Eligibility         10 + 2 Pass
    Course Duration               3 Months
    Mode of Training             Online & Offline (Both Available )

    Advance Java Training for Full Stack Development

    Spring Boot

    • Creating a Spring Boot project using Spring Initializr.
    • Understanding the structure of a Spring Boot project (main application class, resource files, dependencies, etc.).
    • Managing dependencies with Maven or Gradle.
    • @SpringBootApplication: Combines @Configuration, @EnableAutoConfiguration, and @ComponentScan.
    • @RestController and @Controller: Define RESTful and MVC controllers.
    • @RequestMapping, @GetMapping, @PostMapping, etc.: Map HTTP requests to controller methods.
    • @Autowired: Injects dependencies automatically.
    • @Component, @Service, @Repository: Define beans for Spring’s component scanning.
    • Understanding Spring Boot starters (spring-boot-starter-web, spring-boot-starter-data-jpa, etc.).
    • Benefits of using starters to simplify dependency management.
    • Commonly used starters and their purposes.
    • Understanding the concepts of DI and IoC.
    • Using @Autowired for field, constructor, and setter-based injection.
    • Managing beans with the Spring IoC container.
    • Working with Spring Data JPA and Spring Data JDBC.
    • Configuring data sources and JPA properties.
    • Using JpaRepository and CrudRepository for database operations.
    • Writing custom queries using JPQL or the @Query annotation.

    Key Components of Spring Boot MVC:

    1. Model:
    • Represents the application’s data and business logic.
    • Can be a simple POJO (Plain Old Java Object) or an entity representing a database table.
    • Contains the state of the application and methods to manipulate that state.
    • Interacts with the database using repositories or services (e.g., JpaRepository for data access).
    1. View:
    • Represents the user interface of the application.
    • Displays data from the model to the user and collects user input.
    • Typically written in JSP, Thymeleaf, or another templating engine.
    • Uses data provided by the controller to render a response.
    1. Controller:
    • Acts as the intermediary between the Model and the View.
    • Handles HTTP requests from the user, processes them (using services and repositories), and returns an appropriate view.

    Contains request handling methods annotated with @GetMapping, @PostMapping, etc., that map specific URLs to Java methods.

    • Understanding RESTful API Principles:
    • Creating a Spring Boot REST API:
    • Dependency Injection and Inversion of Control:
    • Data Validation
    • Data Persistence
    • Deployment and Configuration

    Hibernate

    • What Hibernate is and its role in Java applications.
    • Understanding Object-Relational Mapping (ORM) and how Hibernate simplifies database interactions.
    • Differences between Hibernate and JDBC (Java Database Connectivity).
    • Session: Represents a single unit of work with the database, provides methods to interact with the database (e.g., CRUD operations).
    • SessionFactory: A factory for Session objects; created once and used throughout the application to open sessions.
    • Transaction: Manages the unit of work and provides a mechanism for transaction management.
    • Query: An interface to create queries against the database (HQL, Criteria API).
    • Configuration: Defines configuration settings (like database connection, dialect, etc.) for Hibernate.
    • Understanding the architecture: Application Layer → Hibernate Layer (SessionFactory, Session, etc.) → Database Layer.
    • Role of SessionFactory, Session, Transaction, and how they interact with the database.
    • Using Hibernate annotations like:
      • @Entity: Marks a class as a persistent entity.
      • @Table: Specifies the table name in the database.
      • @Id: Marks a field as a primary key.
      • @GeneratedValue: Specifies generation strategy for primary key (auto, sequence, identity, etc.).
      • @Column: Defines column attributes (name, length, nullable, etc.).
    • Using XML-based mapping (.hbm.xml files) as an alternative to annotations.
    • Performing basic CRUD (Create, Read, Update, Delete) operations using Hibernate.
    • Using Session methods like save(), get(), load(), update(), delete().
    • Understanding the differences between get() and load() for fetching entities.
    • Understanding HQL and its syntax, which is similar to SQL but operates on entity objects rather than tables.
    • Writing HQL queries for basic CRUD operations, joins, grouping, and aggregations.
    • Using HQL with named queries and parameters.
    • Using the Hibernate Criteria API to build queries programmatically.
    • Creating dynamic queries without writing HQL or SQL directly.
    • Using methods like createCriteria(), add(), setProjection(), etc., to build complex queries.

    Java Script

    • About Java Script
    • Benefits of Java Script
    • Variable declaration
    • Operators
    • Control Statements
    • Error Handling
    • Understanding arrays
    • Function Declaration
    • Built In Functions
    • Standard Date and Time Functions
    • HTML Document object Model
    • Working with HTML form and its elements
    • HTML Document object Model
    • Working with HTML form and its elements
    • Other Document Object Model
    • Working with Objects
    • Call method in JavaScript
    • Inheritance in JavaScript using prototype

    React JS

    • Overview of ReactJS and its advantages.
    • Setting up the development environment with Node.js and npm.
    • Understanding the basics of JSX (JavaScript XML) syntax.
    • Understanding React components and their role in UI development.
    • Creating functional and class components.
    • Passing data to components using props and rendering dynamic content.
    • Understanding component state and its management.
    • Updating component state using setState() and handling events.
    • Using the State Hook
    • Implementing form elements and handling form submissions.
    • Managing form state with controlled components.
    • Handling user events like onClick, onChange, onSubmit, etc.
    • Rendering lists of data with React.
    • Using keys for efficient list rendering and updating.
    • Implementing conditional rendering based on list data.
    • Managing global state using the Context API.
    • Creating and consuming context providers and consumers.
    • Avoiding prop drilling by using context for state management.
    • Making HTTP requests with fetch or axios.
    • Handling asynchronous data fetching and updating component state.
    • Implementing loading indicators and error handling for API requests.

    HTML & CSS

    • Elements , Tags , Attributes
    • Text ,  Formatting
    • Lists ,  Images ,  Image Links
    • Tables , – Bgcolor ,  Color Codes ,  Background
    • Web Forms , Input ,  Text Fields , Hidden Fields , Password, Submit
    • Checkboxes ,  Radio Button
    • Layouts ,  Frames
    • CSS Syntax
    • CSS Id & Class
    • Styling Backgrounds
    • Styling Text
    • Styling Fonts
    • Styling Links
    • Styling Lists
    • Styling Tables
    • CSS Border
    • CSS Outline
    • CSS Margin

     

    • CSS Display
    • CSS Positioning
    • CSS Floating
    • CSS Navigation Bar
    • CSS Image Gallery
    • CSS Image Opacity
    • CSS Align

    SQL

    • Basics of SQL Types of SQL Statements
    • DDL, DML, DQL, DCL and TCL
    • Create Database using Management Studio
    • Datatypes in SQL Server
    • Exploring DDL Statements on Table using Management Studio
    • Why write statements in Frontends?
    • Create, Alter and Drop Table Insert,
    • Update and Delete Statement Truncate Statement
    • Understanding Select Statement
    • Usage of Top, Distinct, Null ..keywords
    • Using String and Arithmetic Expressions
    • Exploring Where Clause with Operators
    • Using Advanced Operators
    • Sorting data using Order By clause
    • Working with basic of Sub Queries
    • Using functions in Queries
    • Count, Sum, Min, Max, Avg Group By and Having Clause
    • Using Group By with Rollup and Cube
    • Introduction to Joins Cross Joins
    • Inner Join
    • Outer Join
    • Self Join
    • Co-related Sub Queries
    • Set Operations using Unions, Intersect and Except
    • Unique
    • Not NULL
    • Primary Key
    • Default Check Foreign Key

    Minimum Eligibility         10 + 2 Pass
    Course Duration               8 Months including Project
    Mode of Training             Online & Offline (Both Available )

    About IIT Bombay ST Program

    The Spoken Tutorial(ST) project is being developed at IIT Bombay for Ministry of Education (previously MHRD), Government of India.The Spoken Tutorial project is funded by the National Mission on Education through Information and Communication Technology (ICT), launched by Ministry of Education, erstwhile Ministry of Human Resources and Development, Government of India.

    Spoken Tutorial is a multi-award winning educational content portal. Here one can learn various Free and Open Source Software all by oneself. Our self-paced, multi-lingual courses ensure that anybody with a computer and a desire for learning, can learn from any place, at any time and in a language of their choice. All the content published on this website are shared under the CC BY SA license.

    Our courses are simple and easy to follow even for a beginner but they also meet the growing needs of the learner. Our engaging digital content ensures that learning happens at all levels – Basic, Intermediate and Advanced. Our content mandates side-by-side practice thereby ensuring that learners are actively learning. Many of the software taught, are used in various disciplines of Engineering, pure Sciences and several other Under-Grad and Post-Grad studies, and can be extended to Commerce, Arts and Management streams as well. Alongside these, there are some courses relevant at School level, too, which help school students to visualise difficult concepts of Math and Science. These can also be used by Teachers to prepare lesson plans, explain abstract concepts and give digital assignments to students.

    The learning can happen in an organised manner as well. Faculty in institutes can organise their batch of students into groups, who will learn a particular software course for an entire semester. The ST course can be mapped to the Course/Lab manuals and systematic learning can take place. If the academic timetable permits, then a single student can learn upto 3 different ST courses in one semester during the designated academic Lab hours.

    End-of-Course online tests and certificates are available for those who wish to test their expertise in a particular software. These certificates give an edge to students during placement by increasing their employability potential.

    IIT MUMBAI CERTIFICATE for best java training institute in kolkata For REGISTRATION
    IIT Bombay Spoken Tutorial
    Open chat
    1
    Powered by Joinchat
    Hello , How can I help you ?