Java Classes as User-Defined Data Types

💻 Exploring Java Data Types & Literals While revisiting Java fundamentals, I explored how literals work with different data types. Literals are fixed values assigned directly in code, and Java provides some interesting ways to use them. 📌 Here are some useful things I learned: 🔹 Binary Literal (Base 2) We can write numbers in binary using 0b Example: int num = 0b101; // Output: 5 🔹 Hexadecimal Literal (Base 16) We can use 0x to represent hexadecimal values Example: int num2 = 0x7E; // Output: 126 🔹 Using Underscore for Readability Underscores can be used to make large numbers more readable Example: int num3 = 10_00_000; // Output: 1000000 🔹 Scientific Notation (e-notation) Used to represent large values in floating-point numbers Example: double numd = 12e10; 🔹 Character Increment Trick Characters in Java are internally stored as numbers (ASCII/Unicode), so we can increment them: Example: char c = 'a'; c++; // Output: 'b' 📌 In simple terms: These features make Java code more readable and also reveal how data is handled internally. Continuing to strengthen my Java fundamentals step by step 🚀 #Java #Programming #LearningJourney #JavaBasics #BackendDevelopment

🚀 Core Java Learning Journey Explored Data Types in Java ☕ 🔹 What are Data Types? Data types define the type of data a variable can store and how much memory it occupies. 📌 Types of Data Types in Java: ✅ Primitive Data Types (store actual values) - "int" → Integer values - "float" → Decimal values - "double" → High precision decimal values - "char" → Single character - "boolean" → true/false - "byte", "short", "long" → Integer types with different ranges ✅ Non-Primitive Data Types (store references) - "String" - Arrays - Classes - Interfaces 💡 Example: "int age = 21;" "double price = 99.99;" "char grade = 'A';" 🎯 Key Takeaway: Choosing the right data type helps in efficient memory usage and better performance of Java programs. Learning and growing at Dhee Coding Lab 💻 #Java #CoreJava #DataTypes #Programming #LearningJourney #FullStackDevelopment

📘 Deep Dive into Java Collections – LinkedList & Deque Recently, I explored LinkedList and Deque in Java to understand how dynamic data structures work internally. LinkedList is implemented using a doubly linked list, where elements are stored in non-contiguous memory locations. Each node contains data along with references to the previous and next nodes, enabling flexible memory usage. Unlike ArrayList, LinkedList does not require continuous memory allocation. This makes insertion and deletion operations efficient, especially in the middle or at the ends, with O(1) time complexity when the position is known. It supports heterogeneous data, allows duplicates, and preserves the order of insertion. The default capacity starts at zero and grows dynamically as elements are added. I also learned different ways to traverse a LinkedList: - Using a traditional for loop - Using an enhanced for-each loop - Using Iterator (forward traversal) - Using ListIterator (both forward and backward traversal) Another key concept I explored is Deque (Double-Ended Queue). It allows insertion and deletion at both ends, making it highly flexible. Common operations include: addFirst(), addLast(), offer(), poll(), peek(), getFirst(), and getLast() Queues follow FIFO (First In First Out), and Deque extends this by allowing operations from both ends. Key takeaway: Choosing the right data structure matters. LinkedList is highly efficient for frequent insertions and deletions, while ArrayList is better suited for fast random access. This exploration helped me understand internal implementations, time complexities, and practical use cases of Java Collections. #Java #DataStructures #LinkedList #Deque #Programming #LearningJourney #JavaCollections

