Java var keyword: Type Inference Explained

🔍 Pattern Matching in Java: Stop Writing Boilerplate, Start Writing Intent How many times have you written this? if (obj instanceof String) { String s = (String) obj; System.out.println(s.toUpperCase()); } Java 16+ eliminated this ceremony forever. ✅ if (obj instanceof String s) { System.out.println(s.toUpperCase()); } But that's just the beginning. With Java 21, Pattern Matching exploded into something extraordinary via switch expressions: String result = switch (shape) { case Circle c -> "Area: " + Math.PI * c.radius() * c.radius(); case Rectangle r -> "Area: " + r.width() * r.height(); case Triangle t -> "Area: " + 0.5 * t.base() * t.height(); default -> "Unknown shape"; }; No casting. No NPE traps. No noise. Just pure, readable logic. 🔥 Why does this matter? → It closes the gap between Java and functional languages like Scala or Kotlin → Works beautifully with sealed classes — the compiler ensures exhaustiveness → Reduces cognitive load and bug surface area simultaneously → Makes your domain model express behavior, not just data Guarded patterns take it even further: case Integer i when i > 0 -> "Positive: " + i; case Integer i -> "Non-positive: " + i; This isn't syntactic sugar. It's a paradigm shift in how we model logic in Java. The language is finally letting us write what we mean, not what the compiler demands. Are you already using Pattern Matching in production? What's your favorite use case? Drop it below 👇 #Java #Java21 #PatternMatching #CleanCode #SoftwareEngineering #JVM #BackendDevelopment

📄Java clone() 1️⃣ What clone means Shallow copy → copy the Object reference Deep copy → copy the Object reference+ copy their fields deeply 2️⃣ What Java actually does by default super.clone() ➡ Copies object structure ➡ Inner objects are shared So Java clone copies: ✔ primitives ❌ references (pointer copied, not object) 3️⃣ How we make it Deep Copy Manually clone inner objects: new Location(this.location) So: super.clone() + manual cloning = Deep Copy 4️⃣ Return Type Confusion Java forces method signature: Object clone() Compiler only sees Object So we cast: User copy = (User) original.clone(); 🧠 Casting does NOT create or convert objects It only changes how compiler views the reference 5️⃣ What actually happens internally clone() → memory duplication (no constructor called) Casting → only permission to access methods Object ref = userClone; ((User)ref).getName(); // allowed after cast No new object created here. 6️⃣ Important internal fact clone() in Object is a native method Real implementation exists inside JVM (C/C++), so IDE cannot open its source code. return (User) super.clone(); → works, but only shallow copy return new User(this); → works and can be deep copy GitHub Link: https://lnkd.in/g5Zj48m6 🔖Frontlines EduTech (FLM) #java #coreJava #BackendDevelopment #Programming #CleanCode #ResourceManagement #AustraliaJobs #SwitzerlandJobs #NewZealandJobs #USJobs #cloneMethod #deepCopy #shallowCopy

Day 21 – Accessing Non-Static Members of a Class in Java Yesterday I explored static members in Java. Today’s concept was the opposite side of it: 👉 Non-Static Members (Instance Members) Unlike static members, non-static members belong to objects, not the class itself. That means we must create an object of the class to access them. 🔹 Syntax new ClassName().memberName; or ClassName obj = new ClassName(); obj.memberName; 🔹 Example class Demo4 { int x = 100; int y = 200; void test() { System.out.println("running test() method"); } } class MainClass2 { public static void main(String[] args) { System.out.println("x = " + new Demo4().x); System.out.println("y = " + new Demo4().y); new Demo4().test(); } } Output x = 100 y = 200 running test() method 🔹 Important Observation Every time we write: new Demo4() ➡️ A new object is created. Each object has its own copy of non-static variables. This is why instance variables are object-specific, unlike static variables which are shared across objects. 📌 Key takeaway • Static members → belong to the class • Non-static members → belong to objects • Accessing instance members requires object creation Understanding this concept is essential for mastering Object-Oriented Programming in Java. Step by step building stronger Core Java fundamentals. #Java #CoreJava #JavaFullStack #OOP #Programming #BackendDevelopment #LearningInPublic #SoftwareDevelopment

