Java OOP Cheat Sheet – A Quick Guide to Object Oriented Programming in Java

 class Test{
 // Added by the Java Compiler at the Run Time
 public Test(){ 
 }
 public static void main(String args[]) {
   Test testObj = new Test();
  }
}

This constructor is called parameterized as it contains one or more parameters. It is used to provide different values to the distinct objects at the time of their creation.

public class Test {
 int appId; 
 String appName;  
 //parameterized constructor with two parameters
 Test(int id, String name) {
    this.appId = id;
    this.appName = name; 
} 
void info() {
 System.out.println("Id: "+appId+" Name: "+appName);
}
public static void main(String args[]){ 
 Test obj1 = new Test(11001,"Facebook"); 
 Test obj2 = new Test(23003,"Instagram"); 
 obj1.info(); 
 obj2.info(); 
 }
}

Java access modifiers specify the scope of accessibility of a data member, method, constructor or class.

The non-access modifiers in Java, do not change the accessibility of variables and methods rather they provide special properties. These modifiers can alter the behavior of elements as well.

Inheritance is the property of a child/derived/subclass which allows it to inherit the properties(data members) and functionalities(methods) from its parent/base/superclass. 

• All objects have the Object class as their top parent. 
• Methods can be overridden but attributes can not.
• To call a parent class constructor, super() is used.

Java supports 5 types of inheritance:

1. Single Inheritance
2. Multi-level Inheritance
3. Hierarchical Inheritance
4. Hybrid Inheritance
5. Multiple Inheritance

In this, a class inherits the properties of a single parent class.

Class A{
  //your parent class code
}
Class B extends A {
   //your child class code
}

In multi-level inheritance, one class has more than one parent class but at different levels of inheritance.

Class A{
  //your parent class code
}
Class B extends A {
   //your code
}
Class C extends B {
    //your code 
}

In hierarchical inheritance, one parent can have one or more child/sub/derived classes.

Class A{
  //your parent class code
}
Class B extends A {
   //your child class code
}
Class C extends A {
    //your child class code 
}

Hybrid Inheritance is the combination of more than one type of inheritance in a single program, for example, you can combine a multilevel inheritance with a hierarchical inheritance. 

       A
       / 
    B     C
    /         
  D          E

Multiple inheritance is not supported in Java as it leads to the diamond problem. The diamond problem is an ambiguity where the compiler doesn’t know which superclass method to execute in case the superclasses has a method with the same name.

                   A
                 /     
 {abc()} B       C {abc()}
                      /
                    D {?}

*But multiple inheritance in Java can be achieved using interfaces.