Tech Jargon - Decoded

Abstract Classes and Interfaces

abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public abstract String makeSound();

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

interface Swimmable {
    void swim();
}

class Dog extends Animal implements Swimmable {
    public Dog(String name) {
        super(name);
    }

    @Override
    public String makeSound() {
        return "Woof!";
    }

    @Override
    public void swim() {
        System.out.println(getName() + " is swimming.");
    }
}

class Fish implements Swimmable {
    private String name;

    public Fish(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public void swim() {
        System.out.println(name + " is swimming.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        Fish fish = new Fish("Goldie");

        System.out.println(dog.getName() + " says: " + dog.makeSound());
        dog.eat();
        dog.swim();

        fish.swim();
    }
}

Polymorphism: Compile-time and Runtime

class Animal {
    void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow!");
    }
}

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

    double add(double a, double b) {
        return a + b;
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal1 = new Animal();
        Animal animal2 = new Dog();
        Animal animal3 = new Cat();

        animal1.makeSound();
        animal2.makeSound();
        animal3.makeSound();

        Calculator calc = new Calculator();
        System.out.println(calc.add(2, 3));
        System.out.println(calc.add(2.5, 3.5));
    }
}

Inheritance and 'super' Keyword

class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }

    void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    String breed;

    Dog(String name, String breed) {
        super(name);
        this.breed = breed;
    }

    @Override
    void makeSound() {
        super.makeSound();
        System.out.println("Woof!");
    }

    void displayBreed() {
        System.out.println("Breed: " + breed);
    }

    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy", "Golden Retriever");
        myDog.makeSound();
        myDog.displayBreed();
        System.out.println("Name: " + myDog.name);
    }
}

Method Overloading and Overriding

class Animal {
 public void makeSound() {
 System.out.println("Generic animal sound");
 }
}

class Dog extends Animal {
 @Override
 public void makeSound() {
 System.out.println("Woof!");
 }

 public void makeSound(String volume) {
 System.out.println("Woof! at " + volume + " volume");
 }
}

public class Main {
 public static void main(String[] args) {
 Animal animal = new Animal();
 Dog dog = new Dog();
 Animal animalDog = new Dog();

 animal.makeSound();
 dog.makeSound();
 dog.makeSound("High");
 animalDog.makeSound();
 }
}

Constructors and Constructor Overloading

public class Student {
    String name;
    int age;

    public Student() {
        this.name = "Unknown";
        this.age = 18;
    }

    public Student(String name) {
        this.name = name;
        this.age = 18;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student("Alice");
        Student student3 = new Student("Bob", 20);

        student1.display();
        student2.display();
        student3.display();
    }
}

Creating Classes and Objects in Java

class Dog {
    String name;
    String breed;

    Dog(String name, String breed) {
        this.name = name;
        this.breed = breed;
    }

    void bark() {
        System.out.println("Woof!");
    }

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

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog("Buddy", "Golden Retriever");
        Dog dog2 = new Dog("Lucy", "Poodle");

        dog1.bark();
        dog1.displayDetails();

        dog2.bark();
        dog2.displayDetails();
    }
}

ld Analogy: Imagine you are designing a program to simulate a zoo. - **Classes:** You might have classes like `Animal`, `Mammal`, `Bird`, `Lion`, `Eagle`, etc. - **Objects:** Instances of these classes would be specific animals in the zoo, like `simbaTheLion`, `rockyTheEagle`. - **Inheritance:** `Lion` and `Eagle` inherit from `Mammal` and `Bird` respectively, which inherit from `Animal`. - **Polymorphism:** A `makeSound` method might produce different sounds depending on the type of `Animal`. - **Encapsulation:** An `Animal` object encapsulates its internal data (e.g., age, health) and exposes methods to interact with it (e.g., `eat`, `sleep`). - **Abstraction:** When interacting with the `Animal`, you don't need to know how its digestive system works; you just need to know that it can `eat`. OOP helps organize your code in a way that models the real world, making it easier to understand, maintain, and extend. Keep practicing, and you'll become an OOP master in no time! 🎉

Okay, let's unravel the world of Object-Oriented Programming (OOP) in Java! 🚀 It might sound intimidating, but it's actually a really intuitive way to structure your code. Think of it as organizing your code like you organize real-world objects. OOP is a programming paradigm based on the concept of "objects", which contain data, in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods). A distinguishing feature of objects is that an object's procedures can access and often modify the data fields of the object with which they are associated. Let's break down the key concepts: 1. **Classes and Objects: The Blueprint and the Reality** 🧱 Imagine a "Class" as a blueprint for a house. 🏠 It defines what the house will look like, what rooms it will have, and what functions each room serves. An "Object" is the actual house built from that blueprint. You can build many houses (objects) from the same blueprint (class). - **Class:** A template or blueprint that defines the characteristics and behavior of objects. 🧠 It's the plan. - **Object:** An instance of a class. ✅ It's a real thing created from the blueprint. Example: a `Dog` class could produce objects like `myDog` or `yourDog`. 2. **Encapsulation: Bundling and Protecting** 📦 Encapsulation is like putting all the parts of a car engine inside a protective casing. ⚙️ You don't need to know *how* the engine works internally; you just need to know how to start it and drive. Encapsulation bundles data (attributes) and methods (behavior) that operate on that data into a single unit (the class), and it hides the internal implementation details from the outside world. - It restricts direct access to some of the object's components. - Provides controlled access through methods. - Protects data integrity by preventing unauthorized modifications. 🛡️ 3. **Abstraction: Showing Only What's Necessary** 📱 Abstraction is showing only the essential details to the user and hiding the complex implementation. Think of your phone. 📱 You know how to make calls, send texts, and browse the internet, but you don't need to know the intricate electronic circuits behind it all. Abstraction simplifies things. - Focuses on what an object does rather than how it does it. - Hides complex implementation details. - Provides a simplified interface for users. ✅ 4. **Inheritance: Building Upon Existing Foundations** 👪 Inheritance is like inheriting traits from your parents. 🧬 A child inherits characteristics from its parents and can also have its own unique features. In OOP, a class can inherit properties and methods from another class (the parent or superclass). The inheriting class (the child or subclass) can then add its own unique properties and methods or modify the inherited ones. - Allows creating new classes based on existing ones. - Promotes code reusability. ♻️ - Reduces code duplication. - Establishes an "is-a" relationship (e.g., a `Dog` *is a* `Animal`). 5. **Polymorphism: Many Forms, One Name** 🎭 Polymorphism means "many forms." In OOP, it allows objects of different classes to respond to the same method call in their own way. Think of a "speak" method. A `Dog` object might "speak" by barking, while a `Cat` object might "speak" by meowing. 🗣️ They both respond to the same method ("speak"), but their behavior is different. - Allows objects of different classes to be treated as objects of a common type. - Enhances flexibility and extensibility of code. - Achieved through method overloading and method overriding. 💡 Master Classes: The term "Master Class" doesn't have a specific technical meaning in OOP. However, it is used colloquially to describe a well-designed, foundational class that serves as a base for other classes in a system. For example, you can consider an `Animal` class to be like a master class for different kinds of animals. Real-Wor

