SRCMBMM Sanchalit SMT K.S Kapashi Bca College, Palitana Java Unit-3

SRCMBMM SANCHALIT SMT K.
S KAPASHI BCA
COLLEGE,PALITANA
JAVA UNIT-3
 Inheritance
- The class which inherits the properties of other is known as subclass (derived
class, child class) and the class whose properties are inherited is known as
superclass (base class, parent class).
- Inheritance can be defined as the procedure or mechanism of acquiring all the
properties and behavior of one class to another, i.e., acquiring the properties and
behavior of child class from the parent class. This concept was built to achieve
the advantage of creating a new class that gets built upon an already existing
class(es). It is mainly used for code reusability within a Java program.
- Moreover, a hierarchical order of management of information can also be done
using this concept. Here two types of classes build relationships with each other
which are a base class and derived class.
- The class that gets inherited taking the properties of another class is the subclass
or derived class or child class. Again, the class whose properties get inherited is
the superclass or base class or parent class. The keyword extends used to inherit
the properties of the base class to derived class.
 Extends Keyword
extends is the keyword used to inherit the properties of a class. Following is the syntax of
extends keyword.
Syntax
class Super {
.....
.....
}
class Sub extends Super {
.....
.....
PREPARED BY: VEEDHEE AMBALIYA PAGE 1

SRCMBMM SANCHALIT SMT K.S KAPASHI BCA
COLLEGE,PALITANA
JAVA UNIT-3
Example:-
class employee {
intwt = 8;
}
class clerk extends employee {

intwt = 10; //work time
void display() {
System.out.println(super.wt); //will print work time of
clerk
}
public static void main(String args[]) {

clerk c = new clerk();
c.display();
}
}
 The super keyword
Super is a keyword of Java which refers to the immediate parent of a class and is used inside
the subclass method definition for calling a method defined in the superclass. A superclass
having methods as private cannot be called. Only the methods which are public and protected
can be called by the keyword super. It is also used by class constructors to invoke
constructors of its parent class.
Syntax:-
super.<method-name>();
 Super variables refer to the variable of a variable of the parent class.

 Super() invokes the constructor of immediate parent class.
 Super refers to the method of the parent class.
Example:-
class Superclass {
int age;
Superclass(int age) {
this.age = age;
}
public void getAge() {

COLLEGE,PALITANA
JAVA UNIT-3
System.out.println("The value of the variable named age in

super class is: " +age);
}
}
public class Subclass extends Superclass {

Subclass(int age) {
super(age);
}
public static void main(String argd[]) {

Subclass s = new Subclass(24);
s.getAge();
}
}
IS-A Relationship
IS-A is a way of saying: This object is a type of that object. Let us see how the extends
keyword is used to achieve inheritance.
publicclassAnimal{
}
publicclassMammalextendsAnimal{
}
publicclassReptileextendsAnimal{
}
publicclassDogextendsMammal{
}
Now, based on the above example, in Object-Oriented terms, the following are true −
 Animal is the superclass of Mammal class.

 Animal is the superclass of Reptile class.
 Mammal and Reptile are subclasses of Animal class.
 Dog is the subclass of both Mammal and Animal classes.
Now, if we consider the IS-A relationship, we can say −
 Mammal IS-A Animal

