Java Constructor Basics: Initialization and Types

☕ Core JAVA Notes — Complete Study Guide 📖 About the Document A thorough, beginner-to-intermediate Core Java study guide spanning 130 pages, packed with clear explanations, syntax breakdowns, real code examples, and comparison tables. Scanned and formatted for students and aspiring Java developers. 🚀 🏗️ What's Inside? 🔷 Chapter 1 — Java Introduction ➤ What is Java? — A high-level, object-oriented, platform-independent language by Sun Microsystems (now Oracle), born in 1995 ➤ The legendary "Write Once, Run Anywhere" (WORA) principle powered by the JVM ➤ Key features: Platform Independence, OOP, Robustness, Multithreading, Rich Standard Library ➤ Where Java is used: Web Development, Mobile Apps (Android), Enterprise Systems ➤ First program: Hello, World! 👋 🔶 Chapter 2 — OOP Concepts (Object-Oriented Programming) ➤ Classes & Objects — Blueprints and instances of real-world entities ➤ POJO (Plain Old Java Object) — private fields, constructors, getters/setters, toString/hashCode ➤ Constructors — Default, Parameterized, this() and super() keywords ➤ Inheritance — extends keyword, parent-child relationships, super calls ➤ Polymorphism — Method Overloading & Overriding ➤ Abstraction — Abstract classes & Interfaces ➤ Encapsulation — Access modifiers: public, private, protected 🟡 Chapter 3 — Core Language Features ➤ Data Types, Variables, Operators, Control Statements (if, switch, loops) ➤ Arrays — single/multi-dimensional, iteration patterns ➤ Exception Handling — try, catch, finally, throws, custom exceptions 🟢 Chapter 4 — String Handling ➤ String class — immutable, pool concept ➤ Key methods: length(), charAt(), substring(), equals(), compareTo(), replace() ➤ StringBuilder — mutable, faster, single-threaded environments ➤ StringBuffer — mutable, thread-safe for concurrent modifications 🔵 Chapter 5 — Collections Framework ➤ ArrayList vs Array — dynamic sizing, java.util.ArrayList ➤ List, Set, Map interfaces — HashMap, HashSet, LinkedList ➤ Iterating with for, for-each, and Iterator ➤ Java Collections = store & manipulate groups of objects efficiently 📦 #CoreJava #Java #JavaProgramming #OOPConcepts #LearnJava #JavaForBeginners #ObjectOrientedProgramming #JVM #WORA #JavaCollections #StringHandling #StringBuilder #Inheritance #Polymorphism #Encapsulation #Abstraction #LambdaExpressions #AnonymousClass #Multithreading #JavaInterviewPrep #PlacementPreparation #ComputerScience #CodingNotes #ProgrammingLanguage #SoftwareDevelopment #JavaDeveloper #BackendDevelopment #TechNotes #StudyMaterial #CodeWithJava

