Java Deep Diving - From the Beginning

Discover how the java.util.Scanner class reads integers from the command prompt by importing java.util.Scanner, creating a new Scanner(System.in), and using nextInt to compute a sum.

Explore Java's reserved words, including 50 keywords and 3 reserved literals, and learn primitive and reference data types, modifiers, and flow control keywords.

Learn how Java identifiers work: valid characters and starting rules, case sensitivity, unlimited length, and why reserved words or predefined names like string and runnable affect naming.

Explore Java data types, distinguishing primitive from reference types. Identify the eight primitive types: byte, short, int, long, float, double, char, boolean, and understand their roles.

Explore how the byte data type uses eight bits with a sign bit, yielding -128 to 127 via two's complement, and its role in network and file I/O.

Explore the short data type in Java, its 16-bit size, range (-32,768 to 32,767), and why it's rarely used today except for exams and 16-bit historical context.

Explain the byte, short, int, long data types, their bit sizes, and how integer literals, ranges, default int behavior, and floating point types (float, double) affect compilation.

Explore the long data type in Java, a 64-bit integer for large values, such as file character counts returned by java.io.File.length, beyond int range.

Compare float and double data types to understand their 32-bit and 64-bit storage, single and double precision, and the 5–6 and 14–15 decimal place accuracy defined by IEEE 754.

Explore the boolean data type in Java, using true and false literals while avoiding invalid values, and learn how the JVM decides size and why non-boolean values trigger compile-time errors.

Explore how Java's char data type represents a single character with 16-bit Unicode values, differing from C's 8-bit ASCII, including literals, printing, and the range 0 to 65,535.

Explore variable declaration and initialization in Java, illustrate with int x and its initialization, highlight compile-time errors for uninitialized variables, and introduce the concept of strongly typed languages.

Explore why Java is strongly typed, with points that every variable and expression has a type, every data type is well defined, and the compiler checks type compatibility.

Explore Java integer literals, including decimal, octal, hexadecimal, and binary forms, learn how literals assign constant values to variables, and distinguish long literals using the L suffix.

Learn long literals in Java with L or l suffixes, and how long and int types interact, including compile-time errors, absence of byte/short literals, and wrap-around casting.

Explore floating point literals in Java, including float and double literals with f or d suffixes, the default double behavior, and why upcasting occurs when assigning to float.

Explore boolean literals, including true and false, and learn why assigning an int or a string to boolean triggers compile-time errors in Java’s strongly typed system.

Learn how char literals use single quotes to represent characters, distinguish them from string literals in double quotes, and assign int literals to char within the Unicode range 0–65535.

Explore how Java char literals use Unicode escape sequences—backslash u followed by four hex digits—to represent characters like capital A and B, converting hex to decimal for their Unicode values.

Explore java escape characters, including tab, backspace, newline, carriage return, form feed, and escaping quotes and backslashes; learn through examples how these literals affect output and line handling.

Explore four ways to specify a Java character literal: single quotes, integer literals, unicode escapes (\\uXXXX), and valid escapes, with notes on illegal escape errors and System.out.print behavior.

Explore string literals as sequences of characters inside double quotes, see how to declare a string variable and print it, and preview Java 1.7 enhancements to literals.

Explore how Java 1.7 adds binary literals to integer constants, using 0b or 0B prefixes with digits 0 and 1, and understand compile-time errors for invalid binary values.

Learn how the underscore symbol is used between digits in Java numeric literals to improve readability, from Java 7 onwards, with rules about placement and compiler removal.

Explore Java variables by category: primitive and reference data types, and local, instance, and static variables, including method local and block variables, with a peek at JVM architecture.

Explore java method local variables and the jvm architecture, including class loader, memory areas, and execution engine, and learn how a main method's local variable is created and stored.

Explore the eight steps of running a Java program, from starting the JVM and creating the main thread to loading class files, executing the main method, unloading, and shutting down.

Copy the value of a local variable to another using simple assignment, print both values, and explore how the JVM loads classes, memory areas, and stack frames during execution.

Explore method local variables in Java, including declarations, initialization, and compile-time errors when printing uninitialized locals; understand that Java has no garbage value and how assignment rewrites existing values.

