• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Dacj 2-1 c
 

Dacj 2-1 c

on

  • 595 views

 

Statistics

Views

Total Views
595
Views on SlideShare
564
Embed Views
31

Actions

Likes
0
Downloads
0
Comments
0

1 Embed 31

http://niitcourseslides.blogspot.in 31

Accessibility

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Dacj 2-1 c Dacj 2-1 c Presentation Transcript

    • CollaborateKnowledge 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
    • CollaborateThe 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. ©NIIT Collaborate Lesson 1C / Slide 2 of 23
    • CollaborateThe 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. ©NIIT Collaborate Lesson 1C / Slide 3 of 23
    • CollaborateThe super and this Keywords (Contd.) • 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. ©NIIT Collaborate Lesson 1C / Slide 4 of 23
    • CollaborateThe super and this Keywords (Contd.) • 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. ©NIIT Collaborate Lesson 1C / Slide 5 of 23
    • CollaborateThe super and this Keywords (Contd.) • 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. ©NIIT Collaborate Lesson 1C / Slide 6 of 23
    • CollaborateThe super and this Keywords (Contd.) • 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; } } ©NIIT Collaborate Lesson 1C / Slide 7 of 23
    • CollaborateThe 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 { ©NIIT Collaborate Lesson 1C / Slide 8 of 23
    • CollaborateThe 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>; } } } ©NIIT Collaborate Lesson 1C / Slide 9 of 23
    • CollaborateFrom 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 ©NIIT Collaborate Lesson 1C / Slide 10 of 23
    • CollaborateBest PracticesThe 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. ©NIIT Collaborate Lesson 1C / Slide 11 of 23
    • CollaborateBest PracticesThe 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. ©NIIT Collaborate Lesson 1C / Slide 12 of 23
    • CollaborateBest PracticesThe Use of final Keyword (Contd.) • 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. ©NIIT Collaborate Lesson 1C / Slide 13 of 23
    • CollaborateBest PracticesThe Use of final Keyword (Contd.) • 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. ©NIIT Collaborate Lesson 1C / Slide 14 of 23
    • CollaborateTipsThe 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 • Class2 constructor • Class3 constructor ©NIIT Collaborate Lesson 1C / Slide 15 of 23
    • CollaborateTipsThe 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. ©NIIT Collaborate Lesson 1C / Slide 16 of 23
    • CollaborateFAQs • 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. ©NIIT Collaborate Lesson 1C / Slide 17 of 23
    • CollaborateFAQs (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. ©NIIT Collaborate Lesson 1C / Slide 18 of 23
    • CollaborateFAQs (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. ©NIIT Collaborate Lesson 1C / Slide 19 of 23
    • CollaborateChallenge 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. ©NIIT Collaborate Lesson 1C / Slide 20 of 23
    • CollaborateChallenge (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; } ©NIIT Collaborate Lesson 1C / Slide 21 of 23
    • CollaborateSolutions 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; ©NIIT Collaborate Lesson 1C / Slide 22 of 23
    • CollaborateSolutions to Challenge (Contd.) try { num3 = num1/num2; } catch( ArithmeticException e) { System.out.println(" Error Message"); } ©NIIT Collaborate Lesson 1C / Slide 23 of 23