🚨 Day 11: Diving into Java's Exception Handling! 🚨 Ever had your program crash unexpectedly? That's where exceptions come in! Today, we'll learn how to make our code robust and user-friendly using `try`, `catch`, and `finally`.

`try`: Encloses code that might throw an exception.
`catch`: Catches and handles specific exceptions.
`finally`: Guarantees code execution, whether an exception occurred or not.

Let's prevent those crashes and handle errors gracefully! 👇

```java
public class ExceptionHandlingDemo {
public static void main(String[] args) {
System.out.println("Program starting...");

try {
// Code that might throw an exception
int numerator = 10;
int denominator = 0; // This will cause an ArithmeticException

int result = numerator / denominator;
System.out.println("Result: " + result); // This line won't execute
} catch (ArithmeticException e) {
// Code to handle a specific exception (e.g., division by zero)
System.err.println("🚫 Caught an ArithmeticException: " + e.getMessage());
System.err.println("Suggestion: Please do not divide by zero!");
} catch (Exception e) { // A general catch block for any other unexpected exception
System.err.println("⚠️ Caught a general exception: " + e.getMessage());
} finally {
// Code that always executes, regardless of an exception
System.out.println("✅ The 'finally' block always runs. Cleanup or final message complete.");
}

System.out.println("Program finished.");
}
}
```

Output example:
```
Program starting...
🚫 Caught an ArithmeticException: / by zero
Suggestion: Please do not divide by zero!
✅ The 'finally' block always runs. Cleanup or final message complete.
Program finished.
```

✅ Your Challenge: Modify the example! Write a small program that asks the user for two numbers. Use `try-catch` to handle `NumberFormatException` if the user enters non-numeric input, and also `ArithmeticException` if the second number is zero. Make sure a `finally` block prints a 'Thank you for using the calculator!' message.

Day 11: Exception Handling \(try, catch, finally\) \- Code & Output

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

---

🎉 Day 12: Packages and Import Statements! 🎉

Ready to keep your Java code neat and tidy? 🧹 On Day 12, we're diving into `Packages` and `Import Statements`! These aren't just fancy keywords; they're essential tools for organizing your classes, preventing naming conflicts, and making your code much more readable and manageable, especially in larger projects. Think of packages as folders for your classes, and import statements as shortcuts to access files in those folders easily. Let's make our code professional! 🧑‍💻

```java
// File: src/com/example/myapp/utilities/Greeter.java
package com.example.myapp.utilities;

public class Greeter {
public static String greet(String name) {
return "Hello from package utilities, " + name + "!";
}
}

// File: src/com/example/myapp/main/MyMainApp.java
package com.example.myapp.main;

import com.example.myapp.utilities.Greeter; // Importing the Greeter class

public class MyMainApp {
public static void main(String[] args) {
// Now you can use Greeter directly thanks to the import!
String message = Greeter.greet("Java Learner");
System.out.println(message);

// Without import, you would need the fully qualified name:
// String message2 = com.example.myapp.utilities.Greeter.greet("Another Learner");
// System.out.println(message2);
}
}
```

Output example:
```
Hello from package utilities, Java Learner!
```

---

🚀 **Small Challenge:**
Your turn! Create a new package, say `com.example.myapp.mathutils`, and add a class `Calculator` with a static method `add(int a, int b)`. Then, modify `MyMainApp` to import and use your `Calculator` class to print the sum of two numbers! Good luck! ✨

---

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

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

---

**✨ Java Learning Series - Day 13: Object-Oriented Programming (Classes & Objects) ✨**

Hello, future Java wizards! 🚀 Today is a *big* day as we dive into the heart of Java: Object-Oriented Programming (OOP)! Specifically, we're unlocking the power of **Classes and Objects**.

Think of a `class` as a blueprint or a cookie cutter. It defines the structure and behavior that its "products" will have. An `object`, then, is the actual cookie – a real instance created from that blueprint! It's how we model real-world entities and organize our code in a powerful, reusable way. Get ready to build some software architecture! 🏗️

Let's see them in action! 👇

