Build Projects using Java JDBC & SQL with practical examples

Connect to the database server via MySQL Workbench on port 3306 and show databases. Create a category table with category_id as auto_increment primary key and category_name not null.

Create a menu table with menu_id, menu_name, description, and unit_price, defining primary key and constraints; explore altering table to add foreign keys, renaming tables, and compare drop versus truncate.

Learn how to insert data into a table using insert statements, handle auto-generated ids, and link menu items to categories via category ids across category and menu tables.

Explore select queries to fetch data, choose columns (projection), from tables, and apply where, group by, having, and order by; rename columns with as and use like for strings.

Learn how to perform an update in SQL using the DML update query: specify the table, set new values, and apply a where clause to target specific rows.

Discover how to perform dml delete queries by removing rows from a table with a where clause, using like with percent for contains, and verify with a prior select.

Learn to join tables in SQL to fetch related data, such as obtaining category names from a categories table by joining with the menu table, using aliases and selective columns.

Explore how sql joins combine data from two tables using related columns such as primary keys and foreign keys, illustrating inner, left, right, and cross joins with practical examples.

Explore Java as a high level, object-oriented language with platform independence via byte code and the JVM, highlighting its security, automatic memory management, and parallel task handling.

Discover the disadvantages of Java, including performance variability from the JVM and bytecode execution, memory management challenges, and how memory profiling and garbage collector tuning can optimize performance.

Explore basics of Java programming with focus on classes, main method, file naming conventions, and the distinction between static and instance members; cover data types, operators, and control statements.

Understand the Java life cycle from writing .java source code to compiling with javac, producing .class bytecode, and running on the JVM with java, enabling platform independence.

Download and install the Java development kit, choose a version and installer (Windows MSI or ZIP), set JAVA_HOME and PATH, then verify with java -version.

Write your first Java program by creating a fruit.java file with a public class and main method, then compile with javac and run with Java.

Understand the basics of a Java program by inspecting a public class with a main method and command line arguments, and learn to compile and run with javac and java.

This lecture explains why a good editor is essential for managing many Java files and guides downloading and installing the IntelliJ community edition, with alternatives like Eclipse and NetBeans.

Create your first Java project in the IDE by selecting Java, configuring the JDK, and running a simple main method to print hello world in the console.

Explore comments in Java, including single-line and multi-line syntax, and learn best practices for documenting code, with pascal case naming, packages, and a runnable main method.

Learn Java naming conventions for packages, classes, interfaces, variables, and methods, using lowercase for packages, Pascal case for classes and interfaces, and camelCase for variables and methods.

Learn Java naming conventions, including camelCase for variables and methods and uppercase underscores for constants. Understand how keywords and lowercase packages shape valid identifiers.

Learn about variables and Java data types, from primitive types like int, float, boolean, char, and double to non-primitive strings, arrays, and classes; understand data containers and ranges.

Learn to declare variables and data types in Java, using int, float, double, boolean, long, char, and String, and perform operations with arithmetic, assignment, comparison, and logical operators.

Learn how to use for loops in Java to perform repetitive tasks, control initialization, condition checks, and increments, with examples printing ranges, filtering odd numbers, and summing values.

Explore how to implement a while loop in Java, including initialization outside the loop, condition checks, and body execution, with demos that print odd or even numbers.

Explore the Java do-while loop and how it differs from a standard while loop by executing the body at least once before evaluating the condition, with a practical example.

Explore conditional logic in Java with if, else if, and control statements. Learn how to decide voting eligibility and practice taking keyboard input.

Learn to implement if, else if, and else in java to assign grades based on student marks using ranges 400 to 500 and 200 to 399, and print the grade.

Learn to read user input in Java with a Scanner, using System.in to collect values like doubles and strings, making programs dynamic and capable of looping for continuous input.

Build a Java program that never stops by using loops and user input, compare print and println, and apply conditions, for loops, and operators to keep it running.

