The super and this Keywords

Collaborate

Knowledge Byte
In this section, you will learn about:

• The super and this keywords
• The nested try and catch block

©NIIT Collaborate Lesson 1C / Slide 1 of 23

Collaborate

The super and this Keywords
• The super keyword
• Java provides the super keyword that enables a subclass to refer to its
superclass. The super keyword is used to access:
• superclass constructors
• superclass methods and variables
• The syntax to invoke the constructor of a superclass using the super()
method is:
super (<parameter1>, <parameter 2>,..,<parameterN>);
In the above syntax, <parameter1>, <parameter 2>,..,<parameterN>
refer to the list of parameters that you need to pass to the constructor of
the superclass.


Collaborate

The super and this Keywords (Contd.)
• The super Keyword (Contd.)
• If no parameters are passed to the super() method, it invokes the default
constructor of the superclass.
• If the superclass contains the overloaded constructor, you can pass
parameters to the super() method to invoke a particular constructor.
• When you use the super() method in the constructor of the subclass, it
should be the first executable statement in the constructor.


Collaborate

• The super Keyword (Contd.)
• The syntax to access the member variable of a superclass is:
super.<variable>;
• The subclass can also access the member methods of the superclass using
the super keyword.


Collaborate

• The this Keyword
• The this keyword is used to refer to the current object.
• You can use the this keyword when a method defined in a Java class
needs to refer to the object used to invoke that method.
• The following code snippet shows how to use the this keyword:
Book(int bcode, double bprice)
{
this.bookCode=bcode;
this.bookPrice=bprice;
}
In the above code snippet, the this keyword refers to the object that
invokes the Book() constructor.


Collaborate

• The this Keyword (Contd.)
• Another situation where you can use the this keyword is when the local
and instance variables have the same name.
• The following code snippet shows how to use the this keyword when
instance and formal parameters have the same name:
Book(int bcode, double bprice)
{
this.bcode=bcode;
this.bprice=bprice;
}
In the above code snippet, this keyword refers to the instance variables,
bcode and bprice. The values of the formal parameters, bcode and
bprice of the Book() constructor are assigned to the instance variables.


Collaborate

• The this Keyword (Contd.)
• In addition, you can use the this keyword in a constructor of a class to
invoke another constructor of the class.
• Unlike the super keyword, the this keyword can invoke the
constructor of the same class.
• The following code snippet shows how to invoke a constructor using
the this keyword:
class Book {
public Book(String bname) {
this(bname, 1001); }
public Book(String bname, int bcode) {
bookName=bname;
bookCode=bcode; }
}


Collaborate

The Nested try-catch Block
• The try-catch block is used to handle exceptions in Java applications.
• You can enclose a try-catch block in an existing try-catch block.
• The enclosed try-catch block is called the inner try-catch block, and the
enclosing block is called the outer try-catch block.
• If the inner try block does not contain the catch statement to handle an
exception then the catch statement in the outer block is checked for the
exception handler.
• The following syntax shows how to create a nested try-catch block:
class SuperClass
{
public static void main(String a[])
{
<code>;
try
{


Collaborate

The Nested try-catch Block (Contd.)
• The following syntax shows how to create a nested try-catch block: (Contd.)
<code>;
try
{
<code>;
}
catch(<exception_name> <var>)
{
<code>;
}
}
catch(<exception_name> <var>)
{
<code>;
} } }

Collaborate

From the Expert’s Desk

In this section, you will learn:

• Best practices on:
• The Use of final Keyword
• Tips on:
• The Use of Constructors
• The finally Block
• FAQs


Collaborate

Best Practices
The Use of final Keyword
• The final keyword can be used with:
• A variable
• A method
• A class
• The use of the final keyword prevents you from changing the value of a
variable.
• When you use the final keyword with a variable, the variable acts as a
constant.
• It is recommended that you name the final variable in uppercase.


Collaborate