🚀 Day 30 and 31 – Deep Dive into Static in Java Over the last two days, I gained a strong understanding of the Static concept in Java from both execution and real-world perspectives. 1️⃣ How Java Program Executes (Memory Understanding) I understood how a Java program runs inside JRE memory, which includes: 1.Code Segment 2.Stack 3.Heap 4.Method Area (Static Segment / Meta space) 2️⃣ Execution Order in Java 1.Static variables 2.Static block 3.main() method 4.Object creation 5.Instance block 6.Constructor 7.Instance methods This clearly explains the difference between class-level loading and object-level creation. 3️⃣ Static vs Instance – Core Difference 🔹 Static Belongs to Class Memory allocated once Loaded during class loading Shared among all objects 🔹 Instance Belongs to Object Memory allocated per object Loaded during object creation Separate copy for each object 4️⃣ 💡 Real-Time Use Case of Static (Banking Example) Using a loan interest calculation example: If 10000 objects are created Instance variable creates 10000 copies in memory Static variable creates only 1 shared copy ✅ This improves memory efficiency and application performance. 5️⃣ 🔧 Static Members and Their Use Cases 🔹 Static Variable Used when value must be common for all objects Example: rate of interest, PI value, shared counters 🔹 Static Block Executes once during class loading Used to initialize static variables 🔹 Static Method Can be called without creating an object Used for utility/helper methods Example: Math class methods 6️⃣ 📌 Key Takeaways Static improves memory optimization Static belongs to class, not object Static variables load only once Static block runs once during class loading Static methods do not require object creation Execution flow understanding is important before learning Inheritance Feeling more confident about how Java works internally in memory 💻✨ Grateful to my trainer Sharath R for explaining the concept clearly and practically 🙌 #Java #CoreJava #OOPS #StaticKeyword #LearningJourney #BackendDevelopment #SoftwareEngineering #FullStackDeveloper

Java Array A data structure that stores multiple values of the same data type in a single variable. Arrays Class A utility class in Java that provides methods to perform operations on arrays such as sorting and searching. String A class used to represent a sequence of characters in Java; String objects are immutable. String Methods Predefined methods used to manipulate and retrieve information from String objects. StringBuffer and StringBuilder Classes used to create mutable strings; StringBuffer is thread-safe, while StringBuilder is faster but not thread-safe. Immutable and Mutable Immutable objects cannot be changed after creation, while mutable objects can be modified. Exception Handling A mechanism to handle runtime errors and maintain the normal flow of program execution. Shallow Copy and Deep Copy Shallow copy copies object references, while deep copy creates a new independent object. File Handling A process of creating, reading, writing, and deleting files in Java. Multithreading A feature that allows multiple threads to execute concurrently within a program. Synchronization A mechanism used to control access to shared resources in a multithreaded environment. Interthread Communication A technique that allows threads to communicate with each other during execution. Deadlock A situation where two or more threads wait indefinitely for each other’s resources. Daemon Thread A background thread that runs to support user threads and terminates when they finish. Inner Class A class defined inside another class to logically group related classes. Object Class The root superclass of all Java classes from which every class implicitly inherits. pdf Link :- https://lnkd.in/gXEWSAJ2 #Java #CoreJava #JavaDeveloper #JavaInterview #ProgrammingBasics  #SoftwareDevelopment #LearnJava #StudentDeveloper #TechLearning

Java Compiled Or Interpreted. Is Java a compiled or interpreted language? The standard picture of Java is of a language that’s compiled into .class files before being run on a JVM. Lot of developers can also explain that bytecode starts off by being interpreted by the JVM but will undergo just-in-time (JIT) compilation at some later point. Here, however, many people’s understanding breaks down into a somewhat hazy conception of bytecode as basically being machine code for an imaginary or simplified CPU. In fact, JVM bytecode is more like a halfway house between human-readable source and machine code. In the technical terms of compiler theory, bytecode is really a form of intermediate language (IL) rather than actual machine code. This means that the process of turning Java source into bytecode isn’t really compilation in the sense that a C++ or a Go programmer would understand it, And javac isn’t a compiler in the same sense as gcc is — it’s really a class file generator for Java source code. The real compiler in the Java ecosystem is the JIT compiler. Some people describe the Java system as “dynamically compiled.” This emphasizes that the compilation that matters is the JIT compilation at runtime, not the creation of the class file during the build process. So, the real answer to “Is Java compiled or interpreted?” is “both.” I’m building a complete Senior Java Interview Guide. If this helps you, you can support the series here  #Java #JavaStreams #SoftwareEngineering #Programming #CleanCode #Interviews #interviewGuide

🛑 A Quick Java Memory Guide Understanding the Java Memory Model is non-negotiable for writing performant, bug-free code. If you don’t know where your data lives, you don’t really know Java. Here is the breakdown of Stack vs Heap: 🧠 The Stack (LIFO - Last In, First Out) · What lives here: Primitive values (int, double) and references to objects (pointers). · Scope: Each thread has its own private stack. Variables exist only as long as their method is running. · Access Speed: Very fast. · Management: Automatically freed when methods finish. 🗄️ The Heap (The Common Storage) · What lives here: The actual objects themselves (all instances of classes). · Scope: Shared across the entire application. · Access Speed: Slower than the stack due to global access. · Management: Managed by the Garbage Collector (GC). 💡 The Golden Rule: The reference is on the Stack, but the object it points to is on the Heap. Map<String, String> myMap = new HashMap<>(); (Stack: myMap) --> (Heap: HashMap object) 👇 Q1: If I declare int id = 5; inside a method, where is this value stored? A1: Stack. It's a local primitive variable, so it lives directly in the stack frame. Q2: I created an array: int[] data = new int[100];. The array holds primitives. Is the data stored on the Stack or Heap? A2: Heap. The array itself is an object in Java. The reference data lives on the Stack, but the 100 integers are stored contiguously on the Heap. Q3: What happens to memory if I pass this object reference to another method? A3: A copy of the reference is passed (passed by value). Both methods now have a pointer (on their respective stacks) to the same single object on the Heap. ♻️ Repost if you found this helpful! Follow me for more Java wisdom. #Java #Programming #SoftwareEngineering #MemoryManagement #Coding

