object oriented programming unit two ppt

UNIT-II INHERITANCES,PACKAGES AND INTERFACE
Overloading Methods – Objects as Parameters – Returning Objects
–Static, Nested and Inner Classes. Inheritance: Basics– Types of
Inheritance -Super keyword -Method Overriding – Dynamic Method
Dispatch –Abstract Classes – final with Inheritance. Packages and
Interfaces: Packages – Packages and Member Access –Importing
Packages – Interfaces.

Overloading Methods
 Method Overloading is a feature in Java that allows a class to have
more than one methods having same name, but with different
signatures (Parameters).
 (Each method must have different number of parameters or
parameters having different types and orders).

Three ways to overload a method
1. Number of parameters. (Different number of parameters in argument list)
• For example: This is a valid case of overloading
• add(int, int)
• add(int, int, int)
2. Data type of parameters. (Difference in data type of parameters)
• For example:
• add(int, int)
• add(int, float)

3. Sequence of Data type of parameters.
• For example:
• add(int, float)
• add(float, int)

Method Overloading with Type
Promotion:
• The name Type Promotion specifies that a small size
datatype can be promoted to a large size datatype. i.e., an
Integer data type can be promoted to long, float, double, etc.
• This Automatic Type Promotion is done when any method
which accepts a higher size data type argument is called with
the smaller data type.

STATIC, NESTED & INNER CLASSES
• An inner class is a class that is defined inside another class.
SYNTAX: FOR DECLARING INNER CLASSES
[modifier] class OuterClassName
{
---- Code -----
[modifier] class InnerClassName
{
---- Code ----
}
}

 It is possible to define a class within another class; such classes are known as
nested classes.
 if class B is defined within class A, then B does not exist independently of A.
 There are two types of nested classes: static and non-static.
 Static nested class is one that has the static modifier applied.
 Because it is static, it must access the non-static members of its enclosing class
through an object.
 That is, it cannot refer to non-static members of its enclosing class directly.
 The most important type of nested class is the inner class.
 An inner class is a non-static nested class.
 It has access to all of the variables and methods of its outer class and may
refer to them directly in the same way that other non-static members of the
outer class do.

Access Outer Class From Inner Class
• We can access attributes and methods of the
inner class.

Static Inner Class
• Inner class also be a static class,which means when you
access it without creating an objects for inner class.

Inheritance
• Inheritance is a process of deriving a new class from existing class, also
called as “extending a class”.
• The class whose property is being inherited by another class is called
“base class” (or) “parent class” (or) “super class”.
• The class that inherits a particular property or a set of properties from
the base class is called “derived class” (or) “child class” (or) “sub class”.

• ADVANTAGES OF INHERITANCE:
• Reusability of Code:
• Inheritance is mainly used for code reusability (Code reusability means
that we can add extra features to an existing class without modifying it).
• Effort and Time Saving:
• The advantage of reusability saves the programmer time and effort. Since
the main code written can be reused in various situations as needed.
• Increased Reliability:
• The program with inheritance becomes more understandable and easily
maintainable as the sub classes are created from the existing reliably
working classes.

“extends” KEYWORD:
• Inheriting a class means creating a new class as an extension of another
class.
• The extends keyword is used to inherit a class from existing class.
• The general form of a class declaration that inherits a superclass is shown
here:
•  Syntax:

Characteristics of Class Inheritance:
1. A class cannot be inherited from more than one base
class. Java does not support multiple inheritance
2. Sub class can access only the non-private members
of the super class.
3. Private data members of a super class are local only
to that class. Therefore, they can’t be accessed outside
the super class, even sub classes can’t access the private
members.
4. Protected features in Java are visible to all subclasses
as well as all other classes in the same package.

TYPES OF INHERITACE:
1. Single Inheritance
2. Multilevel Inheritance
3. Multiple Inheritance
4. Hierarchical Inheritance
5. Hybrid Inheritance

SINGLE INHERITANCE
• The process of creating only one subclass from
only one super class is known as Single
Inheritance.
• Only two classes are involved in this inheritance.
• The subclass can access all the members of
super class.