 Reptile IS-A Animal
 Dog IS-A Mammal
 Hence: Dog IS-A Animal as well

COLLEGE,PALITANA
JAVA UNIT-3
With the use of the extends keyword, the subclasses will be able to inherit all the properties
of the superclass except for the private properties of the superclass.
HAS-A relationship
These relationships are mainly based on the usage. This determines whether a certain class
HAS-A certain thing. This relationship helps to reduce duplication of code as well as bugs.
Lets look into an example −
Example
publicclassVehicle{}
publicclassSpeed{}
publicclassVanextendsVehicle{
privateSpeedsp;
}
 Types of Inheritance

COLLEGE,PALITANA
JAVA UNIT-3
 Single inheritance:-
When a single class gets derived from its base class, then this type of inheritance is termed
as single inheritance. The figure drawn above has class A as the base class, and class B gets
derived from that base class.
class Teacher {
void teach() {
System.out.println("Teaching subjects");
}
}
class Students extends Teacher {
void listen() {
System.out.println("Listening to teacher");
}
}
classCheckForInheritance {
Students s1 = new Students();
s1.teach();
s1.listen();
}
}
 Multi-level Inheritance
In this type of inheritance, a derived class gets created from another derived class and can
have any number of levels.
Example:-
class Teacher {
void teach() {
System.out.println("Teaching subject");
}
}
class Student extends Teacher {
void listen() {
System.out.println("Listening");
}
}
classhomeTution extends Student {
void explains() {
System.out.println("Does homework");
}
}

COLLEGE,PALITANA
JAVA UNIT-3
public static void main(String argu[]) {

homeTution h = new himeTution();
h.explains();
d.teach();
d.listen();
}
}
 Hierarchical Inheritance
In this type of inheritance, there are more than one derived classes which get created from
one single base class.
Example:-
class Teacher {
void teach() {
System.out.println("Teaching subject");
}
}
class Student extends Teacher {
void listen() {
System.out.println("Listening");
}
}
class Principal extends Teacher {
void evaluate() {
System.out.println("Evaluating");
}
}
Principal p = new Principal();
p.evaluate();
p.teach();
// p.listen(); will produce an error
}
}
 Method Overriding
Declaring a method in the subclass which already exists there in the parent class is known as
method overriding. When a class is inheriting a method from a superclass of its own, then
there is an option of overriding the method provided it is not declared as final. The
advantage of using overriding is the ability to classify a behavior that's specific to the child
class, and the child class can implement a parent class method based on its necessity.

COLLEGE,PALITANA
JAVA UNIT-3
There are certain rules that a programmer should follow to implement overriding. These are:
 In Java, a method can only be written in the child class and not in same class.
 Argument list should be the same as that of the overridden method of that class.
 Instance methods can also be overridden if they are inherited by the child class.
 A constructor cannot be overridden.
 Final - declared methods cannot be overridden.
 Any method that is static cannot be used to override.
 The return type must have to be the same, or a subtype of the return type declared in
the original overridden method in the parent class.
 If a method cannot be inherited, then it cannot be overridden.
 A child class within the same package as the instance's parent class can override any
parent class method that is not declared private or final.
 A child class in a different package can only override the non-final methods declared
as public or protected.
Example:-
class college {
public void move() {
System.out.println("College is open");
}
}
classuniv extends college {
public void move() {
System.out.println("University is open too");
}
}
public class stud {
college a = new college();
college b = new univ();
a.move();
b.move();
}
}
Example:-2
class parent {
public void work() {
System.out.println("Parent is under retirement from work.");
}
}
class child extends parent {
public void work() {
System.out.println("Child has a job");
System.out.println(" He is doing it well");
}

COLLEGE,PALITANA
JAVA UNIT-3

child c1 = new child();
c1.work();
}
}
 Polymorphism
 Static Polymorphism
 Dynamic Polymorphism.
Polymorphism is another special feature of object-oriented programming (OOPs). The

approach which lies beneath this concept is "single interface with multiple implementations."
It offers a single interface for controlling access to a general class of actions.
Polymorphism can be achieved in two of the following ways:
 Method Overloading(Compile time Polymorphism)

 Method Overriding(Run time Polymorphism)
 Abstract classes
A class which contains the abstract keyword in its declaration is known as abstract class.
 Abstract classes may or may not contain abstract methods, i.e., methods without body
( public void get(); )
 But, if a class has at least one abstract method, then the class must be declared
abstract.
 If a class is declared abstract, it cannot be instantiated.
 To use an abstract class, you have to inherit it from another class, provide
implementations to the abstract methods in it.
 If you inherit an abstract class, you have to provide implementations to all the abstract
