A Core Java course typically covers the fundamental concepts and features of the Java programming language. It begins with basic syntax, data types, operators, control statements (like loops and conditionals), and progresses to object-oriented programming (OOP) concepts such as classes, objects, inheritance, polymorphism, encapsulation, and abstraction. The course also includes important Java APIs like java.lang, java.util, and java.io, along with exception handling, multithreading, collections framework, input/output operations, and basic file handling. Additionally, topics like interfaces, packages, inner classes, and Java memory management are covered to build a strong foundation for advanced Java development or frameworks like Spring and Hibernate.

Course Content:

1. Introduction to Java and Java Development Environment

2. Data Types, Variables, and Operators

3. Control Statements: If-Else, Switch, Loops

4. Object-Oriented Programming Concepts: Classes, Objects, Inheritance, Polymorphism

5. Exception Handling and Debugging

6. Core Java Libraries and Packages

7. File Handling in Java

8. Collections Framework (Lists, Sets, Maps)

9. Advanced Java Concepts: Threads, Generics, Annotations

10. JDBC and Database Connectivity

11. GUI Development with Swing/AWT

12. Java Projects: Hands-on Application Development

13. Best Practices in Java Programming

Module 1: Introduction to Angular

• What is Angular and why it’s used

• Angular vs React vs Vue

• Overview of Angular architecture (Modules, Components, Templates, Services, Dependency Injection)

• Setting up the development environment (Node.js, npm, Angular CLI, VS Code)

• Creating your first Angular app

Module 2: TypeScript Fundamentals

• Introduction to TypeScript and its advantages

• Variables, data types, interfaces, and classes

• Modules and decorators

• Working with arrow functions and promises

• Hands-on: Converting simple JS code to TypeScript

Module 3: Components and Templates

• Creating and using components

• Component lifecycle hooks (ngOnInit, ngOnDestroy, etc.)

• Template syntax: interpolation, property binding, event binding, and two-way binding

• ViewEncapsulation and component communication (@Input, @Output)

• Hands-on: Building reusable components

Module 4: Directives and Pipes

• Built-in directives (ngIf, ngFor, ngSwitch, ngClass, ngStyle)

• Creating custom directives

• Built-in pipes (date, uppercase, currency, etc.)

• Creating custom pipes

• Hands-on: Custom structural directive and pipe

Module 5: Services and Dependency Injection

• What are services in Angular

• Creating and injecting services

• Hierarchical injectors

• Singleton pattern and service scope

• Hands-on: Service for shared data and business logic

Module 6: Routing and Navigation

• Setting up routing in Angular

• Route parameters and query parameters

• Child routes and nested routes

• Route guards (CanActivate, CanDeactivate, Resolve)

• Lazy loading modules

• Hands-on: Multi-page app with routing

Module 7: Forms in Angular

• Template-driven forms

• Reactive forms (FormGroup, FormControl, FormBuilder)

• Validation (built-in and custom)

• Handling form submissions

• Hands-on: User registration and login forms

Module 8: HTTP Client and APIs

• Using Angular HttpClient module

• GET, POST, PUT, DELETE requests

• Handling responses and errors

• Interceptors for authentication and logging

• Hands-on: Consuming a RESTful API

Module 9: State Management and RxJS

• Introduction to RxJS and Observables

• Subjects and BehaviorSubjects

• Async pipe and reactive programming

• Simple state management patterns

• Introduction to NgRx (optional advanced topic)

Module 1: Introduction to Databases and MySQL

• What is a Database?

• Types of Databases (Relational vs Non-Relational)

• Introduction to RDBMS concepts

• Overview of MySQL – features, advantages, use cases

• MySQL installation & setup (Workbench / Command-line)

• Understanding Database, Table, Row, and Column structure

• Hands-on: Creating your first database

Module 2: Data Modeling and Normalization

• What is Data Modeling?

• Entities, Attributes, and Relationships

• Primary Keys and Foreign Keys

• Concept of Redundancy

• Normalization:

  • 1NF, 2NF, 3NF (with examples)

  • Denormalization (when and why)

• Hands-on: Designing a normalized database schema (e.g., Student or Employee DB)

Module 3: SQL Basics and Data Definition Language (DDL)

• What is SQL? (Structured Query Language)

• SQL Syntax and Structure

• DDL Commands:

  • CREATE (Database, Table)

  • ALTER (Modify Table Structure)

  • DROP (Delete Table/Database)

  • TRUNCATE (Remove all records)

• Understanding Data Types in MySQL

• Hands-on: Creating and modifying database tables

Module 4: Data Manipulation Language (DML)

• DML Commands:

  • INSERT (Add records)

  • UPDATE (Modify records)

  • DELETE (Remove records)

• Using SELECT for basic data retrieval

• Sorting (ORDER BY) and Filtering (WHERE, LIKE, BETWEEN, IN)

• Hands-on: CRUD operations on real tables

Module 5: SQL Functions and Operators

• Arithmetic and Logical operators

• Built-in functions:

  • String Functions: CONCAT, LENGTH, UPPER, LOWER

  • Numeric Functions: ROUND, ABS, MOD

  • Date Functions: NOW, CURDATE, DATEDIFF

  • Aggregate Functions: COUNT, SUM, AVG, MIN, MAX

