Week-3 (OOP with Java Part-III)

CEN206 Object-Oriented Programming¶

Week-3 (Interfaces, Type System and Code Organization)¶

Spring Semester, 2025-2026¶

Download DOC-PDF, DOC-DOCX, SLIDE

Module A: Defining and Implementing Interfaces¶

Module Outline¶

• Defining an Interface in Java
• Implementing an Interface
• Implementing Multiple Interfaces

Defining an Interface in Java¶

Defining an Interface in Java¶

• In java, an interface is similar to a class,
• but it contains abstract methods and static final variables only.
• The interface in Java is another mechanism to achieve abstraction.
• We may think of an interface as a completely abstract class.
• None of the methods in the interface has an implementation,
• and all the variables in the interface are constants.
• All the methods of an interface,
• implemented by the class that implements it.
• The interface in java enables java to support multiple-inheritance.
• An interface may extend only one interface,
• but a class may implement any number of interfaces.

Defining an Interface in Java¶

• An interface is a container of abstract methods and static final variables.

• An interface, implemented by a class. (class implements interface).

• An interface may extend another interface. (Interface extends Interface).

• An interface never implements another interface, or class.

• A class may implement any number of interfaces.

• We can not instantiate an interface.

• Specifying the keyword abstract for interface methods is optional, it automatically added.

• All the members of an interface are public by default.

Defining an Interface in Java¶

• Defining an interface is similar to that of a class. We use the keyword interface to define an interface.
• All the members of an interface are public by default. The following is the syntax for defining an interface.

1
2
3
4
5

interface InterfaceName{
    ...
    members declaration;
    ...
}

Defining an Interface in Java¶

• In the example we defined an interface HumanInterfaceExample that contains two abstract methods learn(), work() and one constant duration.

1
2
3
4
5
6
7
8

interface HumanInterfaceExample {

    void learn(String str);
    void work();

    int duration = 10;

}

Defining an Interface in Java Example-1¶

• Every interface in Java is auto-completed by the compiler. For example, in the above example code,
• no member is defined as public, but all are public automatically.
• The above code automatically converted as follows.

1
2
3
4
5
6
7
8

interface HumanInterfaceExample {

    public abstract void learn(String str);
    public abstract void work();

    public static final int duration = 10;

}

Implementing an Interface in Java¶

Implementing an Interface in Java¶

• In java, an interface is implemented by a class.
• The class that implements an interface must provide code for all the methods defined in the interface, otherwise,
• it must be defined as an abstract class.
• The class uses a keyword implements to implement an interface.
• A class can implement any number of interfaces.
• When a class wants to implement more than one interface,
• we use the implements keyword is followed by a comma-separated list of the interfaces implemented by the class.

Implementing an Interface in Java¶

• The following is the syntax for defineing a class that implements an interface.

1
2
3
4
5

class className implements InterfaceName{
    ...
    boby-of-the-class
    ...
}

Implementing an Interface in Java Example-1¶

1
2
3
4
5
6
7
8

interface Human {

    void learn(String str);
    void work();

    int duration = 10;

}

Implementing an Interface in Java Example-1¶

1
2
3
4
5
6
7
8

class Programmer implements Human{
    public void learn(String str) {
        System.out.println("Learn using " + str);
    }
    public void work() {
        System.out.println("Develop applications");
    }
}

Implementing an Interface in Java Example-1¶

1
2
3
4
5
6
7
8

public class HumanTest {

    public static void main(String[] args) {
        Programmer trainee = new Programmer();
        trainee.learn("coding");
        trainee.work();
    }
}

Implementing an Interface in Java Example-1¶

• In the example we defined an interface
• Human that contains two abstract methods
  • learn(),
  • work() and one constant duration.
• The class Programmer implements the interface.
• As it implementing the Human interface it must provide the body of all the methods those defined in the Human interface.

Implementing an Interface in Java Example-2¶

1
2
3

interface Polygon {
  void getArea(int length, int breadth);
}

1
2
3
4
5
6
7
8

// implement the Polygon interface
class Rectangle implements Polygon {

  // implementation of abstract method
  public void getArea(int length, int breadth) {
    System.out.println("The area of the rectangle is " + (length * breadth));
  }
}

Implementing an Interface in Java Example-2¶

1
2
3
4
5
6

class Main {
  public static void main(String[] args) {
    Rectangle r1 = new Rectangle();
    r1.getArea(5, 6);
  }
}

Implementing an Interface in Java Example-3¶

1
2
3
4

// create an interface
interface Language {
  void getName(String name);
}

1
2
3
4
5
6
7
8

