Core Java Made Easy (Covers the latest Java 21)

Learn why Java is platform independent by compiling to bytecode and running on any operating system through the JVM, which uses just-in-time compilation to translate bytecode into machine code.

Install the java development kit to access the compiler and runtime environment. The compiler converts source code to bytecode, which runs on the jre's jvm and uses the API libraries.

Explore object oriented programming by examining objects, properties, variables, and methods that communicate to map real-world problems to Java solutions, with examples from online shopping and hospital management.

Identify and explain encapsulation, inheritance, abstraction, and polymorphism as core object-oriented principles; explore their cross-language applicability in languages like C++, Python, and C# using classes and objects.

Learn how encapsulation protects an object's data and behavior by restricting access through methods, using the capsule analogy and Java classes to bundle data and code.

Explore inheritance in Java using extends to access and reuse an existing object's functionality while extending it. Understand reusability and the is-a relationship through car, bus, and vehicle examples.

Explore abstraction in Java, hiding unnecessary details and exposing only essential features to enable object communication. See how interfaces implement this concept through everyday examples like televisions and cell phones.

Explore polymorphism in Java, where an object exhibits different shapes or behaviors through function overloading and overriding as it interacts with various objects in life.

Compare procedure oriented and object oriented programming, highlighting data versus procedures, encapsulation, data hiding, and access specifiers, with examples like C, C++ and Java.

Identify the four building blocks of a Java program—class, variables, methods, and blocks—and distinguish static and non-static variables by object versus class level, illustrated with a banking example.

Discover Java methods and their syntax—return type, name, argument list, and body—and learn four types: no arguments, no return; no input with output; input with output; input without output.

Install the latest Java by downloading the JDK from Oracle's downloads page and using Windows or Mac installer. Verify with java -version and ensure the bin path is in PATH.

Install the Java development kit on a Windows machine by downloading the JDK from Oracle, running the installer via the command line, and updating the PATH to enable Java commands.

Install the Java EE version of Eclipse, download the appropriate package, unzip the file (zip or tar.gz), and set your workspace to begin core Java development.

Launch the Eclipse IDE, set a workspace, and configure the JDK path in Eclipse preferences to enable compilation.

Install the latest Eclipse IDE, set up a workspace, and configure preferences to use the matching Java compiler and installed JREs for your Windows or macOS system.

Download corejava.zip from the resources, unzip it, and import all Core Java projects into Eclipse via existing projects into workspace, then run the multithreading project as a Java application.

Download assignment solutions from resources, unzip the zip file, and import Eclipse project into Eclipse IDE; use topic-based solutions (abstraction, annotations, arrays, encapsulation, exception) as reference to complete and submit.

Launch Eclipse, create a Java project named javaBasics, and add a HelloWorld class with a main method. Print Hello World with System.out.println and run with the play button.

Analyze the hello world program, covering class declaration, public access specifier, main method, static invocation, string arguments, and system.out.println usage.

Master static and non-static contexts in Java, learning how class-level members are shared and accessed via the class name. See per-object members like account balance contrasted with loan interest rates.

Explore static blocks: run once when the class is loaded before main, using the static keyword for initialization; multiple blocks execute in order.

Learn how to create and invoke static methods in Java, use void return types, and call them from main and static blocks, demonstrated with console output.

Explore static versus non-static contexts, with class-level static properties and methods shared across all objects, accessed via the class name, non-static requires object, illustrated by banking concepts like account balance.

Master non-static members in core Java, including non-static variables, blocks, user-defined methods, and constructors, and learn how to access them via an object.

Define non static members in java, including a non static variable, a constructor, and a non static block, in eclipse; instantiate with new in main to observe order.

Compare static blocks and non static blocks in Java: static blocks run once when the class loads, while non static blocks and constructors run per object creation.

Explore how the Java compiler injects a no-argument constructor with the same name as the class when none exists, ensuring object creation with new remains unaffected.

Learn how to create an object reference in Java by defining a class, instantiating it with new ObjectReferenceDemo(), and using an object reference variable to access its variables or methods.

Learn how to create a local object inside a static block, assign it to a reference, and print its address in a simple Demo class.

Declare a global static Demo obj and access it via the class name to show how the object moves from null to a memory address after the static block executes.

Explore the this keyword and how it refers to a specific object's non-static members and memory address, using this.x and constructor demonstrations to distinguish object instances.

Learn to create and return an object reference inside a static method, using a static variable and calling Demo.init to observe how the reference changes.

Discover how to invoke a non static method on an object by creating a NonStaticMembersDemo instance and calling obj.doSomething(), with static blocks and constructors executing first.

Compare static and non static members: static belongs to class; non static belongs to objects. Static blocks load at class loading, while non static blocks run when objects are created.

Compare constructors and methods in a class, noting automatic execution, return types, and naming rules; explore how this and super relate to object creation and inheritance.

Explore primitive and reference data types in Java, including byte, short, int, long, char, float, double, and boolean, with memory sizes and value ranges explained.

Define and assign core Java data types: byte, short, int, long, char, float, and double; explain range and typecasting, and note char uses single quotes and float requires f suffix.

Learn how Java converts data between primitive and object types through implicit and explicit casting. See examples like byte to int and int to long, plus introduction to reference casting.

Learn implicit type casting in Java by assigning smaller types to larger ones, such as byte to int and int to long, and char to int.

Explore explicit type casting by converting higher-range types to lower-range types, such as int to byte and int to char, using explicit casts to resolve type mismatch.

