Java Full Stack Course: HAS-A Relationships & Object Class Internals

#Day35 : 🚀 AI Powered Java Full Stack Course Learning Java Full Stack with Frontlines EduTech (FLM) || AI Powered Java Full Stack Course Multithreading in Java – join(), Race Conditions, Synchronization & Deadlocks Hello connections 👋, Today’s class was a continuation of Multithreading in Java, and it focused on how threads coordinate with each other in real-time scenarios. I learned how thread execution order is controlled, how data inconsistency occurs, and how Java ensures thread safety. Here’s a structured summary of what I learned today 👇 🔹 1️⃣ Thread Execution & join() Method When multiple threads are executed inside main() without sleep() or join(): ✔ Threads execute immediately when CPU time is allocated ✔ Main thread does not wait for other threads by default To control execution order, we use join(): join() pauses the current thread until another thread completes Helps prioritize execution Useful when one task depends on another 📌 sleep() vs join(): sleep() pauses a thread for a fixed time join() waits until another thread finishes execution 🔹 2️⃣ Race Condition in Java A race condition occurs when: Multiple threads modify the same shared variable Results become inconsistent Variable becomes not thread-safe Explained using a real-time example of simultaneous ATM withdrawals from the same account. 🔹 3️⃣ Synchronization & Thread Safety To prevent race conditions, Java provides the synchronized keyword. Ways to use synchronized: Method-level synchronization Block-level synchronization ✔ Only one thread can access the critical section at a time ✔ Lock is released after execution ✔ Ensures data consistency 📌 Trade-off: Synchronization increases safety but may reduce performance. Real-time usage: Debit operations → thread-safe Credit operations → can be concurrent Balance checks → design-dependent 🔹 4️⃣ Synchronized Block (Fine-Grained Locking) ✔ Synchronizes only critical code ✔ Other threads can execute non-critical code ✔ Better performance than method-level locking 🔹 5️⃣ Deadlocks in Java A deadlock occurs when: Thread T1 waits for a resource held by T2 Thread T2 waits for a resource held by T1 Both threads wait forever Caused by: Multiple locks join() misuse Circular dependencies ✔ Proper lock ordering helps prevent deadlocks. 🎯 Key Learning Outcomes ✔ Controlled thread execution using join() ✔ Understood race conditions ✔ Ensured thread safety with synchronization ✔ Learned real-time multithreading scenarios ✔ Understood deadlocks and prevention ✔ Balanced performance vs safety Today’s class gave me strong clarity on real-world multithreading challenges in Java 🚀✨ Special thanks to Krishna Mantravadi, Upendra Gulipilli, and my trainer Fayaz S for their continuous guidance and practical explanations. 🔖 Hashtags #Java #Multithreading #ThreadSafety #Synchronization #RaceCondition #Deadlock #JavaConcurrency #AIPoweredLearning #JavaFullStack #FLM #FrontlinesEduTech #SoftwareEngineering

