Terms and definitions in java OOP? Hints: Static, abstract, finally, public, private, protected …. Use case and example

Sure! Here are the terms and definitions in object-oriented programming (OOP) in Java:

1. Static: The static keyword is used to declare a variable or method that belongs to the class itself, rather than an instance of the class. It can be accessed without creating an object of the class. For example:

public class MyClass {
    public static int myStaticVariable = 10;
    
    public static void myStaticMethod() {
        System.out.println("This is a static method.");
    }
}

2. Abstract: The abstract keyword is used to declare a class or method that cannot be instantiated or implemented directly. It serves as a blueprint for other classes to inherit from. For example:

public abstract class Animal {
    public abstract void makeSound();
}

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

3. Finally: The finally block is used in exception handling to specify a block of code that will be executed regardless of whether an exception is thrown or not. It is often used to release resources or perform cleanup operations. For example:

try {
    // Code that may throw an exception
} catch (Exception e) {
    // Exception handling code
} finally {
    // Code that will always be executed
}

4. Public: The public access modifier is used to declare a class, method, or variable that can be accessed from any other class. For example:

public class MyClass {
    public int myPublicVariable = 10;
    
    public void myPublicMethod() {
        System.out.println("This is a public method.");
    }
}

5. Private: The private access modifier is used to declare a class, method, or variable that can only be accessed within the same class. It provides encapsulation and data hiding. For example:

public class MyClass {
    private int myPrivateVariable = 10;
    
    private void myPrivateMethod() {
        System.out.println("This is a private method.");
    }
}

6. Protected: The protected access modifier is used to declare a class, method, or variable that can be accessed within the same package or by subclasses in different packages. For example:

public class MyClass {
    protected int myProtectedVariable = 10;
    
    protected void myProtectedMethod() {
        System.out.println("This is a protected method.");
    }
}

These are some of the terms and definitions related to Java OOP. I hope this helps!