methods in it.

COLLEGE,PALITANA
JAVA UNIT-3
Example:-
abstract class cycle {

abstract void work();
}
classHeroCycle extends cycle {

void work() {
System.out.println("Selling good");
}

cycle o = new HeroCycle();
o.work();
System.out.println("Code executed");
}
}
 Abstract method
When a programmer wants any class having a specific method but also want the actual
execution of that method to be resolute by its child classes, the methods can be declared in
the base class in the form of abstract methods.
 The keyword abstract is used for declaring abstract method

 The abstract keyword needs to be implemented before the name of method
 Abstract method does not contain any method body
 If there are no curly braces given, there should have to be semicolon put at the end of
the abstract method
public abstract class professor {

private String str;
private float sal;
privateintregnNo;
public abstract double salaryCompute();
// abstract metho body here
}
 Interfaces
An interface is a reference type in Java. It is similar to class. It is a collection of abstract
methods. A class implements an interface, thereby inheriting the abstract methods of the
interface.
Writing an interface is similar to writing a class. But a class describes the attributes and
behaviors of an object. And an interface contains behaviors that a class implements.

COLLEGE,PALITANA
JAVA UNIT-3
Unless the class that implements the interface is abstract, all the methods of the interface need
to be defined in the class.
Use:-
 For achieving full data abstraction

 Using Interface, you can use the concept of multiple inheritances
 Interfaces can also be used to achieve loose coupling
an interface is different from a class in several ways, including −
 You cannot instantiate an interface.

 An interface does not contain any constructors.
 All of the methods in an interface are abstract.
 An interface cannot contain instance fields. The only fields that can appear in an
interface must be declared both static and final.
 An interface is not extended by a class; it is implemented by a class.
 An interface can extend multiple interfaces.
an interface is different from a class in several ways, including −
 You cannot instantiate an interface.

 An interface does not contain any constructors.
 All of the methods in an interface are abstract.
 An interface cannot contain instance fields. The only fields that can appear in an
interface must be declared both static and final.
 An interface is not extended by a class; it is implemented by a class.
 An interface can extend multiple interfaces.
Declaring Interfaces
The interface keyword is used to declare an interface. Here is a simple example to declare an
interface −
Example
/* File name : NameOfInterface.java */
importjava.lang.*;
// Any number of import statements
publicinterfaceNameOfInterface{
// Any number of final, static fields
// Any number of abstract method declarations\
}
Interfaces have the following properties −

COLLEGE,PALITANA
JAVA UNIT-3
 An interface is implicitly abstract. You do not need to use the abstract keyword while
declaring an interface.
 Each method in an interface is also implicitly abstract, so the abstract keyword is not
needed.
 Methods in an interface are implicitly public.
Example
/* File name : Animal.java */
interfaceAnimal{
publicvoid eat();
publicvoid travel();
}
Implementing Interfaces
When a class implements an interface, you can think of the class as signing a contract,
agreeing to perform the specific behaviors of the interface. If a class does not perform all the
behaviors of the interface, the class must declare itself as abstract.
When implementation interfaces, there are several rules −
 A class can implement more than one interface at a time.

 A class can extend only one class, but implement many interfaces.
 An interface can extend another interface, in a similar way as a class can extend
