✨ **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

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

---

🚀 Day 23: Try-with-Resources (Resource Management) 🚀

Tired of manually closing your streams, files, or database connections? 😅 Forgetting to close resources can lead to serious performance issues and resource leaks! Java 7+ introduced a brilliant feature to tackle this: `try-with-resources`.

It automatically closes any resource that implements the `AutoCloseable` interface once the `try` block finishes, *regardless* of whether an exception occurs. ✨ This means cleaner, safer, and more robust code with less boilerplate! Say goodbye to cumbersome `finally` blocks just for closing! 👋

Let's see this powerful construct in action:

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

public class ResourceManagementDemo {
public static void main(String[] args) {
// For this example, assume 'example.txt' exists in the same directory
// and contains at least one line, e.g., "Hello Try-with-Resources!"

String fileName = "example.txt";

System.out.println("Attempting to read from file: " + fileName);

// try-with-resources automatically closes FileReader and BufferedReader
try (FileReader fileReader = new FileReader(fileName);
BufferedReader bufferedReader = new BufferedReader(fileReader)) {

String line = bufferedReader.readLine(); // Read the first line
if (line != null) {
System.out.println("Successfully read: "" + line + """);
} else {
System.out.println("File is empty or could not read any line.");
}

} catch (IOException e) {
System.err.println("An error occurred while reading the file: " + e.getMessage());
// The resources are still automatically closed even if an exception happens here!
} finally {
System.out.println("Resources are guaranteed to be closed!");
}
}
}
```

Output example:
```
Attempting to read from file: example.txt
Successfully read: "Hello Try-with-Resources!"
Resources are guaranteed to be closed!
```
*(If `example.txt` contains "Hello Try-with-Resources!")*

**Small Challenge:**
Can you modify the code above to read and print *all* lines from `example.txt` until the end of the file is reached, still using the `try-with-resources` block? 🤔 What other common `AutoCloseable` resources can you think of besides file readers?

---

Day 23: Try\-with\-Resources \(Resource Management\) \- Code & Output

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

---

🚀 Day 25: Unit Testing (JUnit) 🚀

It's time to build robust Java applications! Today, we dive into the world of Unit Testing with **JUnit**. 🧪 Writing tests ensures your code behaves exactly as expected, catches bugs early, and makes refactoring a breeze. We'll learn how to create simple test cases to verify individual components (units) of your code. Let's make our code reliable! 💪

```java
// Calculator.java - The class we want to test
public class Calculator {
public int add(int a, int b) {
return a + b;
}

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

public int multiply(int a, int b) {
return a * b;
}

// A simple method to demonstrate an edge case for testing
public int divide(int a, int b) {
if (b == 0) {
throw new IllegalArgumentException("Cannot divide by zero");
}
return a / b;
}
}
```

```java
// CalculatorTest.java - Our JUnit test class
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*; // Import static assertions

public class CalculatorTest {

// Test method for the add operation
@Test
void testAdd() {
Calculator calculator = new Calculator();
// assertEquals(expected, actual, message)
assertEquals(5, calculator.add(2, 3), "2 + 3 should be 5");
assertEquals(0, calculator.add(-1, 1), "-1 + 1 should be 0");
assertEquals(-5, calculator.add(-2, -3), "-2 + -3 should be -5");
}

// Test method for the subtract operation
@Test
void testSubtract() {
Calculator calculator = new Calculator();
assertEquals(1, calculator.subtract(3, 2), "3 - 2 should be 1");
assertEquals(-5, calculator.subtract(0, 5), "0 - 5 should be -5");
assertEquals(0, calculator.subtract(7, 7), "7 - 7 should be 0");
}

// Test method for the multiply operation
@Test
void testMultiply() {
Calculator calculator = new Calculator();
assertEquals(6, calculator.multiply(2, 3), "2 * 3 should be 6");
assertEquals(0, calculator.multiply(5, 0), "5 * 0 should be 0");
assertEquals(-10, calculator.multiply(-2, 5), "-2 * 5 should be -10");
}

// Test method to verify division by zero throws an exception
@Test
void testDivideByZeroThrowsException() {
Calculator calculator = new Calculator();
// assertThrows(expectedType, executable, message)
assertThrows(IllegalArgumentException.class, () -> calculator.divide(10, 0),
"Dividing by zero should throw IllegalArgumentException");
}

// Example of a failing test (if you change expected to 4 for 2+3)
// @Test
// void testAddFailingExample() {
// Calculator calculator = new Calculator();
// assertEquals(4, calculator.add(2, 3), "2 + 3 should be 5 (this will fail)");
// }
}
```

Output example:
```
[INFO] Running CalculatorTest
[INFO] Tests run: 4, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS
```

**Challenge for you!** 💡
Add a new method `power(int base, int exponent)` to the `Calculator` class that calculates `base` raised to the power of `exponent`. Then, write a JUnit test method (`testPower()`) to verify its correctness. Don't forget edge cases like `exponent = 0` and `exponent = 1`!

---

Day 25: Unit Testing \(JUnit\) \- Code & Output

🚀 Day 26: Diving into Basic Web Scraping with Jsoup! 🕸️ Ever wished you could automatically pull information from websites? Today, we're exploring the fascinating world of web scraping using Jsoup, a robust Java library. Jsoup simplifies parsing HTML, navigating the DOM, and extracting specific data with familiar CSS selectors. It's an essential skill for data collection, monitoring, and automation. Let's write some code! 🧑‍💻

Here's how to get started with Jsoup to extract a page title and a paragraph:

```java
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.IOException;

