| | |
    Java Beginner Home
    Table of Contents
    Introduction to Java
    Getting Started with Java
    Basic Language Elements
    Java Operators
    Java Control Statements
    Java Access Modifiers
    Classes and Objects
    Java Constructors
    Object Serialization
    Java Class Inheritance
    Java Object Type Casting
    Abstract class and Interface
    Java Method Overiding
    Java toString Method
    Java String Class
    Java String Comparison
    Java StringBuffer
    Java Exceptions
    Singleton Pattern
    Java Threads Tutorial
    Java Collections Framework
    Java Date Util
    Swing Tutorial
    Download Java Software
    Advertise
    Feedback
    Java books
    Eclipse Plugin Site

Java Method Overriding



Method Overriding is achieved when a subclass overrides non-static methods defined in the superclass, following which the new method implementation in the subclass that is executed.

The new method definition must have the same method signature (i.e., method name and parameters) and return type. Only parameter types and return type are chosen as criteria for matching method signature. So if a subclass has its method parameters as final it doesn’t really matter for method overriding scenarios as it still holds true. The new method definition cannot narrow the accessibility of the method, but it can widen it. The new method definition can only specify all or none, or a subset of the exception classes (including their subclasses) specified in the throws clause of the overridden method in the super class

A program to explain the different concepts of Java Method Overridding

class CustomException extends Exception {

}

class SuperClassWithDifferentMethods {

	protected int field1 = 10;
	protected static int field2 = 20;
	public void method1() {
		System.out.println("SuperClassWithDifferentMethods.method1()");
	}
	public final void method2() {
		System.out.println("SuperClassWithDifferentMethods.method2()");
	}
	private void method3() {
		System.out.println("SuperClassWithDifferentMethods.method3()");
	}
	private final void method4() {
		System.out.println("SuperClassWithDifferentMethods.method4()");
	}
	public static void method5() {
		System.out.println("SuperClassWithDifferentMethods.method5()");
	}
	public void method6() throws Exception {
		System.out.println("SuperClassWithDifferentMethods.method6()");
	}
	private void method7() {
		System.out.println("SuperClassWithDifferentMethods.method7()");
	}
	private void method8(int x) {
		System.out.println("SuperClassWithDifferentMethods.method8()");
	}
	public static void method9() {
		System.out.println("SuperClassWithDifferentMethods.method9()");
	}
}

class OverridingClass extends SuperClassWithDifferentMethods {

	public int field1 = 30;
	public static int field2 = 40;
	public void method1() {
		System.out.println("OverridingClass.method1()");
	}
	//We can't override a public final method
	/*	  public final void method2(){		

	 System.out.println("OverridingClass.method2()");

	 }*/
	private void method3() {
		System.out.println("OverridingClass.method3()");
	}
	private final void method4() {
		System.out.println("OverridingClass.method4()");
	}
	public static void method5() {
		System.out.println("OverridingClass.method5()");
	}
	public void method6() throws CustomException {
		System.out.println("OverridingClass.method6()");
	}
	public void method7() {
		System.out.println("OverridingClass.method7()");
	}
	public void method8(final int x) {
		System.out.println("OverridingClass.method8()");
	}
	//A static method cannot be overridden to be non-static instance method
	/*public void method9() {

	 System.out.println("OverridingClass.method9()");

	 }*/
}

public class MethodOverridingDemo {

	public static void main(String[] args) {
		OverridingClass oc1 = new OverridingClass();
		SuperClassWithDifferentMethods sc3 = new OverridingClass();
		oc1.method1();
		oc1.method2();
		//	    Since its private, the below 2 methods are not visible
		/*	    oc1.method3();

		 oc1.method4();*/
		oc1.method5();
		try {
			oc1.method6();
		} catch (CustomException e) {
			e.printStackTrace();
		}
		oc1.method7();
		oc1.method8(100);
		System.out.println("oc1.field1 : " + oc1.field1);
		System.out.println("oc1.field2 : " + oc1.field2);
		System.out.println("sc3.field1 : " + sc3.field1);
		System.out.println("sc3.field2 : " + sc3.field2);
		sc3.method5();
		OverridingClass overClass = new OverridingClass();
	SuperClassWithDifferentMethods supClass = (SuperClassWithDifferentMethods) overClass;
		supClass.method5();
		supClass.method1();
	}
}


Output


OverridingClass.method1()
SuperClassWithDifferentMethods.method2()
OverridingClass.method5()
OverridingClass.method6()
OverridingClass.method7()
OverridingClass.method8()
oc1.field1 : 30
oc1.field2 : 40
sc3.field1 : 10
sc3.field2 : 20
SuperClassWithDifferentMethods.method5()
SuperClassWithDifferentMethods.method5()
OverridingClass.method1()

Download MethodOverridingDemo.java

The new method definitions in the subclass OverridingClass have the same signature and the same return type as the methods in the superclass SuperClassWithDifferentMethods. The new overridden method6 definition specifies a subset of the exceptions (CustomException). The new overridden method7 definition also widens the accessibility to public from private. The overriding method8 also declares the parameter to be final, which is not a part of the method signature and Method Overriding holds good. A static method cannot be overridden to be non-static instance method as shown in the overridden method declaration of method9. A static method is class-specific and not part of any object, while overriding methods are invoked on behalf of objects of the subclass. There are no such restrictions on the fields, as for fields only the field names matter. A final method cannot be overridden, an attempt to which will result in a compile-time error. A private method is not accessible outside the class in which it is defined; therefore, a subclass cannot override it.


A subclass must use the ‘super’ keyword in order to invoke an overridden method in the superclass. A subclass cannot override fields of the superclass, but it can hide them. Code in the subclass can use the keyword super to access members, including hidden fields.

The following distinction between invoking instance methods on an object and accessing fields of an object must be noted. When an instance method is invoked on an object using a reference, it is the class of the current object denoted by the reference, not the type of the reference, that determines which method implementation will be executed. When a field of an object is accessed using a reference, it is the type of the reference, not the class of the current object denoted by the reference, that determines which field will actually be accessed. This is demonstrated in the above program

 
 
    Java is a trademark of Sun Microsystems, Inc.
| | |
© Copyright 2007-08 javabeginner.com