another class.
A class uses the implements keyword to implement an interface. The implements keyword
appears in the class declaration following the extends portion of the declaration.
Example
/* File name : MammalInt.java */
publicclassMammalIntimplementsAnimal{
publicvoid eat(){
System.out.println("Mammal eats");
}
publicvoid travel(){
System.out.println("Mammal travels");
}
publicintnoOfLegs(){
return0;
}
publicstaticvoid main(Stringargs[]){
MammalInt m =newMammalInt();

COLLEGE,PALITANA
JAVA UNIT-3
m.eat();
m.travel();
}
}
Extending Interfaces
An interface can extend another interface in the same way that a class can extend another
class. The extends keyword is used to extend an interface, and the child interface inherits the
methods of the parent interface.
The following Sports interface is extended by Hockey and Football interfaces.
Example
// Filename: Sports.java
publicinterfaceSports{
publicvoidsetHomeTeam(String name);
publicvoidsetVisitingTeam(String name);
}
// Filename: Football.java
publicinterfaceFootballextendsSports{
publicvoidhomeTeamScored(int points);
publicvoidvisitingTeamScored(int points);
publicvoidendOfQuarter(int quarter);
}
// Filename: Hockey.java
publicinterfaceHockeyextendsSports{
publicvoidhomeGoalScored();
publicvoidvisitingGoalScored();
publicvoidendOfPeriod(int period);
publicvoidovertimePeriod(intot);
}
Extending Multiple Interfaces
A Java class can only extend one parent class. Multiple inheritance is not allowed. Interfaces
are not classes, however, and an interface can extend more than one parent interface.The
extends keyword is used once, and the parent interfaces are declared in a comma-separated
list.
For example, if the Hockey interface extended both Sports and Event, it would be declared as
Example
publicinterfaceHockeyextendsSports,Event

COLLEGE,PALITANA
JAVA UNIT-3
 Introduction to Packages
A package is a mechanism to group the similar type of classes, interfaces and sub-packages
and provide access control. It organizes classes into single unit.
In Java already many predefined packages are available, used while programming.
For example: java.lang, java.io, java.util etc.
Advantages of Packages
 Packages provide code reusability, because a package has group of classes.

 It helps in resolving naming collision when multiple packages have classes with the
same name.
 Package also provides the hiding of class facility. Thus other programs cannot use the
classes from hidden package.
 Access limitation can be applied with the help of packages.
 One package can be defined in another package.
 Types of Packages
There are two types of packages available in Java.
1. Built-in packages
Built-in packages are already defined in java API. For example: java.util, java.io, java,lang,
java.awt, java.applet, java.net, etc.
2. User defined packages
The package we create according to our need is called user defined package.
Creating a Package
We can create our own package by creating our own classes and interfaces together. The
package statement should be declared at the beginning of the program.
Syntax:
package <packagename>;
class ClassName
{
……..
……..
}

COLLEGE,PALITANA
JAVA UNIT-3
Example: Creating a Package
// Demo.java
package p1;
class Demo
{
public void m1()
{
System.out.println("Method m1..");
}
}
How to compile?
Syntax: javac –d directory javafilename
For Example: javac –d . Demo.java
How to run?
To run: java p1.Demo
Example: Program to create and use a user defined ackage in Java.
// Vehicle.java
package vehicles;
interface Vehicle
{
public void run();
public void speed();
}
//Bike.java
package vehicles;
public class Bike implements Vehicle
{
public void run()
{
System.out.println("Bike is running.");
}
public void speed()
{
System.out.println("Speed of Bike: 50 Km/h");
}
public static void main(String args[])
{
Bike bike = new Bike();

COLLEGE,PALITANA
JAVA UNIT-3
bike.run();
bike.speed();
}
}
Compile:
javac –d . Vehicle.java
javac –d . Bike.java
Run:
java vehicles.Bike
Output:
Bike is running
Speed of Bike: 50 Km/h
 The “import” keyword
The import keyword provides the access to other package classes and interfaces in current
packages. “import” keyword is used to import built-in and user defined packages in java
program.
 Interface
 Interface is similar to a class, but it contains only abstract methods.

 By default the variables declared in an interface are public, static and final.
 Interface is a mechanism to achieve full abstraction.
 An interface does not contain any constructor.
Syntax:
interface InterfaceName
{
public void method1();
public void method2();
<type> variableName = value;
}

COLLEGE,PALITANA
JAVA UNIT-3
Example: Sample of an interface
interface Employee
{
static final Id = 101;
static final String name = “ABC”;
void show();
void getSalary(double salary);
}
 Extending interfaces