public class SimpleWebScraper {
public static void main(String[] args) {
String url = "http://example.com/"; // A simple, static page for demonstration

try {
// 1. Connect to the URL and get the HTML document
// Jsoup.connect(url) creates a Connection object
// .get() fetches the URL and parses the HTML into a Document object
Document document = Jsoup.connect(url).get();

// 2. Extract the page title
String title = document.title();
System.out.println("Page Title: " + title);

// 3. Extract the text from the first paragraph (<p> tag)
// .select("p") finds all <p> tags
Elements paragraphs = document.select("p");
if (!paragraphs.isEmpty()) {
// .first() gets the first Element in the collection
// .text() extracts the plain text content of the element
System.out.println("First Paragraph Text: " + paragraphs.first().text());
}

// 4. Extract the text from the <h1> tag
// .selectFirst("h1") finds only the first <h1> tag
Element h1Tag = document.selectFirst("h1");
if (h1Tag != null) {
System.out.println("H1 Tag Text: " + h1Tag.text());
}

} catch (IOException e) {
System.err.println("Error connecting to " + url + ": " + e.getMessage());
e.printStackTrace(); // For more detailed error info
}
}
}
```

Output example:
```
Page Title: Example Domain
First Paragraph Text: This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission.
H1 Tag Text: Example Domain
```

💡 **Challenge:** Can you modify the code to find *all* `<a>` (anchor) tags on `http://example.com/` and print their `href` attributes? (Hint: Loop through the `Elements` collection and use `element.attr("href")`!) Happy scraping! 🕵️‍♂️

---

Day 26: Basic Web Scraping \(Jsoup\) \- Code & Output

Here's your Telegram post and quiz for Day 27!

---

**🌟 Day 27: Introduction to Spring Boot 🚀**

Ready for something game-changing? Today, we're diving into Spring Boot – the powerhouse framework that makes building robust, production-ready Java applications a breeze! 🎉 Say goodbye to complex configurations and hello to convention over configuration, embedded servers, and rapid development. We'll build our very first 'Hello World' REST API, showcasing just how easy it is to get started. Let's make some magic! ✨

```java
// SpringBootDemoApplication.java
// This is your main application entry point.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication // Marks this as a Spring Boot application
public class SpringBootDemoApplication {

public static void main(String[] args) {
// This line launches the Spring Boot application
SpringApplication.run(SpringBootDemoApplication.class, args);
}
}

// HelloController.java
// This would typically be in a separate file (e.g., com.example.demo.controller)
// It handles incoming web requests.
@RestController // Marks this class as a REST controller
class HelloController {

// Maps HTTP GET requests to the "/hello" path
@GetMapping("/hello")
public String sayHello() {
return "Hello from Spring Boot! 👋"; // The response sent to the client
}
}
```

**How to run (conceptual):**
1. Set up a Spring Boot project (e.g., using Spring Initializr).
2. Place `SpringBootDemoApplication.java` and `HelloController.java` in appropriate packages (e.g., `com.example.demo`).
3. Run the `main` method in `SpringBootDemoApplication`.
4. Open your browser and navigate to `http://localhost:8080/hello`.

**Output example:**
When you open `http://localhost:8080/hello` in your browser:

```
Hello from Spring Boot! 👋
```

**Small Challenge:**
Can you add another endpoint to our `HelloController`? Create a new method mapped to `/greet` that returns the string "Greetings, Java Learner! Happy coding! 💪".

---