Day 14: Inheritance and Polymorphism \- Code & Output

🚀 Day 15: Dive into Java Libraries! 📚 Today, we unlock the power of `java.util` and `java.io`! These essential packages provide a vast collection of utility classes and robust tools for handling input/output operations. From data structures like `ArrayList` and `HashMap` in `java.util` to file manipulation with `FileReader` and `FileWriter` in `java.io`, you'll see how these libraries simplify complex tasks. Get ready to supercharge your Java applications! 💡📁

```java
import java.util.Scanner; // Part of java.util for input
import java.io.FileWriter; // Part of java.io for writing files
import java.io.FileReader; // Part of java.io for reading files
import java.io.BufferedReader; // Part of java.io for efficient reading
import java.io.IOException; // For handling I/O exceptions

public class LibraryDemo {
public static void main(String[] args) {
String fileName = "greeting.txt";

// --- Demonstrating java.util.Scanner for console input ---
System.out.print("Enter a greeting message: ");
try (Scanner scanner = new Scanner(System.in)) {
String message = scanner.nextLine();

// --- Demonstrating java.io.FileWriter for writing to a file ---
try (FileWriter writer = new FileWriter(fileName)) { // try-with-resources ensures writer is closed
writer.write(message);
System.out.println("✅ Message successfully written to " + fileName);
} catch (IOException e) {
System.err.println("❌ Error writing to file: " + e.getMessage());
}

// --- Demonstrating java.io.FileReader and BufferedReader for reading from a file ---
try (FileReader fileReader = new FileReader(fileName);
BufferedReader bufferedReader = new BufferedReader(fileReader)) {
String line = bufferedReader.readLine();
System.out.println("📖 Content read from " + fileName + ": " + line);
} catch (IOException e) {
System.err.println("❌ Error reading from file: " + e.getMessage());
}
}
}
}
```

Output example:
```
Enter a greeting message: Hello from Day 15!
✅ Message successfully written to greeting.txt
📖 Content read from greeting.txt: Hello from Day 15!
```

✨ **Your Challenge:** Modify the `FileWriter` part of the code to append a *second* line of text (e.g., "Keep learning Java!") to `greeting.txt` *without* overwriting the first line. (Hint: Look for overloaded `FileWriter` constructors that accept a boolean argument for appending!) 📝

---

Day 15: Introduction to Java Libraries \(java\.util, java\.io\) \- Code & Output

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

---

Hey Java learners! 👋 Ready to connect your applications to the vast world of external services?

On **Day 16**, we're diving into the exciting realm of **Working with APIs**! 🌐 Learn how your Java programs can talk to web services using `HttpClient` (the modern API since Java 11) or `HttpURLConnection` (the traditional way). We'll make a simple GET request to fetch data, opening up endless possibilities for integrating with third-party services, pulling dynamic content, and much more! Let's make our apps truly connected. 💻

```java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.IOException;

public class ApiClientExample {
public static void main(String[] args) {
HttpClient client = HttpClient.newHttpClient(); // Create an HttpClient instance

// Build an HttpRequest for a GET request
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://jsonplaceholder.typicode.com/posts/1")) // Target API endpoint
.GET() // Specify GET method
.build();

try {
// Send the request and get the response
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

// Print the status code and response body
System.out.println("Status Code: " + response.statusCode());
System.out.println("Response Body:n" + response.body());

} catch (IOException | InterruptedException e) {
System.err.println("Error making API request: " + e.getMessage());
e.printStackTrace();
}
}
}
```

Output example:
```
Status Code: 200
Response Body:
{
"userId": 1,
"id": 1,
"title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
"body": "quia et suscipitnsuscipit recusandae consequuntur expedita et cumnreprehenderit molestiae ut ut quas totamnnostrum rerum est autem sunt rem eveniet architecto"
}
```

**Small challenge:**
Can you modify the code to fetch data for a different post (e.g., post ID 5) or try fetching a user's data from `https://jsonplaceholder.typicode.com/users/1`? Share your code snippets in the comments! 👇

---

Day 17: JSON Data Handling \(Jackson/Gson\) \- Code & Output

🌟 Java Learning Series - Day 18 🌟

Hello, Java learners! 👋 Today, we're diving into the powerful world of **Regular Expressions** (Regex)! 🚀 Regular expressions are sequence of characters that define a search pattern. They are incredibly useful for searching, manipulating, and validating strings. Think of them as super-charged pattern matchers for text data! In Java, we use the `java.util.regex` package, featuring the `Pattern` and `Matcher` classes, to harness this power. Let's explore how to find and replace text using regex! ✨