// class implements interface
class ProgrammingLanguage implements Language {

  // implementation of abstract method
  public void getName(String name) {
    System.out.println("Programming Language: " + name);
  }
}

Implementing an Interface in Java Example-3¶

1
2
3
4
5
6

class Main {
  public static void main(String[] args) {
    ProgrammingLanguage language = new ProgrammingLanguage();
    language.getName("Java");
  }
}

Implementing multiple Interfaces¶

• When a class wants to implement more than one interface,
• we use the implements keyword is followed by a comma-separated list of the interfaces implemented by the class.

Implementing multiple Interfaces¶

• The following is the syntax for defineing a class that implements multiple interfaces.

1
2
3
4
5

class className implements InterfaceName1, InterfaceName2, ...{
    ...
    boby-of-the-class
    ...
}

Implementing multiple Interfaces Example-1¶

• In the example we defined a class that implements multiple interfaces.

1
2
3
4

interface Human {   
    void learn(String str);
    void work();
}

1
2
3
4

interface Recruitment {
    boolean screening(int score);
    boolean interview(boolean selected);
}

Implementing multiple Interfaces Example-1¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class Programmer implements Human, Recruitment {
    public void learn(String str) {
        System.out.println("Learn using " + str);
    }
    public boolean screening(int score) {
        System.out.println("Attend screening test");
        int thresold = 20;
        if(score > thresold)
            return true;
        return false;
    }
    public boolean interview(boolean selected) {
        System.out.println("Attend interview");
        if(selected)
            return true;
        return false;
    } 
    public void work() {
        System.out.println("Develop applications");
    }
}

Implementing multiple Interfaces Example-1¶

1
2
3
4
5
6
7
8
9

public class HumanTest {
    public static void main(String[] args) {
        Programmer trainee = new Programmer();
        trainee.learn("Coding");
        trainee.screening(30);
        trainee.interview(true);
        trainee.work();
    }
}

• In the example, two interfaces Human and Recruitment, and a class Programmer implements both the interfaces.

Implementing multiple Interfaces Example-2¶

1
2
3

interface A {
  // members of A
}

1
2
3

interface B {
  // members of B
}

1
2
3
4

class C implements A, B {
  // abstract members of A
  // abstract members of B
}

Takeaway: Defining and Implementing Interfaces¶

• An interface is a contract - it defines WHAT a class must do, not HOW
• Interfaces contain abstract methods and static final variables
• A class implements an interface using the 'implements' keyword
• Java allows implementing multiple interfaces (multiple inheritance of type)
• All interface methods are implicitly public and abstract

Module B: Nested Interfaces¶

Nested Interfaces in Java¶

Nested Interfaces in Java¶

• In java, an interface may be defined inside another interface,
• and also inside a class.
• The interface that defined inside another interface or a class is konwn as nested interface.
• The nested interface is also refered as inner interface.

Nested Interfaces in Java¶

• The nested interface declared within an interface is public by default.

• The nested interface declared within a class can be with any access modifier.

• Every nested interface is static by default.

Nested Interfaces in Java¶

• The nested interface cannot be accessed directly.
• We can only access the nested interface by using outer interface or outer class name followed by dot( . ), followed by the nested interface name.

Nested interface inside another interface Example¶

• The nested interface that defined inside another interface must be accessed as OuterInterface.InnerInterface.

1
2
3
4
5
6
7

interface OuterInterface{
    void outerMethod();

    interface InnerInterface{
        void innerMethod();
    }
}

Nested interface inside another interface Example¶

1
2
3
4
5

class OnlyOuter implements OuterInterface{
    public void outerMethod() {
        System.out.println("This is OuterInterface method");
    }
}

1
2
3
4
5

class OnlyInner implements OuterInterface.InnerInterface{
    public void innerMethod() {
        System.out.println("This is InnerInterface method");
    }
}

Nested interface inside another interface Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class NestedInterfaceExample {

    public static void main(String[] args) {
        OnlyOuter obj_1 = new OnlyOuter();
        OnlyInner obj_2 = new OnlyInner();

        obj_1.outerMethod();
        obj_2.innerMethod();
    }

}

Nested interface inside a class Example¶

• The nested interface that defined inside a class must be accessed as ClassName.InnerInterface

1
2
3
4
5
6

class OuterClass{

    interface InnerInterface{
        void innerMethod();
    }
}

Nested interface inside a class Example¶

1
2
3
4
5

class ImplementingClass implements OuterClass.InnerInterface{
    public void innerMethod() {
        System.out.println("This is InnerInterface method");
    }
}