#Day38 – AI Powered Java Full Stack Course Learning Java Fullstack with Frontlines EduTech (FLM) || AI Powered Java Full Stack Course Callable Interface, Future, Try-with-Resources & Core Java Utilities Hello connections 👋, In today’s class, I explored some advanced and practical Java concepts related to multithreading, resource management, strings, exceptions, and utility classes. These topics are highly relevant for real-time applications and technical interviews. Here’s a structured summary of what I learned 👇 🔹1️⃣ Callable Interface & Future in Java The Callable interface is an enhanced alternative to Runnable. Contains a single abstract method: call() Supports generics, so it can return: Wrapper classes User-defined objects Return type and return value must match 📌 Execution Flow: Callable tasks are submitted using executorService.submit(callableObj) submit() returns a Future object future.get() retrieves the value returned by call() ✔ future.get() is a blocking call ✔ Used when we need a result from a thread 📌 Key Difference: Runnable → executes a task (no return value) Callable → executes a task and returns a value 🔹 2️⃣ Try-with-Resources (Java 7) I learned how try-with-resources simplifies resource management. Introduced in Java 7 Works with classes implementing AutoCloseable Automatically closes resources like files, streams, DB connections Removes the need for finally blocks ✔ Cleaner code ✔ Prevents resource leaks ✔ Improves reliability 🔹 3️⃣ StringBuffer vs StringBuilder Key differences discussed: Both are mutable StringBuffer → thread-safe, synchronized StringBuilder → not thread-safe, non-synchronized (faster) Both modify the same object Memory allocated in heap 📌 Capacity Concept: Default capacity = 16 With initial string → string length + 16 New capacity = (old capacity × 2) + 2 🔹 4️⃣ Exception Breakdown in Java Java exceptions provide: Exception name Error message Line number of occurrence This information is essential for debugging runtime issues, especially in the main thread 🔹 5️⃣ Math Class in Java All methods are static No object creation required Part of java.lang package (no import needed) ✔ Widely used for calculations and problem-solving 🎯 Key Learning Outcomes (Day 38) ✔ Returned values from threads using Callable & Future ✔ Understood blocking behavior of future.get() ✔ Improved resource handling with try-with-resources ✔ Gained clarity on StringBuffer vs StringBuilder ✔ Understood capacity growth mechanism ✔ Learned exception structure and Math utilities Today’s session strengthened my understanding of advanced Java utilities and multithreading used in real-world Special thanks to Krishna Mantravadi , Upendra Gulipilli, and my trainer Fayaz S for their continuous guidance and practical explanations 🔖 Hashtags #Java #Callable #Future #ExecutorService #Multithreading #TryWithResources #StringBuffer #StringBuilder #JavaUtilities #ExceptionHandling #AIPoweredLearning #JavaFullStack #FLM #FrontlinesEduTech

#Day34 : 🚀 AI Powered Java Full Stack Course Learning Java Fullstack with Frontlines EduTech (FLM) || AI Powered Java Full Stack Course Multithreading & Threads in Java Hello connections 👋, In today’s class, I was introduced to one of the most important and powerful concepts in Java — Multithreading. This session helped me understand how Java applications achieve parallel execution and better performance in real-time systems. Here’s a clear summary of what I learned today 👇 🔹 Understanding the Basics Before jumping into threads, I understood the fundamentals: Core, Processor, and RAM A process is a running application A single process can contain multiple threads JVM itself is a process that manages memory, class loading, object creation, and execution 🔹 What is a Thread? A thread is a lightweight process Every method execution runs inside a thread Threads are stored in stack memory After execution, JVM cleans up thread memory Threads share memory with each other Threads execute independently 🔹 Thread Scheduling Java normally executes code line by line In multithreading, execution depends on the Thread Scheduler Execution order is not guaranteed Output in multithreading is unpredictable 📌 Current thread details can be checked using: Thread.currentThread().getName() 🔹 Ways to Create Threads in Java There are two ways to create threads: 1️⃣ By extending the Thread class Override run() method Call start() to begin execution 2️⃣ By implementing Runnable interface (Best Practice) Implement run() method Pass object to Thread constructor Call start() ✔ Runnable is preferred as it supports better design and avoids inheritance limitations ✔ Priority rule: extends → implements 🔹 Thread Lifecycle & Sleep Threads start only after calling start() Thread.sleep() pauses execution temporarily It throws InterruptedException (checked exception) 🔹 Why Thread Class Is Not Imported Classes like Thread, System, Object, and wrapper classes belong to java.lang, which is auto-imported by Java. 🔹 Real-Time Usage of Multithreading Used where execution order is not critical, such as: Banking systems Insurance applications Gaming applications Large database operations Multithreading helps save time and improve performance. 🎯 Key Learnings ✔ Difference between process and thread ✔ Role of thread scheduler ✔ Thread creation techniques ✔ Why Runnable is preferred ✔ Importance of multithreading in real-world projects Special thanks to Krishna Mantravadi, Upendra Gulipilli, and my trainer Fayaz S for the practical explanations and hands-on approach. 🔖 Hashtags #Java #Multithreading #ThreadsInJava #JavaConcurrency #JavaLearning #CoreJava #AIPoweredLearning #JavaFullStack #FrontlinesEduTech #FrontlinesMedia #flm #ai

