Learn inner classes in Java

Inner class, also called Nested class, is a non-static class which is defined inside another class. Inner classes are nothing but classes that are defined within other classes. The nesting is a relationship between classes, not objects.
They may be defined as public, protected, private, or with package access. They may only be used "in the context" of the containing class (outer class, or enclosing class), unless they are marked as static

Java inner classes have feature that makes them richer and more useful. An object of an inner class has an implicit reference to the outer class object that instantiated it. Through this pointer, it gains access to any variable of the outer object. Only static inner classes don’t have this pointer. It is actually invisible when we write the code, but compiler takes care of it. Inner classes are actually a phenomenon of the compiler and not the JVM.

Inner Classes:

  • The outer class (the class containing the inner class) can instantiate as many number of inner class objects as it wishes, inside it’s code.
  • If the inner class is public & the containing class as well, then code in some other unrelated class can as well create an instance of the inner class.
  • No inner class objects are automatically instantiated with an outer class object.
  • If the inner class is static, then static inner class can be instantiated without an outer class instance, otherwise, the inner class object must be associated with an instance of the outer class.
  • Inner class code has free access to all elements of the outer class object that contains it, by name (no matter what the access level of the elements is), if the inner class has a varible with same name then the outer class’s variable can be accessed.
There are two more types of inner classes, i.e local inner classes & anonymous inner classes. The local inner class are defined within a method. Anonymous inner classes are also defined with in a method but have no name.

Local Inner Classes:

  • Local classes are never declared with an access specifier (that is, public or private). Their scope is always restricted to the block in which they are declared.
  • Local classes have a great advantage: they are completely hidden from the outside world.
  • They can not only access the instance variables but local variables of the method (in which they are defined) as well, but the local varible has to be declared final.

Anonymous Inner Classes:

When using local inner classes, you can often go a step further. If you want to make only a single object of this class, you don’t even need to give the class a name.
Such a class is called an anonymous inner class. Usually the inner class extend some interface or extend other class.

  • Here, SuperType can be an interface, such as ActionListener; then, the inner class implements that interface. Or SuperType can be a class; then, the inner class extends that class.
  • An anonymous inner class cannot have constructors because the name of a constructor must be the same as the name of a class, and the class has no name. Instead, the construction parameters are given to the superclass constructor. In particular, whenever an inner class implements an interface, it cannot have any construction parameters.

  • It is recommended to refrain from using them as many programmers find too many anonymous classes hard to read.

Static Inner Classes:

  • Static members of the outer class are visible to the static inner class, what ever their access level be.
  • Non-static members of the outer class are not available, because there is not instance of the outer class.
  • An inner class may not have static members unless the inner class is itself marked as static.
  • Sometimes static nested class are not refered to as inner class at all, as they don’t require outer classes instance.
  • A static inner class is just like any other inner class, but it dose not have the reference to its outer class object that generated it.
  • The outer class can call even the private methods of the inner class.

Example for Inner Classes:

