Yogesh Sonkar’s Post

Today, I worked on a simple yet fundamental Java program to determine the largest among three numbers entered by the user. KEY POINTS ‣Package & Class Definition ‣User Input Handling ‣Decision Making (Conditional Logic) ‣Comparison Operators ‣Output ‣Resource Management ‣Simplicity and Readability Here is the code snippet!👇 #Java #LearningToCode #Practice #Buildinpublic #JavaDevelopment

Unlock the power of Java 8! 🚀 My latest PDF gives a high-level overview of key features like Streams API, Lambda Expressions, Method References, Optional, Default Methods, Date & Time API, and CompletableFuture. Perfect for every Java developer to quickly grasp modern Java concepts. follow and comment if interested for detailed doc.. #Java #Java8 #StreamsAPI #LambdaExpressions #MethodReferences #DefaultMethods #Optional #DateTimeAPI #CompletableFuture #FunctionalProgramming #CleanCode #JavaDevelopers #Programming #CodeBetter

Day 7/30 — Java + DSA Journey 🚀 Today’s focus was on understanding and working with Strings in Java: ➡ Immutable vs Mutable Strings ➡ StringBuffer (synchronized, thread-safe) ➡ StringBuilder (fast, non-synchronized) ➡ Efficiency in text operations Strings are at the heart of Java programming. Knowing when to use String, StringBuffer, or StringBuilder is key to writing efficient and scalable code. Revising all week’s concepts has solidified the foundation Small steps, consistent progress 🌱 #Java #DSA #Strings #LearnInPublic #CodingJourney

💥 “𝘛𝘩𝘪𝘯𝘬 𝘊𝘰𝘭𝘭𝘦𝘤𝘵𝘪𝘰𝘯𝘴.𝘴𝘰𝘳𝘵() 𝘪𝘴 𝘢𝘭𝘭 𝘺𝘰𝘶 𝘯𝘦𝘦𝘥? 𝘞𝘢𝘪𝘵 𝘵𝘪𝘭𝘭 𝘺𝘰𝘶 𝘮𝘦𝘦𝘵 𝘊𝘰𝘮𝘱𝘢𝘳𝘢𝘵𝘰𝘳 𝘢𝘯𝘥 𝘊𝘰𝘮𝘱𝘢𝘳𝘢𝘣𝘭𝘦!” Sorting in Java gets really fun when you start adding your own logic. In my latest video, I’ve explained how to sort not just integers — but your custom objects (like students, names, anything!) — using Comparator, Comparable, and Lambda expressions. 📺 Watch the full breakdown here: https://lnkd.in/gkvb2VxY #Java #Programming #Coding #Comparator #Comparable #LearnJava #SoftwareDevelopment

🧠 Deep Dive into Java’s Object Class Methods Every class in Java ultimately traces back to the Object class, the universal ancestor of all! This powerful class defines essential methods that give life to object behavior in Java 👇 getClass() – Identifies the runtime class of an object hashCode() – Generates a unique code for each object equals() – Enables logical comparison between objects clone() – Creates a copy of an existing object toString() – Converts an object into a human-readable string wait(), notify(), notifyAll() – Facilitate communication between threads. #ObjectClass #OOPsConcepts #LearnJava #ObjectOrientedProgramming #CodeWithJava #JavaDeveloper #ProgrammingConcepts

I had this post on my wall today and actually, while really basic, this topic is weirdly interesting. The post mentioned that "a+b is promoted to int" which is not exactly what happens. Actually the operants are converted to "int" before the operation is performed. This is actually the same (and in fact specified) for several languages like Java, C#, C, C++ and for multiple reasons - which are partially decisions made around historic constraints. Newer languages like Rust, Go, Zig, Kotlin, ... don't mirror this and keep the type as specified in the parameters. Back to the example: Java (and also C#) won't do the implicit narrowing to "byte" for strictness and safety reasons, thus the compiler will complain. In C or C++ the implicit narrowing cast is actually done, so the first example compiles just fine "uint8_t c = a + b;". But handling this strictly raises a problem for C# and Java with compount operators. Here the parameters still are promoted to "int" but the specification explicitely states that the behaviour is identical to "E1 = (T)((E1) op (E2))", so a cast is performed. Pretty much solely to support compount operators as syntactic sugar. #Java #CSharp #CPlusPlus #Codingtrivia

Here’s a quick breakdown that makes Stack vs Heap finally easy to understand — 📄 Check out the short PDF below 👇 Which one confused you the most when you first learned Java — Stack or Heap? #Java #BackendDevelopment #MemoryManagement #ProgrammingConcepts #SoftwareEngineering #LearnJava

💡 What I Learned Today: Functional Interfaces in Java While revisiting Java 8 concepts, I explored Functional Interfaces — a key feature that paved the way for Java’s shift toward functional programming. A Functional Interface is simply an interface with a single abstract method. It allows us to use lambda expressions and method references, making our code cleaner and more expressive. Some common examples include: Runnable → run() Comparator → compare() Function, Predicate, Consumer, and Supplier from java.util.function This approach helps reduce boilerplate code, improves readability, and encourages a more functional style of writing Java. Understanding this concept made me realize how Java has evolved to balance both object-oriented and functional programming — giving developers the best of both worlds. 🚀 #Java #FunctionalProgramming #LambdaExpressions #CodingTips #JavaDeveloper #LearningJourney #BackendDevelopment

Day 20: Exploring Java Interfaces with Static, Private, and Public Methods 🧑💻 Today I practiced Java interfaces and learned: Static methods – Called using the interface name (Calculator.add(...)) Private methods – Used inside the interface to support other methods Public methods – Implemented in the class (multiply(...)) Example: int sum = Calculator.add(5, 10); SimpleCalculator calc = new SimpleCalculator(); int product = calc.multiply(5, 10); 💡 Key takeaway: Interfaces in Java can now have static, private, and default methods, making code modular and reusable. ✅ Note: Before Java 1.8, interfaces could only have abstract methods. From Java 1.8, default and static methods were introduced. From Java 1.9, private methods in interfaces became possible to help reuse code inside the interface. 10000 Coders #Java #Interface #OOps #LearningEveryDay #100DaysOfCode #Day20 #CodingJourney