#Day31🚀 AI Powered Java Full Stack Course Learning Java Full Stack with Frontlines EduTech (FLM) || AI Powered Java Full Stack Course Dynamic Method Dispatch & Exception Handling in Java Hello connections 👋, In today’s class, I explored two important and real-time Java concepts that play a major role in backend development and frameworks like Spring Boot. Here’s a structured summary of what I learned today 👇 🔹 1️⃣ Dynamic Method Dispatch (Runtime Polymorphism) Dynamic Method Dispatch is a mechanism where method calls are resolved at runtime, based on the actual object rather than the reference type. Since this binding happens during execution, it is also known as late binding. ✔ Achieved using runtime polymorphism ✔ Requires inheritance or interface implementation ✔ Method overriding is essential In real-time applications (especially Spring Boot): Parent references (interfaces) are used to hold child class objects This helps restrict modifications at the interface level Any change in the interface forces child classes to implement it, ensuring consistency This concept helps build loosely coupled and scalable applications. 🔹 2️⃣ Introduction to Exception Handling in Java Exception handling prevents abnormal termination of a program and allows it to continue execution safely. 🔸 Error vs Exception Error: Serious issues that cannot be handled (e.g., JVM crash) Exception: Issues that occur during execution and can be handled 🔸 Why Exception Handling is Needed ✔ Prevents JVM from shutting down abruptly ✔ Allows program continuation ✔ Displays meaningful messages to users 🔹 3️⃣ Types of Exceptions ✔ Checked Exceptions – compile-time exceptions ✔ Unchecked Exceptions – runtime exceptions 📌 Parent class of all exceptions: Throwable 📌 Parent class of exception hierarchy: Exception 🔹 4️⃣ try–catch Mechanism 🔹 try block – contains error-prone code 🔹 catch block – handles exceptions thrown by try Using try–catch ensures the program continues after an exception. 🔹 5️⃣ Advanced Exception Handling Concepts ✔ Multiple try–catch blocks ✔ Nested try–catch blocks ✔ Single try with multiple catch blocks ✔ Importance of exception hierarchy ⚠️ Parent exception should not be written before child exceptions, or child blocks become unreachable. 🔹 6️⃣ Exception Debugging Methods ✔ toString() – returns exception name and message ✔ printStackTrace() – displays detailed error trace for debugging 🎯 Key Learning Outcomes ✔ Understood runtime method resolution ✔ Learned real-time usage of runtime polymorphism ✔ Differentiated error and exception ✔ Gained clarity on exception hierarchy Special thanks to Krishna Mantravadi, Upendra Gulipilli, and my trainer Fayaz S for their continuous guidance. 🔖 Hashtags #Java #DynamicMethodDispatch #RuntimePolymorphism #LateBinding #ExceptionHandling #JavaExceptions #TryCatch #JavaLearning #BackendDevelopment #AIPoweredLearning #JavaFullStack #FrontlinesEduTech #FrontlinesMedia #flm #ai