MULTILEVEL INHERITANCE
• The process of creating a new sub class from an already
inherited sub class is known as Multilevel Inheritance.
• Multiple classes are involved in inheritance, but one
class extends only one.
• The lowermost subclass can make use of all its super
classes' members.
• Multilevel inheritance is an indirect way of
implementing multiple inheritance.

Example: Animal ->Dog -> BabyDog

Hybrid Inheritance
• In Hierarchical Inheritance, one class serves as a superclass
(base class) for more than one subclass.
• Class A serves as a base class for the derived classes B, C, and D.

Super keyword
• Super keyword is refer to the super class(parent class) object.
• It is used to call superclass methods, and to access the superclass
constructor.
• The super keyword is used to access the parent class object and is
based on the concept of inheritance in Java.
• The most common use of the super keyword is to eliminate the
confusion between superclasses and subclasses that have methods
with same name.
• super keyword is used for the following three purposes:
1. To invoke superclass constructor.
2. To invoke superclass members variables.
3. To invoke superclass methods.

Access Attributes of the Superclass

Use of super() to access superclass constructor

Method overriding
• If subclass (child class) has the same method as
declared in the parent class, it is known as method
overriding in Java.
• Rules for Java Method Overriding
1. The method must have the same name as in the
parent class
2. The method must have the same parameter as in
the parent class.
3. There must be an (inheritance).

Dynamic method dispatch
• Dynamic method dispatch is the mechanism
by which a call to an overridden method is
resolved at run time, rather than compile time.
• Dynamic method dispatch is important
because this is how Java implements run-time
polymorphism

ABSTRACT CLASSES
• Abstraction is a process of hiding the
implementation details and showing only the
essential features to the user.
• For example: sending sms, you just type the text
and send the message. You don't know the
internal processing about the message delivery.

• Keyword for abstract-”abstract”
• It contains
 Abstract class-(a class contains atleast one abstract
method).
 Abstract method(methods having only declaration inside
the class)-definition will be in derived class.
 Concrete class/method-(class which doesn’t contain any
abstract method/class)
• We can’t create object for abstract class.

Rules for abstract class
• An abstract class must be declared with an abstract
keyword.
• It can have abstract and non-abstract methods.
• It cannot be instantiated i.e.,object of such class cannot be
created directly using new keyword. .
• It can have constructors and static methods also.
• It can have final methods which will force the subclass not to
change the body of the method.

Rules for Abstract Methods
• The abstract keyword is also used to declare a
method as abstract.
• An abstract method consists of a parameters, but
no method body.
• Abstract method would have no definition, and its
parameters is followed by a semicolon, not curly
braces

Example for abstract class
abstract class shape
{
int x,y; //member declaration
void draw() //concrete method
{
System.out.println(“draw”);
}
abstract void draw(); //abstract method
}

FINAL WITH INHERITANCE
• Final is a keyword or reserved word in java used for restricting some
functionality.
• It can be applied to member variables, methods, class and local
variables in Java.
• final keyword has three uses:
1. For declaring variable – to create a named constant. A final
variable cannot be changed once it is initialized.
2. For declaring the methods – to prevent method overriding. A
final method cannot be overridden by subclasses.
3. For declaring the class – to prevent a class from inheritance. A
final class cannot be inherited.

1. Final Variable:
• Any variable either member variable or local
variable (declared inside method) modified by final
keyword is called final variable.
• Syntax:

• The final variable can be assigned only once.
• The value of the final variable will not be changed during the
execution of the program.
• If an attempt is made to alter the final variable value, the
java compiler will throw an error message.

• There is a final variable speedlimit, we are going to change the value of
this variable, but It can't be changed because final variable once
assigned a value can never be changed.

2. Final Methods:
• Final keyword in java can also be applied to methods.
• A java method with final keyword is called final method and it cannot
be overridden in sub-class.
• If a method is defined with final keyword, it cannot be overridden in the
subclass and its behaviour should remain constant in sub-classes.