An interface has to extend another interface as it happens in class. It cannot implement another
interface.
Example: Sample program for extending interfaces
interface Base
{
public void display ();
}
interface Derive extends Base
{
public void show ();
}
 Implementing interfaces
 A class implements an interface. After that, class can perform the specific behavior on
an interface.
 The implements keyword is used by class to implement an interface.
Syntax:
class ClassName implements interfacename

{
// body of class
}
interface Results
{
final static float pi = 3.14f;
float areaOf(float l, float b);
}
class Rectangle implements Results
{
public float areaOf(float l, float b)

COLLEGE,PALITANA
JAVA UNIT-3
{
return (l * b);
}
}
class Square implements Results
{
public float areaOf(float l, float b)
{
return (l * l);
}
}
class Circle implements Results
{
public float areaOf(float r, float b)
{
return (pi * r * r);
}
}
public class InterfaceDemo
{
{
Rectangle rect = new Rectangle();
Square square = new Square();
Circle circle = new Circle();
System.out.println("Area of Rectangle: "+rect.areaOf(20.3f, 28.7f));
System.out.println("Are of square: "+square.areaOf(10.0f, 10.0f));
System.out.println("Area of Circle: "+circle.areaOf(5.2f, 0));
}
}
Output:
Area of Rectangle: 582.61
Are of square: 100.0
Area of Circle: 84.905594
Example: Sample program to implements multiple inheritance
interface Vehicle
{
void run();
}
interface Bike extends Vehicle
{
void stop();
}
public class Demo implements Bike

COLLEGE,PALITANA
JAVA UNIT-3
{
public void run()
{
System.out.println("Vehicle is running.");
}
public void stop()
{
System.out.println("Bike is stop.");
}
{
Demo obj = new Demo();
obj.run();
obj.stop();
}
}
Output:
Vehicle is running.
Bike is stop.
 Marker Interface
An interface which does not contain any fields and methods is known as marker or tag
interface. It is an empty interface.
For example Serializable, EventListener, MouseListner, Remote, Cloneable etc.
Example:
package java.util;
public interface EventListner
{
}
Differences between Abstract class and Interface
Abstract class Interface

It cannot support multiple inheritances. Interface supports multiple inheritances.
It contains both abstract and non abstract method. It contains only abstract method.
Abstract class is the partially implemented class. Interface is fully unimplemented class.
It cannot have main method and
It can have main method and constructor.
constructor.
It can have static, non-static, final, non-final
It contains only static and final variable.
variables.

COLLEGE,PALITANA
JAVA UNIT-3
 Access Modifiers(Access Protection)
Access modifiers are simply a keyword in Java that provides accessibility of a class and its
member. They set the access level to methods, variable, classes and constructors.
 Types of access modifier
There are 4 types of access modifiers available in Java.
 public
 default
 protected
 private
 public
The member with public modifiers can be accessed by any classes. The public methods,
variables or class have the widest scope.
Example: Sample program for public access modifier

{
// code
}
 default
When we do not mention any access modifier, it is treated as default. It is accessible only within
same package.
Example: Sample program for default access modifier
int a = 25;
String str = "Java";
boolean m1()
{
return true;
}

COLLEGE,PALITANA
JAVA UNIT-3
 protected
The protected modifier is used within same package. It lies between public and default access
modifier. It can be accessed outside the package but through inheritance only.
A class cannot be protected.
Example: Sample program for protected access modifier
class Employee
{
protected int id = 101;
protected String name = "Jack";
}
public class ProtectedDemo extends Employee
{
private String dept = "Networking";
public void display()
{
System.out.println("Employee Id : "+id);
System.out.println("Employee name : "+name);
System.out.println("Employee Department : "+dept);
}
{
ProtectedDemo pd = new ProtectedDemo();
pd.display();
}
}
Output:
Employee Id : 101
Employee name : Jack
Employee Department : Networking
 Private
The private methods, variables and constructor are not accessible to any other class. It is the most
restrictive access modifier. A class except a nested class cannot be private.
Example: Sample program for private access modifier
public class PrivateDemo