#Day32 : 🚀 AI Powered Java Full Stack Course Learning Java Fullstack with Frontlines EduTech (FLM) || AI Powered Java Full Stack Course finally, throw, throws & Custom Exceptions in Java Hello connections 👋, In today’s class, I explored advanced exception-handling concepts in Java that are very important for writing safe, reliable, and real-time applications. The session focused on how Java manages resources, propagates exceptions, and allows developers to define their own exceptions. Here’s a clear summary of what I learned today 👇 🔹 1️⃣ finally Block in Java The finally block is used to close resources and execute cleanup code, regardless of whether an exception occurs or not. ✔ Always executes after try or catch ✔ Used to close files, database connections, and streams ✔ Helps avoid resource leaks Valid usages: try-catch-finally try-finally 📌 We cannot use multiple finally blocks. ⚠️ Scenarios where finally does NOT execute: Forceful JVM shutdown using System.exit(0) OutOfMemoryError 📌 If a return statement is used in try/catch/finally, the value returned from finally overrides others. 🔹 2️⃣ throws Keyword The throws keyword is used at the method level to delegate exception handling to the caller. ✔ Used for both checked and unchecked exceptions ✔ Alternative to try–catch blocks ✔ JVM never handles exceptions automatically 📌 Exceptions must be handled either using: try–catch or throws 🔹 3️⃣ throw Keyword The throw keyword is used to explicitly throw an exception. ✔ Mostly used for custom exceptions ✔ Can also throw predefined exceptions ✔ Widely used in web applications to send error responses (status codes + messages) Used when: Input validation fails Business rules are violated 🔹 4️⃣ Custom (User-Defined) Exceptions Custom exceptions are created to handle application-specific errors. ✔ Created by extending: Exception (checked) or RuntimeException (unchecked) ✔ Parameterized constructor is used to pass error messages using super(message) 📌 If a class extends Exception, the compiler forces handling at compile time. 🎯 Key Learning Outcomes ✔ Learned guaranteed resource handling using finally ✔ Understood exception delegation with throws ✔ Learned how to explicitly throw exceptions ✔ Gained clarity on creating and using custom exceptions ✔ Strengthened real-time and interview-ready Java skills Today’s class helped me understand how Java handles failures gracefully and communicates errors effectively, which is essential for backend and web application development 🚀✨ Special thanks to Krishna Mantravadi, Upendra Gulipilli, and my trainer Fayaz S for their continuous guidance. 🔖 Hashtags #Java #ExceptionHandling #finally #throw #throws #CustomExceptions #JavaLearning #BackendDevelopment #AIPoweredLearning #JavaFullStack #FrontlinesEduTech #FrontlinesMedia #flm #ai

#Day43 : 🚀 AI Powered Java Full Stack Course Learning Java Full Stack with Frontlines EduTech (FLM) Set Internal Working & Important Miscellaneous Java Concepts Hello connections 👋, Today’s session was a combination of deep internal concepts and important Java fundamentals that are frequently asked in interviews. Here’s a structured summary of what I learned 👇 🔹 1️⃣ Internal Implementation of Set Today I understood how Set internally uses Map to store elements. ✔ When we use add() in a Set (like HashSet), internally it calls a HashMap. ✔ The value we pass in add() is stored as the key in the Map. ✔ The Map stores a dummy static object (commonly called PRESENT) as the value. Example internally: map.put(element, PRESENT); Since Map does not allow duplicate keys: ✔ If the key already exists → it replaces the value ✔ So Set automatically prevents duplicates This is the core reason why: ✔ Set doesn’t allow duplicates ✔ Set relies on hashCode() and equals() Understanding this internal mechanism is very important for interviews. 🔹 2️⃣ Command Line Arguments I learned how Java programs accept inputs from the command line. ✔ Passed through String[] args in main method ✔ Useful for dynamic inputs at runtime ✔ Commonly used in automation, batch jobs, and real-time tools Example: public static void main(String[] args) Arguments are passed while running the program. 🔹 3️⃣ Var-Args (Variable Arguments) Var-args allow passing multiple arguments to a method dynamically. Syntax: methodName(int... numbers) ✔ Internally treated as an array ✔ Simplifies method overloading ✔ Must be the last parameter in method signature Very useful when number of inputs is not fixed. 🔹 4️⃣ Enums in Java Enum is a special type used to define fixed constants. Example: enum Status { ACTIVE, INACTIVE } ✔ Improves type safety ✔ Avoids using hardcoded strings ✔ Used heavily in real-world applications (status codes, roles, days, etc.) Enums can also contain: ✔ Variables ✔ Constructors ✔ Methods 🔹 5️⃣ Types of Blocks in Java We discussed two important blocks: ✔ Static Block Executes once when class is loaded Used for static initialization ✔ Instance Block Executes whenever object is created Runs before constructor These blocks help in controlling initialization flow. 🎯 Key Learning Outcomes – Day 43 ✔ Understood how Set internally uses Map ✔ Learned why duplicates are not allowed in Set ✔ Gained clarity on command line arguments ✔ Learned practical usage of var-args ✔ Understood enums and type safety ✔ Differentiated static and instance blocks Today’s class strengthened my understanding of both internal collection mechanisms and important core Java features that are commonly asked in interviews 🚀 Special thanks to Krishna Mantravadi, Upendra Gulipilli, and my trainer Fayaz S for their continuous guidance. #Java #Collections #HashSet #CoreJava #Enums #VarArgs #CommandLineArguments #JavaInternals #InterviewPreparation #AIPoweredLearning #JavaFullStack #FLM #FrontlinesMedia