3. Final Classes:
• Java class with final modifier is called final class in Java and they cannot
be sub-classed or inherited.

Points to Remember
1) A constructor cannot be declared as final
2) We cannot change the value of a final variable.
3) A final method cannot be overridden.
4) A final class cannot be inherited.
5) If method parameters are declared final then the value of
these parameters cannot be changed.

PACKAGES
• A Package can be defined as a collection of classes,
interfaces, enumerations providing access protection and
name space management.
Package can be categorized in two form:
1. Built-in package
2. user-defined package.

CREATING USER DEFINED PACKAGES:
• Java package created by user to categorize their project's
classes and interface are known as user-defined packages.
• When creating a package, you should choose a name for the
package.
• Put a package statement with that name at the top of every
source file that contains the classes and interfaces.
• The package statement should be the first line in the source
file.
• There can be only one package statement in each source file

Steps involved in creating user-defined package:
• Include package statement along with the
package name as the first statement in the
program.
• Write class declarations.
• Save the file in this directory as “name of
class.java”.
• Compile this file using java compiler.

Syntax
package packagename;
Class classname
{
………………
}

To create the above package,
1. Create a directory called pack.
2. Open a new file and enter the code given
above.
3. Save the file as class1.java in the directory.
4. A package called pack has now been created
which contains one class class1.

ACCESSING A PACKAGE (using “import” keyword):
• The import keyword is used to make the classes and interface
of another package accessible to the current package.

• There are three ways to access the package
from outside the package.
1. import package.*;
2. import package.classname;
3. fully qualified name.

Using packagename.*
• If you use package.* then all the classes and interfaces of this
package will be accessible but not subpackages.
Using packagename.classname
• If you import package.classname then only declared class of this
package will be accessible.
Using fully qualified name
• If you use fully qualified name then only declared class of this
package will be accessible.
• Now there is no need to import. But you need to use fully qualified
name every time when you are accessing the class or interface.

PACKAGES AND MEMBER ACCESS
• Access level modifiers determine whether
other classes can use a particular field or
invoke a particular method.
• There are two levels of access control:
• At the top level— public, or package-private
At the member level—public, private,
protected, or package-private

Top Level access control:
• A class may be declared with the modifier public, in
which case that class is visible to all classes
everywhere.
• If a class has no modifier (the default, also known
as package-private), it is visible only within its own
package.

Member Level access control:
• public – if a member is declared with public, it is visible
and accessible to all classes everywhere.
• private - The private modifier specifies that the member
can only be accessed in its own class.
• protected - The protected modifier specifies that the
member can only be accessed within its own package
and, in addition, by a subclass of its class in another
package.

INTERFACES
• “interface” is a keyword which is used to achieve full
abstraction. Using interface, we can specify what the class
must do but not how it does.
• An interface is a collection of method definitions (without
implementations) and constant values.
• It is a blueprint of a class.
• It has static constants and abstract methods.

• An interface is similar to a class in the following
ways:
• An interface can contain any number of methods.
• An interface is written in a file with a .java
extension, with the name of the interface matching
the name of the file.
• The bytecode of an interface appears in a .class file.

Where,
• Access_specifer : either public or none.
• Name: name of an interface can be any valid java identifier.
• Variables: They are implicitly public, final and static,
meaning that they cannot be changed by the implementing
class. They must be initialized with a constant value.
• Methods: They are implicitly public and abstract, meaning
that they must be declared without body and defined only by
the implementing class.

Implementing Interfaces (“implements” keyword):
• Once an interface has been defined, one or
more classes can implement that interface.
• 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.

Implementing Interfaces
• The general form of a class that includes the
implements clause looks like this:

Nested Interfaces
• An interface can be declared a member of a
class or another interface.
• Such an interface is called a member interface
or a nested interface.
• A nested interface can be declared as public,
private, or protected.

object oriented programming unit two ppt

Recommended

More Related Content

Similar to object oriented programming unit two ppt (20)

Recently uploaded (20)

object oriented programming unit two ppt