🗂️ Java Collections Framework When I first started Java, I just used ArrayList everywhere. 😅 Need a list? ArrayList. Need to store data? ArrayList. Need anything? ArrayList. Sound familiar? Then I discovered there's an entire UNIVERSE of data structures in Java — each built for a specific purpose. ━━━━━━━━━━━━━━━━━━━━━━ 🏗️ The Big Picture — Collections Hierarchy ━━━━━━━━━━━━━━━━━━━━━━ Java Collections has TWO separate hierarchies: 1️⃣ Collection (Iterable → Collection → List / Set / Queue) 2️⃣ Map (completely separate — Key-Value pairs) 📌 Collection Side: ▸ List → ordered, duplicates allowed   → ArrayList, LinkedList, Vector, Stack ▸ Set → no duplicates   → HashSet, LinkedHashSet, TreeSet ▸ Queue / Deque → FIFO / double-ended   → PriorityQueue, ArrayDeque 📌 Map Side: ▸ HashMap → fast, unordered ▸ LinkedHashMap → insertion-order maintained ▸ TreeMap → sorted by keys ▸ Hashtable → legacy (avoid in new code) ━━━━━━━━━━━━━━━━━━━━━━ 🔑 The Golden Rule: ━━━━━━━━━━━━━━━━━━━━━━ Choosing the WRONG collection = slow code. Choosing the RIGHT collection = clean, efficient code. And that's exactly what this series is about. 🎯 📌 What's coming next in this series: ✅ ArrayList vs LinkedList — when does it actually matter? ✅ HashSet vs TreeSet — hashing vs sorting ✅ HashMap vs TreeMap vs LinkedHashMap ✅ Queue, Deque & PriorityQueue with real use cases ✅ Interview questions on Collections ━━━━━━━━━━━━━━━━━━━━━━ If you followed my OOPs series — this one is going to be even better. 🚀 Drop a 🙋 in the comments if you're in for this series!TAP Academy #Java #Collections #JavaDeveloper #Programming #DSA #100DaysOfCode #JavaSeries #SoftwareEngineering #LearningInPublic #LinkedInLearning#tapacademy

🤔 Do you know the size of char in Java? 🚀 Java Data Types — Tiny Choices, Massive Impact And more importantly… ❓ Is it the same as in C? While learning Java, I came across something interesting: ❓ Why do we need so many data types…? At first, it felt like just syntax. But slowly, I realized they actually define how data behaves inside a program. 👉 Every data type affects: • Memory usage (in bytes) • Value limits (range) • Precision (for decimals) • Runtime behavior (overflow, rounding) 🔹 Primitive Data Types (The Real Foundation) These are the basic ones we use everywhere. Integer Types: • byte (1 byte) → -128 to 127 • short (2 bytes) → -32,768 to 32,767 • int (4 bytes) → most commonly used • long (8 bytes) → for large values 💡 I realized choosing between int and long is not random — it depends on the use case Floating Types: • float (4 bytes) → ~6–7 digits precision • double (8 bytes) → ~15–16 digits precision 💡 Using the wrong one can affect accuracy Other Primitives: • char → 2 bytes (UTF-16 Unicode) • boolean → true/false ⚠️ One thing that surprised me: 👉 In C: char = 1 byte 👉 In Java: char = 2 bytes This is because Java supports Unicode characters. 🔹 Reference Types Then there are non-primitive types: • String • Arrays • Objects • Interfaces 👉 These don’t store actual values 👉 They store references (addresses in memory) ⚙️ What I’m Learning At first, data types looked very basic. But now I’m starting to see: 💥 They affect memory 💥 They affect accuracy 💥 They can even cause bugs if used incorrectly 🧠 A Small Thought Next time I write: int count = 10; I’m trying to think: 👉 Do I really need int? 👉 What if the value increases? Still learning, but this made me look at “basics” differently. 🔥 It’s interesting how even small things like data types can impact bigger systems. #Java #Programming #Learning #CodingJourney #ComputerScience

