
Already know some of this? A 2-minute test skips the lessons you know.
Take the placement testA free 82-lesson course built from Telusko's 12h 23m of YouTube video. 8 days at 90 minutes a day, with study notes and a quiz in every lesson. A 2-minute placement test skips what you already know.
Taught by Telusko on YouTube. Videos play in YouTube's own player, so the creator keeps every view.
Understand why Java is widely used in enterprise, mobile, and web development, and how learning core Java helps with other JVM languages.
Install JDK 17 (LTS) and VS Code, configure environment variables, and verify the installation with java --version and javac --version.
Create a Hello.java file in VS Code, write a main method, print 'Hello World', compile with javac, and run with java.
Use JShell (Java 9+) to experiment with expressions like addition and subtraction, and understand the difference between JShell and .java files.
Explain the roles of hardware, OS, JVM, JRE, and JDK; understand bytecode, compilation, and platform independence.
Declare variables with types (int, double, float, char, boolean), assign values, and print results using System.out.println.
Differentiate between byte, short, int, long, float, double, char, and boolean; understand ranges, default types, and memory sizes.
Use integer, floating-point, character, and boolean literals; perform implicit type promotion and explicit casting between primitive types.
Apply arithmetic, assignment, increment/decrement, relational, and logical operators; understand pre/post increment and short-circuit evaluation.
Control program flow with if-else blocks, combine conditions using logical operators, and print the greatest of three numbers.
Use the ternary operator for concise conditional assignments; implement switch statements with break and default for multi-way branching.
Write while, do-while, and for loops; use nested loops; understand loop initialization, condition, and increment in for loops.
Design a Calculator class with methods and instance variables; create objects with 'new', call methods, and pass parameters.
Detail the relationship between JDK (compiler), JRE (runtime), and JVM (execution); understand bytecode and platform independence.
Define methods with return types and parameters; overload methods by varying parameter count or type; distinguish from overriding.
Visualize stack frames for method calls and heap for objects; trace variable storage, object references, and garbage collection eligibility.
Create single and multi-dimensional arrays; initialize with values; access elements via index; use length property for bounds safety.
Identify fixed size, search cost, and single-type limitations; store custom objects in arrays to hold mixed data types.
Iterate arrays and collections with enhanced for loop (for-each); simplify syntax for reading elements without index management.
Understand string immutability, string constant pool, and reference sharing; explain why string concatenation creates new objects.
Use mutable StringBuffer (thread-safe) and StringBuilder (non-thread-safe); apply append, insert, delete, and capacity methods.
Share data across objects with static variables; initialize with static blocks; call static methods via class name; restrict instance variable access in static context.
Make fields private; provide public getter and setter methods; use IDE generation; follow naming conventions (getX, setX).
Differentiate instance and local variables with 'this'; create default and parameterized constructors; understand object initialization.
Call same-class constructors with this(); invoke superclass constructors with super(); control execution order in inheritance hierarchies.
Apply camelCase for classes, variables, methods; use UPPER_SNAKE for constants; create anonymous objects with 'new Class()' for one-time use.
Extend classes for code reuse; implement single and multilevel inheritance; override methods for subclass-specific behavior; understand dynamic method dispatch.
Organize code with packages; apply public, private, protected, default access; understand visibility across classes, subclasses, and packages.
Distinguish compile-time (overloading) and runtime (overriding) polymorphism; use parent reference for child object; method resolution at runtime.
Create constants with final variables; prevent method overriding with final methods; stop inheritance with final classes.
Override equals for content comparison, toString for readable output, hashCode for hash-based collections; understand default Object implementations.
Assign child object to parent reference (upcasting); cast parent reference to child type (downcasting); handle ClassCastException risk.
Declare abstract methods without implementation; enforce subclass implementation; prevent instantiation of abstract classes; mix abstract and concrete methods.
Define classes inside classes for encapsulation; instantiate inner classes via outer class object; use anonymous inner classes for one-time implementations.
Declare interface methods (public abstract by default); implement with 'implements'; create objects of implementing classes; use interface references.
Define single-method (functional) interfaces; implement with anonymous classes; simplify to lambda expressions (->) for concise, readable code.
Use lambdas for functional interfaces returning values; omit types, braces, and return for single expressions; distinguish normal, functional, and marker interfaces.
Distinguish checked (compile-time) and unchecked (runtime) exceptions; handle with try-catch; print stack traces; catch multiple exception types.
Trace Throwable -> Error/Exception -> RuntimeException/IOException; throw exceptions manually; create custom exceptions extending Exception.
Build custom exception classes with constructors; declare checked exceptions with 'throws'; delegate handling to caller; maintain exception hierarchy order in catch blocks.
Read console input with BufferedReader (wrap InputStreamReader) and Scanner (nextInt, nextLine); parse strings to integers; handle IOExceptions.
Declare resources in try(...) block; implement AutoCloseable; automatically close BufferedReader, files, connections; use finally for cleanup.
Extend Thread or implement Runnable; start threads with start(); set priority; pause with Thread.sleep(); handle InterruptedException.
Implement Runnable to avoid single-inheritance limit; pass Runnable to Thread constructor; understand race conditions on shared mutable data.
Identify thread states (new, runnable, running, blocked, dead); use synchronized methods/blocks for thread safety; prevent data corruption.
Use ArrayList with generics; add, get, set, remove by index; iterate with enhanced for loop; understand dynamic resizing vs arrays.
Store unique elements with HashSet; lose insertion order; use TreeSet for sorted sets; understand Set interface constraints.
Store key-value pairs with HashMap; retrieve values by key; iterate via keySet and entrySet; handle null keys/values.
Implement Comparable for natural ordering; use Comparator for external sorting logic; apply lambdas for concise comparator definitions.
Process collections with streams; chain filter, map, reduce, sorted; use forEach for terminal operations; leverage lazy evaluation and pipelines.