Nested interface inside a class Example¶

1
2
3
4
5
6
7
8
9

public class NestedInterfaceExample {

    public static void main(String[] args) {
        ImplementingClass obj = new ImplementingClass();

        obj.innerMethod();
    }

}

Takeaway: Nested Interfaces¶

• Interfaces can be nested inside other interfaces or classes
• Nested interfaces help organize related contracts together
• A class implementing a nested interface uses OuterInterface.InnerInterface syntax
• Nested interfaces in classes can have any access modifier

Module C: Interface Variables and Extending Interfaces¶

Variables in Java Interfaces¶

Variables in Java Interfaces¶

• In java, an interface is a completely abstract class.
• An interface is a container of abstract methods and static final variables.
• The interface contains the static final variables.
• The variables defined in an interface can not be modified by the class that implements the interface,
• but it may use as it defined in the interface.

Variables in Java Interfaces¶

• The variable in an interface is public, static, and final by default.

• If any variable in an interface is defined without public, static, and final keywords then, the compiler automatically adds the same.

• No access modifier is allowed except the public for interface variables.

• Every variable of an interface must be initialized in the interface itself.

• The class that implements an interface can not modify the interface variable, but it may use as it defined in the interface.

Variables in Java Interfaces Example-1¶

1
2
3
4
5
6
7

interface SampleInterface{

    int UPPER_LIMIT = 100;

    //int LOWER_LIMIT; // Error - must be initialised

}

1
2
3
4
5
6
7
8
9

public class InterfaceVariablesExample implements SampleInterface{

    public static void main(String[] args) {

        System.out.println("UPPER LIMIT = " + UPPER_LIMIT);

        // UPPER_LIMIT = 150; // Can not be modified
    }
}

Extending an Interface in java¶

Extending an Interface in java¶

• In java, an interface can extend another interface.
• When an interface wants to extend another interface,
  • it uses the keyword extends.
• The interface that extends another interface has its own members and all the members defined in its parent interface too.
• The class which implements a child interface needs to provide code for the methods defined in both child and parent interfaces,
• otherwise, it needs to be defined as abstract class.

Extending an Interface in Java¶

• An interface can extend another interface.

• An interface can not extend multiple interfaces.

• An interface can implement neither an interface nor a class.

• The class that implements child interface needs to provide code for all the methods defined in both child and parent interfaces.

Extending an Interface in Java Example-1¶

1
2
3

interface ParentInterface{
    void parentMethod();
}

1
2
3

interface ChildInterface extends ParentInterface{
    void childMethod();
}

Extending an Interface in Java Example-1¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class ImplementingClass implements ChildInterface{

    public void childMethod() {
        System.out.println("Child Interface method!!");
    }

    public void parentMethod() {
        System.out.println("Parent Interface mehtod!");
    }
}

Extending an Interface in Java Example-1¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class ExtendingAnInterface {

    public static void main(String[] args) {

        ImplementingClass obj = new ImplementingClass();

        obj.childMethod();
        obj.parentMethod();

    }

}

Extending an Interface in Java Example-2¶

• Here, the Polygon interface extends the Line interface. Now, if any class implements Polygon, it should provide implementations for all the abstract methods of both Line and Polygon

1
2
3
4
5
6
7
8
9

interface Line {
  // members of Line interface
}

// extending interface
interface Polygon extends Line {
  // members of Polygon interface
  // members of Line interface
}

Extending Multiple Interfaces in Java Example¶

1
2
3

interface A {
   ...
}

1
2
3

interface B {
   ... 
}

1
2
3

interface C extends A, B {
   ...
}

Takeaway: Interface Variables and Extending¶

• Interface variables are implicitly public, static, and final (constants)
• Interfaces can extend other interfaces using the 'extends' keyword
• A class implementing a child interface must implement ALL methods from the entire hierarchy
• An interface can extend multiple interfaces (unlike classes)

Module D: Modern Interface Features and Advantages¶

Advantages of Interface in Java¶

Advantages of Interface in Java¶

• Similar to abstract classes, interfaces help us to achieve abstraction in Java
• Here, we know getArea() calculates the area of polygons but the way area is calculated is different for different polygons. Hence, the implementation of getArea() is independent of one another.

Advantages of Interface in Java¶

• Interfaces provide specifications that a class (which implements it) must follow.
• In our previous example, we have used getArea() as a specification inside the interface Polygon. This is like setting a rule that we should be able to get the area of every polygon.
• Now any class that implements the Polygon interface must provide an implementation for the getArea() method.

Advantages of Interface in Java¶

