🌟 **Java Learning Series - Day 5: Loops!** 🌟

Ready to make your code work harder, not smarter? 💪 Today, we're diving into the wonderful world of loops! 🔁 We'll explore `for`, `while`, and `do-while` loops – your essential tools for repeating actions and automating tasks. Understanding loops is crucial for writing efficient and dynamic Java programs. They allow you to execute a block of code multiple times based on a condition. Let's get looping! 👇

```java
public class LoopExamples {
public static void main(String[] args) {
System.out.println("--- For Loop (Known number of iterations) ---");
// A 'for' loop is ideal when you know how many times you want to loop.
for (int i = 0; i < 3; i++) {
System.out.println("For loop count: " + i);
}

System.out.println("n--- While Loop (Condition-controlled) ---");
// A 'while' loop executes as long as a condition is true.
// The condition is checked *before* each iteration.
int countWhile = 0;
while (countWhile < 3) {
System.out.println("While loop count: " + countWhile);
countWhile++;
}

System.out.println("n--- Do-While Loop (Executes at least once) ---");
// A 'do-while' loop is similar to 'while', but its body is executed at least once
// because the condition is checked *after* the first iteration.
int countDoWhile = 0;
do {
System.out.println("Do-While loop count: " + countDoWhile);
countDoWhile++;
} while (countDoWhile < 3);

System.out.println("n--- Do-While example (condition initially false) ---");
// See how this runs once even if 'neverRun < 5' is immediately false!
int neverRun = 5;
do {
System.out.println("This runs at least once: " + neverRun);
neverRun++;
} while (neverRun < 5);
}
}
```

Output example:
```
--- For Loop (Known number of iterations) ---
For loop count: 0
For loop count: 1
For loop count: 2

--- While Loop (Condition-controlled) ---
While loop count: 0
While loop count: 1
While loop count: 2

--- Do-While Loop (Executes at least once) ---
Do-While loop count: 0
Do-While loop count: 1
Do-While loop count: 2

--- Do-While example (condition initially false) ---
This runs at least once: 5
```

💡 **Your Challenge!**
Modify the `for` loop above to print only even numbers from 0 to 10 (inclusive). Hint: You might need to change the loop's increment or add an `if` statement! Share your solution in the comments! 👇

---

Day 5: Loops \(for, while, do\-while\) \- Code & Output

Here's your Telegram post for Day 7 of the Java learning series!

---

🚀 Day 7 of our Java journey is here, and it's a big one! Today, we're diving into the fundamental world of **Arrays and ArrayLists**! 🎉 You'll learn how to store collections of data efficiently. Arrays offer a fixed-size container for primitives or objects, while ArrayLists provide a dynamic, resizable solution for objects, part of Java's powerful Collections Framework. Understanding these is crucial for organizing your data structures. Let's conquer them! 💡

```java
import java.util.ArrayList;
import java.util.Arrays; // Needed for Arrays.toString()

public class DataCollections {
public static void main(String[] args) {
// --- Working with Arrays ---
System.out.println("--- Working with Arrays ---");
int[] numbers = new int[3]; // Declare an array of 3 integers
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

System.out.println("Array elements: " + Arrays.toString(numbers));
System.out.println("First element of array: " + numbers[0]);

// --- Working with ArrayLists ---
System.out.println("n--- Working with ArrayLists ---");
ArrayList<String> fruits = new ArrayList<>(); // Create an ArrayList of Strings
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");
fruits.add("Date");

System.out.println("ArrayList elements: " + fruits);
System.out.println("Size of ArrayList: " + fruits.size());
System.out.println("Element at index 1: " + fruits.get(1));

fruits.remove("Banana"); // Remove an element by value
// fruits.remove(0); // You can also remove by index

System.out.println("ArrayList after removing Banana: " + fruits);
System.out.println("Does ArrayList contain 'Apple'? " + fruits.contains("Apple"));
}
}
```

Output example:
```
--- Working with Arrays ---
Array elements: [10, 20, 30]
First element of array: 10

--- Working with ArrayLists ---
ArrayList elements: [Apple, Banana, Cherry, Date]
Size of ArrayList: 4
Element at index 1: Banana
ArrayList after removing Banana: [Apple, Cherry, Date]
Does ArrayList contain 'Apple'? true
```

**Small challenge:**
Your challenge for today: Modify the `fruits` ArrayList in the code to add a new fruit, "Grape", at the *second* position (index 1), and then iterate through the updated ArrayList using a `for-each` loop to print each fruit on a new line! 🍇👩‍💻

---

Day 7: Arrays and ArrayLists \- Code & Output

