Master The Java Programming Language

Explore Java basics and object oriented programming through variables, data types, scanner input, and a simple interest example, plus package structure and main method templates.

Explore arithmetic, relational, logical, and bitwise operators, and learn how casting to double fixes integer division when calculating percentages from obtained and total marks.

Explore branching statements in Java, including if and switch, with practical examples showing value comparisons, else paths, and the importance of break statements in switch cases.

Explore looping statements in Java: while, do..while, and for, explaining when conditions are checked and how loops repeat, with examples of increments and printing.

Define arrays as a homogeneous collection in Java, allocated by the new operator and accessed via arr[i]. Explore initialization options and traverse with arr.length, including direct values and for-each printing.

Learn how to pass arrays to functions in Java, see how arrays are passed by address, and how in-place modifications affect the original array when using static helper methods.

Implement an array search by declaring and initializing an int array, then use a static search method with a for loop to return the index or -1 if not found.

Explore multidimensional arrays in Java by creating a 3-by-4 matrix and learning how to allocate jagged rows, access elements, and determine each row's length with array[index].length.

Design classes to create your own types by combining data and operations, using a Sample class and two objects with independent x values through set and get.

Demonstrates data hiding and encapsulation by using a class with a private field and public set and get methods to enforce positive values and protect data integrity.

Explain data hiding and encapsulation using an Account class, showing private balance and public withdraw, deposit, and getBalance methods to protect data integrity.

Explore data hiding and encapsulation by building a stack class with push, pop, and peek. Model stacks as objects and prevent array access, preparing for exception handling in Java.

Explore static and non-static members in Java, using a shared board versus individual notes, and learn to call static methods via the class name.

Explore static vs instance members in Java by visualizing a shared board and per-object notes, and understand why main() is public static void.

Learn static utility methods with a simple ArrayUtils search example. The method returns the index or -1 and shows calling static methods directly, without creating an object.

Master method overloading by presenting multiple print() variants for int, float, and String, with the compiler selecting the appropriate version by argument type.

Explore overloading in Java by implementing overloaded static search methods in a SearchUtil class, returning first and subsequent occurrences from a given position, and refactoring to reuse logic.

Explore the this reference variable, this.x usage, and getRef to understand how current objects are identified, how shadowing is resolved, and how objects share methods while maintaining state.

Explore static and non-static initializers in Java, showing static initializers run once when a class loads, while non-static initializers run for each object, with config loading and driver registration examples.

Explore constructors in Java, including no-argument and argument constructors, and learn constructor overloading through practical object initialization examples like Sample and PositiveInteger.

Explore how constructors control object creation through overloading, default behavior, and visibility, showing required constructor matching with a ComplexNumber example.

Master the Java constructor invocation pattern by using this() to chain no-argument and argument constructors, ensuring the first statement initializes without redundancy.

Learn how Java strings are immutable, why literals enable shared references, how StringBuilder and StringBuffer build strings efficiently, and how equals, equalsIgnoreCase, compareTo, and compareToIgnoreCase compare content.

Design a shopping cart with a ShoppingCart class that stores items in an array, tracks size and item count, and provides default and size constructors along with addToCart and order.

Design a CartItem with private itemCode and quantity using a mandatory constructor and this for shadowing, and build ShoppingCart with a default or custom size, addToCart and order capabilities.

Explore how inheritance extends a base class to reuse functionality, letting a scientific calculator gain sin() while maintaining the is-a relationship with a basic calculator.

Explore how composition uses delegation to reuse calculator functionality within a scientific calculator. Compare inheritance and composition, and learn why has-a delegation can be preferred for reusing behavior in Java.

Understand how overriding lets a subclass modify and extend base class behavior, using super calls and the override annotation to preserve the signature and prevent mistakes.

Generalize code through inheritance by designing base classes like Animal and Object, enabling a single feed method to work across subclasses such as WildAnimal, DomesticAnimal, Lion, Tiger, Cow, and Dog.

Understand dynamic binding in Java: how base and derived classes resolve overridden methods like f() and g() based on the actual object, and how h() requires Derived with instanceof checks.

Demonstrate dynamic binding by using instanceof to safely cast a BasicCalc to ScientificCalc, enabling access to sin() while invoking add() and subtract().

Master constructors in inheritance by learning how to select base class constructors with super when creating derived objects, handling private and protected fields, and using the override annotation on print.

Explore how the final modifier in java inheritance prevents method overriding and class extension, with examples of final methods and final classes.

Explore abstract classes, how they cannot be instantiated and require abstract methods, and how concrete subclasses complete them to enable object creation, using base and derived examples.

Extending an abstract class requires overriding all abstract methods, otherwise the subclass remains abstract. In the A, B, C example, override g() and h() to obtain a concrete class.