• Interfaces are also used to achieve multiple inheritance in Java
• In the example, the class Rectangle is implementing two different interfaces. This is how we achieve multiple inheritance in Java.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

interface Line {
…
}

interface Polygon {
…
}

class Rectangle implements Line, Polygon {
…
}

Advantages of Interface in Java¶

• All the methods inside an interface are implicitly public and all fields are implicitly public static final. For example,

1
2
3
4
5
6
7
8

interface Language {

  // by default public static final
  String type = "programming language";

  // by default public
  void getName();
}

default methods in Java Interfaces¶

default methods in Java Interfaces¶

• With the release of Java 8, we can now add methods with implementation inside an interface.
• These methods are called default methods.
• To declare default methods inside interfaces, we use the default keyword. For example,

1
2
3

public default void getSides() {
   // body of getSides()
}

why default methods in Java Interfaces¶

• Let's take a scenario to understand why default methods are introduced in Java.
• Suppose, we need to add a new method in an interface.
• We can add the method in our interface easily without implementation. However, that's not the end of the story. All our classes that implement that interface must provide an implementation for the method.
• If a large number of classes were implementing this interface, we need to track all these classes and make changes to them. This is not only tedious but error-prone as well.
• To resolve this, Java introduced default methods. Default methods are inherited like ordinary methods.

Default Method in Java Interface Example¶

1
2
3
4
5
6
7
8

interface Polygon {
  void getArea();

  // default method 
  default void getSides() {
    System.out.println("I can get sides of a polygon.");
  }
}

Default Method in Java Interface Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// implements the interface
class Rectangle implements Polygon {
  public void getArea() {
    int length = 6;
    int breadth = 5;
    int area = length * breadth;
    System.out.println("The area of the rectangle is " + area);
  }

  // overrides the getSides()
  public void getSides() {
    System.out.println("I have 4 sides.");
  }
}

Default Method in Java Interface Example¶

1
2
3
4
5
6
7
8

// implements the interface
class Square implements Polygon {
  public void getArea() {
    int length = 5;
    int area = length * length;
    System.out.println("The area of the square is " + area);
  }
}

Default Method in Java Interface Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Main {
  public static void main(String[] args) {

    // create an object of Rectangle
    Rectangle r1 = new Rectangle();
    r1.getArea();
    r1.getSides();

    // create an object of Square
    Square s1 = new Square();
    s1.getArea();
    s1.getSides();
  }
}

Default Method in Java Interface Example¶

• In the example, we have created an interface named Polygon. It has a default method getSides() and an abstract method getArea().
• Here, we have created two classes Rectangle and Square that implement Polygon.
• The Rectangle class provides the implementation of the getArea() method and overrides the getSides() method. However, the Square class only provides the implementation of the getArea() method.
• Now, while calling the getSides() method using the Rectangle object, the overridden method is called. However, in the case of the Square object, the default method is called.

private and static Methods in Interface¶

private and static Methods in Interface¶

• The Java 8 also added another feature to include static methods inside an interface.
• Similar to a class, we can access static methods of an interface using its references. For example,

1
2
3
4
5
6
7

// create an interface
interface Polygon {
  staticMethod(){..}
}

// access static method
Polygon.staticMethod();

private and static Methods in Interface¶

• Note: With the release of Java 9, private methods are also supported in interfaces.
• We cannot create objects of an interface.
• Hence, private methods are used as helper methods that provide support to other methods in interfaces.

Java Interface Practical Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// To use the sqrt function
import java.lang.Math;

interface  Polygon {
   void getArea();

 // calculate the perimeter of a Polygon
   default void getPerimeter(int... sides) {
      int perimeter = 0;
      for (int side: sides) {
         perimeter += side;
      }

   System.out.println("Perimeter: " + perimeter);
   }
}

Java Interface Practical Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class Triangle implements Polygon {
   private int a, b, c;
   private double s, area;

// initializing sides of a triangle
   Triangle(int a, int b, int c) {
      this.a = a;
      this.b = b;
      this.c = c;
      s = 0;
   }

// calculate the area of a triangle
   public void getArea() {
      s = (double) (a + b + c)/2;
      area = Math.sqrt(s*(s-a)*(s-b)*(s-c));
      System.out.println("Area: " + area);
   }
}

Java Interface Practical Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Main {
   public static void main(String[] args) {
      Triangle t1 = new Triangle(2, 3, 4);

// calls the method of the Triangle class
      t1.getArea();

// calls the method of Polygon
      t1.getPerimeter(2, 3, 4);
   }
}

Java Interface Practical Example¶