➡️ Encapsulation in Java with Example ➡️ Encapsulation = Binding data + methods together and restricting direct access using private variables. Let’s understand with a simple program class Employee { // ✅ Step 1: Make variables private (Data Hiding) private int id; private String name; // ✅ Step 2: Getter method (Read data) public int getId() { return id; } // ✅ Step 3: Setter method (Write data) public void setId(int id) { this.id = id; } // Getter for name public String getName() { return name; } // Setter for name public void setName(String name) { this.name = name; } } public class Main { public static void main(String[] args) { Employee emp = new Employee(); // 🎯 Accessing data using setter emp.setId(101); emp.setName("John"); // 🎯 Accessing data using getter System.out.println(emp.getId()); System.out.println(emp.getName()); } } 📌 Highlight: ✔ Variables are private → cannot access directly ✔ We use getters & setters to control access ✔ This ensures data security and flexibility 💡 Why? Instead of exposing data directly, we control how it is accessed and modified. This is the foundation for building secure and maintainable applications! #Java #Encapsulation #OOP #Programming #Developers

Day 51-What I Learned In a Day (JAVA) Today I stepped into the next important concept in Java -Non-Static Members. Unlike static members, non-static members belong to an object, not the class. This means they require an instance of the class to be accessed. What are Non-Static Members? Non-static members include: • Non-static variables (instance variables) • Non-static methods • Constructors Key Understanding: 🔹 Instance Variables Each object has its own copy of variables. Changes in one object do not affect another. 🔹 Non-Static Methods These methods can directly access both static and non-static members. They require object creation to be called. 🔹 Object Creation is Mandatory !To access non-static members: ClassName obj = new ClassName(); Important Difference I Learned: • Static → Belongs to class (no object needed) • Non-Static → Belongs to object (object required) What I Realized Today: Understanding non-static members is crucial because real-world applications mainly work with objects. This concept is the base for Object-Oriented Programming (OOP). #Java #OOP #Programming #LearningJourney #DeveloperLife

Day 4 of Java I/O Journey Today I explored Writing Data in Java using Output Streams. 📤 Learned how Java writes data to files: 🔹 writeByte() → Writes a byte 🔹 writeChar() → Writes a character 🔹 write() → Writes a string Understanding output streams is essential for storing and managing data in real-world applications. Consistency + small steps = big progress 💡 What do you usually use for writing data in Java? #Java #LearningInPublic #100DaysOfCode #Programming #JavaIO #CodingJourney #Developers #Consistency #Hariom #HariomKumar #Hariomcse

Day 3 of Java I/O Journey Today I focused on Reading Data in Java using Input Streams. 📥 Learned how Java reads different types of data: 🔹 readByte() → Reads a byte 🔹 readChar() → Reads a character 🔹 readLine() → Reads a full line Understanding these methods helps in handling real-world data from files and user input. Every day, one step closer to mastering Java 💡 What’s your favorite way to handle input in Java? #Java #LearningInPublic #100DaysOfCode #Programming #JavaIO #CodingJourney #Developers #Consistency #Hariom #HariomKumar #Hariomcse

🚀 Understanding Data Structures in Java: ArrayList vs LinkedList & Arrays vs LinkedList Choosing the right data structure can significantly impact your application’s performance. Let’s break down two commonly discussed comparisons in Java 👇 🔹 ArrayList vs LinkedList ✅ ArrayList Backed by a dynamic array Fast random access (O(1)) Slower insertions/deletions (O(n)) due to shifting elements Efficient for read-heavy operations ✅ LinkedList Based on a doubly linked list Slower random access (O(n)) — needs traversal Faster insertions/deletions (O(1)) if position is known Ideal for frequent modifications 👉 Key Insight: Use ArrayList when you need fast access, and LinkedList when you frequently add/remove elements. 🔹 Arrays vs LinkedList ✅ Arrays Fixed size (static) Stored in contiguous memory Faster access using index (O(1)) Less memory overhead ✅ LinkedList Dynamic size (can grow/shrink) Stored in non-contiguous memory Access requires traversal (O(n)) Extra memory needed for storing pointers 👉 Key Insight: Use arrays when size is known and performance matters. Use LinkedList when flexibility is required. 💡 Final Thought: There is no “one-size-fits-all” — the best data structure depends on your use case. Understanding these differences helps you write more efficient and scalable code. #Java #DataStructures #Programming #Coding #SoftwareDevelopment #InterviewPrep TAP Academy