#Day41 : 🚀 AI Powered Java Full Stack Course Learning Java Full Stack with Frontlines EduTech (FLM) || AI Powered Java Full Stack Course Set & Map Interfaces in Java – HashSet, TreeSet, LinkedHashSet, HashMap & More Hello connections 👋, In today’s class, I explored two very important parts of the Java Collection Framework — Set and Map — along with their internal working, differences, and real-time behavior. Here’s a structured summary of what I learned 👇 🔹 1️⃣ Set Interface ✔ Set is an interface in the Collection Framework ✔ Does not allow duplicate elements ✔ Does not maintain index-based access ✔ No traditional for-loop (we use for-each or Iterator) ✔ Internally uses hashing (backed by Map implementations) 🔹 2️⃣ HashSet ✔ No duplicates allowed ✔ No insertion order maintained ✔ Allows only one null ✔ Uses hashCode() and equals() to identify duplicates If hashCode() and equals() are not overridden in custom objects, duplicates will not be detected properly. 🔹 3️⃣ LinkedHashSet ✔ No duplicates ✔ Maintains insertion order ✔ Allows one null ✔ Combines hashing + linked list structure 🔹 4️⃣ TreeSet ✔ No duplicates ✔ Sorted in ascending order ✔ Does NOT allow null ✔ Implements SortedSet For custom objects, TreeSet requires: ✔ Comparable or ✔ Comparator Otherwise → ClassCastException Sorting is mandatory in TreeSet, so it must know how to compare objects. 🔹 5️⃣ Removing Duplicates from List I practiced converting an ArrayList into a Set or manually filtering duplicates using contains() to understand uniqueness behavior. 🔹 6️⃣ Map Interface ✔ Map is NOT part of Collection interface ✔ Works with key–value pairs ✔ Keys are unique ✔ Repeating a key overrides the value ✔ Values can have duplicates Structure example: { maths:90, science:98, social:67 } Key behaves like a Set (unique). 🔹 7️⃣ Types of Map 🔸 HashMap • No order • Allows one null key & multiple null values • Key uniqueness enforced 🔸 TreeMap • Keys sorted in ascending order • No null key allowed • Allows null values • Uses natural ordering or Comparator 🔸 LinkedHashMap • Maintains insertion order • Allows one null key • Allows multiple null values 🎯 Key Learning Outcomes ✔ Understood uniqueness using hashCode() & equals() ✔ Learned difference between HashSet, TreeSet & LinkedHashSet ✔ Understood Map vs Collection ✔ Learned key–value storage mechanism ✔ Understood sorting behavior in TreeSet & TreeMap ✔ Strengthened knowledge for interviews & backend development Today’s session helped me understand how Java handles uniqueness, ordering, hashing, and key-value mapping internally — which is critical for writing efficient real-world applications 🚀✨ Special thanks to Krishna Mantravadi, Upendra Gulipilli, and my trainer Fayaz S for their continuous guidance. 🔖 Hashtags #Java #CollectionsFramework #Set #HashSet #TreeSet #LinkedHashSet #Map #HashMap #TreeMap #LinkedHashMap #JavaFullStack #AIPoweredLearning #BackendDevelopment #FLM

