Java Programming

UNIT-2
Inheritance
• Java, Inheritance is an important pillar of OOP(Object-
Oriented Programming).
• It is the mechanism in Java by which one class is allowed
to inherit another class's features(fields and methods).
• In Java, Inheritance means creating new classes based on
existing ones.
• A class that inherits from another class can reuse the
methods and fields of that class.
• In addition, you can add new fields and methods to your
current class as well.
• The class that is inherited is called the Super class (base
class), the class that inherits the superclass is sub class
(derived class)
Types of Inheritance
extends keyword
• To inherit the class we use the keyword “extends”

class Subclass-name extends Superclass-name

{
//methods and fields
}

• Java does not support multiple inheritance due to ambiguity-problem.

• But, it supports multiple inheritance using interfaces.
super()

• The super() method is used to call super class constructor.

super(<parameters of constructors>)
Method Overriding
• In class hierarchy a method in a sub class has the same name and
signature as that of parent class, then the method in subclass is said
to override the method of superclass.
super keyword
• The super keyword can be used to access super class variables and
methods. This is used when superclass and subclass members have
same name
Usage: super.variable_name[=value]

super.method_name(<parameters>)
 Task
• Check the access modifiers working in Inheritance
• Check final keyword working with methods and classes
Super class variable can reference subclass object

• A reference variable of a superclass can be assigned to any subclass derived from that
superclass.
Ex: class A
{
}
class B extends A
{
}
-----
A oba=new B();
// oba is a superclass variable assigned with subclass memory i.e object of the
subclass
• But the superclass variable can access only the superclass members but not the
subclass. (common sense that superclass does not know what is its derived class)
Polymorphism
• Compile-Time Polymorphism: Whenever an object is bound with its
functionality at compile time, this is known as compile-time
polymorphism. An example is method overloading.

• Run-Time Polymorphism: Whenever an object is bound with the

functionality at run time, this is known as runtime polymorphism. An
example is method overriding.
Dynamic method dispatch is the mechanism that shows how java
implements run time polymorphism
Dynamic method dispatch
• It is a mechanism by which a call to an overridden method is resolved
at runtime, rather than compile time.
• It shows how Java implements run-time polymorphism.
• We know that A reference variable of a superclass can be assigned to
any subclass derived from that superclass.
• When an overridden method is called through superclass reference,
java determines which version of the method to execute based on the
type of object being referred to at the time the call occurs.
 Object class
• Super most class in java
• Every class in Java is directly or indirectly derived from the Object
class
• If a class does not extend any other class then it is a direct child class
of Object and if extends another class then it is indirectly derived.
• Therefore the Object class methods are available to all Java classes
Object class methods
Task
• Implement Java programs to show the working of
1. getClass()
2. equals(Object obj)
3. hashCode()
4. finalize()
5. clone()
This keyword
• this can be used to refer current class instance variable.
• this can be used to invoke current class method (implicitly)
• this() can be used to invoke current class constructor.
• this can be passed as an argument in the method call.
• this can be passed as argument in the constructor call.
• this can be used to return the current class instance from the method.

Task: Write java program(s) to understand the usage of this

Abstract class

• The situation where you want to define the superclass that only defines a generalized
form that will be shared by all of its subclasses, leaving it to each subclass to fill in the
details.
• Such a class determines the nature of methods that the subclass must implement.
• The abstract class is defined by the keyword abstract.
• The methods whose code is not defined must also be declared with the keyword abstract.
abstract class <classname>
{
---
abstract access_modifier return_type method_name(parameters_list);
}

Note:
• The subclass must implement the code for the abstract method otherwise the subclass
will also be an abstract class.
• We can not instantiate an object of an abstract class.
Example situation
Shape
-stores base and height
-abstract method for computing
area