• In the example, we have created an interface named Polygon.
• It includes a default method getPerimeter() and an abstract method getArea().
• We can calculate the perimeter of all polygons in the same manner so we implemented the body of getPerimeter() in Polygon.
• Now, all polygons that implement Polygon can use getPerimeter() to calculate perimeter.
• However, the rule for calculating the area is different for different polygons.
• Hence, getArea() is included without implementation.
• Any class that implements Polygon must provide an implementation of getArea().

Takeaway: Modern Interface Features¶

• Interfaces enable polymorphism, loose coupling, and multiple inheritance of type
• Java 8+ default methods: provide implementation in interfaces for backward compatibility
• Java 9+ private methods in interfaces: share code between default methods
• Static methods in interfaces: utility methods that belong to the interface
• Interfaces evolved from pure contracts to powerful abstractions

Module E: Abstract Class vs Interface - When to Use Which?¶

Abstract Class vs Interface: Comparison¶

Abstract Class vs Interface: Visual Comparison¶

Abstract Class vs Interface: Relationship Types¶

• Abstract Class expresses is-a relationship
• "A Dog is-a Animal" -> abstract class Animal

• Share common state and behavior among family of classes

• Interface expresses can-do capability

• "A Dog can Swim" -> interface Swimmable
• Define a contract that any class can fulfill

Abstract Class vs Interface: The Diamond Problem¶

• Java does NOT allow multiple class inheritance (no diamond problem with classes)
• Interfaces CAN have the diamond problem with default methods
• Java resolves this by requiring the implementing class to override the conflicting method

1
2
3
4
5
6
7
8
9

interface A { default void hello() { System.out.println("A"); } }
interface B { default void hello() { System.out.println("B"); } }

class C implements A, B {
    // MUST override hello() to resolve conflict
    public void hello() {
        A.super.hello(); // explicitly choose A's version
    }
}

Abstract Class vs Interface: Decision Flowchart¶

• Need to share code among closely related classes? -> Abstract Class
• Need to define a contract for unrelated classes? -> Interface
• Need multiple inheritance of type? -> Interface
• Need to define constants? -> Interface (public static final)
• Need non-public members? -> Abstract Class
• Need to maintain state? -> Abstract Class
• Need backward-compatible API extension? -> Interface (default methods)

Takeaway: Abstract Class vs Interface¶

• Abstract Class = 'is-a' relationship, Interface = 'can-do' capability
• Use abstract class when classes are closely related and share state/behavior
• Use interfaces when unrelated classes need to fulfill the same contract
• Java resolves diamond problem by requiring explicit override of conflicting default methods
• Modern Java: interfaces are more powerful than ever with default, static, and private methods

Module F: Nested, Static and Anonymous Classes¶

Module Outline¶

• Non-Static Nested Class (Inner Class)
• Accessing Members of Outer Class within Inner Class
• Static Nested Class
• Java Anonymous Class
• Advantages of Anonymous Classes

Java Nested and Inner Class¶

Java Nested and Inner Class¶

• In Java, you can define a class within another class.
• Such class is known as nested class

1
2
3
4
5
6

class OuterClass {
  // ...
  class NestedClass {
      // ...
  }
}

Java Nested and Inner Class¶

• There are two types of nested classes you can create in Java.
• Non-static nested class (inner class)
• Static nested class

Java Nested Class Types Overview¶

Non-Static Nested Class (Inner Class)¶

• A non-static nested class is a class within another class.

• It has access to members of the enclosing class (outer class).

  • It is commonly known as inner class.

• Since the inner class exists within the outer class,

• you must instantiate the outer class first,
  • in order to instantiate the inner class.

Non-Static Nested Class (Inner Class) Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class CPU {
    double price;
    // nested class
    class Processor{

        // members of nested class
        double cores;
        String manufacturer;

        double getCache(){
            return 4.3;
        }
    }

    // nested protected class
    protected class RAM{

        // members of protected nested class
        double memory;
        String manufacturer;

        double getClockSpeed(){
            return 5.5;
        }
    }
}

Non-Static Nested Class (Inner Class) Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class Main {
    public static void main(String[] args) {

        // create object of Outer class CPU
        CPU cpu = new CPU();

       // create an object of inner class Processor using outer class
        CPU.Processor processor = cpu.new Processor();

        // create an object of inner class RAM using outer class CPU
        CPU.RAM ram = cpu.new RAM();
        System.out.println("Processor Cache = " + processor.getCache());
        System.out.println("Ram Clock speed = " + ram.getClockSpeed());
    }
}

Non-Static Nested Class (Inner Class) Example¶