Explore explicit type casting beyond range with Java examples, showing how 130 becomes -126 when cast to byte, and how 612 becomes d when cast to byte and to char.

Identify how identifiers name classes, methods, and variables, following rules: letters and digits, underscore, and dollar sign; cannot start with a digit or use Java keywords; Java is case sensitive.

Learn how static, non-static (instance), and local variables differ, how static fields initialize when a class loads, and why local variables require initialization.

Apply data types to two use cases by building an employee id class and a bank account class in Java, using int, string, boolean, and double fields, and printing results.

Master wrapper classes for converting primitive types to objects for the collections API, and learn boxing, unboxing, and string conversions between primitives, strings, and objects.

Learn how to convert between primitive ints and Integer objects using boxing and unboxing, using Integer.valueOf and intValue, in a Java project setup.

Learn to convert primitive to string using toString on wrapper types, and convert strings back to primitives with parseByte, parseInt, and parseFloat.

Explore converting between objects, strings, and primitives in Java 18 using wrapper classes, toString, and valueOf, including object to string and string to object conversions.

Wrapper classes provide two constructors to create objects from primitives or strings, demonstrated by new Long(primitive) or new Long(string).

Explore six wrapper conversions by building an all-in-one class that demonstrates converting int to string, using Integer constructors with strings and primitives, and parsing strings back to primitives.

Explore how Java passes command line arguments to main as a string array, checks args length, and prints each argument via Eclipse run configurations.

Learn to apply wrapper classes and command line arguments by building a program that reads two numbers from args, converts them with Integer.parseInt, and prints their product.

Explore the unary increment and decrement operators in java, including pre and post forms. See how x and y change with ++ and --, and why constants cannot be incremented.

Explore arithmetic operators in Java, including plus, minus, multiply, divide, and modulus, with a hands-on Eclipse IDE demo using int x=20 and y=10 to show each operation.

Explore how the Java plus operator performs numeric addition and string concatenation, demonstrating left-to-right evaluation and how mixing strings with numbers yields concatenated results.

Explore relational operators in Java, including <=, >=, ==, and !=, and note booleans cannot use >. Cast characters to int to view codes and compare a and A.

Explore how bitwise operators behave on booleans and integers, including and, or, xor, and not, with binary examples such as 4 and 5.

Master short circuit operators in Java, using && and || to evaluate booleans efficiently and avoid unnecessary checks, unlike & and | which evaluate both sides.

Explore the assignment operator in java: declare variables, chain assignments like x = y = z = 200, and apply compound assignments such as b += 40 to update values.

Learn the ternary operator in Java, which uses a boolean test with ? and : to choose x is greater or y is greater, demonstrated with x and y values.

Build a Java BMI calculator by creating a BMI calculator class, applying the BMI formula, converting height from feet to meters and weight to pounds, and printing the result.

Explore flow control statements that determine runtime execution order, including selection, iterative, and transfer statements such as if-else, switch, while, do-while, for, for-each, break, continue, return, try-catch-finally, and assert.

Learn how to use if-else blocks to execute code conditionally in Java, including if, else-if, and else with boolean expressions, optional braces, and a demo comparing two numbers.

See how the switch statement selects a case from an expression, readable versus if-else, using break and default, syntax and constants like integer, byte, short, char, enum, and string.

Understand switch fall-through in java: learn how missing break lets flow continue to the next case, how default activates, and how to share logic using fall-through across cases.

Master the while loop with its boolean condition and body, repeating until the condition becomes false. See a hands-on example iterating JDBC result set and printing numbers 1 to 10.

Discover how a do-while loop runs its body at least once, then checks the condition to continue; see a Java example in Eclipse.

Master the for loop in core java made easy by understanding initialization, condition, and increment or decrement, with semicolon syntax and examples printing 1 to 20 or 20 to 1.

Learn how the break statement transfers control in Java, exiting a switch or a loop when a condition is met, with an example that stops at i == 10.

Learn how to use break inside a labelled block in Java, exiting a named block like l1 when x equals 20, with visible outputs block begins and outside the block.

Learn how to use the continue statement in Java to skip iterations inside a for loop, illustrated by printing odd numbers from 0 to 10.

Learn to implement a Java if-else ladder for ATM use cases, check balance, change pin, withdraw cash, and deposit check, within an Eclipse project.

Recap the switch statement in Java, showing cases like check balance, change pin, and withdraw cash, with break and default for proper flow.

This lecture explains how to use the switch statement and switch expressions in Java, highlighting constant case labels, final variables, fall-through, default handling, and compile-time constraints.

Relocate the input variable and fix switch formatting, remove the break, and set input to one to output one, two, and three on separate lines when run.

Explore how the while loop repeats with a boolean condition, avoid infinite runs by breaking or turning the condition false, and the importance of braces for readability.

Master the do while loop and learn how a constant true triggers unreachable code and infinite loops, with the compiler flagging the issue when printing even numbers up to 30.

Understand the for loop in java, focusing on initialization, condition, and increment, and what happens when parts are omitted. Initialization can occur outside loop, causing infinite loops or unreachable code.

Explore Java access modifiers: private, protected, public, and default package access, and how they govern visibility of classes and members across packages and during inheritance.

Explore Java access modifiers from private to public by building class A in package p1 and testing access within the package, across packages, and through inheritance.

Create class B in the same package to test access to A's fields; observe that A.a is private and inaccessible from B, while default access remains open within the package.

Explores the protected modifier, inheritance, and access rules across packages in Java, using extends and imports to show how protected fields are inherited but not directly accessed.