Triangle Rectangle
Define computing area computing area
Interface
• A pure abstract class said be to an interface.
• An Interface in Java programming language is defined as an abstract type
used to specify the behavior of a class.
• An interface in Java is a blueprint of a behavior.
• An interface would have only abstract methods.
• The variables in the interface are public, static, and final by default.
• This is what makes multiple inheritance possible in Java through interfaces.
• the abstract keyword applies only to classes and methods, indicating that
they cannot be instantiated directly and must be implemented.
• The job of the subclass to implement the code of all the methods of
interface, otherwise the subclass would become an abstract class. The key
word used for by a class to implement the interface is implements
Syntax for interfaces
interface <interfacename>
{
// declare constant fields by default final, public, and static.
// declare methods that abstract by default.
}
class <subclassname> implements <interfacename>
{
// variables and methods belonging to the subclass
// overriding methods of interface
}
Example:
interface Player
{
final int id = 10;
int move();
}
Note:
• We cannot instantiate the object of an interface.
• We need not to explicitly mention the variable as public, static and final, they are by
default.
• We need not to mention the methods as public and abstract explicitly, they are by
default. But while implementing in subclass we must declare as public.
• We can extend one interface into another. (use extends keyword)
• One or more interfaces can be implemented into single class (multiple inheritance).
Permitted access modifiers for
interfaces by default public
Relationship Between Class and
Interface
Task
• Write a java program to understand the extension of interfaces.
• Write a java program to understand multiple inheritance through
interfaces.
Understanding the terminology

• Interface its is the pure form of abstraction, uses keyword

implements for implementing into a class.

• Abstract class it can contain methods with code and at least one
abstract method. Sub class must extend and define the code for the
abstract methods by overriding the abstract methods.

• Concrete class. which is a complete class with no abstract methods.

Packages
• Package in Java is a mechanism to encapsulate a group of classes, sub-packages
and interfaces.
Packages are used for:
• Preventing naming conflicts. For example, there can be two classes with the
name Employee in two packages,
college.staff.cse.Employee and college.staff.aids.Employee
• Making searching/locating and usage of classes, interfaces, enumerations and
annotations easier.
• Providing controlled access: protected and default have package-level access
control.
• A protected member is accessible by classes in the same package and its
subclasses (even of different package).
• A default member (without any access specifier) is accessible by classes in the
same package only.
• Packages can be considered as data encapsulation (or data-hiding).
• Package in java can be categorized in two form, built-in
package and user-defined package.
• There are many built-in packages such as java, lang,
awt, javax, swing, net, io, util, sql etc.
Defining a package
Use the syntax
package <packagename>;
Example:
package mypackage;

We can create a hierarchy of packages

package pkg1.pkg2.pkg3….;
Compilation and Execution
• Compilation:
javac –d <directoryname> <programname.java>

Where you want to create the package dot (.) indicates

current directory

javac –d . Packdemo.java
• Execution:
java <package path>.<MainmethodClass>

java MyPack.Packdemo
Finding Packages and CLASSPATH
• Important Question: How does the Java Run-time system know
where to look for packages that you create?

• Answer has two parts:

• First, by default the Java run-time system uses the current working
directory as its stating point.

• Second, you can specify a directory path or paths by setting

CLASSPATH environment variable.
Importing packages
• Syntax
import PackageHierarchy.ClassName;
import PackageHierarchy.*;

Example:
import java.util.Scanner;
import mypack.ClassName;
import mypack.*;

Note: to access the class of a package it should be declared public

Nested and inner Classes
• It is possible to define a class within another class
• These can be static and non-static
• A static nested class in called a Nested class
• A non-static nested class in called Inner class
Nested class
class OuterClass
{
static class NestedClass
{
----
}
}
Types of Inner classes
• Local Inner Class-> A local inner class is a class defined within a
method or a block.
• Member Inner Class A member inner class is a non-static class
defined inside another class but outside any method. It can access all
members (even private members) of the outer class.
• Anonymous Inner ClassAn anonymous inner class is a class without
a name and for which only a single object is created. It is used when
you need to override methods of a class or an interface.
Inner Class
class OuterClass
{
returntype localmethod()
{
class LocalInnerClassname
{
----
}
}
}
Member Inner Class
class OuterClass
{
class MemberInnerClassname
{
----
}

}
 Anonymous Inner Class
public class OuterClass
{
public void createAnonymousInnerClass()
{
// Creating an anonymous inner class implementing Runnable
Runnable r = new Runnable() {
public void run()
{
System.out.println("Hello from Anonymous Inner Class");
}
};
new Thread(r).start();
}