Java's private fields not as secure as thought

Nullability in Java: Is There Finally a Clean Solution? Java, in favor of backward compatibility, still gives developers little more than Optional when it comes to null-safety. And let’s be honest — Optional is not a real nullability system. Then there is JSpecify https://jspecify.dev/. Your first reaction might be: “Oh no… not another set of @NonNull annotations.” But actually — it’s different. Why I’ve never liked most @NonNull tools 1️⃣ They come as part of some external library or framework I don’t actually need. 2️⃣ No proper class-level default — and package-info.java feels unnecessarily verbose. 3️⃣ Many of them don’t provide meaningful compiler hints or real guarantees. Why JSpecify is interesting JSpecify aims to define a standard for nullness in Java — not another random annotation library, but a common specification that tools and frameworks can align around. - It’s minimal. - It’s focused. - It’s designed to improve tooling support. And most importantly — it feels like a step toward making null-safety a first-class concern in Java without breaking everything built over the last 25 years. If you care about clean APIs, clear contracts, and better design — it’s worth a look. ----------------------------------------------------- I’d really appreciate your opinion. Have you tried JSpecify? Do you think Java needs built-in null-safety? Have a great design and a clear mind, colleagues.

🔹FUNDAMENTALS OF JAVA ✅ Why main() Must Be Public? class Hello {   public static void main(String[] args) {     System.out.println("Hello Java!");   } } public is an access modifier. Access modifiers control who can access a method or class. Java has: 👉public 👉private 👉protected 👉default (no modifier) When you run: java Hello You are not calling main() yourself. 👉 JVM calls main() automatically. Now think carefully: JVM is outside your class. JVM must access your main() method. If it cannot access it → program will not start. So main() must be: public So that JVM can access it from anywhere. 🔥 What Happens If You Remove public? Example: class Hello {   static void main(String[] args) {     System.out.println("Hello");   } } Now compile: javac Hello.java Compilation works ✔ But when you run: java Hello You get error: Main method not found in class Hello Because JVM requires: public static void main(String[] args) Exactly that signature. 🔍 Technical Reason The JVM looks specifically for: public static void main(String[] args) If it is: private ❌ protected ❌ default ❌ JVM cannot access it. Only public allows access from outside the class protected

After almost four days of trying to understand java.util.logging I have come to understand why facades suck. Today I came across the recommendation that I should use System.Logger facade. It uses java.util.logging as the default implementation as it is just an interface. It can also be used with the other logging frameworks. So why, in my incompetent opinion, should you never use System.Logger or, quite frankly, SLF4J? I can sum it up in one line of code. LOG.log(Level.TRACE, "Using LOG.log at Level.TRACE"); The second line of output is: FINER: Using LOG.log at Level.TRACE WTF, I know that Level.TRACE maps to Level.FINER but I want my log to read: TRACE: Using LOG.log at Level.TRACE So, should I change to SLF4J? I don't think so. It claims to be a facade to all frameworks such that you can easily change the logging backend. First, how often is the backend changed? Second, SLF4J and Logback use the same level designations. Log4J2 adds FATAL. Neither System.Logger or SLF4J have FATAL. So, how will I proceed? I will stick with java.util.logging and not use the System.Logger facade. If asked, I will suggest that SLF4J should only be used with Logback and that really means that there is no need to bother with SLF4J. As always, feel free to tell me I am wrong.