Recursive Fibonacci Number

public class Fibonacci {
    public static int fibonacci(int n) {
        if (n <= 1) {
            return n;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static void main(String[] args) {
        int n = 10;
        System.out.println("Fibonacci(" + n + ") = " + fibonacci(n));
    }
}

Palindrome Check using Recursion

public class PalindromeChecker {

    public static boolean isPalindrome(String s) {
        if (s.length() <= 1) {
            return true;
        }
        if (s.charAt(0) != s.charAt(s.length() - 1)) {
            return false;
        }
        return isPalindrome(s.substring(1, s.length() - 1));
    }

    public static void main(String[] args) {
        String str1 = "madam";
        String str2 = "racecar";
        String str3 = "hello";

        System.out.println(str1 + " is palindrome: " + isPalindrome(str1));
        System.out.println(str2 + " is palindrome: " + isPalindrome(str2));
        System.out.println(str3 + " is palindrome: " + isPalindrome(str3));
    }
}

Reverse a Number Using Recursion

public class ReverseNumber {

    public static int reverse(int n, int reversed) {
        if (n == 0) {
            return reversed;
        }
        int lastDigit = n % 10;
        int newReversed = reversed * 10 + lastDigit;
        return reverse(n / 10, newReversed);
    }

    public static int reverseNumber(int n) {
        return reverse(n, 0);
    }

    public static void main(String[] args) {
        int num = 12345;
        int reversedNum = reverseNumber(num);
        System.out.println("Reversed number: " + reversedNum);
    }
}

Sum of Digits using Recursion

public class SumOfDigits {

    public static int sumDigits(int n) {
        if (n == 0) {
            return 0;
        }
        return (n % 10) + sumDigits(n / 10);
    }

    public static void main(String[] args) {
        int number = 12345;
        int result = sumDigits(number);
        System.out.println("Sum of digits of " + number + " is " + result);
    }
}

Recursive Power Function

public class RecursivePower {
 public static int power(int a, int b) {
 if (b == 0) {
 return 1;
 }
 return a * power(a, b - 1);
 }

 public static void main(String[] args) {
 int base = 2;
 int exponent = 3;
 int result = power(base, exponent);
 System.out.println(result);
 }
}

Check Prime Number Using Function

public class PrimeChecker {

    public static boolean isPrime(int n) {
        if (n <= 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int number = 29;
        if (isPrime(number)) {
            System.out.println(number + " is a prime number.");
        } else {
            System.out.println(number + " is not a prime number.");
        }
    }
}

Is this number special? 🤔 Let's find out if it's prime using functions in Java!

public class PrimeChecker {
    public static boolean isPrime(int n) {
        if (n <= 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int number = 29;
        if (isPrime(number)) {
            System.out.println(number + " is a prime number.");
        } else {
            System.out.println(number + " is not a prime number.");
        }
    }
}

Unlocking Math Secrets: GCD and LCM with Recursion in Java 🚀

public class GCDLCMRecursive {

    public static int gcd(int a, int b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static int lcm(int a, int b) {
        return (a * b) / gcd(a, b);
    }

    public static void main(String[] args) {
        int num1 = 12;
        int num2 = 18;
        System.out.println("GCD of " + num1 + " and " + num2 + " is " + gcd(num1, num2));
        System.out.println("LCM of " + num1 + " and " + num2 + " is " + lcm(num1, num2));
    }
}

#JavaRecursion #FibonacciSequence

Unlocking the Fibonacci Sequence: A Recursive Journey in Java!

public class FibonacciRecursive {
    public static int fibonacci(int n) {
        if (n <= 1) {
            return n;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static void main(String[] args) {
        int n = 10;
        System.out.println("Fibonacci sequence up to " + n + ":");
        for (int i = 0; i < n; i++) {
            System.out.print(fibonacci(i) + " ");
        }
    }
}

Unlocking Factorials: Can you compute them with recursion in Java?

public class Factorial {

    public static int factorial(int n) {
        if (n == 0) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }

    public static void main(String[] args) {
        int number = 5;
        int fact = factorial(number);
        System.out.println("Factorial of " + number + " is: " + fact);
    }
}

#JavaMethods #AreaCalculation #FunctionParameters