• Hands-on: Applying functions in queries

Module 6: Joins and Relationships

• Understanding table relationships (one-to-one, one-to-many, many-to-many)

• Types of Joins:

  • INNER JOIN

  • LEFT JOIN

  • RIGHT JOIN

  • FULL JOIN (conceptual, workaround in MySQL)

  • CROSS JOIN

• Hands-on: Querying related tables using joins (e.g., Employee & Department tables)

Module 7: Subqueries and Nested Queries

• What is a Subquery?

• Subquery in WHERE clause

• Subquery in FROM clause (Derived Tables)

• Subquery with IN, EXISTS, ANY, ALL

• Correlated Subqueries

• Hands-on: Writing nested queries for data analysis

Module 8: Constraints and Keys

• Primary Key, Foreign Key, Unique, Not Null, Default

• Referential Integrity and Cascading actions (ON DELETE, ON UPDATE)

• Hands-on: Applying constraints in table creation

Module 1: Introduction to PL/SQL

• What is PL/SQL and why it’s needed

• Differences between SQL and PL/SQL

• Advantages of PL/SQL (performance, modularity, security)

• Understanding PL/SQL architecture (Block structure, Engine, etc.)

• Anonymous blocks and the PL/SQL execution environment

• Hands-on: Writing your first PL/SQL program

Module 2: PL/SQL Block Structure

• Structure of a PL/SQL block:

  • DECLARE (declaration section)

  • BEGIN (executable section)

  • EXCEPTION (error handling section)

  • END (termination)

• Understanding variables, constants, and datatypes

• Using bind variables and substitution variables

• Hands-on: Writing and executing simple blocks in SQL Developer

Module 3: Variables and Data Types

• Scalar and composite data types

• Anchored declarations (%TYPE, %ROWTYPE)

• Assignments and expressions

• Using substitution variables

• Hands-on: Working with different data types

Module 4: Control Structures

• Conditional statements:

  • IF...THEN

  • IF...THEN...ELSE

  • ELSIF and nested conditions

• Looping structures:

  • LOOP, WHILE LOOP, FOR LOOP

  • EXIT, CONTINUE

• Hands-on: Writing PL/SQL programs using decision and looping constructs

Module 5: Cursors

• What is a cursor?

• Implicit Cursors (for SELECT INTO, DML statements)

• Explicit Cursors:

  • Declaring, opening, fetching, and closing

  • Cursor attributes (%FOUND, %NOTFOUND, %ROWCOUNT, %ISOPEN)

• Cursor FOR loops

• Hands-on: Retrieving data using explicit cursors

Module 6: Exception Handling

• What are exceptions?

• Types of exceptions:

  • Predefined exceptions (NO_DATA_FOUND, TOO_MANY_ROWS, etc.)

  • User-defined exceptions

• Raising exceptions using RAISE and RAISE_APPLICATION_ERROR

• Hands-on: Handling and debugging PL/SQL exceptions

Module 7: Records and Collections

• Introduction to records (%ROWTYPE, custom RECORD types)

• Introduction to collections:

  • Associative arrays

  • Nested tables

  • VARRAYs

• Iterating over collections

• Hands-on: Working with records and arrays

Module 8: Stored Procedures and Functions

• Difference between anonymous and named blocks

• Creating and executing procedures

• Creating and executing functions

• Parameter modes: IN, OUT, IN OUT

• Using stored programs inside SQL statements

• Hands-on: Writing and invoking procedures and functions

Module 9: Packages

• What are packages and why use them?

• Package specification vs body

• Creating and calling packaged procedures and functions

• Advantages of packages (modularity, encapsulation)

• Hands-on: Building a package for business logic

Module 10: Triggers

• What are triggers and their purpose?

• Types of triggers:

  • Row-level vs Statement-level

  • BEFORE, AFTER, INSTEAD OF

• Creating triggers for:

  • Auditing

  • Data validation

  • Logging changes

• Hands-on: Writing and testing row-level triggers

1. Introduction to Python

   • History and features

   • Setting up environment (Anaconda, Jupyter, or plain Python)

   • Running Python scripts and REPL

2. Data Types and Variables

   • Numbers, strings, booleans

   • Lists, tuples, dictionaries, sets

   • Type conversion and type checking

3. Control Flow

   • Conditional statements (if, else, elif)

   • Loops (for, while)

4. Functions and Modules

   • Defining and calling functions

   • Function parameters and return values

   • Importing modules and using built-in libraries

5. Object-Oriented Programming (OOP)

   • Classes and objects

   • Attributes and methods

   • Inheritance and polymorphism basics

6. Collections

   • List comprehensions

   • Dictionary comprehensions

   • Using collections module (Counter, defaultdict, namedtuple)

7. Exception Handling

   • try, except, else, finally blocks

   • Raising exceptions

   • Custom exception classes

8. Database Connectivity

   • Connecting Python to databases (MySQL / SQLite / Oracle)

   • Using libraries like mysql-connector-python or sqlite3

   • Basic CRUD operations with Python and SQL