• In the example program, there are two nested classes:
• Processor and RAM inside the outer class:
  • CPU.
• We can declare the inner class as protected.

• Hence, we have declared the RAM class as protected.

• Inside the Main class,

• we first created an instance of an outer class CPU named cpu.
• Using the instance of the outer class, we then created objects of inner classes

1
2

CPU.Processor processor = cpu.new Processor;
CPU.RAM ram = cpu.new RAM();

Accessing Members of Outer Class within Inner Class¶

• We can access the members of the outer class by using this keyword

Accessing Members of Outer Class within Inner Class Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class Car {
    String carName;
    String carType;

    // assign values using constructor
    public Car(String name, String type) {
        this.carName = name;
        this.carType = type;
    }

    // private method
    private String getCarName() {
        return this.carName;
    }
...

Accessing Members of Outer Class within Inner Class Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

...
// inner class
    class Engine {
        String engineType;
        void setEngine() {

           // Accessing the carType property of Car
            if(Car.this.carType.equals("4WD")){

                // Invoking method getCarName() of Car
                if(Car.this.getCarName().equals("Crysler")) {
                    this.engineType = "Smaller";
                } else {
                    this.engineType = "Bigger";
                }

            }else{
                this.engineType = "Bigger";
            }
        }
        String getEngineType(){
            return this.engineType;
        }
    }
}

Accessing Members of Outer Class within Inner Class Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Main {
    public static void main(String[] args) {

// create an object of the outer class Car
        Car car1 = new Car("Mazda", "8WD");

        // create an object of inner class using the outer class
        Car.Engine engine = car1.new Engine();
        engine.setEngine();
        System.out.println("Engine Type for 8WD= " + engine.getEngineType());

        Car car2 = new Car("Crysler", "4WD");
        Car.Engine c2engine = car2.new Engine();
        c2engine.setEngine();
        System.out.println("Engine Type for 4WD = " + c2engine.getEngineType());
    }
}

Accessing Members of Outer Class within Inner Class Example¶

• In the example program, we have the inner class named
• Engine inside the outer class Car. Here, notice the line,

1

if(Car.this.carType.equals("4WD")) {...}

• We are using this keyword to access the carType variable of the outer class.
• You may have noticed that instead of using this.carType we have used Car.this.carType

Accessing Members of Outer Class within Inner Class Example¶

• It is because if we had not mentioned the name of the outer class Car,

• then this keyword will represent the member inside the inner class.

• Similarly, we are also accessing the method of the outer class from the inner class.

1