✨ Most Useful Keywords In Java✨ ➡️final : The final keyword can be applied to classes, variables, methods, and blocks. Once assigned, it cannot be changed. A final class cannot be extended, a final variable cannot be reassigned, and a final method cannot be overridden. ➡️static : The static keyword can be applied to variables, methods, and blocks. Static members can be accessed using the class name without creating an object. Static methods cannot be overridden. ➡️abstract : Used to create a class or method that is incomplete and must be implemented by sub-classes ➡️assert : Used for debugging to test assumptions during runtime ➡️boolean : Represents a logical data type with values true or false ➡️break : Terminates a loop or switch statement immediately ➡️byte : Data type to store 8-bit integer values ➡️case : Defines a branch in a switch statement ➡️catch : Handles exceptions raised in a try block ➡️char : Stores a single character ➡️class : Used to declare a class ➡️continue : Skips the current loop iteration and continues with the next one ➡️default : Executes when no case matches in switch Defines default methods in interfaces ➡️do : Used in a do-while loop (executes at least once) ➡️double : Stores 64-bit decimal numbers ➡️else : Executes when an if condition is false ➡️enum :Defines a fixed set of constants ➡️extends : Used by a subclass to inherit another class ➡️finally : Block that always executes, used for cleanup ➡️float : Stores 32-bit decimal values ➡️for : Used for loop execution with initialization, condition, and increment ➡️if : Executes code when a condition is true ➡️implements : Used by a class to implement an interface ➡️import : Allows access to classes defined in other packages ➡️instanceof : Checks whether an object belongs to a specific class ➡️int : Stores 32-bit integer values ➡️interface : Used to declare a contract that classes must follow ➡️long : Stores 64-bit integer values ➡️new : Creates an object or instance ➡️package : Groups related classes and interfaces ➡️return : Sends a value back from a method and exits it ➡️short : Stores 16-bit integer values ➡️static : Belongs to the class, not object ➡️super : Refers to parent class object or constructor ➡️switch : Selects execution paths based on an expression ➡️synchronized : Controls thread access to prevent data inconsistency ➡️this : Refers to the current object ➡️throw : Explicitly throws an exception ➡️throws : Declares exceptions that a method may pass upward ➡️transient : Prevents variable from being serialized ➡️try : Wraps code that may generate exceptions ➡️void : Indicates a method returns no value ➡️volatile : Ensures variable value is read from main memory, not cache ➡️while: Executes a loop while condition remains true ➡️var: var enables local variable type inference ➡️record: record is a special immutable class used to store data only #javafeatures #oops #opentowork #fresher #softwareengineer #hiring #javadeveloper

🔥 Day 22: Deadlock in Java (with Example 🔥) One of the most dangerous problems in multithreading — and a favorite interview topic 👇 🔹 What is Deadlock? 👉 Definition: A situation where two or more threads are stuck forever, waiting for each other’s resources. 🔹 Simple Real-Life Example 👤 Person A holds Resource 1 and waits for Resource 2 👤 Person B holds Resource 2 and waits for Resource 1 👉 Result = ❌ No one proceeds (Deadlock) 🔹 Java Example class DeadlockExample { public static void main(String[] args) { final Object lock1 = new Object(); final Object lock2 = new Object(); Thread t1 = new Thread(() -> { synchronized(lock1) { System.out.println("Thread 1: Holding lock1"); try { Thread.sleep(100); } catch (Exception e) {} synchronized(lock2) { System.out.println("Thread 1: Holding lock2"); } } }); Thread t2 = new Thread(() -> { synchronized(lock2) { System.out.println("Thread 2: Holding lock2"); try { Thread.sleep(100); } catch (Exception e) {} synchronized(lock1) { System.out.println("Thread 2: Holding lock1"); } } }); t1.start(); t2.start(); } } 🔹 What Happens? ✔ Thread 1 locks lock1 ✔ Thread 2 locks lock2 ❌ Both wait for each other → Deadlock 🔹 Deadlock Visualization Thread 1 → lock1 → waiting for lock2 Thread 2 → lock2 → waiting for lock1 🔹 Conditions for Deadlock (Must Have All 4) 1️⃣ Mutual Exclusion 2️⃣ Hold and Wait 3️⃣ No Preemption 4️⃣ Circular Wait 🔹 How to Prevent Deadlock? ✔ Always lock resources in same order ✔ Use tryLock() (from ReentrantLock) ✔ Avoid nested locks when possible ✔ Use timeouts 🔹 Key Takeaway 👉 Deadlock doesn’t crash your program — it freezes it forever ❗ 💡 Pro Tip: Consistent lock ordering is the easiest and most effective solution 🚀 📌 Final Thought: "Deadlock is not an error — it’s a silent killer in multithreading." #Java #Multithreading #Deadlock #Concurrency #Programming #JavaDeveloper #Coding #InterviewPrep #Day22