```java
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexBasics {
public static void main(String[] args) {
String text = "Java is a powerful language. Version 1.8 is widely used, but Java 21 is out!";

// 1. Finding all occurrences of "Java" (case-insensitive)
Pattern javaPattern = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher javaMatcher = javaPattern.matcher(text);

System.out.println("🔍 Finding all 'Java' occurrences:");
while (javaMatcher.find()) {
System.out.println("Found: '" + javaMatcher.group() + "' at index " + javaMatcher.start());
}

// 2. Replacing all digits with a hash '#'
// "\d" is the regex for any digit (0-9)
String textWithNumbers = "My project ID is P123 and my build number is 4567.";
String replacedText = textWithNumbers.replaceAll("\d+", "#"); // \d+ matches one or more digits
System.out.println("n✏️ Text after replacing digits: " + replacedText);

// 3. Checking if the entire string matches a pattern (e.g., starts with a letter and ends with a number)
Pattern specificPattern = Pattern.compile("^[A-Za-z].*\d$"); // Starts with letter, ends with digit
String validString = "HelloWorld1";
String invalidString = "1HelloWorld";

System.out.println("n✅ Does '" + validString + "' match: " + specificPattern.matcher(validString).matches());
System.out.println("❌ Does '" + invalidString + "' match: " + specificPattern.matcher(invalidString).matches());
}
}
```

Output example:
```
🔍 Finding all 'Java' occurrences:
Found: 'Java' at index 0
Found: 'Java' at index 48

✏️ Text after replacing digits: My project ID is P# and my build number is #.

✅ Does 'HelloWorld1' match: true
❌ Does '1HelloWorld' match: false
```

### Small Challenge:
Can you modify the code to find and print all words that contain at least one digit in the original `text` variable? (Hint: Use `\b` for word boundaries and `\w*\d\w*` for words with digits). Good luck! 🧠💡

---

✨ **Day 19: Mastering Java Build Tools & Dependency Management!** ✨

Hey Java learners! 👋 Today we dive into the backbone of professional Java development: **Build Tools** like Maven and Gradle. 🛠️ These tools are indispensable for automating tasks like compiling code, running tests, packaging applications, and most importantly, managing project dependencies. Say goodbye to manual JAR hell! 📦 They ensure your project builds consistently and efficiently, making collaboration a breeze.

Let's look at a simple Java application that leverages an external library – something build tools handle seamlessly!

```java
package com.example;

import org.apache.commons.lang3.StringUtils; // An external dependency!

public class App {
public static void main(String[] args) {
String originalMessage = "hello java world";
// StringUtils comes from Apache Commons Lang3, managed by Maven/Gradle!
String capitalizedMessage = StringUtils.capitalize(originalMessage);

System.out.println("Original String: " + originalMessage);
System.out.println("Capitalized String: " + capitalizedMessage);
System.out.println("nThis app uses an external library. Build tools like Maven or Gradle make integrating 'StringUtils' effortless by simply declaring it as a dependency!");
}
}
```

Output example:
```
Original String: hello java world
Capitalized String: Hello java world

This app uses an external library. Build tools like Maven or Gradle make integrating 'StringUtils' effortless by simply declaring it as a dependency!
```

**Small Challenge:** 💡
When you use Maven or Gradle, you don't manually download `.jar` files for libraries. What is the name of the central configuration file in a Maven project where you would declare `org.apache.commons:commons-lang3:3.12.0` as a dependency? (Hint: It's the Project Object Model!)

Happy coding! 🚀📚

Day 19: Build Tools and Dependency Management \(Maven/Gradle\) \- Code & Output

Day 20: Working with Dates and Times \(java\.time\) \- Code & Output

Day 21: Interfaces and Abstract Classes \- Code & Output

Here's your Telegram post for Day 22 on Java Generics! ✨

---

**Day 22: Generics - Type-Safe Code, Reimagined!** ✨

Ready to write more robust, reusable, and type-safe Java code? Today we're diving into Generics, a powerful feature that allows you to define classes, interfaces, and methods with a type parameter. This means fewer `ClassCastException`s at runtime and more compile-time safety! 🚀 Let's make our code shine by creating a simple generic `Box` class. 📚

```java
public class MyGenericBox<T> {
private T content;

public MyGenericBox(T content) {
this.content = content;
}

public T getContent() {
return content;
}

public void setContent(T content) {
this.content = content;
}

// A generic method example:
public static <U> void printBoxContentInfo(MyGenericBox<U> box) {
System.out.println("Box contains: " + box.getContent() +
" (Actual Type: " + box.getContent().getClass().getSimpleName() + ")");
}

public static void main(String[] args) {
// Box for String
MyGenericBox<String> stringBox = new MyGenericBox<>("Hello Generics");
System.out.println("String Box content: " + stringBox.getContent());

// Box for Integer
MyGenericBox<Integer> intBox = new MyGenericBox<>(123);
System.out.println("Integer Box content: " + intBox.getContent());

// Using the generic method with different box types
printBoxContentInfo(stringBox);
printBoxContentInfo(intBox);

// ⭐ Generics in action! This line would cause a compile-time error:
// stringBox.setContent(456); // Error: Incompatible types. Integer cannot be converted to String
}
}
```

Output example:
```
String Box content: Hello Generics
Integer Box content: 123
Box contains: Hello Generics (Actual Type: String)
Box contains: 123 (Actual Type: Integer)
```

**Small Challenge:**
Can you extend our understanding of generics? Create a generic `Pair<K, V>` class that can hold two different types of values (e.g., a key and a value). Then, instantiate it with `Pair<String, Integer>` and `Pair<Double, String>` and print their contents! 💡

---

Day 22: Generics \- Code & Output