{
private int a = 101;
private String s = "TutorialRide";

COLLEGE,PALITANA
JAVA UNIT-3
public void show()

{
System.out.println("Private int a = "+a+"\nString s = "+s);
}
{
PrivateDemo pd = new PrivateDemo();
pd.show();
System.out.println(pd.a+" "+pd.s);
}
}
Output:
Private int a = 101
String s = TutorialRide
101 TutorialRide
Table for Access Modifier
Access modifier In class In package Outside package by subclass Outside package
Public Yes Yes Yes No
protected Yes Yes Yes No
Default Yes Yes No No
Private Yes No No No

SRCMBMM Sanchalit SMT K.S Kapashi Bca College, Palitana Java Unit-3

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

SRCMBMM Sanchalit SMT K.S Kapashi Bca College, Palitana Java Unit-3

Uploaded by

Copyright:

Available Formats

SRCMBMM SANCHALIT SMT K.

PREPARED BY: VEEDHEE AMBALIYA PAGE 1

class clerk extends employee {

public static void main(String args[]) {

 The super keyword

 Super variables refer to the variable of a variable of the parent class.

public void getAge() {

PREPARED BY: VEEDHEE AMBALIYA PAGE 2

System.out.println("The value of the variable named age in

public class Subclass extends Superclass {

public static void main(String argd[]) {

 Animal is the superclass of Mammal class.

Now, if we consider the IS-A relationship, we can say −

 Mammal IS-A Animal

PREPARED BY: VEEDHEE AMBALIYA PAGE 3

Lets look into an example −

PREPARED BY: VEEDHEE AMBALIYA PAGE 4

PREPARED BY: VEEDHEE AMBALIYA PAGE 5

public static void main(String argu[]) {

PREPARED BY: VEEDHEE AMBALIYA PAGE 6

PREPARED BY: VEEDHEE AMBALIYA PAGE 7

public static void main(String argu[]) {

Polymorphism is another special feature of object-oriented programming (OOPs). The

Polymorphism can be achieved in two of the following ways:

 Method Overloading(Compile time Polymorphism)

PREPARED BY: VEEDHEE AMBALIYA PAGE 8

abstract class cycle {

classHeroCycle extends cycle {

public static void main(String argu[]) {

 The keyword abstract is used for declaring abstract method

public abstract class professor {

PREPARED BY: VEEDHEE AMBALIYA PAGE 9

 For achieving full data abstraction

an interface is different from a class in several ways, including −

 You cannot instantiate an interface.

an interface is different from a class in several ways, including −

 You cannot instantiate an interface.

Interfaces have the following properties −

PREPARED BY: VEEDHEE AMBALIYA PAGE 10

When implementation interfaces, there are several rules −

 A class can implement more than one interface at a time.

PREPARED BY: VEEDHEE AMBALIYA PAGE 11

The following Sports interface is extended by Hockey and Football interfaces.

Extending Multiple Interfaces

PREPARED BY: VEEDHEE AMBALIYA PAGE 12

 Packages provide code reusability, because a package has group of classes.

PREPARED BY: VEEDHEE AMBALIYA PAGE 13

Example: Creating a Package

Example: Program to create and use a user defined ackage in Java.

PREPARED BY: VEEDHEE AMBALIYA PAGE 14

 The “import” keyword

 Interface is similar to a class, but it contains only abstract methods.

PREPARED BY: VEEDHEE AMBALIYA PAGE 15

Example: Sample of an interface

Example: Sample program for extending interfaces

class ClassName implements interfacename

PREPARED BY: VEEDHEE AMBALIYA PAGE 16

Example: Sample program to implements multiple inheritance

PREPARED BY: VEEDHEE AMBALIYA PAGE 17

For example Serializable, EventListener, MouseListner, Remote, Cloneable etc.

Differences between Abstract class and Interface

Abstract class Interface

PREPARED BY: VEEDHEE AMBALIYA PAGE 18