⏳ Day 24 – 1 Minute Java Clarity – Exception Handling Basics** Try, Catch, Finally… Java's safety net! 🛡️ 📌 What is an Exception? An unexpected event that disrupts the normal flow of a program. 👉 Java handles this gracefully using try-catch blocks. 📌 Example: class ExceptionDemo {   public static void main(String[] args) {     try {       int result = 10 / 0; // ArithmeticException     } catch (ArithmeticException e) {       System.out.println("Cannot divide by zero! " + e.getMessage());     } finally {       System.out.println("This always runs ✅");     }   } } 📌 Block Breakdown: ✔ try → Code that might throw an exception ✔ catch → Handles the exception ✔ finally → Always executes (clean up code) 💡 Real-time Example: Think of an ATM 🏧 try → You attempt a withdrawal catch → "Insufficient funds!" message shown finally → Card is always returned ✅ 📌 Exception Hierarchy: Throwable ├── Error (JVM level – don't handle) └── Exception   ├── Checked (compile-time)   └── Unchecked (runtime – RuntimeException) ⚠️ Interview Trap: Does finally always execute? 👉 YES — except when `System.exit()` is called or JVM crashes! 📌 Common Exceptions: ✔ ArithmeticException → divide by zero ✔ NullPointerException → null object access ✔ ArrayIndexOutOfBoundsException → invalid index ✔ ClassCastException → invalid type casting ✔ NumberFormatException → invalid string to number 💡 Quick Summary: ✔ try-catch prevents program crashes ✔ finally runs regardless of exception ✔ Checked exceptions must be handled at compile time ✔ Unchecked exceptions occur at runtime 🔹 Next Topic → throw vs throws in Java Did you know `finally` block even runs after a `return` statement? Drop 🔥 if this surprised you! #Java #ExceptionHandling #JavaProgramming #TryCatch #CoreJava #JavaDeveloper #BackendDeveloper #Coding #Programming #1MinuteJavaClarity #100DaysOfCode

🚀 Mastering Java Collections & Utility Classes 🚀 I spent today exploring the internals of the Java Collections Framework, specifically focusing on how to efficiently manage data using ArrayList, LinkedList, and the power of Utility Classes. Here are my key takeaways: 1. The Power of Utility Classes (Collections vs. Arrays) Utility classes are "helper" classes designed to make a developer's life easier by providing built-in logic for common tasks. -Static Nature: Utility classes like Collections and Arrays cannot be instantiated because they have private constructors; instead, you access their functionality through static methods. -Collections Class: This is used to operate on collection objects (like ArrayList or LinkedList) to perform tasks such as sorting, or finding maximum and minimum elements. -Arrays Class: This specifically helps with primitive arrays, such as using Arrays.toString(arr) to print actual data instead of a memory hashcode. 2. ArrayList vs. LinkedList: Choosing the Right Tool While both implement the List interface, their internal architectures dictate their performance: -Internal Structure: ArrayList uses a resizable/dynamic array (contiguous memory), whereas LinkedList is implemented as a doubly linked list (dispersed memory). Performance Trade-offs:Retrieval: ArrayList is superior for data retrieval with a time complexity of O(1). -Insertion: LinkedList is the "best of the best" for frequent insertions or deletions at any random location because it only requires updating node addresses rather than shifting elements. -Memory: LinkedList has an initial capacity of zero because it only accommodates space in the RAM as data is inserted. 3. Key Properties of LinkedList -Supports heterogeneous data (storing different object types). -Preserves insertion order and allows duplicate entries. -Allows null insertions because it stores objects, and a null object represents the absence of a value. 💡 Example: Sorting a List with the Collections Utility Instead of writing complex sorting logic, we can use the Collections.sort() static method to handle it in one line. // 1. Create and populate an ArrayList ArrayList<Integer> al = new ArrayList<>(); al.add(100); al.add(50); al.add(187); // 2. Use the Utility Class to sort the data Collections.sort(al); // 3. Finding the extremes int maxVal = Collections.max(al); int minVal = Collections.min(al); System.out.println("Sorted List: " + al); Understanding these nuances is crucial for writing high-performance Java applications! 💻 #Java #WebDevelopment #CollectionsFramework #Coding #SoftwareEngineering #LearningJourney #TapAcademy #HarshitT