Explore the ternary operator in Java, a shorthand form of the if-else that returns a value based on a condition, using the question mark syntax.

Explore switch-case in Java, including default handling and break to prevent fall-through, and learn how break helps exit loops and control flow.

Define the difference between a class and an object, and explain how state and behavior shape real world entities in object oriented programming.

Explore the six concepts of object oriented programming, including class and objects, inheritance, polymorphism, abstraction, and encapsulation.

Explore object oriented programming with analogies for abstraction, polymorphism, inheritance, and encapsulation; learn how abstract classes and interfaces hide functionality and support static and dynamic polymorphism with access modifiers.

Explore how objects and classes define state and behavior, and learn inheritance, polymorphism, abstraction, and encapsulation with practical real-world examples.

Explore how objects and reference variables are stored in memory, with heap and stack areas, object creation, and how references point to objects (initially null).

Learn to design a Java class and its objects by defining state variables like employeeId and salary, adding getters and setters, and testing with a main method.

Explore polymorphism in Java, distinguishing static (compile-time) and dynamic (runtime) forms. See how method overloading illustrates static polymorphism and how overriding with inheritance enables dynamic polymorphism.

Explore polymorphism and method overloading with a Java area example, demonstrating compile-time polymorphism and debugging techniques to trace overloaded methods and outcomes.

Discover how constructors in a class share the class name, omit a return type, and support default and parameterized forms through overloading and static polymorphism.

Study how default and overloaded constructors initialize shape objects, and use the this keyword to reference the current object and delegate to other constructors.

Explore inheritance in Java as an is-a relationship between superclass and subclass, covering single inheritance, why constructors aren’t inherited, and the use of super to invoke superclass constructors.

Explore inheritance in Java by building a vehicle hierarchy with a super class and child classes, using the super keyword, constructors, and method overriding to demonstrate dynamic polymorphism.

Explore inner classes in Java by creating a class inside another, see how to access and instantiate the inner class from its outer class, and call its display method.

Explore how the Java abstract keyword enables abstraction with abstract and concrete methods, and how abstract classes enable dynamic polymorphism through concrete implementations.

Explore abstraction in Java using abstract classes or interfaces, with concrete and abstract methods, and see how subclasses implement them across hierarchical, single, and multi-level inheritance.

Explore how Java arrays store multiple elements of the same type, including one-dimensional and multi-dimensional arrays, indexing, initialization, and passing or returning arrays in methods, with primitive and object examples.

Engage in hands-on Java array exercises, creating and manipulating arrays of primitives and objects, initializing values, printing elements, searching, adding or removing items, and handling bounds and exceptions.

Create a mini project in Java that uses scanner input to build a dynamic array of employee IDs, prompts for count, stores entries, and prints them.

Explore the concept of static in Java, covering static blocks, static variables, and static methods, and explain class loading and memory sharing.

Explore hands-on debugging and static concepts in Java, including static and non-static blocks, static variables, constructors, and method access, with practical code refactoring.

Explore the final keyword in java, applying it to variables, methods, and classes to create constants, prevent overriding, and restrict inheritance while noting initialization rules.

Practice using the Java final keyword by building packages and classes, showing how final prevents overriding and inheritance, and how final variables behave as constants.

Explore how interfaces in Java provide complete abstraction, enable multiple inheritance, and loose coupling by defining a blueprint of methods that implementing classes must realize.

Explore Java interfaces and multiple inheritance by implementing animal and super animal interfaces, practicing dynamic polymorphism, and debugging with a main method to test interface-driven design.

Explore how wrapper classes make primitive types objects in Java, enabling autoboxing and unboxing. Learn type conversion, parsing, and default null values for references.

Explore hands-on wrapper classes, autoboxing and unboxing in Java, including parsing strings to numbers and observing default null values in a main class.

Learn the Java string datatype, memory concepts (literal vs new, string pool), immutability, and efficient concatenation with string builder, plus key methods like length, substring, indexOf, and trim.