#Day37 : 🚀 AI Powered Java Full Stack Course Learning Java Fullstack with Frontlines EduTech (FLM) || AI Powered Java Full Stack Course wait(), notify(), Thread Pool & ExecutorService in Java Hello connections 👋, Today’s class was a continuation of Multithreading in Java, where I learned how threads communicate with each other and how Java efficiently manages threads using Thread Pools and ExecutorService. These concepts are crucial for building scalable, high-performance applications. Here’s a structured summary of what I learned 👇 🔹 1️⃣ wait(), notify(), notifyAll() These methods come from the Object class and are used for inter-thread communication. wait() → sends a thread into waiting state notify() → wakes up one waiting thread notifyAll() → wakes up all waiting threads 📌 Important Rules: ✔ Must be used only inside synchronized blocks ✔ Same object must be used for wait/notify/notifyAll ❌ Otherwise, IllegalMonitorStateException occurs These methods allow threads to coordinate safely instead of busy waiting. 🔹 2️⃣ Thread Pool Concept Threads are created by the OS and managed by the JVM. ⚠️ Creating too many threads: Consumes CPU & memory Reduces application performance ✔ Thread Pool benefits: Reuses existing threads Limits active threads Improves performance and stability Thread pools are widely used in banking, insurance, gaming, and backend systems. 🔹 3️⃣ ExecutorService in Java Java provides ExecutorService to manage thread pools efficiently. ✔ Accepts tasks (Runnable / Callable) ✔ Executes tasks using pooled threads ✔ Reuses threads instead of creating new ones ✔ Manages task scheduling internally 🔹 4️⃣ Single Thread Executor Using Executors.newSingleThreadExecutor(): Only one thread executes tasks Multiple tasks can be submitted Tasks execute sequentially, in submission order Other tasks wait until the current task finishes 📌 This behaves like a fixed thread pool of size 1. 🔹 5️⃣ Shutting Down ExecutorService After task execution, resources must be released: executorService.shutdown() → stops accepting new tasks Already submitted tasks continue execution ✔ Prevents memory leaks ✔ Frees system resources properly 🎯 Key Learning Outcomes (Day 37) ✔ Learned thread communication using wait/notify ✔ Understood need for thread pools ✔ Learned task execution via ExecutorService ✔ Understood single-thread executor behavior ✔ Learned importance of graceful shutdown ✔ Improved real-world concurrency understanding This session gave me strong clarity on how Java handles task execution, performance, and scalability in multithreaded applications 🚀✨ Special thanks to Krishna Mantravadi, Upendra Gulipilli, and my trainer Fayaz S for their continuous guidance. 🔖 Hashtags #Java #Multithreading #ExecutorService #ThreadPool #JavaConcurrency #waitNotify #ThreadManagement #AIPoweredLearning #JavaFullStack #FLM #FrontlinesEduTech #SoftwareEngineering

#Day33 : 🚀 AI Powered Java Full Stack Course Learning Java Full Stack with Frontlines EduTech (FLM) || AI Powered Java Full Stack Course 📂 File Handling in Java | Streams, Byte Streams & Character Streams Hello connections 👋, In today’s class, I started learning File Handling in Java, one of the most important topics for working with real-world data like text files, images, logs, and reports. The session was very practical, and I implemented multiple programs to understand how Java reads and writes data using streams. Here’s a clear overview of what I learned today 👇 🔹 1️⃣ What is a File? A file is used to store data permanently on the system. Different file types store different kinds of data using extensions like: 📄 .txt, 🖼 .jpg, 📑 .pdf, etc. 🔹 2️⃣ What are Streams in Java? A stream represents the flow of data between a program and a file. 📌 Streams are also used in networking to transfer data from one place to another. Java mainly provides two types of streams: 1️⃣ Byte Streams 2️⃣ Character Streams 🔹 3️⃣ Byte Streams Byte streams work with data byte by byte. ✔ Classes used: FileInputStream FileOutputStream 📌 These classes throw checked exceptions, so they must be handled using try-catch or throws. What I Practiced Using Byte Streams: 📥 Reading data from a file 📤 Writing text into a file 📄 Copying data from one file to another 🖼 Copying an image from one file to another While reading data, the returned byte value is converted to characters using type casting. 🔹 4️⃣ Character Streams Character streams are used for text-based data and handle characters directly. ✔ Classes used: FileReader FileWriter What I Practiced Using Character Streams: ✍ Writing text into a file using FileWriter 📖 Reading text from a file using FileReader I also used try-with-resources, which automatically closes resources and helps avoid memory leaks. 🔹 5️⃣ File Operations Practiced ✔ Creating a file using File class ✔ Reading file content ✔ Writing data into files ✔ Copying files and images ✔ Deleting a file ✔ Proper resource closing using finally and try-with-resources 🎯 Key Learning Outcomes ✔ Understood how files store data ✔ Learned stream-based data flow ✔ Practiced byte and character streams ✔ Handled checked exceptions properly ✔ Improved confidence in real-time file operations Today’s class gave me strong clarity on how Java interacts with the file system, which is crucial for backend development and enterprise applications 🚀✨ Special thanks to Krishna Mantravadi, Upendra Gulipilli, and my trainer Fayaz S for the practical explanations and hands-on approach. 🔖 Hashtags #Java #FileHandling #JavaIO #Streams #ByteStreams #CharacterStreams #ExceptionHandling #CoreJava #AIPoweredLearning #JavaFullStack #FrontlinesEduTech #FrontlinesMedia #flm #ai