🚀 Day 38 – Deep Dive into Java Multithreading Today I learned about Class Lock and Object Lock in Java synchronization 🔐 🔹 Object Lock (Instance Level Lock) I understood that object lock is applied to instance methods. Each object has its own lock, so multiple threads can access different objects simultaneously without waiting. This improves concurrency when working with multiple instances. 🔹 Class Lock (Class Level Lock) Class lock is applied to static methods. Here, the lock is on the class itself, meaning only one thread can execute the synchronized static method, regardless of how many objects are created. This ensures strict control over shared static data. 💡 Key Difference: Object Lock → Works on individual objects (more parallelism) Class Lock → Works on the entire class (more control & safety) 📌 Key Takeaway: Understanding when to use class-level vs object-level locking helps in designing efficient and thread-safe applications. #Java #Multithreading #Synchronization #LearningJ🚀 Day 38 – Deep Dive into Java Multithreading Today I learned about Class Lock and Object Lock in Java synchronization 🔐 🔹 Object Lock (Instance Level Lock) I understood that object lock is applied to instance methods. Each object has its own lock, so multiple threads can access different objects simultaneously without waiting. This improves concurrency when working with multiple instances. 🔹 Class Lock (Class Level Lock) Class lock is applied to static methods. Here, the lock is on the class itself, meaning only one thread can execute the synchronized static method, regardless of how many objects are created. This ensures strict control over shared static data. 💡 Key Difference: Object Lock → Works on individual objects (more parallelism) Class Lock → Works on the entire class (more control & safety) 📌 Key Takeaway: Understanding when to use class-level vs object-level locking helps in designing efficient and thread-safe applications. #Java #Multithreading #Synchronization #LearningJo🚀 Day 38 – Deep Dive into Java Multithreading Today I learned about Class Lock and Object Lock in Java synchronization 🔐 🔹 Object Lock (Instance Level Lock) I understood that object lock is applied to instance methods. Each object has its own lock, so multiple threads can access different objects simultaneously without waiting. This improves concurrency when working with multiple instances. 🔹 Class Lock (Class Level Lock) Class lock is applied to static methods. Here, the lock is on the class itself, meaning only one thread can execute the synchronized static method, regardless of how many objects are created. This ensures strict control over shared static data. #Java #Multithreading #Synchronization #LearningJourney #Programming #Day38

🚀 Backend Systems | Post - 3 | How to create Threads in JAVA In the last posts, we understood Multithreading, and the difference between Concurrency and Parallelism , now lets learns how do we actually create threads in Java. 1. Extending the Thread Class You can create a thread by having a subclass which extends the Thread class and overriding the run() method. class MyThread extends Thread { @Override public void run() { System.out.println("Hello World"); } } MyThread t1 = new MyThread(); t1.start(); 2. Implementing Runnable Interface (this is usually recommended) This is the most commonly used approach in real-world systems having a class implements the runnable interface and overriding the run method. what is Runnable interface ? It is functional interface which has only one abstract function run. class MyRunnable implements Runnable { @Override public void run() { System.out.println("Hello World"); } } Thread t1 = new Thread(new MyRunnable()); t1.start(); 💡 Why is this better? --> as in java multilevel inheritance isn't possible with classes but possible with interface , since runnable is a interface because of that it allows for multilevel inheritance , this approach is usually better in backend systems. 3. Using Lambda (Modern Java🔥) In modern java we use lambda as a shortcut way to implement a functional interface , since Runnable is also a functional interface , we use this way when this line of code will only be used only by this thread. Thread t1 = new Thread(() -> { System.out.println("Hello World"); }); t1.start(); ⚠️ Common Mistake (VERY IMPORTANT) Most beginners think this will create a thread: Calling run() directly -->This will NOT create a new thread --> It just runs like a normal function call. --> the correct way is to always use start() to create a new thread. 🚀 Key Takeaways --> Runnable is better than Thread for better design. --> Lambda is a clean way to implement Runnable. --> start() creates a thread, run() does not. #Multithreading #Java #OperatingSystem #BackenedSystems

