Core Java Made Easy for Automation Testing

Learn what the class keyword means in Java and how it represents real-world objects in code. Understand the class block and how to convert a real-world object into programming.

Explore using System.out.println in Java, why code must reside in a method rather than the class body, and how compile-time errors occur when printing at the class level.

Discover why the main method is required and how the compiler turns Java code into a class file and runs on the JVM with execution from top to bottom.

Understand Java data types. Explain how the JVM and compiler check types, and review types such as byte, short, int, long, float, double, and non numeric types boolean and char.

Explain the byte data type as an integral type, its one-bit size, and two as complement storage, with a practical demo showing a compile-time lossy conversion error.

Explore the short data type in Java, its 16-bit range, and how values like 10 and 30 print, while noting compile-time errors for overflow, lossy conversion, incompatible types, and practice.

Explain integral data types—byte, short, int, and long—with their 32-bit and 64-bit ranges, and introduce floating point types float and double for future lessons.

Explore the ranges and limitations of floating point types in Java, including float and double, with their exponential representations, and contrast them with long data type for size considerations.

Explain why a float cannot be stored in a long without a compile-time error due to lossy conversion, while a long to float is permitted by the JVM memory model.

Discover how identifiers denote class names, method names, and variable names in Java, with examples like main, string, System, and println, and relate them to reserved data types and literals.

Learn the rules for identifiers in Java: allowed characters are a to z, 0 to 9, underscore, and dollar; nonconforming symbols cause compile-time errors.

Explore the second rule for identifiers: never start an identifier with a digit, as that triggers a compile-time error; later digits may appear, but not at the start.

Explore Java identifier rule three: identifiers are case sensitive, so similarly named variables with different cases map to distinct memory locations, and reuse of a name causes conflict.

Rule four explains that Java identifiers have no length limit, but overly long names reduce readability and can slow the application by consuming memory, with no compile or runtime errors.

Identify why reserved words and keywords cannot be used as identifiers in Java, per rule number five, and note using them triggers a compile-time error, with literals true and false.

Learn rule six: predefined java class and interface names can be used as identifiers; explore string as a java.lang class and distinguish between a data type and an identifier.

Explore why methods matter in Java by distinguishing business logic and mathematical logic, and show how placing logic at class level triggers illegal start of type.

Explore the method as a sub block of a class implementing object operations, detailing return types, parameter lists, the method body, and accessibility modifiers such as public, protected, and private.

Learn how to create and call static methods within a Java class, understand the main method, and follow compilation to bytecode and top-to-bottom execution flow.

Explore static methods and static versus non-static types in Java, including how static void methods work, how to call them, and when to use objects versus memory and class members.

Explore how to define a static method with a string return type, pass or omit arguments, and see how inputs impact compilation and the method's output.

Explore non-static methods with void return type, understand object creation through constructors, and contrast static versus non-static members in Java, including access via this.

Learn how to define and call non-static methods with return types in Java, access them via objects, and distinguish them from static methods for effective core Java programming.

Learn how non-static methods use parameterization by defining an instance method that accepts parameters such as id, and access it through an object.

Compare the return statement and return with value in a method, explaining how a statement ends execution, while a value return must match the method's type.

Learn how abstract methods declare operations without bodies and require the abstract keyword, indicating a declaration in interfaces and implementations. See real-time examples and syntax details.

Discover how a variable acts as a memory location that stores data temporarily, and learn how to create a variable and specify its data type for your program.

Explore primitive and reference variables, and distinguish class level, local, static, and non-static variables, with guidance on when to use each in Java projects.

Define and create variables using complete syntax, including data type, variable name, and assigned value, while understanding primitive versus reference types and optional accessibility modifiers.

Learn how to create and access static and non-static variables in Java, with real-time examples of memory sharing and class-level access via class name or objects.

Learn what a local variable is, its scope inside a block or method, and why it cannot be accessed outside; final is the applicable modifier.

Learn that local variables are scoped to a single method and cannot be accessed from other methods, must be initialized before use, and cause compile-time errors if used before declaration.

Discover how static members are class level elements defined with the static keyword, including static variables, blocks, methods, and the main method, and their execution flow.

Learn the rules of static member execution in Java, including the order of static variable, static block, main method, and static method calls, with top-to-bottom initialization insights.

Learn what a non static member is, how it differs from a static member, and why it provides a per instance memory copy for data like employee records.

Explore the execution flow of non-static members in Java, including non-static variables, blocks, constructors, and methods; learn how object creation triggers memory and the top-to-bottom JVM order.

Explore why and what a constructor is in Java, how the new keyword initializes memory when you create an object, and that the constructor name must match the class name.

Learn rules for defining constructors: name must match class, avoid return types and static or final modifiers, allow parameters and logic, with access modifiers, but do not return a value.

Demonstrates defining a constructor in a class, calling it with new when creating an object, and the constructor's top-to-bottom execution in Java.

Learn constructor overloading in Java, including private constructors for singleton patterns, and how defining a method with the class name works with different parameter types and orders.

Explore how the this keyword stores the current object reference in non static contexts, separating class level and local variables with the same name, as the compiler adds this keyword.

Explore how this keyword provides the current object reference for non-static member calls, enabling method execution and cleanup by the JVM and compiler.

Master how to use the this keyword to reference the current object, differentiate non-static variables from one object to another, and access constructors of the current class via overloaded constructors.

Learn how the super keyword accesses a superclass's constructor, variables, and methods from a subclass, including resolving name clashes, with practical code examples.

Explains rules on the super call in constructors, showing that super must be the first statement and that other placements trigger compile-time errors.

Explore the rules of the super keyword, showing that it applies only to non static members and cannot be used from a static context, yielding compile time errors.

Learn when to place an explicit super call in a subclass with a parameterized constructor. Avoid compilation errors by matching the super call to initialize the superclass.

Learn to use super dot to access superclass variables and methods when subclass and superclass variables share the same name, with a practical example.

Show that the super keyword applies only to non static members, cannot be used in a static context, and triggers a compile time error when used as a static member.

Learn how object oriented programming converts real world objects into the programming world, with Java as an example, to automate business through net banking and ecommerce platforms like Flipkart.

Explore core object oriented programming concepts, including objects, classes, encapsulation, abstraction, inheritance, and polymorphism, with real-world examples in Java and e-commerce scenarios.

Define object and class by illustrating real world things like a bike or bank account, then explain the class keyword as a logical construct that defines object properties and behavior.

Explore what object oriented programming is and why it matters, mapping real world objects to code through encapsulation and polymorphism with bank and e commerce examples, including dynamic method dispatching.