Explore hands-on string handling in Java, focusing on creation, equality, and the string pool. Practice substring, index, startsWith, endsWith, contains, trim, replace, and case conversions, with debugging using scanner input.

Explore string builder workflows using StringBuilder by appending, inserting, reversing, replacing, and deleting strings to achieve efficient concatenation and memory usage.

Engage in hands-on practice with the string compareTo method, following GitHub steps to observe zero, positive, and negative return values when strings compare.

Explain the four Java access modifiers—public, private, protected, and default—and how they control where classes, fields, and methods can be accessed across the same package or through inheritance.

Explains Java access modifiers using animal, cat, lion, and tiger classes across packages, showing how private, default, protected, and public members are accessed directly, via getters, or through inheritance.

Explore the Java collection framework, comparing list, set, and map, and learn how duplicates, order, and synchronization affect performance and data integrity.

Practice hands-on with a raw ArrayList containing mixed datatype elements, print items using standard and enhanced for loops, reveal element types, and introduce generics to enforce a single data type.

learn how generics enforce type safety in ArrayList by specifying a datatype with angle brackets, restricting elements to integers or strings and enabling safe iteration and printing.

Create a custom employee class with private fields and encapsulation, provide getters, then build an array list of employees, populate objects via constructors, and print details using getters.

Explore Java ArrayList methods through a hands-on fruit-list example, learning add, get, set, remove, contains, and isEmpty, and see dynamic polymorphism with linked lists.

Explore the Java Set and HashSet in the collection framework; learn that sets disallow duplicates, may not preserve order, and how to declare, add, print, and manage size and nulls.

Explore hands-on use of maps in Java, including creating, storing key-value pairs, retrieving with get, iterating via entrySet, and handling complex objects like employees and nested maps.

Master Java exception handling to maintain the normal flow of your program by catching and handling checked and unchecked exceptions, distinguishing exceptions from errors, and using try-catch-finally and custom exceptions.

Engage in hands-on Java exception handling with arithmetic exceptions, focusing on division by zero, how the JVM throws runtime exceptions, and how catching them preserves graceful program flow.

Learn to handle null pointer exceptions in Java with code examples, showing how null checks or proper exception handling prevent runtime errors.

Engage in a hands-on example of array index out of bounds exception handling in Java, showing how to print array elements and continue execution after an error.

Master the finally block in exception handling, guaranteeing cleanup actions like closing database or file connections, even when exceptions occur, unless the program terminates with system exit.

Demonstrates Java exception handling by using a finally block to guarantee code execution after try blocks, including behavior with and without catches. Explore debugging scenarios where finally runs despite exceptions.

Explore exception handling with try, catch, and finally blocks through a practical example. See how the finally block always executes to perform cleanup for database connections and file operations.

Create a custom exception by extending the exception class for business logic validation, throw and catch it across layers, and apply encapsulation with private fields and getters.

Discover how JDBC enables a Java program to connect to a database, run SQL queries from insert to delete, and perform DDL commands with secure, program-level access.

Learn how JDBC connects Java to databases by loading drivers and obtaining a connection with URL and credentials, then execute updates or queries with statement or prepared statement.

Create a new Java project in IntelliJ, link a MySQL JDBC jar (manually or via Maven), and set up a source package to run insert operations on a user table.

Create a Java configuration class to establish a MySQL JDBC connection using URL, username, and password, loading the driver and returning a connection for insert, update, and delete operations.

Take user input and insert a new user into the database using JDBC, prepared statements, and a config-backed connection, handling input fields like username, password, full name, and email.

Learn to test adding a new user using java jdbc and sql, inserting data into a database, and printing success messages.

Learn how to fetch all users with a JDBC select query, iterate the result set, and print user id, username, password, and email using column names or indexes.

Develop an update user class to modify full name and email via a prepared JDBC update statement based on username, then test by running the program.

Learn how to delete a user by username using JDBC with a delete query and where clause, optionally preview data before deletion and verify removal.