🚀 Day 8 of our Java journey! Today we're diving into two incredibly powerful collection types: `HashMaps` and `HashSets`. 📚 These data structures are essential for efficient data storage and retrieval, offering lightning-fast operations.

`HashMaps` store data in key-value pairs, perfect for looking up information quickly, while `HashSets` ensure you only store unique elements. Both are built on the concept of hashing, which allows for O(1) average-case performance for adding, removing, and checking for elements. Get ready to supercharge your Java applications! 💡

```java
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map; // Import for Map.Entry

public class Day8Collections {
public static void main(String[] args) {
// --- HashMap Example ---
System.out.println("--- HashMap Example ---");
HashMap<String, Integer> studentGrades = new HashMap<>();

// Adding elements (Key-Value pairs)
studentGrades.put("Alice", 95);
studentGrades.put("Bob", 88);
studentGrades.put("Charlie", 92);
studentGrades.put("Alice", 97); // Updates Alice's grade (keys must be unique)

System.out.println("Student Grades: " + studentGrades);

// Getting an element by key
System.out.println("Bob's grade: " + studentGrades.get("Bob"));

// Checking if a key exists
System.out.println("Contains Charlie? " + studentGrades.containsKey("Charlie"));
System.out.println("Contains David? " + studentGrades.containsKey("David"));

// Removing an element by key
studentGrades.remove("Bob");
System.out.println("Grades after removing Bob: " + studentGrades);

// Iterating through HashMap using entrySet()
System.out.println("nIterating through grades:");
for (Map.Entry<String, Integer> entry : studentGrades.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}

// --- HashSet Example ---
System.out.println("n--- HashSet Example ---");
HashSet<String> uniqueCourses = new HashSet<>();

// Adding elements (only unique elements are stored)
uniqueCourses.add("Java Basics");
uniqueCourses.add("Data Structures");
uniqueCourses.add("Algorithms");
uniqueCourses.add("Java Basics"); // Duplicate, will not be added again

System.out.println("Unique Courses: " + uniqueCourses);

// Checking if an element exists
System.out.println("Contains 'Algorithms'? " + uniqueCourses.contains("Algorithms"));
System.out.println("Contains 'Python Basics'? " + uniqueCourses.contains("Python Basics"));

// Removing an element
uniqueCourses.remove("Data Structures");
System.out.println("Courses after removing 'Data Structures': " + uniqueCourses);

// Size of the set
System.out.println("Number of unique courses: " + uniqueCourses.size());

// Iterating through HashSet
System.out.println("nIterating through courses:");
for (String course : uniqueCourses) {
System.out.println("- " + course);
}
}
}
```

Output example:
```
--- HashMap Example ---
Student Grades: {Alice=97, Bob=88, Charlie=92}
Bob's grade: 88
Contains Charlie? true
Contains David? false
Grades after removing Bob: {Alice=97, Charlie=92}

Iterating through grades:
Alice: 97
Charlie: 92

--- HashSet Example ---
Unique Courses: [Java Basics, Algorithms, Data Structures]
Contains 'Algorithms'? true
Contains 'Python Basics'? false
Courses after removing 'Data Structures': [Java Basics, Algorithms]
Number of unique courses: 2

Iterating through courses:
- Java Basics
- Algorithms
```

🤔 **Your Challenge:** How would you retrieve all the *keys* from the `studentGrades` HashMap and store them in a `HashSet`? Give it a try! 👇

---

Day 8: HashMaps and HashSets \- Code & Output

Here's your Telegram post and quiz question:

---

🚀 Day 9 of our Java learning series is here! Today, we're diving deep into the fascinating world of *String Manipulation* in Java. 🔧 Strings are fundamental for almost every application, from displaying text to processing user input. Java's `String` class is packed with powerful methods to help you work with text efficiently. Get ready to master extracting, replacing, and transforming text! ✨ Let's code!

```java
public class StringManipulationDemo {
public static void main(String[] args) {
String message = " Hello, Java Learners! Welcome. ";

System.out.println("Original String: '" + message + "'");

// 1. Trim leading/trailing spaces
String trimmedMessage = message.trim();
System.out.println("Trimmed String: '" + trimmedMessage + "'");

// 2. Convert to uppercase
System.out.println("Uppercase: " + trimmedMessage.toUpperCase());

// 3. Find the index of a substring
int javaIndex = trimmedMessage.indexOf("Java");
System.out.println("Index of 'Java': " + javaIndex);

// 4. Extract a substring
String greeting = trimmedMessage.substring(0, 5); // "Hello"
System.out.println("Greeting: " + greeting);

// 5. Replace part of the string
String modifiedMessage = trimmedMessage.replace("Learners", "Developers");
System.out.println("Modified Message: " + modifiedMessage);

// 6. Check if string contains a specific substring
boolean containsWelcome = trimmedMessage.contains("Welcome");
System.out.println("Contains 'Welcome'? " + containsWelcome);
}
}
```