if (Car.this.getCarName().equals("Crysler") {...}

• It is important to note that, although the getCarName() is a private method, we are able to access it from the inner class.

Static Nested Class¶

• In Java, we can also define a static class inside another class.
• Such class is known as static nested class.

• Static nested classes are not called static inner classes.

• Unlike inner class, a static nested class cannot access the member variables of the outer class.

• It is because the static nested class doesn't require you to create an instance of the outer class.

1

OuterClass.NestedClass obj = new OuterClass.NestedClass();

• Here, we are creating an object of the static nested class by simply using the class name of the outer class.
• Hence, the outer class cannot be referenced using OuterClass.this.

Static Inner Class Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class MotherBoard {

   // static nested class
   static class USB{
       int usb2 = 2;
       int usb3 = 1;
       int getTotalPorts(){
           return usb2 + usb3;
       }
   }

}

1
2
3
4
5
6
7
8
9

public class Main {
   public static void main(String[] args) {

       // create an object of the static nested class
       // using the name of the outer class
       MotherBoard.USB usb = new MotherBoard.USB();
       System.out.println("Total Ports = " + usb.getTotalPorts());
   }
}

Static Inner Class Example¶

• In the above program, we have created a static class named USB inside the class MotherBoard. Notice the line,

1

MotherBoard.USB usb = new MotherBoard.USB();

• Here, we are creating an object of USB using the name of the outer class.

• Now, let's see what would happen if you try to access the members of the outer class:

Accessing members of Outer class inside Static Inner Class Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class MotherBoard {
   String model;
   public MotherBoard(String model) {
       this.model = model;
   }

   // static nested class
   static class USB{
       int usb2 = 2;
       int usb3 = 1;
       int getTotalPorts(){
           // accessing the variable model of the outer classs
           if(MotherBoard.this.model.equals("MSI")) {
               return 4;
           }
           else {
               return usb2 + usb3;
           }
       }
   }
}

Accessing members of Outer class inside Static Inner Class Example¶

1
2
3
4
5
6
7
8

public class Main {
   public static void main(String[] args) {

       // create an object of the static nested class
       MotherBoard.USB usb = new MotherBoard.USB();
       System.out.println("Total Ports = " + usb.getTotalPorts());
   }
}

Accessing members of Outer class inside Static Inner Class Example¶

• When we try to run the program, we will get an error:

1

error: non-static variable this cannot be referenced from a static context

Key Points to Remember¶

• Java treats the inner class as a regular member of a class. They are just like methods and variables declared inside a class.
• Since inner classes are members of the outer class, you can apply any access modifiers like private, protected to your inner class which is not possible in normal classes.
• Since the nested class is a member of its enclosing outer class, you can use the dot (.) notation to access the nested class and its members.
• Using the nested class will make your code more readable and provide better encapsulation.
• Non-static nested classes (inner classes) have access to other members of the outer/enclosing class, even if they are declared private.

Java Nested Static Class¶

Java Nested Static Class¶

• we can have a class inside another class in Java. Such classes are known as nested classes. In Java, nested classes are of two types:
• Nested non-static class (Inner class)
• Nested static class.

Java Nested Static Class¶

• We use the keyword static to make our nested class static.
• Note: In Java, only nested classes are allowed to be static.
• Like regular classes, static nested classes can include both static and non-static fields and methods. For example,

1
2
3
4
5
6

Class Animal {
   static class Mammal {
      // static and non-static members of Mammal
   }
   // members of Animal
} 

Static Nested Class Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Animal {

// inner class
   class Reptile {
      public void displayInfo() {
        System.out.println("I am a reptile.");
      }
   }

// static class
   static class Mammal {
      public void displayInfo() {
        System.out.println("I am a mammal.");
      }
   }
}

Static Nested Class Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class Main {
   public static void main(String[] args) {
      // object creation of the outer class
      Animal animal = new Animal();

      // object creation of the non-static class
      Animal.Reptile reptile = animal.new Reptile();
      reptile.displayInfo();

      // object creation of the static nested class
      Animal.Mammal mammal = new Animal.Mammal();
      mammal.displayInfo();

   }
}

Static Nested Class Example¶

• In the example program, we have two nested class Mammal and Reptile inside a class Animal.
• To create an object of the non-static class Reptile, we have used

1

Animal.Reptile reptile = animal.new Reptile()

• To create an object of the static class Mammal, we have used

1

Animal.Mammal mammal = new Animal.Mammal()

Accessing Members of Outer Class¶

• In Java, static nested classes are associated with the outer class.
• This is why static nested classes can only access the class members (static fields and methods) of the outer class.

Accessing Non-static members Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Animal {
  static class Mammal {
   public void displayInfo() {
     System.out.println("I am a mammal.");
   }
 }

 class Reptile {
   public void displayInfo() {
     System.out.println("I am a reptile.");
   }
 }

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

Accessing Non-static members Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Main {
 public static void main(String[] args) {
   Animal animal = new Animal();
   Animal.Reptile reptile = animal.new Reptile();
   reptile.displayInfo();

   Animal.Mammal mammal = new Animal.Mammal();
   mammal.displayInfo();
   mammal.eat();
 }
}

Accessing Non-static members Example¶

• In the example, we have created a non-static method eat() inside the class Animal.

• Now, if we try to access eat() using the object mammal, the compiler shows an error.

• It is because mammal is an object of a static class and we cannot access non-static methods from static classes.

Static Top-level Class¶

• only nested classes can be static.
• We cannot have static top-level classes.

Static Top-level Class¶

• if we try to make a top-level class static.

1
2
3
4
5

static class Animal {
 public static void displayInfo() {
   System.out.println("I am an animal");
 }
}

1
2
3
4
5

class Main {
 public static void main(String[] args) {
   Animal.displayInfo();
 }
}

Static Top-level Class¶

Main.java:1: error: modifier static not allowed here
static class Animal {
       ^
1 error
compiler exit status 1

• In the example, we have tried to create a static class Animal.
• Since Java doesn’t allow static top-level class,
• we will get an error.

Java Anonymous Class¶

Java Anonymous Class¶

• In Java, a class can contain another class known as nested class. It's possible to create a nested class without giving any name.
• A nested class that doesn't have any name is known as an anonymous class.
• An anonymous class must be defined inside another class. Hence, it is also known as an anonymous inner class. Its syntax is:

1
2
3
4
5
6
7

class outerClass {

    // defining anonymous class
    object1 = new Type(parameterList) {
         // body of the anonymous class
    };
}

Java Anonymous Class¶

• Anonymous classes usually extend subclasses or implement interfaces.
• Here, Type can be
• a superclass that an anonymous class extends
• an interface that an anonymous class implements
• The above code creates an object, object1, of an anonymous class at runtime.
• Note: Anonymous classes are defined inside an expression. So, the semicolon is used at the end of anonymous classes to indicate the end of the expression.

Anonymous Class Extending a Class Example¶

1
2
3
4
5

class Polygon {
   public void display() {
      System.out.println("Inside the Polygon class");
   }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class AnonymousDemo {
   public void createClass() {

      // creation of anonymous class extending class Polygon
      Polygon p1 = new Polygon() {
         public void display() {
            System.out.println("Inside an anonymous class.");
         }
      };
      p1.display();
   }
}

Anonymous Class Extending a Class Example¶

1
2
3
4
5
6

class Main {
   public static void main(String[] args) {
       AnonymousDemo an = new AnonymousDemo();
       an.createClass();
   }
}

Anonymous Class Extending a Class Example¶

• In the example, we have created a class Polygon. It has a single method display().
• We then created an anonymous class that extends the class Polygon and overrides the display() method.
• When we run the program, an object p1 of the anonymous class is created.
• The object then calls the display() method of the anonymous class.

Anonymous Class Implementing an Interface Example¶

1
2
3

interface Polygon {
   public void display();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class AnonymousDemo {
   public void createClass() {

      // anonymous class implementing interface
      Polygon p1 = new Polygon() {
         public void display() {
            System.out.println("Inside an anonymous class.");
         }
      };
      p1.display();
   }
}

Anonymous Class Implementing an Interface Example¶

1
2
3
4
5
6

class Main {
   public static void main(String[] args) {
      AnonymousDemo an = new AnonymousDemo();
      an.createClass();
   }
}

• In the example, we have created an anonymous class that implements the Polygon interface.

Advantages of Anonymous Classes¶

• In anonymous classes, objects are created whenever they are required.
• That is, objects are created to perform some specific tasks. For example,

1
2
3
4
5

Object = new Example() {
   public void display() {
      System.out.println("Anonymous class overrides the method display().");
   }
};

• Here, an object of the anonymous class is created dynamically when we need to override the display() method.
• Anonymous classes also help us to make our code concise.

Takeaway: Nested, Static and Anonymous Classes¶

• Inner class (non-static nested): has access to ALL members of the outer class, including private
• Static nested class: does NOT have access to non-static members of outer class
• Anonymous class: a class without a name, defined and instantiated in one expression
• Use inner classes for tightly coupled helper classes
• Use anonymous classes for one-time implementations (event handlers, callbacks)

Module G: Java Enums¶

Module Outline¶

• Java Enum Basics and Switch Statement
• Enum as a Class: Fields, Methods, and the Enum Class
• Enum Methods: ordinal, compareTo, toString, name, valueOf, values
• Why Java Enums?
• Enum Constructors and Custom Strings

Java enums¶

Java enums¶

• In Java, an enum (short for enumeration) is a type that has a fixed set of constant values. We use the enum keyword to declare enums. For example,

1
2
3

enum Size { 
   SMALL, MEDIUM, LARGE, EXTRALARGE 
}

Java Enum Example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

enum Size {
   SMALL, MEDIUM, LARGE, EXTRALARGE
}

class Main {
   public static void main(String[] args) {
      System.out.println(Size.SMALL);
      System.out.println(Size.MEDIUM);
   }
}

Java Enum Example¶

we use the enum name to access the constant values.

Also, we can create variables of enum types. For example

1

Size pizzaSize;

• Here, pizzaSize is a variable of the Size type. It can only be assigned with 4 values.

1
2
3
4

pizzaSize = Size.SMALL;
pizzaSize = Size.MEDIUM;
pizzaSize = Size.LARGE;
pizzaSize = Size.EXTRALARGE;

Java Enum with the switch statement example¶

1
2
3

enum Size {
 SMALL, MEDIUM, LARGE, EXTRALARGE
}

Java Enum with the switch statement example¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class Test {
 Size pizzaSize;
 public Test(Size pizzaSize) {
   this.pizzaSize = pizzaSize;
 }
 public void orderPizza() {
   switch(pizzaSize) {
     case SMALL:
       System.out.println("I ordered a small size pizza.");
       break;
     case MEDIUM:
       System.out.println("I ordered a medium size pizza.");
       break;
     default:
       System.out.println("I don't know which one to order.");
       break;
   }
 }
}

Java Enum with the switch statement example¶

1
2
3
4
5
6

class Main {
 public static void main(String[] args) {
   Test t1 = new Test(Size.MEDIUM);
   t1.orderPizza();
 }
}