Java Unchecked Exceptions – The Surprise You Didn’t See Coming! Ever been on a roller coaster ride? 🎡  👉 You expect thrills and twists 😃  👉 But suddenly, your phone slips out of your pocket 📱💥  👉 Or you scream so loud you lose your voice 😂 These are unexpected problems that you didn’t plan for in advance.  That’s what Unchecked Exceptions are in Java! 🔹 They occur at runtime, not compile-time  🔹 Compiler won’t force you to handle them 🚦  🔹 If not handled, they crash the program ❌ 💻 Example Code public class UncheckedExample {  public static void main(String[] args) {  try {  int numbers[] = {1, 2, 3};  System.out.println(numbers[5]); // Accessing invalid index  } catch (ArrayIndexOutOfBoundsException e) {  System.out.println("⚠️ Oops! You tried to access something outside the ride limits: " + e.getMessage());  }  } } ✅ Output: ⚠️ Oops! You tried to access something outside the ride limits: 5 ✨ Takeaway:  Unchecked Exceptions are like surprises during the ride 🎢.  Java lets your code compile ✅, but if you don’t handle them, they may cause a crash at runtime 💥.

There is quiet change in Java that every Java Developer should know about👀 I still remember the first Java program I ever wrote like every beginner, I memorized this line like a ritual : `public static void main(String[] args)`   But here’s the surprising part In modern Java (21+), you can now write: void main() {     System.out.println("Hello World"); }   Yes… no `static`. 😮 So what actually changed?   **Old JVM behaviour** When a Java program starts: 1️⃣ JVM loads the class 2️⃣ No objects exist yet 3️⃣ JVM looks for a method it can call directly   Since non-static methods need an object, Java forced us to use a static `main()`. That’s why we all memorized that signature. But in Modern JVM behavior (Java 21 → 25) JVM quietly does this behind the scenes: ```java new Main().main(); ``` It creates the object and calls the method for you.   This change actually pushes Java closer to being more object-oriented, because now your program can start from an instance method instead of a static one.   Next time, let’s discuss a fun debate Why Java is still NOT a 100% Object-Oriented language.   Did you know this change already happened?   #Java #Programming #JVM #SoftwareEngineering #Developers

Day 10 | Full Stack Development with Java Today’s focus was on one of the most important building blocks in Java — Methods. Understanding methods helped me clearly see how Java programs are structured and executed. What is a Method? In Java, a method is a block of code that performs a specific task inside a class. Method Syntax: returnType methodName(parameters) { // method body } methodName → Name of the method parameters → Inputs passed to the method returnType → Value returned after execution method body → Code that performs the task Types of Methods in Java I learned that there are 4 types: 1️⃣ No Input, No Output No parameters No return value Example: prints result directly 2️⃣ No Input, With Output No parameters Returns a value 3️⃣ With Input, No Output Takes parameters Does not return anything 4️⃣ With Input, With Output Takes parameters Returns a value This classification made method behavior very clear. Memory Understanding (Stack vs Heap) While calling methods: Stack Segment Stores method calls Creates stack frames Stores local variables Heap Segment Stores objects Stores instance variables When a method is called: A stack frame is created. Parameters and local variables go into stack. Objects created using new go into heap. After method execution, control returns to the caller. Main Method Java Copy code public static void main(String[] args) Entry point of Java program Called by JVM Accepts command-line arguments Does not return any value (void) Key Takeaway Methods are the foundation of: Code reusability Modular programming Clean architecture Understanding how methods interact with memory (Stack & Heap) is helping me think like a backend developer. 10 days of consistency. Building Java fundamentals step by step. #Day10 #Java #Methods #FullStackDevelopment #BackendDevelopment #LearningInPublic #ProgrammingJourney

Day 10: Break Statement in Java: • Definition The break statement is used to terminate (exit) the loop immediately, even if the loop condition is still true. 🔸 Where break can be used? Inside for loop Inside while loop Inside do-while loop Inside switch statement 🔸 How break works in a loop? When break is executed: The loop stops immediately. Control moves to the first statement after the loop. 🔸 Example (for loop): public class BreakExample { public static void main(String[] args) { for(int i = 1; i <= 5; i++) { if(i == 3) { break; } System.out.println(i); } System.out.println("Loop ended"); } } 🔹 Continue Statement in Java: •Definition The continue statement is used to skip the current iteration and move to the next iteration of the loop. 🔸 How continue works? When continue is executed: The remaining statements inside the loop for that iteration are skipped. Control jumps to the next iteration. 🔸 Example (for loop) public class ContinueExample { public static void main(String[] args) { for(int i = 1; i <= 5; i++) { if(i == 3) { continue; } System.out.println(i); } } } 🔹 Important Interview Points ✔ break and continue are called jump statements. ✔ They improve performance by avoiding unnecessary iterations. ✔ Overusing them can make code difficult to read. ✔ break cannot be used outside loop or switch.

🚀 100 Days of Java Tips – Day 10 Topic: Modern Switch Expressions (Java 14+) If you’re still using the traditional switch statement with multiple break statements, it’s time to upgrade 😄 Java 14 introduced switch expressions to make your code cleaner, safer, and more readable. In older versions, switch was mainly used as a statement. That meant you had to manually assign values and remember to add break every time. Missing a break could silently introduce bugs. Example – Old Style Switch: String result; switch (day) { case "MONDAY": result = "Start of week"; break; case "FRIDAY": result = "Almost weekend"; break; default: result = "Mid week"; } Now let’s see the modern version. Example – New Switch Expression: String result = switch (day) { case "MONDAY" -> "Start of week"; case "FRIDAY" -> "Almost weekend"; default -> "Mid week"; }; What changed? • No need for break • Cleaner arrow syntax • Directly returns a value • Less chance of fall-through bugs You can also group cases: String type = switch (day) { case "SATURDAY", "SUNDAY" -> "Weekend"; default -> "Weekday"; }; Why this matters? Modern switch makes your intent clear. It reduces boilerplate code. It improves maintainability. Java is evolving to become more expressive and developer-friendly. If you are using Java 14 or above, start using switch expressions in new code. Write code that is not just working, but elegant. #Java #100DaysOfCode #JavaTips #Developers #ModernJava

📘 Day 8 | Core Java – Revision (Q&A) 🌱 Revising today’s Core Java topics by asking questions and validating my understanding 1. What is an array in Java? ➡️ An array is a collection of elements of the same data type stored in a continuous memory location. 2.What is method overloading? ➡️ Method overloading means defining multiple methods with the same name but different parameters in the same class. It is resolved at compile time. 3.What is method overriding? ➡️ Method overriding occurs when a subclass provides a specific implementation of a method already defined in its parent class. It supports runtime polymorphism. 4. What is the use of the super keyword? ➡️ The super keyword is used to refer to the parent class object, access parent class variables, methods, and constructors. 5.What is method hiding in Java? ➡️ Method hiding happens when a static method in a subclass has the same signature as a static method in the parent class. 6.What is typecasting in Java? ➡️ Typecasting is the process of converting one data type into another. 7.What is an abstract class? ➡️ An abstract class is a class declared using the abstract keyword and may contain abstract and non-abstract methods. 8.What is a concrete class? ➡️ A concrete class is a class that provides implementation for all methods and can be instantiated. 9.What is an interface? ➡️ An interface is a blueprint of a class that contains abstract methods and is used to achieve abstraction and multiple inheritance. 10.What is polymorphism in Java? ➡️ Polymorphism means one method performing different behaviors based on the object type. 11.What are the types of polymorphism? ➡️ Compile-time polymorphism (method overloading) and runtime polymorphism (method overriding). #CoreJava #JavaLearning #LearningJourney #Programming #MCAGraduate