Explore how block variables behave like method local variables, with scope as the difference. Show four kinds of blocks—static, instance, local, and nested—along with conditional blocks that influence visibility.

Explore method local and block variables, distinguish them from instance and static variables, and learn how local variables reside in a stack frame and are deleted after method execution.

Explore how a class acts as a brick mold and how objects map to bricks, emphasizing instance variables and the JVM memory layout (heap, stack, method area) in Java.

Map instance variables to real world car properties like name, brand, color, and speed, and link instance methods such as move, brake, and horn to the Java heap object.

Explore instance variables with a car class having name, brand, color, and speed, and create a Java object using the new operator in a main method; print the values.

Explore how instance variables behave with and without an object, and in main method, highlighting non-static versus static contexts and default values in heap and stack.

Demonstrates instance variables and object creation with new, explains heap and stack memory with t1 and t2 references, shows default int values, and prints 12 and 24.

Show how a single heap object is referenced by two stack variables, t1 and t2, sharing and updating the same number, resulting in 24 after reassignment and final stack cleanup.

Explain how each object has its own instance variables, how assigning a new object updates the reference, and how unreferenced objects become eligible for garbage collection.

Explore how the JVM assigns default values to instance variables, including primitive and reference types. See how object creation in main initializes these fields to 0, 0.0, false, or null.

Define instance variables as per-object state that varies; also called object-level attributes. Store each car's speed copy in heap memory, access it via object references, and JVM default values apply.

Explore static variables as a single shared value across car objects, contrasted with per-object instance variables, and learn how wheels become a class variable in the method area.

Discuss static variable examples and the static modifier, showing how static variables are created at class loading, accessed via the class name, and destroyed on class unloading.

Demonstrate how to access the static variable using the class name, compare static and local variables, and outline the JVM memory areas and loading steps that affect the printed value.

Explore static vs. instance variables through Java examples 17–22, illustrating when to use a single class-wide copy. Understand memory roles, final reassignment, and static access via class names.

Understand why static variables provide a single class-level copy shared by all objects, created at class loading and destroyed at class unloading, versus instance and local variables.

Explore Java methods, including abstract, concrete, and native, with a focus on static and instance methods. Identify a method’s modifiers, return type, method name, and parameters.

Explain how instance methods map to an object's behaviors, using a real-world child mapped to a Java heap object with run and eat methods, including object creation and method calls.

Explore static methods in Java, distinguishing class level methods from instance methods. Learn when to use static methods—when behavior is shared across objects—and how to call them via class name or an object.

Explore Java variable scopes and method types through practical examples, covering method local, local, static, and instance variables, along with static and instance methods, object creation, and compile-time behaviors.

Demonstrate static versus instance variables and methods in Java through practical memory diagrams. Explain heap and stack usage, object creation, parameter passing, and garbage collection.

Explain how the this keyword refers to the currently running object and how instance variables, methods, and stack frames interact, including static context and a compile time error.

Demonstrate how infinite recursion between m and m1 methods exhausts stack memory, causing a stack overflow error. The example traces memory allocation for main, m1, and m methods.

Install Eclipse Neon, create a Java project in a custom workspace, configure the JRE, write test.java with a main method and System.out.println to print hello world, and run it.

Switch between eclipse workspaces for university, educational, and software industry Java projects. Create, run, and rename projects across workspaces, and manage deletion and refactor rename.

Learn how to return a value from a static Java method by implementing a two numbers add program in Eclipse, with scanner input and a dedicated add method returning int.

Explore how method design in Java uses type compatibility to match return types with assigned variables, handle long and int conversions, and address void methods.

Explore practical Java method examples, covering instance versus static methods, object invocation, type casting between int, short, byte, and long, and post and pre increment behavior.

Explore pre- and post-increment behavior in Java, distinguishing literals from variables, and examine how static versus instance variables initialize, update, and print across method calls.

Explore how instance variables are created per object, default values apply, and how object references and memory layout (stack and heap) shape t1, t2, and t3 during method calls.

Explore Java object creation, stack and heap layout, and a main method that shows two objects and a method call printing 20 and 34, with an octal reminder.