Oops (inheritance&interface)

Main Concepts of OOP
• Encapsulation
• Inheritance
• Polymorphism
• Abstraction

Encapsulation
• Encapsulation is the technique of making the fields in a
class private and providing access to the fields via
public methods.
• The main benefit of encapsulation is the ability to
modify our implemented code without breaking the
code of others who use our code.
• Encapsulation gives maintainability, flexibility and
extensibility to our code.

Access Specifiers in java
• public
• private
• protected
• Default

Public access specifier
• A class, method, constructor, interface etc., declared
public can be accessed from any other class.
• Therefore fields, methods, blocks declared inside a
public class can be accessed from any class belonging
to the Java Universe.
• If the public class we are trying to access is in a
different package, then the public class still need to be
imported.

Private access specifiers
• Methods, Variables and Constructors that are declared private
can only be accessed within the declared class itself.
• Private access modifier is the most restrictive access level.
Class and interfaces cannot be private.
• Variables that are declared private can be accessed outside
the class if public getter methods are present in the class.
• Using the private modifier is the main way that an object
encapsulates itself and hide data from the outside world.

Sample code for private access
specifier

Protected access specifier
• Variables, methods and constructors which are declared
protected in a superclass can be accessed only by the
subclasses in other package or any class within the
package of the protected members' class.
• The protected access modifier cannot be applied to
class and interfaces. Methods, fields can be declared
protected, however methods and fields in a interface
cannot be declared protected.

Sample code for protected access
specifier

Default specifier
• The default specifier is used to make a class visible to
all the other classes in its package but not visible to
classes from other packages

Inheritance
• Inheritance is a compile-time mechanism in Java that
allows you to extend a class with another class
• The keyword extends is used for inheriting a Class.
• The class which extends some other class is called as
derived class
• The base class is called as the super class or parent
class.

Types of inheritance
• Simple inheritance
• Multilevel inheritance
• Hierarchical inheritance
• Hybrid inheritance

Simple inheritance
• There are only 1 base class and 1 derived class
• Syntax:
Class Parentclass
{
}
Class Dclass extendsParentclass
{
}

Simple inheritance sample code and
output

Multilevel inheritance
• It contains derived classes which are in turn base class to another class.
class Base
{
}
class Derived1 extends Base
{
}
class Derived2 extends Derived1
{
}

Multilevel inheritance sample code
and output

Hierarchical inheritance
• It contains one base class and more than one derived class.
class Base
{
}
class Derived1 extends Base
{
}
class Derived2 extends Base{ }

Sample code and output for
Hierarchical inheritance

Hybrid inheritance
• It is a combination of any two or more inheritances.

Sample code for hybrid inheritance

Interface
• An interface in Java is similar to a class, but the body of
an interface can include only abstract methods and final
fields (constants).
• A class implements an interface by providing code for
each method declared by the interface.
• The keyword used in interface concepts are interface
and implements

Syntax for interface
interface interfacename
{
method_declaration();
}
class A implements interfacename
{
method_declaration(){ }
}

Oops (inheritance&interface)

More Related Content

What's hot (20)

Viewers also liked (12)

Similar to Oops (inheritance&interface) (20)

More from Muthukumaran Subramanian (17)

Recently uploaded (20)

Oops (inheritance&interface)