Output example:
```
Original String: ' Hello, Java Learners! Welcome. '
Trimmed String: 'Hello, Java Learners! Welcome.'
Uppercase: HELLO, JAVA LEARNERS! WELCOME.
Index of 'Java': 7
Greeting: Hello
Modified Message: Hello, Java Developers! Welcome.
Contains 'Welcome'? true
```

💡 **Your Small Challenge:**
Modify the code to extract the word "Welcome" from the `trimmedMessage` using the `substring()` method combined with `indexOf()`. Share your solution! 👇

---

Day 9: String Manipulation \- Code & Output

🚀 Day 10: Master File I/O in Java! 📁

Hello Java enthusiasts! 👋 Today marks a significant milestone as we dive into **File Input/Output (I/O)**. This is where your programs learn to interact with the outside world, reading from and writing to files on your system. Imagine saving user data, configurations, or processing logs – it all starts here! We'll explore how to effortlessly handle text files, making your applications truly persistent. Let's get hands-on and make your Java programs truly powerful! 💪✍️📖

```java
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileIOExample {
public static void main(String[] args) {
String filename = "mydata.txt";
String contentToWrite = "Hello, Java learners!nThis is Day 10 of our journey.nWe are mastering File I/O.";

// --- Writing to a file (try-with-resources ensures auto-closing) ---
System.out.println("Attempting to write data to " + filename + "...");
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {
writer.write(contentToWrite);
System.out.println("✅ Successfully wrote data to " + filename);
} catch (IOException e) {
System.err.println("❌ Error writing to file: " + e.getMessage());
}

// --- Reading from a file ---
System.out.println("n--- Attempting to read data from " + filename + " ---");
try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
System.out.println("✅ Finished reading data from " + filename);
} catch (IOException e) {
System.err.println("❌ Error reading from file: " + e.getMessage());
}
}
}
```

Output example:
```
Attempting to write data to mydata.txt...
✅ Successfully wrote data to mydata.txt

--- Attempting to read data from mydata.txt ---
Hello, Java learners!
This is Day 10 of our journey.
We are mastering File I/O.
✅ Finished reading data from mydata.txt
```

### 🧠 Small Challenge:
1. **Append, Don't Overwrite:** Modify the `FileWriter` constructor to `new FileWriter(filename, true)` to append new content to `mydata.txt` instead of overwriting it. Add a new line like "Appending more content!" and run the code again.
2. **Number Series:** Create a *new* file (e.g., `numbers.txt`) and write numbers from 1 to 5 into it, each on a new line. Then, read and print the content of this `numbers.txt` file.

---

📦 Day 12: Packages and Import Statements! 📚

Ready to level up your Java organization skills? Today we're diving into `packages` and `import` statements! Packages help us organize our classes, prevent naming conflicts, and make our code more modular. Think of them as folders for your Java files. The `import` statement is your key 🔑 to easily access classes from other packages without typing their full name every time. Let's explore how they work! ✨

```java
// --- File 1: Calculator.java ---
// (Save this in src/com/example/lib/Calculator.java)
package com.example.lib; // Declares this class belongs to 'com.example.lib'

public class Calculator {
public int add(int a, int b) {
return a + b;
}

public int subtract(int a, int b) {
return a - b;
}
}

// --- File 2: App.java ---
// (Save this in src/com/example/app/App.java)
package com.example.app; // Declares this class belongs to 'com.example.app'

// Import the Calculator class from the com.example.lib package
import com.example.lib.Calculator;
// Alternatively, import all classes from a package: import com.example.lib.*;

public class App {
public static void main(String[] args) {
System.out.println("Starting our application...");

// Using the imported Calculator class
Calculator calc = new Calculator();
int sum = calc.add(15, 7);
System.out.println("15 + 7 = " + sum);

int difference = calc.subtract(20, 5);
System.out.println("20 - 5 = " + difference);

// Without import, you'd need the fully qualified name:
// com.example.lib.Calculator anotherCalc = new com.example.lib.Calculator();
// System.out.println("Using FQN: " + anotherCalc.add(1, 1));
}
}
```

Output example:
```
Starting our application...
15 + 7 = 22
20 - 5 = 15
```

💡 Your challenge for today:
1. Create a new directory structure for a package named `com.myproject.data`.
2. Inside it, create a class `Person` with `name` (String) and `age` (int) fields, and a method `getDetails()` that returns a formatted string.
3. Modify your `App.java` (or create a new `Main.java`) to `import com.myproject.data.Person` and create a `Person` object, then print its details using the `getDetails()` method.