```java
// Define a Car class (the blueprint)
class Car {
// Attributes (state/data)
String make;
String model;
int year;

// Constructor (a special method to create objects)
public Car(String make, String model, int year) {
this.make = make; // 'this' refers to the current object
this.model = model;
this.year = year;
System.out.println("A new Car object has been created: " + make + " " + model);
}

// Methods (behavior/actions)
public void start() {
System.out.println("The " + make + " " + model + " is starting...");
}

public void accelerate() {
System.out.println("The " + make + " " + model + " is accelerating!");
}

public void displayInfo() {
System.out.println("Car Info: " + year + " " + make + " " + model);
}
}

public class Day13_ClassesAndObjects {
public static void main(String[] args) {
// Create objects (instances) from the Car blueprint
Car myCar = new Car("Toyota", "Camry", 2023); // Creates an object named myCar
myCar.start();
myCar.accelerate();
myCar.displayInfo();
System.out.println("---");

Car anotherCar = new Car("Honda", "Civic", 2022); // Creates another object
anotherCar.start();
anotherCar.displayInfo();
}
}
```

Output example:
```
A new Car object has been created: Toyota Camry
The Toyota Camry is starting...
The Toyota Camry is accelerating!
Car Info: 2023 Toyota Camry
---
A new Car object has been created: Honda Civic
The Honda Civic is starting...
Car Info: 2022 Honda Civic
```

---

**🤔 Small Challenge for You:**
Modify the `Car` class!
1. Add a new attribute: `double fuelLevel` (initialize it to `100.0` in the constructor).
2. Add a new method: `public void drive(double distance)` that prints "Driving X km." and decreases `fuelLevel` by `distance / 10.0`.
3. Add another method: `public void refuel(double amount)` that increases `fuelLevel` by the given `amount`.
4. In `main`, call `drive()` and `refuel()` on `myCar` and print its `fuelLevel` before and after these actions. 💪

---

**Quiz Question:**

Day 13: Object\-Oriented Programming \(Classes and Objects\) \- Code & Output

Here's your Telegram post for Day 14!

---

**Day 14: Inheritance and Polymorphism – The Pillars of OOP!** 🧬

Hello, Java learners! Today, we're unlocking the power of two fundamental OOP concepts: **Inheritance** and **Polymorphism**. ✨

**Inheritance** allows a class (subclass/child) to inherit properties and methods from another class (superclass/parent). This promotes code reusability and creates a clear "is-a" relationship. Think of it as building on existing foundations!

**Polymorphism** (meaning "many forms") lets objects of different classes be treated as objects of a common type. It's the magic behind writing flexible and extensible code, allowing you to handle different types of objects uniformly. 🔄 Let's see them in action!

```java
// Parent class (Superclass)
class Animal {
public void makeSound() {
System.out.println("Animal makes a sound");
}

public void eat() {
System.out.println("Animal eats food");
}
}

// Child class (Subclass) inheriting from Animal
class Dog extends Animal {
// Method Overriding: Providing a specific implementation for makeSound()
@Override
public void makeSound() {
System.out.println("Woof! Woof!");
}

public void fetch() {
System.out.println("Dog fetches the ball!");
}
}

// Another Child class inheriting from Animal
class Cat extends Animal {
// Method Overriding: Providing a specific implementation for makeSound()
@Override
public void makeSound() {
System.out.println("Meow!");
}

public void scratch() {
System.out.println("Cat scratches the post.");
}
}

public class ZooPark {
public static void main(String[] args) {
// Inheritance: myDog is a Dog, which IS-A Animal
Dog myDog = new Dog();
Cat myCat = new Cat();

System.out.println("--- Specific animal actions ---");
myDog.makeSound(); // Calls Dog's specific sound
myDog.fetch(); // Calls Dog's specific action
myCat.makeSound(); // Calls Cat's specific sound
myCat.scratch(); // Calls Cat's specific action
myDog.eat(); // Calls inherited eat() from Animal

System.out.println("n--- Polymorphism in a common method ---");
// Polymorphism: An Animal reference can point to a Dog or Cat object
makeAnimalPerform(myDog); // Dog object treated as Animal
makeAnimalPerform(myCat); // Cat object treated as Animal

System.out.println("n--- Polymorphism in a collection ---");
// Polymorphism in action: Array of Animal references
Animal[] pets = new Animal[2];
pets[0] = new Dog(); // Dog object assigned to Animal reference
pets[1] = new Cat(); // Cat object assigned to Animal reference

for (Animal pet : pets) {
pet.makeSound(); // Calls appropriate overridden makeSound()
pet.eat(); // Calls inherited eat()
}
}

// A method demonstrating polymorphism by accepting the superclass type
public static void makeAnimalPerform(Animal animal) {
System.out.print("Performing for an animal: ");
animal.makeSound(); // Behaves differently based on actual object type
animal.eat();
}
}
```