Declare a class as abstract to avoid instantiation, even without abstract methods, so a Demo can be instantiated while an abstract Demo blocks object creation and acts as base class.

Create an abstract Graphic with protected fields x1, y1, x2, y2 and setStart and setEnd, and override draw in Line and Rectangle; use drawShape to apply to any Graphic subclass.

Explore the template method design pattern by shaping a search algorithm with an abstract core and overridable match behavior, enabling equality and inequality searches while illustrating open-closed principles.

Explore Java interfaces as a specification that lists methods and constants, then implement them in a class like BasicCalculator that implements Calculator, enabling calls such as add, subtract, and sin.

Explore how the Sample interface defines f() and g(), how Base and Derived implement and extend with h() and i(), and how Base and Sample references limit accessible methods.

Explore how interfaces extend multiple interfaces and how a class can implement multiple interfaces, while clarifying that Java has no multiple class inheritance.

Explain default and static methods in interfaces, showing how default g() and static h() preserve existing implementations using the ITest example.

Design loosely coupled video components using a VideoPlayer interface and a factory to select Mp4Player or MovPlayer behind the scenes, so clients depend on interfaces, not implementations.

Offer feedback and reviews to help the instructor correct mistakes and improve future Java programming content, shaping how this course and other courses are delivered.

Explore the single responsibility principle from SOLID, showing how separating account creation, database storage, and notifications into AccountRepository and NotificationService clarifies responsibilities and improves design.

Apply the open-closed principle by designing a sort utility that is open for extension via a comparator, yet closed for modification, enabling ascending or descending orders without changing code.

Apply the Liskov Substitution Principle by substituting superclass objects with subclass instances, and show how Vehicle, Bike, and Car maintain expected start and stop behavior in tests.

Apply the interface segregation principle by splitting a restaurant interface into vegMeals and nonVegMeals parts, allowing classes to implement only the methods they need.

Explore the dependency inversion principle by showing how the high level messenger depends on a protocol handler interface, not concrete TCP or UDP classes, enabling runtime selection via a factory.

Learn how to organize Java classes into packages with a directory structure mirroring the package hierarchy, using com.bank and com.bank.service, and grasp private, default, protected, and public access.

Explore Java packages by building a demo with demo.service and AccountService, showing public versus default classes, imports, fully qualified names, and the difference between wildcard and explicit imports.

Learn how exceptions represent errors, how division by zero triggers arithmetic exception, and how try-catch blocks handle them by returning zero, while stack traces reveal call hierarchy.

Explore traditional exception handling in Java by comparing status codes with custom exceptions, learning how to propagate and handle errors, and design a robust approach using enums for status outcomes.

Create custom exceptions by extending Exception, declare throws for DataException and InsufficientFundsException, throw them in withdraw, and handle with try-catch and stack traces.

Master Java exception handling, covering throws, checked and unchecked exceptions, and the throwable hierarchy, including multi-catch and generic catch to simplify handling of multiple exceptions.

Master how the finally block guarantees resource release and how try with resources automates cleanup for files and database connections.

Design a stack with push, pop, and peek using an int array while exploring Java wrapper types, autoboxing, and unboxing through primitive to object conversions and exceptions.

Designs a stack in Java using an Integer wrapper array with a default limit of 5, overloads constructors, and implements push, pop, and peek with StackException and optional handling.

Learn how the file class in Java exposes file metadata, including existence, length, last modified, and directory or file status, and creates empty files while handling IOException.

Explore listing files in a directory with baseDir.listFiles() and a simple FileUtils.display utility. Filter results using a FilenameFilter to list only .java files and discuss the open-closed principle.

Learn to copy a file by reading from a FileInputStream and writing to a FileOutputStream, byte by byte until end-of-file (-1), with basic exception handling.

Learn efficient file copy using a byte buffer with file input stream and file output stream, reading into a 1024 byte buffer and writing only the bytes actually read.

Develop a generalized IOUtils.copy(InputStream, OutputStream) utility to copy data between streams, and use try-with-resources for automatic resource management while honoring the Liskov's Substitution Principle.

Master the buffered IO concept by using BufferedInputStream and BufferedOutputStream to wrap FileInputStream and FileOutputStream, learn how buffering and flush operations improve disk read/write performance and the decorator pattern.

Explore how data input and output streams handle primitive types by converting integers and floats to bytes, using DataOutputStream and DataInputStream with file streams and the decorator pattern.

Learn object serialization and deserialization in Java using ObjectOutputStream and ObjectInputStream to write and read Rectangle objects to a file. Understand NotSerializableException, the Serializable marker interface, and transient fields.