Day 16 — #100DaysJava today I learned Stream API in Java. And honestly, this one changed how I write code. ☕ Before streams, I used to write for loops for everything. Filter this, transform that, add them up. Five lines of code for something simple. Streams do the same thing in one line. Clean, readable, powerful. Here is what clicked for me today — saving this for anyone learning Java --- What is a Stream? A Stream is a pipeline. You take data, pass it through a series of operations, and get a result at the end. You are not changing the original data. You are just processing it. Think of it like a factory assembly line. Raw material goes in. Each station does one job. Final product comes out. --- The three operations I practiced today: filter() — keep only the elements that match a condition. I used it to get only even numbers from an array. Arrays.stream(arr).filter(n -> n % 2 == 0) map() — transform every element. I used it to double every number in the array. Arrays.stream(arr).map(n -> n * 2) reduce() — combine everything into one result. I used it to calculate the sum of all numbers. Arrays.stream(arr).reduce(0, (a, b) -> a + b) --- One thing that confused me first — boxed(). When you have an int array, Java creates an IntStream not a Stream of Integer objects. boxed() converts it from primitive int to Integer object so you can collect it into a List. IntStream → boxed() → Stream of Integer → collect to List Once I understood that, everything made sense. --- collect(Collectors.toList()) is how you end the stream and get your result back as a List. The stream itself does not store data — it just processes it. collect() is what actually creates the final collection. --- The real power of Streams — you can chain all of this together. Filter the evens, double them, collect into a list. One line. No loop. No temporary variables. This is exactly how modern Java code looks in real companies. --- 16 days in. Every day something new clicks. 💪 Day 1 ...................................... Day 16 Are you using Streams in your daily Java work? What is the most useful stream operation you use? Drop it below! 🙏 #Java #StreamAPI #FunctionalProgramming #100DaysOfJava #JavaDeveloper #LearningInPublic #BackendDevelopment #100DaysOfCode #CleanCode #ModernJava

🚀 Understanding Generics in Java – Write Flexible & Type-Safe Code If you’ve ever worked with collections like List or Map, you’ve already used Generics — one of the most powerful features in Java. 🔹 What are Generics? Generics allow you to write classes, interfaces, and methods with a placeholder for the data type. This means you can reuse the same code for different data types while maintaining type safety. 🔹 Why use Generics? ✔️ Eliminates type casting ✔️ Provides compile-time type safety ✔️ Improves code reusability ✔️ Makes code cleaner and more readable 🔹 Simple Example: List<String> names = new ArrayList<>(); names.add("Sneha"); // names.add(10); ❌ Compile-time error 🔹 Generic Class Example: class Box<T> { private T value; public void set(T value) { this.value = value; } public T get() { return value; } } 🔹 🔥 Advanced Concepts Explained 🔸 1. Bounded Types (Restricting Types) You can limit what type can be passed: class NumberBox<T extends Number> { T value; } 👉 Only Integer, Double, etc. are allowed (not String) 🔸 2. Wildcards (?) – Flexibility in Collections ✔️ Unbounded Wildcard List<?> list; 👉 Can hold any type, but limited operations ✔️ Upper Bounded (? extends) List<? extends Number> list; 👉 Accepts Number and its subclasses 👉 Used when reading data ✔️ Lower Bounded (? super) List<? super Integer> list; 👉 Accepts Integer and its parent types 👉 Used when writing data 💡 Rule: PECS → Producer Extends, Consumer Super 🔸 3. Generic Methods public <T> void print(T data) { System.out.println(data); } 👉 Works independently of class-level generics 🔸 4. Type Erasure (Important for Interviews) Java removes generic type info at runtime: List<String> → List 👉 No runtime type checking 👉 Only compile-time safety 🔸 5. Multiple Bounds <T extends Number & Comparable<T>> 👉 A type must satisfy multiple conditions 🔸 6. Restrictions of Generics ❌ Cannot use primitives (int, double) → use wrappers ❌ Cannot create generic arrays ❌ Cannot use instanceof with generics 💡 Final Insight: Generics are not just a feature—they are a design tool that helps build scalable, reusable, and maintainable applications. Mastering advanced concepts like wildcards and type erasure can set you apart as a strong Java developer. #Java #Generics #AdvancedJava #Programming #JavaDeveloper #Coding #TechInterview