Best Practices
The Use of final Keyword (Contd.)
• The syntax to declare the final variable is:
final int MY_VAR=10;
In the above syntax, the MY_VAR variable is declared as final. As a result,
the value of the variable cannot be modified.
• The final keyword is used with methods and classes to prevent method and
class overriding while implementing inheritance in a Java application.
• If a method in a subclass has the same name as the final method in a
superclass, a compile time error is generated.


Collaborate

Best Practices
• The following syntax shows how to declare the final method:
class SuperClass
{
final void finalMethod()
{}
}
• Similarly, if a class is declared final, you cannot extend that class.
• If you extend the final class, a compile time error is generated.


Collaborate

Best Practices
• The following syntax shows how to declare the final class:
final class SuperClass
{
//This is a final class.
}
In the preceding syntax, the SuperClass class is declared as final.


Collaborate

Tips
The Use of Constructors
• Consider a Java application that contains multiple classes. Each class is
extended from another class in the application and contains a default
constructor.
• When the application is executed, the constructors are called in the order in
which the classes are defined.
• For example, there are three classes in a Java application: Class1, Class2,
and Class3. Class2 extends Class1, and Class3 extends Class2. When you
create an instance of Class 3, the constructors are called in the following
order:
• Class1 constructor


Collaborate

Tips
The finally Block
• The finally block associated with a try block is executed after the try or catch
block is completed.
• It is optional to associate the finally block with a try block, but if the try block
does not have a corresponding catch block, you should provide the finally
block.


Collaborate

FAQs
• Can classes inherit from more than one class in Java?

No, a class cannot be inherited from more than one class in Java. A class is
inherited from a single class only. However, multi-level inheritance is
possible in Java. For example, if class B extends class A and class C extends
class B, class C automatically inherits the properties of class A.

• What is the difference between an interface and a class?

Both, class and interface, contain constants and methods. A class not only
defines methods but also provides their implementation. However, an
interface only defines the methods, which are implemented by the class that
implements the interface.


Collaborate

FAQs (Contd.)
• Do you have to catch all types of exceptions that might be thrown by Java?

Yes, you can catch all types of exceptions that are thrown in a Java
application using the Exception class.

• How many exceptions can you associate with a single try block?

There is no limit regarding the number of exceptions that can be associated
with a single try block. All the exceptions associated with a try block should
be handled using multiple catch blocks.


Collaborate

FAQs (Contd.)
• What are the disadvantages of inner classes?

The inner classes have various disadvantages. The use of inner class
increases the total number of classes in your code. The Java developers also
find it difficult to understand to implement the concept of inner class within
the programs.

• What is the level of nesting for classes in Java?

There is no limit of nesting classes in Java.


Collaborate

Challenge
1. You can access particular constructors in the superclass using
______operator.
2. Which of the following exceptions is raised when a number is divided by
zero:
a. NullPointerException
b. ArithmeticException
c. ArrayIndexOutOfBoundsException
d. NumberFormatException
3. You can have more than one finally block for an exception-handler.
(True/False)
4. Match the following:
a. public 1. Ensures the value is not changed in the classes that
implement an interface.
b. static 2. Ensures that are able to override the data members in
unrelated classes.
c. final 3. Ensures that you cannot create an object of the interface.

Collaborate

Challenge (Contd.)
1. The following code is a jumbled code. Rearrange the following code to make it
executable:
public class Excp
{
public static void main(String args []) {
int num1, num2, num3;
num1 = 10;
num2 = 0;
catch(ArithmeticException e)
{
System.out.println(" Error Message");
} try
{
num3 = num1/num2;
}

Collaborate

Solutions to Challenge

• dot
• b. ArithmeticException
• False
• a. 2
b. 1
c. 3
5. public class Excp
{
public static void main(String args [])
{
int num1, num2, num3;
num1 = 10;
num2 = 0;


Collaborate

Solutions to Challenge (Contd.)
try
{
num3 = num1/num2;
}
catch( ArithmeticException e)
{
System.out.println(" Error Message");
}


The super and this Keywords

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à The super and this Keywords

Similaire à The super and this Keywords (20)

Plus de Niit Care

Plus de Niit Care (20)

Dernier

Dernier (20)

The super and this Keywords