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! 💪

---

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