Day 22 – Reference Variables in Java Today I explored an important concept in Object-Oriented Programming — Reference Variables. Unlike primitive variables, reference variables store the address of an object, not the actual value. 🔹 What is a Reference Variable? A reference variable is a non-primitive variable that refers to an object created from a class. It is declared using the class name. Syntax: ClassName referenceVariable; Initialization- referenceVariable = new ClassName(); Or both together: ClassName referenceVariable = new ClassName(); Here: ClassName → Name of the class referenceVariable → Object reference new → Keyword used to create an object ClassName() → Constructor 🔹 Example class Demo5 { int x = 100; int y = 200; } class MainClass3 { public static void main(String[] args) { Demo5 d1 = new Demo5(); System.out.println("x = " + d1.x); System.out.println("y = " + d1.y); System.out.println("modifying x & y"); d1.x = 300; d1.y = 400; System.out.println("x = " + d1.x); System.out.println("y = " + d1.y); } } Output: x = 100 y = 200 modifying x & y x = 300 y = 400 🔹 Important Observation When we write: Demo5 d1 = new Demo5(); Java performs three things: 1️⃣ Creates a reference variable (d1) 2️⃣ Creates a new object in memory 3️⃣ Stores the object reference in the variable #Java #CoreJava #JavaFullStack #OOP #Programming #BackendDevelopment #LearningInPublic #SoftwareDevelopment

Threads state & Priority in java 🧵 After understanding what thread is and how to create one, the next question is: ➡️What state my thread is and how does the JVM schedule it? 🧠Threads States in Java A thread can be in one of these states during its lifecycle: 🔸NEW Thread is created but not yet started (start() method is not called) 🔸RUNNABLE Thread is ready to run or concurrently running 🔸BLOCKED Waiting to acquire a monitor lock (synchronized block) 🔸 WAITING Waiting indefinitely for another thread to act 🔸TIMED_WAITING Waiting for a specified time( sleep(), wait(timeout), join(timeout) ) 🔸TERMINATED Execution completed 👉A thread doesn't move linearly - it can jump between states multiple times. ---------------------------------------------------------------------- ⚡Thread Priority in Java Each thread has a priority that hints the scheduler: ✓MIN_PRIORITY — 1 ✓NORM_PRIORITY — 5(default) ✓MAX_PRIORITY — 10 ☘️Example: Thread t = new Thread(task); t.setPriority(Thread.MAX_PRIORITY); IMPORTANT ⚠️ 1.Priority is a hint, not a guarantee. 2.Behaviour is OS and JVM dependent. 3.High priority doesn't mean it will always run first. #Java #Threads #Concurrency #Multithreading #SoftwareEngineering #Backend #Programming

Most Java performance problems weren't caused by bad algorithms. They were caused by objects no one thought twice about creating. Here's the hidden cost most developers overlook: Every object you create in Java lands on the heap. The Garbage Collector is responsible for cleaning it up. And that cleanup isn't free — it consumes CPU, and at worst, it pauses your entire application. Here's how it unfolds: → Every new object is born in Eden — a small, fast memory space → Fill it too quickly with throwaway objects and Java triggers a GC sweep → Most short-lived objects die there — that part is cheap and fast → But survivors get promoted deeper into memory (Old Generation) → When Old Generation fills up, Java runs a Full GC — and your app pauses That final pause isn't milliseconds. In heavy systems, it can be seconds. Users feel it. And the surprising part? Most of this pressure comes from innocent-looking code: ❌ new String("hello") instead of just "hello" ❌ String concatenation inside loops ❌ Autoboxing primitives (int → Integer) without thinking ❌ Calling Pattern.compile() inside a method that runs thousands of times ❌ Creating SimpleDateFormat repeatedly instead of using java.time None of these feel dangerous when you write them. But at scale, they add up to thousands of short-lived objects per second — and a GC that's constantly playing catch-up. The fix isn't complicated: ✅ Prefer primitives over wrapper types ✅ Use StringBuilder for string building in loops ✅ Cache reusable objects as static final constants ✅ Embrace immutable java.time classes — they're designed for reuse The best object, from a GC perspective, is the one you never created. I'm curious — what's the worst unnecessary allocation you've come across in a real codebase? And did it actually cause a production issue? Drop your story below 👇 Let's learn from each other. #Java #SoftwareEngineering #Performance #GarbageCollection #BackendDevelopment #CleanCode #CodeReview