**Output example:**
```
--- Specific animal actions ---
Woof! Woof!
Dog fetches the ball!
Meow!
Cat scratches the post.
Animal eats food

--- Polymorphism in a common method ---
Performing for an animal: Woof! Woof!
Animal eats food
Performing for an animal: Meow!
Animal eats food

--- Polymorphism in a collection ---
Woof! Woof!
Animal eats food
Meow!
Animal eats food
```

**Small challenge:**
Can you add a new animal, `Cow`, to our `Animal` hierarchy? 🐄 Give it its unique `makeSound()` (e.g., "Moo!") and maybe a special action like `graze()`. Then, demonstrate its behavior using polymorphism by adding it to the `pets` array in the `main` method! Show its unique sound and inherited `eat()` method. 🚀

---

Day 14: Inheritance and Polymorphism \- Code & Output

🚀 Day 15 already! Today, we're diving into the heart of Java's power: its standard libraries! 📚 We'll explore `java.util` for essential utility classes like `Scanner` to handle input, and `java.io` for all your input/output needs, like reading from or writing to files. Mastering these will unlock a whole new level of programming possibilities! ✨ Let's get hands-on! 💡

```java
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class LibraryDemo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter your name: ");
String name = scanner.nextLine();

String fileName = "greeting.txt";

// Writing to a file using java.io.FileWriter
System.out.println("n--- Writing to file ---");
try (FileWriter writer = new FileWriter(fileName)) {
writer.write("Hello, " + name + "!n");
writer.write("Welcome to Day 15 of Java learning.n");
System.out.println("Message written to " + fileName + " successfully.");
} catch (IOException e) {
System.err.println("Error writing to file: " + e.getMessage());
}

// Reading from a file using java.io.FileReader
System.out.println("n--- Reading from file ---");
System.out.println("Content of " + fileName + ":");
try (FileReader reader = new FileReader(fileName)) {
int character;
while ((character = reader.read()) != -1) {
System.out.print((char) character);
}
System.out.println("File read successfully!");
} catch (IOException e) {
System.err.println("Error reading from file: " + e.getMessage());
} finally {
scanner.close(); // Important to close resources!
}
}
}
```

Output example:
```
Enter your name: JavaLearner

--- Writing to file ---
Message written to greeting.txt successfully.

--- Reading from file ---
Content of greeting.txt:
Hello, JavaLearner!
Welcome to Day 15 of Java learning.
File read successfully!
```

Small challenge:
Can you modify the code to also ask for the user's favorite programming language and append it as a new line to the `greeting.txt` file after the initial message? Remember to handle potential `IOException` when appending! (Hint: Look for `FileWriter` constructors that take a boolean `append` argument!) 🤓

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!

---

🌟 **Day 16: Mastering APIs with Java!** 🌟

Ever wondered how your apps can fetch data from the internet or interact with other services? Today, we unlock the power of **APIs (Application Programming Interfaces)**! 🚀

APIs are the backbone of modern web communication, allowing different software systems to talk to each other. In Java, we have powerful tools like the modern `HttpClient` (introduced in Java 11) and the traditional `HttpURLConnection` to make these interactions happen.

In this lesson, we'll focus on making a simple GET request using `HttpClient` to fetch data from a public API. Get ready to connect your Java applications to the world! 🌍

```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 ApiFetcher {
public static void main(String[] args) {
// Create an HttpClient instance
HttpClient client = HttpClient.newHttpClient();

// Build an HttpRequest
// We'll fetch a single post from JSONPlaceholder
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://jsonplaceholder.typicode.com/posts/1"))
.GET() // Specifies the HTTP method as GET
.build();

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

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

} catch (IOException | InterruptedException e) {
System.err.println("An error occurred while making the HTTP 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:
Your turn! 💪 Try fetching a list of *users* instead of posts from `https://jsonplaceholder.typicode.com/users`. Can you modify the code to print only the `name` and `email` of the *first* user in the list? (Hint: You'll need to parse the JSON response!)

---

Day 16: Working with APIs \(HttpClient/HttpURLConnection\) \- Code & Output

Here's your Telegram post for Day 17!

---

🎉 Day 17 is here, and we're tackling a crucial skill for modern Java development: **JSON Data Handling!** 🚀