public class OuterClass {
 private int x;
 OuterClass(int x, int y) {
  this.x = x;
  new InnerClass(y).privateDisplay();
 public class InnerClass {
  private int y;
  InnerClass(int y) {
   this.y = y;
  private void privateDisplay() {
   System.out.println("privateDisplay x = " + x + " and y = " + y);
  public void publicDisplay() {
   System.out.println("publicDisplay x = " + x + " and y = " + y);

Explanation of above example:
  • OuterClass has one property, x; the inner class InnerClass has one property, y
  • the OuterClass constructor accepts two parameters; the first is used to populate x
  • it creates one InnerClass object, whose y property is populated with the second parameter
  • note that the inner class has free access to the private outer class x element
  • and the outer class has free access to the private inner class privateDisplay() method
The connection between the two classes is handled automatically


Learn Overriding in Java

Overriding is nothing but giving the implentation to the method in the derived class.Here method signature is same. Method overriding occurs when sub class declares a method that has the same signature (name, plus the number and the type of its parameters) and return type as a method declared by one of its superclass.
Overriding is happening with in super class and sub class. Overriding is the process where the sub class changes the behavior of super class and updates it according to sub class requirement. There are some rules for method overriding.

o    Access level of the method in the sub class should be same or wider as super class method.
o   The return type and the signature of the method in sub class      should be same as super class.
o    Static method can be overriding.
o    Dynamic binding or late binding happens in method overriding.
o    Final method cannot be overridden.
o    Constructors cannot be overridden. 

Also keep in mind below points about Overriding methods:
  •  late-binding also supports overriding
  •  overriding allows a subclass to re-define a method it inherits from it's superclass
  •  overriding methods:
1.     appear in subclasses
2.     have the same name as a superclass method
3.     have the same parameter list as a superclass method
4.     have the same return type as as a superclass method
5.     the access modifier for the overriding method may not be more    restrictive than the access modifier of the superclass method
  •   if the superclass method is public, the overriding method must be public
  •  if the superclass method is protected, the overriding method may be protected or public
  •  if the superclass method is package, the overriding method may be packagage, protected, or public
  •  if the superclass methods is private, it is not inherited and overriding is not an issue
6.     the throws clause of the overriding method may only include exceptions that can be thrown by the superclass method, including it's subclasses


class Parent
    int num, num1;
    Parent(int num, int num1)
        this.num = num;
        this.num = num1;
    void show()
        System.out.println("The values in num and num1 are: " +num+" " +num1);
class Child extends Parent  //inherited class
    int count;
    Child(int num, int num1, int num2)
        super(num, num1);
        count = num2;
    void show()
        System.out.println("The values in count is: " +count);
class OverrideDemo
    public static void main(String args[])
        Child sObj = new Child(5, 10, 15);
 The program will generate the following output:

     The  values in count is: 15


Learn Overloading in Java

Overloading is defining more than one set of statement with same name but different signature. Method overloading means  to have two or more methods with same name  in the same class and its subclass with different arguments and optionally different return type. Which overloaded version of the method to be called is based on the reference type of the argument passed at compile time. As the constructor name should be as class name, Overloading can be apply by writing more than one constructor with different type of parameters and their different order.

Some rules we must know about overloading in Java

  •  Overloaded methods must change the argument list.
  •  Overloaded methods can change the return type.
  •  Overloaded methods can declare new or broader checked exacpetions
  •  Overloaded methods can change the access modifier.
  •  Constructors can be overloaded.
Also keep in mind below points about overloaded methods:

  1.    appear in the same class or a subclass
 2.    have the same name but,
 3.    have different parameter lists, and,
 4.    can have different return types   
Example for Constructor overloading:

public class Person {
    String name;
    int age;
    public Person() {
        // do somthing
    public Person(String name, int age) {
        // do somthing
    public Person(int age, String name) {
        // do somthing
    public Person(int age) {
        // do somthing
    public Person(String name) {
        // do somthing
In the above example class Person has five different type of constructor with different parameters and their order.
Example for Method overloading:   
public class Person {
    String name;
    int age;
    public void doStuff() {
        // do something
    public void doStuff(String name) {
        // do something
    public void doStuff(int age) {
        // do something
    public void doStuff(String name, int age) {
        // do something
    public void doStuff(int age, String name) {
        // do something

In the above example of method overloading the doStuff() method of Person class is overloaded many time with different parameter and parameter order.


Learn Inheritace in Java

Java Inheritance is an object oriented concept that enables deriving new class from an already existing class. To know the concept of inheritance clearly you must have the idea of class and its features like methods, data members, access controls, constructors, keywords this, super etc. Object-oriented programming allows classes to inherit commonly used state and behavior from other classes. Inheritance is the mechanism through which we can derived classes from other classes. The derived class is called as child class or the subclass or  we can say the extended class and the class from which we are deriving the subclass is called the base class or the parent class. To derive a class in java the keyword extends is used.
For example a car class can inherit some properties from a General vehicle class. Here we find that the base class is the vehicle class and the subclass is the more specific car class.
A subclass must use the extends clause to derive from a super class which must be written in the header of the subclass definition. The subclass inherits members of the superclass and hence promotes code reuse. The subclass itself can add its own new behavior and properties. The java.lang.Object class is always at the top of any Class inheritance hierarchy.

Types of Java Inheritance are:
  • Single Inheritance – Single Inheritance is a type of Java Inheritance in which the derived class will have only one super class or base class. Single Inheritance is implemented using Java Class.
  • Hierarchical Inheritance – Hierarchical Inheritance is a type of Java Inheritance in which one base class can have many derived classes inherited from it. Hierarchical Inheritance is implemented using Java Class.
  • Multilevel Inheritance – Multilevel Inheritance is a type of Java Inheritance in which the derived class can be derived further by another derived class to any number of levels. Multilevel Inheritance is implemented using Java Class.
  • Multiple Inheritance – Multiple Inheritance is a type of Java Inheritance in which the derived class will have several super classes or base classes. Multiple Inheritance is implemented using Java Interfaces. 

class Box {

 double width;
 double height;
 double depth;
 Box() {
 Box(double w, double h, double d) {
  width = w;
  height = h;
  depth = d;
 void getVolume() {
  System.out.println("Volume is : " + width * height * depth);

public class MatchBox extends Box {

 double weight;
 MatchBox() {
 MatchBox(double w, double h, double d, double m) {
  super(w, h, d);
  weight = m;
 public static void main(String args[]) {
  MatchBox mb1 = new MatchBox(10, 10, 10, 10);
  System.out.println("width of MatchBox 1 is " + mb1.width);
  System.out.println("height of MatchBox 1 is " + mb1.height);
  System.out.println("depth of MatchBox 1 is " + mb1.depth);
  System.out.println("weight of MatchBox 1 is " + mb1.weight);
Volume is : 1000.0
width of MatchBox 1 is 10.0
height of MatchBox 1 is 10.0
depth of MatchBox 1 is 10.0
weight of MatchBox 1 is 10.0