🚀 Day 11 at Tap Academy – Methods in Java ☕💻 ☘️Today I learned one of the most powerful concepts in Java – Methods. Methods help us organize, reuse, and simplify our code. Let’s understand it in a simple way 👇 🔹 What is a Method? A method is a block of code that performs a particular task. It is also called a function in Java. ✅ Methods help in: ♻️ Code Reusability (use same code many times) 📉 Code Reduction (avoid writing duplicate code) 🧩 Code Organization and Documentation Instead of writing the same code again and again, we can just call the method multiple times. 🔹 Methods and Objects Relationship Objects have: 🧾 State (Has) → Data (Data Types) ⚙️ Behavior (Does) → Methods Ex: A Car 🚗 Has → color, speed, model (State) Does → start(), stop(), accelerate() (Behavior → Methods) 🔹 Syntax of a Method access_modifier return_type methodName(input) { // method body } Ex: public void display() { System.out.println("Hello Java"); } ✔ access modifier → public, private,etc. ✔ return type → void, int, String,etc. ✔ method name → display() ✔ parentheses () → input parameters If method returns nothing → use void 🔹 4 Types of Methods in Java 1️⃣ No Input, No Output public void greet() { System.out.println("Hello Student"); } Call: obj.greet(); 📌Working: Heap → object stored Stack → greet() method called → prints output → removed from stack 2️⃣ Input, No Output public void printNumber(int num) { System.out.println(num); } Call: obj.printNumber(10); 📌 Working: Heap → object created Stack → printNumber(10) stored → executes → removed 3️⃣ No Input, Output public int getNumber() { return 100; } Call: int result = obj.getNumber(); 📌 Working: Stack → getNumber() runs returns 100 → stored in variable 4️⃣ Input, Output public int add(int a, int b) { return a + b; } Call: int sum = obj.add(10, 20); 📌 Working: Stack → add(10,20) executes returns 30 → stored in sum Execution → Result → Stack cleared 🔹 Types of Methods in Java 1️⃣ User-Defined Methods Methods created by programmer Ex: public void display() { System.out.println("User defined method"); } 2️⃣ Inbuilt Methods Methods already provided by Java Ex: Scanner sc = new Scanner(System.in); sc.nextInt(); sc.nextFloat(); sc.nextDouble(); sc.nextLine(); 🔹 Beauty of Methods ✨ Instead of writing: System.out.println("Hello"); System.out.println("Hello"); Write once: public void sayHello() { System.out.println("Hello"); } Call many times: obj.sayHello(); obj.sayHello(); ✔ Cleaner Code ✔ Less Code ✔ Better Structure 🔹 Key Points Summary ✔ Method = block of code ✔ Used for reuse and reduce code 🎯 My Learning Outcome – Day 11 Today I understood how methods make Java programs more structured, reusable, and efficient. Methods are the backbone of object behavior in Java. Learning step by step towards becoming a better Java developer 🚀 #Java #Methods #CoreJava #Programming #JavaLearning #TapAcademy #CodingJourney #JavaDeveloper #LearnJava #CodeReuse #ObjectOrientedProgramming