JSON (JavaScript Object Notation) is everywhere – from web APIs to configuration files. Today, you'll learn how to seamlessly convert Java objects into JSON strings (serialization) and vice-versa (deserialization) using powerful libraries like **Jackson** or **Gson**. It's easier than you think and opens up a world of possibilities for your applications!

Let's dive into an example using Jackson. 🛠️

```java
// Product.java
// This is our simple Java POJO (Plain Old Java Object)
public class Product {
private int id;
private String name;
private double price;
private boolean available;

// Default constructor for deserialization
public Product() {}

public Product(int id, String name, double price, boolean available) {
this.id = id;
this.name = name;
this.price = price;
this.available = available;
}

// Getters and Setters (required by Jackson for serialization/deserialization)
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public double getPrice() { return price; }
public void setPrice(double price) { this.price = price; }
public boolean isAvailable() { return available; }
public void setAvailable(boolean available) { this.available = available; }

@Override
public String toString() {
return "Product [id=" + id + ", name=" + name + ", price=" + price + ", available=" + available + "]";
}
}

// MainJsonHandler.java
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;

public class MainJsonHandler {
public static void main(String[] args) {
ObjectMapper objectMapper = new ObjectMapper();

try {
// --- 1. Serialize Java Object to JSON String ---
Product laptop = new Product(101, "SuperLaptop", 1200.00, true);
String jsonOutput = objectMapper.writeValueAsString(laptop);
System.out.println("Serialized Product to JSON:n" + jsonOutput);

// --- 2. Deserialize JSON String to Java Object ---
String jsonInput = "{"id":202,"name":"GamingMouse","price":75.50,"available":false}";
Product mouse = objectMapper.readValue(jsonInput, Product.class);
System.out.println("nDeserialized JSON to Product:n" + mouse);

} catch (IOException e) {
e.printStackTrace();
}
}
}
```

**Note:** To run this code, you'll need the Jackson dependency. For Maven, add this to your `pom.xml`:
```xml
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.15.2</version> <!-- Use the latest version -->
</dependency>
```

Output example:
```
Serialized Product to JSON:
{"id":101,"name":"SuperLaptop","price":1200.0,"available":true}

Deserialized JSON to Product:
Product [id=202, name=GamingMouse, price=75.5, available=false]
```

### Your Challenge! 🚀
Modify the `MainJsonHandler` to:
1. Create a `List<Product>` with a few different product objects.
2. Serialize this `List<Product>` into a JSON array string.
3. Deserialize that JSON array string back into another `List<Product>`.
Can you do it? Show us your solution! 👇

Happy coding, and see you tomorrow! #JavaLearning #JSON #Jackson #Serialization #Programming

---

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

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

---

🎉 **Day 18: Mastering Regular Expressions in Java!** 🎉

Hey Java Learners! 👋 Today, we're unlocking a superpower for text manipulation: Regular Expressions (Regex)! 🕵️‍♀️ Ever needed to validate input formats, search for complex patterns, or extract specific data from large strings? Regex is your ultimate tool!

In Java, the `java.util.regex` package provides the `Pattern` and `Matcher` classes to work with regex. `Pattern` compiles your regex into an object, and `Matcher` uses that pattern to perform search operations on a given input string. Let's dive into an example! ✨

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

public class RegexFun {
public static void main(String[] args) {
String text = "Hello world! My email is example@domain.com, and another one is user123@sub.net. Don't forget my number: 12345.";

// Regex to find email addresses
String emailRegex = "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b";

Pattern pattern = Pattern.compile(emailRegex);
Matcher matcher = pattern.matcher(text);

System.out.println("🔍 Finding email addresses:");
while (matcher.find()) {
System.out.println("Found: " + matcher.group());
}

System.out.println("n🔢 Finding all numbers (one or more digits):");
String numberRegex = "\d+";
Pattern numberPattern = Pattern.compile(numberRegex);
Matcher numberMatcher = numberPattern.matcher(text);
while (numberMatcher.find()) {
System.out.println("Number found: " + numberMatcher.group());
}
}
}
```

Output example:
```
🔍 Finding email addresses:
Found: example@domain.com
Found: user123@sub.net

🔢 Finding all numbers (one or more digits):
Number found: 12345
```

### Small Challenge:
Can you modify the `emailRegex` to *also* find phone numbers like `123-456-7890` or `(123) 456-7890` in the same text, perhaps by creating a new `Pattern` and `Matcher`? Or, try to find all words starting with "D" or "d"! 💡

---