Share your setup if you get stuck! 🚀

---

Day 12: Packages and Import Statements \- Code & Output

🎉 Java Learning Series: Day 13! 🎉

Hello, Java learners! Today, we're diving into the heart of Java: **Object-Oriented Programming (OOP)**! 🚀 Get ready to understand the magic behind `Classes` and `Objects`.

Think of a `Class` as a blueprint or a template for creating something. It defines what attributes (data) and behaviors (methods) that "thing" will have. An `Object`, on the other hand, is a real-world instance of that class. You can create many objects from a single blueprint, each with its unique state but sharing the same defined behaviors. This concept brings structure, reusability, and modularity to your code! 🏗️💡

Let's see an example with a `Dog` class and its objects! 🐕‍🦺

```java
// Define a Class: Dog
class Dog {
// Attributes (properties) of a Dog
String name;
String breed;

// Constructor: A special method to create Dog objects
public Dog(String name, String breed) {
this.name = name;
this.breed = breed;
}

// Methods (behaviors) of a Dog
public void bark() {
System.out.println(name + " says Woof! Woof!");
}

public void displayInfo() {
System.out.println("Name: " + name + ", Breed: " + breed);
}
}

public class Day13_OOP {
public static void main(String[] args) {
// Create Objects (instances) of the Dog class
Dog myDog = new Dog("Buddy", "Golden Retriever"); // myDog is an object
Dog neighborDog = new Dog("Max", "German Shepherd"); // neighborDog is another object

// Access attributes and call methods on these objects
System.out.println("--- My Dog ---");
myDog.displayInfo();
myDog.bark();

System.out.println("n--- Neighbor's Dog ---");
neighborDog.displayInfo();
neighborDog.bark();

// Each object has its own unique data
// System.out.println(myDog.name); // Buddy
// System.out.println(neighborDog.name); // Max
}
}
```

Output example:
```
--- My Dog ---
Name: Buddy, Breed: Golden Retriever
Buddy says Woof! Woof!

--- Neighbor's Dog ---
Name: Max, Breed: German Shepherd
Max says Woof! Woof!
```

---
### Small Challenge:
Can you modify the `Dog` class to include an additional attribute like `age` (an `int`) and a new method called `play()` that prints "[Dog's Name] is playing fetch!"? Don't forget to update the constructor and create a new dog object with an age! 🐾🧠

Happy coding, and see you tomorrow! 👋

---

Here's your Telegram post for Day 14! 🚀

---

Hey Java learners! 👋 It's Day 14, and we're diving deep into two of the most fundamental concepts in Object-Oriented Programming (OOP): **Inheritance** and **Polymorphism**! 🧬

These powerful principles are key to writing reusable, flexible, and scalable code. Inheritance allows classes to inherit properties and methods from other classes, saving you from writing redundant code. Polymorphism, on the other hand, lets objects take on many forms, enabling you to treat objects of different classes in a unified way. 🏗️

Let's see them in action with an example using shapes! 👇

```java
// Parent class representing a generic shape
class Shape {
public double calculateArea() {
System.out.println("Calculating area for a generic shape.");
return 0; // Default implementation
}
}

// Child class: Circle inherits from Shape
class Circle extends Shape {
private double radius;

public Circle(double radius) {
this.radius = radius;
}

// Method overriding: providing a specific implementation for Circle
@Override
public double calculateArea() {
return Math.PI * radius * radius;
}
}

// Child class: Rectangle inherits from Shape
class Rectangle extends Shape {
private double length;
private double width;

public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}

// Method overriding: providing a specific implementation for Rectangle
@Override
public double calculateArea() {
return length * width;
}
}

public class Day14Demo {
public static void main(String[] args) {
// Polymorphism in action:
// A Shape reference can point to a Circle or Rectangle object
Shape circle = new Circle(5.0);
Shape rectangle = new Rectangle(4.0, 6.0);
Shape genericShape = new Shape(); // Can also instantiate the parent

System.out.println("Area of Circle: " + circle.calculateArea());
System.out.println("Area of Rectangle: " + rectangle.calculateArea());
System.out.print("Generic Shape action: ");
System.out.println("Area of Generic Shape: " + genericShape.calculateArea());
}
}
```

Output example:
```
Area of Circle: 78.53981633974483
Area of Rectangle: 24.0
Generic Shape action: Calculating area for a generic shape.
Area of Generic Shape: 0.0
```

**Small challenge for you!** 🤔
Can you add another shape, like a `Triangle`? 🔺 Make it inherit from `Shape` and override the `calculateArea()` method to return its specific area. Then, add an instance of your `Triangle` to the `main` method and calculate its area! Show off your inheritance and polymorphism skills! 💪

---