🚀 Exploring Emojis in Java 21 – Complete Guide with Examples! 😄🔥 Did you know that emojis in Java are handled using Unicode code points? Even in Java 21, there is no direct API like isEmoji(), but we can still work with emojis effectively using built-in features. Here’s a complete set of practical programs you can use 👇 💡 1. Print Emoji from Unicode Code Point public class EmojiFromCode { public static void main(String[] args) { int codePoint = 0x1F604; // 😄 String emoji = new String(Character.toChars(codePoint)); System.out.println("Emoji: " + emoji); } } 💡 2. Print Multiple Emojis public class MultipleEmoji { public static void main(String[] args) { int[] codePoints = {0x1F525, 0x1F680, 0x1F44D}; for (int cp : codePoints) { System.out.print(new String(Character.toChars(cp)) + " "); } } } 💡 3. Get Unicode from Emoji (Reverse) public class EmojiToCode { public static void main(String[] args) { String emoji = "😄"; int codePoint = emoji.codePointAt(0); System.out.println("Unicode: U+" + Integer.toHexString(codePoint).toUpperCase()); } } 💡 4. Print All Code Points in a String public class EmojiString { public static void main(String[] args) { String text = "Hello 🔥😄"; text.codePoints().forEach(cp -> System.out.println("U+" + Integer.toHexString(cp).toUpperCase()) ); } } 💡 5. Detect Emoji in a String (Custom Logic) public class EmojiDetector { public static boolean containsEmoji(String text) { return text.codePoints() .anyMatch(cp -> cp >= 0x1F600 && cp <= 0x1F64F); } public static void main(String[] args) { String messageWithEmoji = "Hello Java 21! 😄"; String messageWithoutEmoji = "Hello Java!"; System.out.println(containsEmoji(messageWithEmoji)); // true System.out.println(containsEmoji(messageWithoutEmoji)); // false } } 💡 6. JUnit Test for Emoji Detection import static org.junit.jupiter.api.Assertions.*; import org.junit.jupiter.api.Test; public class EmojiTest { boolean containsEmoji(String text) { return text.codePoints() .anyMatch(cp -> cp >= 0x1F600 && cp <= 0x1F64F); } @Test void testEmoji() { String messageWithEmoji = "Hello Java 21! 😄"; String messageWithoutEmoji = "Hello Java!"; assertTrue(containsEmoji(messageWithEmoji)); assertFalse(containsEmoji(messageWithoutEmoji)); } } 🔍 Key Takeaways: ✔ Emojis are Unicode characters (code points) ✔ Use codePoints() instead of charAt() ✔ Convert Unicode → Emoji using Character.toChars() ✔ Java doesn’t provide direct emoji detection (custom logic needed) ✔ Great concept for interviews & teaching Core Java #Java21 #CoreJava #Unicode #Programming #Developers #JavaLearning #CodingTips #JUnit