Object oriented programming tutorial

Object Oriented Programming Tutorial
DMA vs SMA
Dynamicmemoryallocationisruntime
Staticmemoryallocationiscompile time
Object Oriented Programming
Object means a real word entity such as pen, chair, table etc. Object-Oriented
Programming is a methodology to design a program using classes and objects. Its main
concepts:
 Object
 Class
 Inheritance
 Polymorphism
 Abstraction
 Encapsulation
Primitive
Primitive data type
Int, float, double Boolean,string…..
Explicitly
Anythingcreate bycustomize call isexplicitly.
Change the type of variable customlly iscall explicitly.
Change the type of variable onruntime iscall explicitly.
Implicitly
Anythingcreate bydefaultcall isimplicitly.
Change the type of variable bycustomlly
Change the type of variable oncompile time iscall explicitly.
Instance
Anythingbelongs toobjectisinstance
An instance is a specific representation of an object,
an instance is a single object that has been created in memory.
Instances have attribute and behaviors of class
Instance:
Students1=new student("Martin");Students2=new student ("Kumar");
s1 and s2 are instances of object student the two are unique.
it can be called as reference also.
Basically the s1 and s2 are variables that are assigned an object
All the objects are instances. All the instances may not be objects. Instances may be
"structure instances" or "objects".
worldclock

Instance
The instance of operator is used to test whether the object is an instance of the specified
type (class or subclass or interface).
The instance of in java is also known as type comparison operator because it compares the
instance with type. It returns either true or false. If we apply the instance of operator with
any variable that has null value, it returns false
Instantiating
any thing point to object is call instantiating
B =new class ()// its call instantiating
an instance (chair 3) is a single unique, specific representation of an object (a chair).
Member
Members are just objects or primitive types belonging to a class
The following table provides an overview of the kinds of members a class can contain.
(Rows for...)
 Constants
 Fields
 Methods
 Properties
 Indexers
 Events
 Operators
 Constructors
 Destructors
 Types
Property
 A propertydescribessome aspectof the object
 Propertiesare away to expose fields, wherefieldsare the actual variables
 Classmembervariablesare called"properties
 Variablesinthe classiscall property
Instance variable
A variable that is created inside the class but outside the method is known as instance
variable. Instance variable doesn't get memory at compile time. It gets memory at runtime
when object (instance) is created. That is why, it is known as instance variable.
current local time

Instance membervariable
Create a variable withoutstatickeyword iscall instance membervariable
Instance membermethod
Create a methodwithout statickeywordis call instance membermethod
Static membervariable or class membervariable
Create a variable withstatickeywordis call classmemberorstaticmembervariable
Static membermethod or class membermethod
Create a method withstatickeywordis call classmemberorstatic membermethod
Object An entity that has state and behavior is known as an object e.g. chair, bike,
marker, pen, table, car etc. It can be physical or logical (tangible and intangible). The
example of intangible object is banking system.
An object has three characteristics:
 State: represents data (value) of an object.
 Behavior: represents the behavior (functionality) of an object such as deposit,
withdraw etc.
 Identity: Object identity is typically implemented via a unique ID. The value of the
ID is not visible to the external user. But, it is used internally by the JVM to identify
each object uniquely.
For Example: Pen is an object. Its name is Reynolds, color is white etc. known as its
state. It is used to write, so writing is its behavior.
Object is an instance of a class. Class is a template or blueprint from which objects
are created. So object is the instance (result) of a class.
Any entity that has state and behavior is known as an object. For example: chair, pen,
table, keyboard, bike etc. It can be physical and logical.
Object is a thing, but instance is a part of a bundle thing. For example, if Car is a class, then
it should contain some of the objects like wheel, steering, door and seat. Now lets come to
the point: an object (wheel) is an instance of the Car
Memory allocated for the member of class at run time is called object or object is the
instance of Class.
Object - An instance of a class that has its own state and access to all of the behaviour
defined by its class.
Objects are instancesof class
Objectiscomplex datastructure
Attribute andbehaviors
Students1=new student("Martin");Students2=new student("Kumar");
The s1, s2 are havingobjectof classStudent

time zone
Anonymous object
Anonymous simply means nameless. An object that have no reference is known as
anonymous object.
If you have to use an object only once, anonymous object is a good approach.
Class
A class is a group of objects that has common properties. It is a template or blueprint
from which objects are created.
A class in java can contain:
 data member
 method
 constructor
 block
 class and interface
Difference between object and class
There are many differences between object and class. A list of differences between object
and class are given below:
No. Object Class
1) Object is an instance of a class. Class is a blueprint or
template from which objects
are created.
2) Object is a real world entity such as pen, laptop,
mobile, bed, keyboard, mouse, chair etc.
Class is a group of similar
objects.
3) Object is a physical entity. Class is a logical entity.

4) Object is created through new keyword mainly
e.g.
Student s1=new Student();
Class is declared using class
keyword e.g.
class Student{}
5) Object is created many times as per requirement. Class is declared once.
6) Object allocates memory when it is created. Class doesn't allocated
memory when it is
created.
7) There are many ways to create object in java
such as new keyword, new Instance() method,
clone() method, factory method and
deserialization.
There is only one way to
define class in java using
class keyword.
Aggregation
If a class have an entity reference, it is known as Aggregation. Aggregation represents HAS-
A relationship.
Consider a situation, Employee object contains many information’s such as id, name, email
ID etc. It contains one more object named address, which contains its own information’s
such as city, state, country, zip code etc
Why use Aggregation?
 For Code Reusability.
When use Aggregation?
 Code reuse is also best achieved by aggregation when there is no is-a relationship.
 Inheritance should be used only if the relationship is-a is maintained throughout the
lifetime of the objects involved; otherwise, aggregation is the best choice.
New keyword
The new keyword is used to allocate memory at runtime.
time change
Static keyword

The static keyword in java is used for memory management mainly. We can apply java
static keyword with variables, methods, blocks and nested class. The static keyword belongs
to the class than instance of the class.
The static can be:
1. variable (also known as class variable)
2. method (also known as class method)
3. block
4. nested class
Staticmean methodandpropertyaccesswithoutCreatingobject.
Staticdoes not belongtoobjectbutbelongtoclass
Static property
Staticproperty In differentname andparametercanhide the property of superclass itscall overridden;
In Staticterm cannothave conceptof overridingbuthave overridingconcept
Accesswayuse classname double colon:: andproperty
Mostlyuse for database connectionandservices.
Staticpropertyisnot boundof object
Staticpropertyischangeable
Staticproperty access insame classmethoduse self:: and otherclassesuse class name::and then
property name
:: this sign is call scope resolution operator
Static Members
A non-static class can contain static methods, fields, properties, or events. The static member is callable on
a class even when no instance of the class has been created. The static member is always accessed by the
class name, not the instance name. Only one copy of a static member exists. Static methods and
properties cannot access non-static fields and events in their containing type, and they cannot access an
instance variable of any object unless it is explicitly passed in a method parameter.
It is more typical to declare a non-static class with some static members, than to declare an entire class as
static. Two common uses of static fields are to keep a count of the number of objects that have been
instantiated, or to store a value that must be shared among all instances.
Static methods can be overloaded but not overridden, because they belong to the class, and not to any
instance of the class.
time difference

Although a field cannot be declared as static const, a const field is essentially static in its behavior. It
belongs to the type, not to instances of the type. Therefore, const fields can be accessed by using the
same ClassName. MemberName notation that is used for static fields. No object instance is required.
Static Block
Static block is mostly used for changing the default values of static variables. This block gets
executed when the class is loaded in the memory.
A class can have multiple Static blocks, which will execute in the same sequence in which
they have been written into the program.
Static Variables
If you declare any variable as static, it is known static variable.
 The static variable can be used to refer the common property of all objects (that is
not unique for each object) e.g. company name of employees, college name of
students etc.
 The static variable gets memory only once in class area at the time of class loading.
 Static variables are also known as Class Variables.
 Such variables get default values based on the data type.
 Data stored in static variables is common for all the objects ( or instances ) of that
Class.
 Memory allocation for such variables only happens once when the class is loaded in the
memory.
 These variables can be accessed in any other class using class name.
 Unlike non-static variables, such variables can be accessed directly in static and non-
static methods.
Static local variable
In function we create a static variable is static local variable
Simple variably function call reputedly but static variable call once
watch time in qlocktwo

Static global or member variable
In class we create a static variable and access it any static method is call static global variable
In class create a variable with static keyword is call static member is call static member variable
and also known as class member variable created only once time in class;
Private static member variable cannot access outside the class
If want to access a private instance then create a public method in same class then assign the
static variable to this method then access the private class
static member method/function
Any method which static keyword is call static member method
static member method created when we don’t need object in the class then we create static
member function
Static functions and variable are used to access Variables/functions in a global scope,
When something is static, it can be accessed anywhere, and is very similar to a procedural
type function
Staticmethodindifferentname andparametercanextend;
In Staticterm cannothave conceptof overridingbuthave overhand concept
Accesswayuse double colon::
Mostlyuse for database connectionandservices.
In staticmethodonlygetstaticproperty
Staticpropertyisnot boundof object
Staticmethodaccessin same class use self-keyword and this sign :: and use class name::
:: this sign is call scope resolution operator
Static Methods
Static Methods can access class variables without using object of the class. It can
access non-static methods and non-static variables by using objects. Static methods
can be accessed directly in static and non-static methods.
If you apply static keyword with any method, it is known as static method.
o A static method belongs to the class rather than object of a class.
o A static method can be invoked without the need for creating an instance of a class.
o static method can access static data member and can change the value of it.
personal worldclock

Restrictions for static method
There are two main restrictions for the static method. They are:
1. The static method cannot use non static data member or call non-static method
directly.
2. this and super cannot be used in static context.
Static Class
Collectionofobjects iscalledclass.Itis a logical entity.
A Classcan be made static onlyif itis a nestedClass.The nestedstaticclasscanbe accessedwithout
havingan objectof outerclass.
Static Classes and Static Members Class
A static class is basically the same as a non-static class, but there is one difference: a static class cannot be
instantiated. In other words, you cannot use the new keyword to create a variable of the class type.
Because there is no instance variable, you access the members of a static class by using the class name
itself.
Creating a static class is therefore basically the same as creating a class that contains only static members
and a private constructor. A private constructor prevents the class from being instantiated. The advantage
of using a static class is that the compiler can check to make sure that no instance members are
accidentally added. The compiler will guarantee that instances of this class cannot be created.
Static classes are sealed and therefore cannot be inherited. They cannot inherit from any class
except Object. Static classes cannot contain an instance constructor; however, they can contain a static
constructor. Non-static classes should also define a static constructor if the class contains static members
that require non-trivial initialization
Static vs non static
2
Memory is allocated for these variable
whenever an object is created
Memory is allocated for these variable at the time
of loading of the class.
3
Memory is allocated multiple time
whenever a new object is created.
Memory is allocated for these variable only once
in the program.
4
Non-static variable also known as
instance variable while because memory
is allocated whenever instance is created.
Memory is allocated at the time of loading of class
so that these are also known as class variable.
5
Non-static variable are specific to an
object
Static variable are common for every object that
means there memory location can be sharable by
every object reference or same class.

6
Non-static variable can access with object
reference.
Syntax
obj_ref.variable_name
Static variable can access with class reference.
Syntax
class_name.variable_name
Final keyword
Final Variable if final variable assign one time value then final variable cannot change the
value and assign value by three way
i during deceleration
ii assign value by block {}
iii assign value by constructer
Final Class final class cannot extend
Final method final method cannot override
The final keyword is used to restrict the user. The java final keyword can be used in many
contexts. Final can be:
1. Variable If you make any variable as final, you cannot change the value of final
variable (It will be constant).
2. Method If you make any class as final, you cannot override it.
3. Class If you make any class as final, you cannot extend it.
The final keyword can be applied with the variables, a final variable that have no value it is
called blank final variable or uninitialized final variable. It can be initialized in the
constructor only. The blank final variable can be static also which will be initialized in the
static block only. We will have detailed learning of these. Let's first learn the basics of final
keyword.
time converter

Is final method inherited?
Ans) Yes, final method is inherited but you cannot override it
What is blank or uninitialized final variable?
A final variable that is not initialized at the time of declaration is known as blank final
variable.
If you want to create a variable that is initialized at the time of creating object and once
initialized may not be changed, it is useful. For example PAN CARD number of an employee
Can we initialize blank final variable?
Yes, but only in constructor
Static blank final variable
A static final variable that is not initialized at the time of declaration is known as static blank
final variable. It can be initialized only in static block.
What is final parameter?
If you declare any parameter as final, you cannot change the value of it.
Can we declare a constructor final?
No, because constructor is never inherited.
This Keyword
There can be a lot of usage of java this keyword. In java, this is areference
variable that refers to the current object.
military time zone

Usage of java this keyword
This keyword is reference variable contain reference (address) of other variable and represent
the caller object this make on call function and destroy on stop function
Here is given the usage of this keyword.
1. This keyword can be used to refer current class instance variable.
2. this() can be used to invoke current class constructor.
3. this keyword can be used to invoke current class method (implicitly)
4. this can be passed as an argument in the method call.
5. this can be passed as argument in the constructor call.
6. this keyword can also be used to return the current class instance
7. If there is ambiguity between the instance variable and parameter, this keyword resolves the
problem of ambiguity.
8. In event handling (or) in a situation where we have to provide reference of a class to
another one
9. We can pass the keyword in the constructor also. It is useful if we have to use one
object in multiple classes
Where this keyword is not required
If local variables (formal arguments) and instance variables are different, there is no
need to use this keyword
this() can be used to invoked current class constructor.
The this () constructor call can be used to invoke the current class constructor (constructor
chaining). This approach is better if you have many constructors in the class and want to
reuse that constructor.
Where to use this () constructor call?
The this () constructor call should be used to reuse the constructor in the constructor. It
maintains the chain between the constructors i.e. it is used for constructor chaining. Let's
see the example given below that displays the actual use of this keyword.
time zones abbreviation

The keyword can be used to invoke current class method
(implicitly).
You may invoke the method of the current class by using the this keyword. If you don't
use the this keyword, compiler automatically adds this keyword while invoking the
method
This keyword can be passed as an argument in the method.
The keyword can also be passed as an argument in the method. It is mainly used in the
event handling
The keyword can be used to return current class instance.
We can return the keyword as an statement from the method. In such case, return type
of the method must be the class type (non-primitive)
Supper keyword
Super keyword is reference variable of parent class;
Call the overridden method by supper keyword
Mostly use in overridden
Call the super class property method then use super keyword
It is use for avoid naming conflict
The super keyword in java is a reference variable that is used to refer immediate parent
class object.
Whenever you create the instance of subclass, an instance of parent class is created
implicitly i.e. referred by super reference variable.
daylight saving time

Usage of java super Keyword
1. Super is used to refer immediate parent class instance variable.
2. super () is used to invoke immediate parent class constructor.
3. Super is used to invoke immediate parent class method.
Super can be used to invoke parent class method
The super keyword can also be used to invoke parent class method. It should be used in
case subclass contains the same method as parent class as in the example given below:
Super keyword is not required
In case there is no method in subclass as parent, there is no need to use super. In the
example given below message () method is invoked from Student class but Student class
does not have message () method, so you can directly call message() method.
Accessspecifier and Access modifier
Access specifier
Theyspecify where avariable canbe accessedfrom.
Access specifier determines the visibility for a certain field / method.
The access specifierdetermineshowaccessible the field
There are 4 types of access specifiers
By using access specifier we define that who one can access our class/method and variable
(or whatever with that we use access specifier ).
Public ,Private, Protected, Default
The public and private are known as access specifiers because they specify the access.
1. public:- Visible to the world,
2. private:- Visible to the class only,
3. protected:- Visible to the package and all subclasses, and
4. default:- Visible to the package
Default
If we not define access modifier with any instance that is call default modifier
Public
Public instance access any where
Protected
Protected instance access in same and child access
Private
Private instance access only same class body
If want to access a private instance then create a public method in same class then assign the
static variable to this method then access the private class
time zones news

Access Modifiers::
Access specifier determines the visibility for a certain field / method.
They specify how variables should (or should not) be accessed;
Final or volatile and/or static and/or transient.
But access modifier are properties of a class/method/variable. Access modifier is five types
1. final:- for finalizing the implementations of classes, methods, and variables
2. static:- for creating class methods and variables
3. Synchronization and volatile modifiers:- which are used for threads
4. abstract:- for creating abstract classes and methods
5. transient
Overbidding
In parent class and child class have (static) method in same name and same parameter with
same static keyword that is call over hiding
Overriding
Method Overriding is when a method defined in a superclass or interface is re-defined by
one of its subclasses, thus modifying/replacing the behavior the superclass provides. The
decision to call an implementation or another is dynamically taken at runtime, depending on
the object the operation is called from. Notice the signature of the method remains the same
when overriding.
If subclass (child class) has the same method as declared in the parent class, it is known
as method overriding in java.
In other words, if subclass provides the specific implementation of the method that has
been provided by one of its parent class, it is known as method overriding.
Changing the behavior of method is overriding.
Overriding use for same method name and parameter if we apply different logic
If we cannot apply overriding then call both method parent and child class method car
Parent class
Function car(int c, int b){
Return gair=a+b;
}
Child class
Function car(int c,int b){
Return gair=a*b;
}
meeting planner

Usage of Java Method Overriding
o Method overriding is used to provide specific implementation of a method that is
already provided by its super class.
o Method overriding is used for runtime polymorphism
Rules for Java Method Overriding
1. method must have same name as in the parent class
2. Method must have same parameter as in the parent class.
3. Must be IS-A relationship (inheritance).
Can we override static method?
No, static method cannot be overridden. It can be proved by runtime polymorphism
Why we cannot override static method?
because static method is bound with class whereas instance method is bound with object.
Static belongs to class area and instance belongs to heap area.
Method Overloading in Java
1. Different ways to overload the method
2. By changing the no. of arguments
3. By changing the data type
4. Why method overloading is not possible by changing the return type
5. Can we overload the main method
6. method overloading with Type Promotion
If a class have multiple methods by same name but different parameters, it is known
as Method Overloading.
If we have to perform only one operation, having same name of the methods increases the
readability of the program.
Suppose you have to perform addition of the given numbers but there can be any number
of arguments, if you write the method such as a(int,int) for two parameters, and
b(int,int,int) for three parameters then it may be difficult for you as well as other
programmers to understand the behavior of the method because its name differs. So, we
perform method overloading to figure out the program quickly.

Advantage of method overloading?
Method overloading increases the readability of the program.
Different ways to overload the method
There are two ways to overload the method in java
1. By changing number of arguments
Why Method Overloading is not possible by changing the return type of method?
In java, method overloading is not possible by changing the return type of the method
because there may occur ambiguity. Let's see how ambiguity may occur:
Can we overload main() method?
Yes, by method overloading. You can have any number of main methods in a class by
method overloading.
Function Overloading
Function overloading gives you the ability to have more than one version of a
function so that it can behave differently according to the context in which and how
it is called.
Operator overloading
When different operations are performedusing the same operator, then it is called operator
overloading.
Operator overloading is a programming language features that allows operators to act differently
depending on the type of data they are operating on
Operators as member functions
Aside from the operators which must be members, operators may be overloaded as member or non-
member functions. The choice of whether or not to overload as a member is up to the programmer.
Operators are generally overloaded as members when they:
1. change the left-hand operand, or
2. require direct access to the non-public parts of an object.
how to dail international call

When an operator is defined as a member, the number of explicit parameters is reduced by one, as
the calling object is implicitly supplied as an operand. Thus, binary operators take one explicit
parameter and unary operators none. In the case of binary operators, the left hand operand is the
calling object, and no type coercion will be done upon it. This is in contrast to non-member
operators, where the left hand operand may be coerced.
Difference between method overloading and
method overriding in java
1. Overloading happens at compile-time while Overriding happens at runtime: The
binding of overloaded method call to its definition has happens at compile-time
however binding of overridden method call to its definition happens at runtime.
2. Static methods can be overloaded which means a class can have more than one static
method of same name. Static methods cannot be overridden, even if you declare a
same static method in child class it has nothing to do with the same method of parent
class.
3. The most basic difference is that overloading is being done in the same class while for
overriding base and child classes are required. Overriding is all about giving a specific
implementation to the inherited method of parent class.
4. Static binding is being used for overloaded methods and dynamic binding is being used
for overridden/overriding methods.
5. Performance: Overloading gives better performance compared to overriding. The
reason is that the binding of overridden methods is being done at runtime.
6. Private and final methods can be overloaded but they cannot be overridden. It means a
class can have more than one private/final methods of same name but a child class
cannot override the private/final methods of their base class.
7. Return type of method does not matter in case of method overloading; it can be same
or different. However in case of method overriding the overriding method can have
more specific return type .
8. Argument list should be different while doing method overloading. Argument list should
be same in method Overriding.

There are many differences between method overloading and method overriding in java. A
list of differences between method overloading and method overriding are given below:
No. Method Overloading Method Overriding
1) Method overloading is used to increase the
Method overriding is used to provide
the specific implementation of the
method that is already provided by its
super class.
2) Method overloading is performed within class. Method overriding occurs in two
classes that have IS-A (inheritance)
relationship.
3) In case of method overloading, parameter must be
different.
In case of method
overriding, parameter must be same.
4) Method overloading is the example of compile time
polymorphism.
Method overriding is the example
of run time polymorphism.
5) In java, method overloading can't be performed by
changing return type of the method only. Return type
can be same or different in method overloading. But
you must have to change the parameter.
Return type must be same or
covariant in method overriding.
CONSTRUCTOR
 A constructor is a special method thatis used to initialize a newly created objectand is called justafter the memory
is allocated for the object.
 It is not mandatoryfor the programmer to write a constructor for the class.If no user defined constructor is provided
for a class,compiler initializes member variables to its defaultvalues.
 Numeric data types are set to 0 .
 char data types are setto null character(0)
 reference variables are setto null

 In order to create a Constructor observe the following rules
1) It has the same name as the class
2) It should notreturn a value not even void
Constructeris instance memberfunctionitcall automaticallywhencall the class instance
Constructoruse for initializationof instance
Objectof any classmake objectby Constructor
In classwe make no constructerthencompilercreate twoconstructercopyand defaultconstructor
If we create ownany constructerthendefaultand copyconstructorcannot create by constructer
If we create any constructerthencompilercreates copy constructer
Constructorisa memberfunctionfunctionof class
The name of constructersame as the name of class;
Constructercannothave returntype
Constructercannota staticbecause itisinstance memberfunction
Constructercall firston execution onprogram
Superclassconstructercall insubclassconstructerbysuperkeyword
In subclasshave parameterizeconstructermusthave superclassconstructer parameterize
Constructor type
Constructerhas three type
i DefaultConstructor
Constructorhas no parameter
Compliercreatedbydefaultwhichbodyhas nocode
ii Parameterize Constructor
Constructorhave parameter
iv Constructor Copy
Copy constructor Compliercreatedbydefaultwhenwe initialize objectof same classthencall
copy constructermustbe objecthave reference type &
iii Constructor overloading
Constructor in java is a special type of method that is used to initialize the object.
Java constructor is invoked at the time of object creation. It constructs the values i.e.
provides data for the object that is why it is known as constructor.
Rules for creating java constructor
There are basically two rules defined for the constructor.
1. Constructor name must be same as its class name
2. Constructor must have no explicit return type
currency exchange rate

Purpose of default constructor?
Default constructor provides the default values to the object like 0, null etc. depending on
the type.
Parameterized constructor
A constructor that has parameters is known as parameterized constructor.
Why use parameterized constructor?
Parameterized constructor is used to provide different values to the distinct objects.
Difference between constructor and method in java
There are many differences between constructors and methods. They are given below.
Java Constructor Java Method
Constructor is used to initialize the state of an
object.
Method is used to expose
behaviour of an object.
Constructor must not have return type. Method must have return type.
Constructor is invoked implicitly. Method is invoked explicitly.
The java compiler provides a default constructor if
you don't have any constructor.
Method is not provided by
compiler in any case.
Constructor name must be same as the class
name.
Method name may or may not be
same as class name.
currency converter

Copy Constructor
There is no copy constructor in java. But, we can copy the values of one object to another
like copy constructor in C++.
There are many ways to copy the values of one object into another in java. They are:
 By constructor
 By assigning the values of one object into another
 By clone() method of Object class
Does constructor return any value?
Ans:yes, that is current class instance (You cannot use return type yet it returns a value).
Can constructor perform other tasks instead of initialization?
Yes, like object creation, starting a thread, calling method etc. You can perform any
operation in the constructor as you perform in the method.
Constructer Channing
Constructorcall on same class Constructoriscall ConstructorChanning;
In same place cannotcontainuse superConstructorand sub Constructor
A class{ __construct(){}}
b class{
__construct a (){ this->__construct()}
__construct t b (){
// firstcall Superconstruct
// thenb construct
//andthena construct
}
 Constructor chaining occurs through the use of inheritance. A subclass constructor
method's first task is to call its super class' constructor method. This ensures that the
creation of the subclass object starts with the initialization of the classes above it in the
inheritance chain.
 there could be any number of classes in an inheritance chain.
 every constructor method will call up the chain until the class at the top has been
reached and initialized. Then each subsequent class below is initialized as the chain
winds back down to the orignal subclass. This process is called constructor chaining.

 Use this() to call another constructor in the same class.
 super () to call another constructor in the super class
 In case we want to call another constructor, this()/super() should be the first line in the
constructor.
CONSTRUCTOR OVERLOADING

Overloading a constructor means typing in multiple versions of the constructor, each
having a different argument list, like the following examples:
?
1
2
3
4
5
6
7
8
9
10
11
class Car
{
Car()
{
}
Car(String s)
{
}
}
holidays and observances

 The preceding Car class has two overloaded constructors, one that takes a string, and
one with no arguments. Because there's no code in the no-arg version, it's actually
identical to the default constructor the compiler supplies, but remember-since there's
already a constructor in this class (the one that takes a string), the compiler won't
supply a default constructor. If you want a no-arg constructor to overload the with-args
version you already have, you're going to have to type it yourself, just as in the Car
example.
 Overloading a constructor is typically used to provide alternate ways for clients to
instantiate objects of your class. For example, if a client knows the Car name, they can
pass that to a Car constructor that takes a string. But if they don't know the name, the
client can call the no-arg constructor and that constructor can supply a default name.
Important points related to Constructor overloading:
1. Constructor overloading is similar to method overloading in Java.
2. You can call overloaded constructor by using this() keyword in Java.
3. Overloaded constructor must be called from another constructor only.
4. Make sure you add no argument default constructor because once compiler will not
add if you have added any constructor in Java.
5. If an overloaded constructor called, it must be first statement of constructor in java.
6. Its best practice to have one primary constructor and let overloaded constructor calls
that. this way your initialization code will be centralized and easier to test and maintain.
Destructor
Destructormake for destroythe resourcesof object
Destructorautomatically call whenclassobjectisdestroy
Destructoris call justbefore whenobjectgoingtodestroy
Destructoris a instance memberfunctionof class
Name of Destructoris same as the name of class
Destructorcan neverbe static
Destructorhas no returntype
Destructortakeson argumenttherefore nooverloadingispossible
Destructoruse for destroythe resources before the objectdestroying
on thisday inhistory

Classa{
__destructor{ firstdestructordestroythe resourcesthendestroyobject}
Obj j=new b();
//resource
}
Constructor and Destructor inheritance
Constructor inheritance
Whenchildclassobject call thenChildclassconstructorcalls the parent class constructor
In inheritance firstcall the constructorof childclassthencall parentclassand execute the parentclass
constructorfirstthenchildclass
If parentclass have parameterize constructerthenwe create constructerinchildclassmustthen child
classconstructor call the parentclass constructorand pass the necessaryparameter
Destructor inheritance
Whenchildclassobjectgoingto destroythen childclassDestructorcall and execute the childclass
constructorcodingthencall the parentclassconstructor call and execute
If we notcreatedown destructorthencompliercreate owndestructorbothparentandchildclass;
If we create owndestructorinchildclassbut not create wondestructorin parentclass the complier
create defaultdestructorinparentclass
Binding
Connecting a method call to the method body is known as binding.
There are two types of binding
1. Static binding (also known as early binding).
2. Dynamic binding (also known as late binding).
Early (or static) binding
All the static, private and final methods have always been bonded at compile-time
Anything that is decided by compiler while compiling can be refer to EARLY/COMPILE
TIME Binding and anything that is to be decided at RUNTIME is
called LATE/RUNTIME binding.
For Example,
Method Overloading and Method Overriding.
1) In Method Overloading your method calls to the methods are decided by the compiler in
the sense that which function is going to be called is decided by your compiler at compile
time. Hence being EARLY BINDING.
2) In method overriding, it is decided at RUNTIME which method is going to be called. So it
is referred as LATE BINDING.
Early binding refers to events that occur at compile time. early binding occurs when all
information needed to call a function is known at compile time
Late binding, or dynamic binding, is a computer programming mechanism in which the
method being called upon an object is looked up by name at runtime

1. Static binding happens at compile-time while dynamic binding happens at
runtime.
2. Binding of private, static and final methods always happen at compile time since
these methods cannot be overridden. Binding of overriddenmethods happen at
runtime.
3. Java uses static binding for overloaded methods and dynamic binding for
overriddenmethods.
What is virtual function?
Virtual function is the member function of a class that can be overridden in its derived class.
It is declared with virtual keyword. Virtual function call is resolved at run-time (dynamic
binding) whereas the non-virtual member functions are resolved at compile time (static
binding).
Virtual Function will have a body and may or may not be overridden by child classes
With "virtual" you get "late binding". Which implementation of the method is used gets
decided at run time based on the type of the pointed-to object - what it was originally
constructed as. This is not necessarily what you'd think based on the type of the pointer that
points to that object.
You can create abstract functions, but you need to declare the parent class as abstract, too:
abstract class Parent {
// no implementation given
abstract public function foo();
}
class Child extends Parent {
public function foo() {
// implementation of foo goes here
}
}
A virtual function can be overridden in a derived class.
A pure virtual function must be overridden in a derived class.
A class with pure virtual functions cannot be instantiated.
united nations days

1. It can be declared inside abstract as well as non abstract class.
2. It contains method implementation.
3. It may be overridden
4. An abstract method is a method that must be implemented to make a concrete class.
The declaration is in the abstract class (and any class with an abstract method must
be an abstract class) and it must be implemented in a concrete class.
5. A virtual method is a method that can be overridden in a derived class using the
override, replacing the behavior in the superclass. If you don't override, you get the
original behavior. If you do, you always get the new behavior. This opposed to not
virtual methods, that cannot be overridden but can hide the original method
6. Basically, you would use a virtual method if you have the 'default' implementation of
it and want to allow descendants to change its behavior.
7. With an abstract method, you force descendants to provide an implementation.
When you have a function in the base class, you can Redefine or Override it in the derived
class.
Redefining a method: A new implementation for the method of base class is given in the
derived class. Does not facilitate Dynamic binding.
Overriding a method: Redefining a virtual method of the base class in the derived class.
Virtual method facilitates Dynamic Binding.
The virtual function provides the ability to define a function in a base class and have a
function of the same name and type in a derived class called when a user calls the base
class function. That is often called run-time polymorphism, dynamic dispatch, or run-time
dispatch because the function called is determined at run time based on the type of the
object used.
The keyword virtual tells the compiler it should not perform early binding. Instead, it should
automatically install all the mechanisms necessary to perform late binding
AbstractFunction:
1. It can be declared only inside abstract class.
2. It contains only method definition not the implementation.
3. It must be overridden
, "An Abstract Method must have to implement in the child class"
** I felt it is like.
foods and drinks days

It is not necessary that an abstract method has to be implemented in a child class, if the
child class is also abstract..
1) An abstract method cant be a private method. 2) An Abstract method cant be
implemented in the same abstract class.
I would say ..if we are implementing an abstract class, you must have to override the
abstract methods from the base abstract class. Because.. Implementing the abstract
method is with override key word .Similar to Virtual method.
It is not necessary for a virtual method to be implemented in an inherited class.
Abstract function cannot have a body and MUST be overridden by child classes
Abstract functionAndVirtual function
An abstract function has no implemention and it can only be declared on an abstract class.
This forces the derived class to provide an implementation. A virtual function provides a
default implementation and it can exist on either an abstract class or a non-abstract class
Abstract method: When a class contains an abstract method, that class must be declared
as abstract. The abstract method has no implementation and thus, classes that derive from
that abstract class, must provide an implementation for this abstract method.
Virtual method: A class can have a virtual method. The virtual method has an
implementation. When you inherit from a class that has a virtual method, you can override
the virtual method and provide additional logic, or replace the logic with your own
implementation.
Virtual method change certain behavior In child class
fun days

INNERCLASS
 Inner classes,also called NestedClasses,are nothing but classes thatare defined within other classes.The
nesting is a relationship between classes,notobjects.
 Inner classes have clearly two benefits,name control & access control.In Java, this benefitis not as important
because Java packages give the name control.
 Java inner classes have feature that makes them richer and more useful.An objectof an inner class has an
implicitreference to the outer class objectthat instantiated it.Through this pointer,it gains access to any variable of
the outer object.Only static inner classes don’thave this pointer.It is actually invisible when we write the code, but
compiler takes care of it. Inner classes are actuallya phenomenon ofthe compiler and notthe JVM.
 Inner classes maybe defined with following access modifiers :public,protected, private, or with default package
access.
The syntax for inner class is as follows:
?
1
2
3
4
[modifiers] class OuterClassName
{
code...
[modifiers] class InnerClassName

5
6
7
8
{
code....
}
}
Inner Classes:
Following properties can be noted about Inner classes:
 The outer class (the class containing the inner class) can instantiate as manynumber of inner classobjects as it
wishes,inside it’s code.
 If the inner class is public & the containing class as well,then code in some other unrelated class can as well
create an instance of the inner class.
 In above case the inner class can be created as follows:
?
1
2
<OuterClassName>outerObj = new <OuterClassName>(arguments);
outerObj.<InnerClassName> innerObj = outerObj.new
<InnerClassName>(arguments);
 No inner class objects are automaticallyinstantiated with an outer class object.
 If the inner class is static, then static inner class can be instantiated withoutan outer class instance,otherwise,
the inner class objectmustbe associated with an instance ofthe outer class.
 Inner class code has free access to all elements ofthe outer class objectthatcontains it, by name (no matter what
the access level of the elements is),ifthe inner class has a variable with same name then the outer class’s variable
can be accessed like this:
<OuterClassName>.this.<variableName>
 The outer class can call even the private methods ofthe inner class.
current weather

Static Inner Classes:
Syntax for static inner classis as follows:
?
1
2
3
4
5
6
7
8
<access-specifier>
class OuterClassName
{
public static class <StaticInnerClassName>
{
}
}
for static inner classes following additional properties hold:
 Static members ofthe outer class are visible to the static inner class,whatever their access level be.
 Non-static members ofthe outer class are notavailable,because there is not instance ofthe outer class.
 An inner class may not have static members unless the inner class is its elfmarked as static.
 Sometimes static nested class are not referred to as inner class atall, as they don’trequire outer classes instance.
 A static inner class is justlike anyother inner class,butit does nothave the reference to its outer class objectthat
generated it.
There are two more types of inner classes, i.e local inner classes & anonymous inner
classes. The local inner class is defined within a method. Anonymous inner classes are
also defined with in a method but have no name.
Local Inner Classes:
Syntax of the local inner class is as follows:
?
1
2
3
<access-specifier>
class <OuterClassName>
{

4
5
6
7
8
9
10
11
12
13
14
15
code...
<access-specifier> <return-type>
<MethodName>(<arguments>)
{
class <LocalInnerClassName>
{
code...
}
code...
}
code...
}
 Local classes are never declared with an access specifier (thatis,public or private). Their scope is always
restricted to the block in which they are declared.
 Local classes have a greatadvantage: they are completelyhidden from the outside world.
 They can not only access the instance variables butlocal variables ofthe method(in which they are defined) as
well,but the local variable has to be declared final.
Wrapper class
Wrapper class provides the mechanism to convert primitive into object and object into
primitive.
Those classwe onlyuse the primitivedatatype everydatatype have ownwrapperclass.
 Java is an object-oriented language and as said everything in java is an object. But what aboutthe primitives? They
are sortof left out in the world of objects,that is,they cannot participate in the objectactivities, such as being
returned from a method as an object, and being added to a Collection of objects,etc. . As a solution to this problem,
Java allows you to include the primitives in the familyof objects by using whatare called wrapper classes.
 There is a wrapper class for every primitive date type in Java. This class encapsulates a single value for the
primitive data type. For instance the wrapper class for intis Integer, for float is Float, and so on. Remember thatthe
primitive name is simplythe lowercase name ofthe wrapper except for char, which maps to Character,and int,
which maps to Integer.
worldwide weather

 The wrapper classes in the Java API serve two primary purposes:
 To provide a mechanism to “wrap” primitive values in an objectso that the primitives can be included in activities
reserved for objects,like as being added to Collections,or returned from a method with an objectreturn value.
 To provide an assortmentof utility functions for primitives.Most of these functions are related to various
conversions:converting primitives to and from String objects,and converting primitives and String objects to and
from different bases (or radix), such as binary, octal, and hexadecimal.
 The wrapper objectof a wrapper class can be created in one of two ways: by instantiating the wrapper class with
the new operator or by invoking a static method on the wrapper class.We will explore this further in this article.
ABSTRACT CLASS
 An abstractclass is something which is not concrete,something which is incomplete.
 Abstract class specifies whatfunctionalityis provided but not how that functionalityis provided.
 An abstractclass is a class thatis declared abstract.
 Abstract class mayor may not include abstractmethods.
 Abstract classes cannotbe instantiated,butthey can be sub-classed.
 An abstractmethod is a method that is declared withoutan implementation (withoutbraces,and followed bya
semicolon),like this:
 abstractvoid move To(double X, double Y);
 An abstractMethod doesn'thave method body.
 Use abstraction ifyou know something needs to be in class butimplementation ofthat varies. e.g for Human class
you know there will be eating method buteating method implementation will be differentfor different country.
 If you declare any method in class as abstract,you have declare class also as abstract.
sunrise and sunsettimes

 Abstract Class can contain abstractas well as non-abstractmethod.
 Eg.
?
package in.java4all.abstractclass;
public abstract class AbstractClasswithNonAbstractMethod {
abstract void abstractmethod();
public void nonabstractmethod(){
System.out.println("Abstract Class can hold non-abstract Method also");
}
}
moonphases

 A class can be declared abstractwithoutany abstractmethod also.
?
1
2
3
4
5
6
7
8
9
10
11
package in.java4all.abstractclass;
public abstract class AbstractClassWithoutAbstractMethod {
public void nonabstractmethod(){
System.out.println("Abstract Class can be declared without any abstract metho
}
public static void main(String[] args){
System.out.println("Main Method can be decalred inside Abstract Class");
}
}
 Abstract Class cannotbe instantiated.
eclipses

 Whichever concrete Class extends Abstract Class mustimplementabstractmethods ofthe class.
 When to Use Abstract Class?
o The purpose ofan abstractclass is to specify the defaultfunctionality of an objectand let its sub-classes to
explicitly implementthatfunctionality.
o Suppose we were modeling the behavior of Human,by creating a class hierarchythat started with a base class
called Human.
o Human are capable ofdoing different things like seeing,sleeping and walking,butthere are some common
operations as well like eating and speaking.
o Some common operations are performed byall human,butin a differentway as well.
o When an operation (behavior) is performed in a different way, it is a good candidate for an abstractmethod (forcing
subclasses to provide a custom implementation).
o Let's look at a very primitive Human base class,which defines an abstractmethod for making a speaking (such as
French speaking French,an Indian Speaking Hindi,or an American speaking English).
Solstice and Equinox times

1
2
3
4
5
6
7
8
9
10
11
12
13
public abstract Human
{
public void eating(Food food)
{
// do something with food....
}
public void sleeping (int hours)
{
// do something with sleeping
}
public abstract void speaking();
}
o Now, any Human that wants to be instantiated (like a Indian or American) mustimplementthe speaking method -
otherwise itis impossible to create an instance ofthat class.
o Let's look at a Indian and American subclass thatextends the Animal class.
?
2
3
4
5
public American extends Animal
{
public void speaking() {
System.out.println ("English English");
}
}
sunrise and sunsettimes

 Why we cannotinstantiate Abstract class in java?
o If the class had everything necessaryto constructa meaningful object,the author wouldn't have declared it
abstract.
o The whole definition of"abstract class"is thatit is an incompletelyimplemented parent,and therefore instances
wouldn'tmake sense.
o An Abstract class mayor may not have abstractmethods.
o So in that case JVM does notknow how much memoryit has to allocate for that abstractmethod because abstract
method does nothave body implementation.
o So JVM will not able to allocate memoryfor the abstractmethods when the time ofcreating instance to Abstract
class.
o So JVM unable to create the instance to Abstract class.So that we can't create the objectfor the Abstract class.
o It is also possible thatwe can create an Abstract class with all concrete methods,thatis without any abstract
methods also.
o In that case also we can't create the instance for the Abstract class.
o Why because the abstractkeyword simplyindicates to JVM that the class cannotbe instantiated.
o The designers ofJava made the JVM that when it find abstractkeyword for any class then JVM can't create the
instance for that class.
INTERFACE
 An interface in the Java programming language is an abstracttype that is used to specify an interface classes
mustimplement.Interfaces are declared using the interface keyword, and may only contain signature and constant
declarations (variable declarations thatare declared to be both static and final. An interface may never contain
method definitions.
 Interfaces cannotbe instantiated,butrather are implemented.A class thatimplements an interface mustimplement
all of the methods described in the interface, or be an abstractclass.
 As you've already learned,objects define their interaction with the outside world through the methods thatthey
expose.Methods form the object's interface with the outside world;the buttons on the front of your television set,for
example,are the interface between you and the electrical wiring on the other side ofits plastic casing.You press
the "power" button to turn the television on and off.
?
1
2
3
interface Interface
{
void test1();
abstract void test2();

4
5
6
public abstract void test3();
}
O/P: Compile successful .
Note :Inside a interface all methods are Abstract & Public by default.
Ex.2
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
interface Interface1
{
void test1();
}
interface Interface2
{
void test2();
}
interface Interface3 extends Interface1,Interface2
{
void test3();
}
class A implements Interface3 /* All methods in the interface
must be implemented within a class.*/
{
public void test1()
{
System.out.println("test1");
}
public void test2()

18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
{
}
public void test3()
{
}
}
class InterfaceMain
{
public static void main(String[] args)
{
A d1 = new A();
d1.test1();
d1.test2();
d1.test3();
System.out.println("done");
}
}
moonrise and moonset times

O/P:
Note: An interface can't inherit from a class in Java but only we can implements.
Concrete Class
A concrete class is a class that can be used to create an object. An abstract class cannot
be used to create an object (you must extend an abstract class and make a concrete class
to be able to then create an object).
if we override all pure virtual function in derived class then it becomes concrete class
The object of these classes can be created
An abstract class is meant to be used as the base class from which other classes are derived.
The derived class is expected to provide implementations for the methods that are not
implemented in the base class. A derived class that implements all the missing functionality is
called a concrete class.
A concrete class in java is any such class which has implementation of all of its inherited
members either from interface or abstract class.
Concrete and Abstract are opposite of each other. So let me tell you something about
abstract classes so that you can easily understand Concrete Classes
Abstract Class
An Abstract Class is a class that has one or more pure virtual member functions. You
cannot make an object (instance) of an Abstract Class
Without "virtual" you get "early binding". Which implementation of the method is used gets
decided at compile time based on the type of the pointer that you call through.
Abstract classes whose object can’t be created are call abstract class.
If a class has multiple methods by same name but different parameters, it is known
as Method Overloading.
distance between cities

If we have to perform only one operation, having same name of the methods increases the
Suppose you have to perform addition of the given numbers but there can be any number
of arguments, if you write the method such as a(int,int) for two parameters, and
b(int,int,int) for three parameters then it may be difficult for you as well as other
programmers to understand the behavior of the method because its name differs. So, we
perform method overloading to figure out the program quickly.
These are just used for inheritance
If we create any pure virtual function in class then it becomes abstract class
1. Are incomplete classes and it must be sub classed in order to use
2. Must be Followed by abstract keyword
3. Must have at least Zero or more abstract method(Method which does not have body)
Advantage of method overloading?
Method overloading increases the readability of the program.
Different ways to overload the method
There are two ways to overload the method in java
1. By changing number of arguments
Abstract and Concrete Classes
All classes can be designated as either abstract or concrete. Concrete is the default. This means
that the class can have (direct) instances. In contrast, abstract means that a class cannot have
its own (direct) instances. Abstract classes exist purely to generalize common behavior that
would otherwise be duplicated across (sub)classes. We'll illustrate this with the following
diagram.
calendars

Concrete classes that can be instantiated; abstract classes cannot directly be instantiated.
Abstract Classand Concrete Class
Abstract classes are super classes which contain abstract methods and are defined such that concrete
subclasses are to extend them by implementing the methods Abstract class cannot be used to
create an object. Whereas, concrete class can be used to create an object.
Concrete means’ ‘existing in reality or in real experience; perceptible by the senses; real''.
Whereas, abstract means 'not applied or practical; theoretical'.
An abstract class can't be instantiated. Whereas, a concrete one can.
An abstract class is one that has one or more pure virtual function. Whereas
a concrete class has no pure virtual functions
1. Only abstract classes can have abstract members.
2. A non-abstract class that inherits from an abstract class must override its abstract
members.
3. An abstract member is implicitly virtual.
4. An abstract member cannot provide any implementation (abstract is called pure
virtual in some languages).
derived class and concrete class
Base-class vs. derived class is an orthogonal concept to abstract class vs. concrete class.
A base class is one that does not inherit from any other class. A derived class does inherit
from another class.
An abstract class is one that has one or more pure virtual functions. A concrete class has
no pure virtual.
An abstract class can be either a base class or a derived class (it is derived from another
abstract class). A concrete class can also be either base or derived. You can even derive
an abstract class from a concrete class, by adding a pure virtual function to the derived
class. But in general use, there is one base abstract class and one or more concrete
derived classes.
Concrete class has all its method implemented
calendars today date

Interface Class
An interface in java is a blueprint of a class. It has static constants and abstract methods
only.
The interface in java is a mechanism to achieve fully abstraction. There can be only
abstract methods in the java interface not method body. It is used to achieve fully
abstraction and multiple inheritance in Java.
Java Interface also represents IS-A relationship.
It cannot be instantiated just like abstract class.
Why use Java interface?
There are mainly three reasons to use interface. They are given below.
 It is used to achieve fully abstraction.
 By interface, we can support the functionality of multiple inheritance.
 It can be used to achieve loose coupling
Multiple inheritance is not supported through class in java but it is
possible by interface, why?
As we have explained in the inheritance chapter, multiple inheritance is not supported in
case of class. But it is supported in case of interface because there is no ambiguity as
implementation is provided by the implementation class
Difference Between Interface and Abstract Class
"An interface is a contract: the guy writing the interface says, "hey, I accept things looking
that way", and the guy using the interface says "OK, the class I write looks that way".
An interface is an empty shell, there are only the signatures (name / params / return
type) of the methods. The methods do not contain anything. The interface can't do
anything. It's just a pattern."
printable calendar

Difference between abstract class and interface
Abstract class and interface both are used to achieve abstraction where we can declare the
abstract methods. Abstract class and interface both can't be instantiated.
But there are many differences between abstract class and interface that are given below.
Abstract class Interface
1) Abstract class can have abstract and
non-abstract methods.
Interface can have only
abstract methods.
2) Abstract class doesn't support multiple
inheritance.
Interface supports multiple inheritance.
3) Abstract class can have final, non-final,
static and non-static variables.
Interface has only static and final
variables.
4) Abstract class can have static methods,
main method and constructor.
Interface can't have static methods,
main method or constructor.
5) Abstract class can provide the
implementation of interface.
Interface can't provide the
implementation of abstract class.
6) The abstract keyword is used to declare
abstract class.
The interface keyword is used to declare
interface.
7) Example:
public abstract class Shape{
public abstract void draw();
}
Example:
public interface Drawable{
void draw();
}
timers

Concrete class vs. Abstract class vs. Interface.
1. A concrete class has concrete methods, i.e., with code and other functionality. This class
a may extend an abstract class or implements an interface.
2. An abstract class must contain at least one abstract method with zero or more concrete
methods
3. An interface must contain only method signatures and static members.
4. An interface does not have definitions of the methods declared in it.
5. An abstract class may have some definition and at least one abstract method.
6. A subclass of an abstract class must either implement all the abstract methods of the
abstract class or declare itself as abstract.
Inheritance
Inheritance in java is a mechanism in which one object acquires all the properties and
behaviors of parent object.
The idea behind inheritance in java is that you can create new classes that are built upon
existing classes. When you inherit from an existing class, you can reuse methods and fields
of parent class, and you can add new methods and fields also.
Inheritance represents the IS-A relationship, also known as parent-child relationship.
The extends keyword indicates that you are making a new class that derives from an
existing class.
In the terminology of Java, a class that is inherited is called a super class. The new class is
called a subclass.
Why use inheritance in java
 For Method Overriding (so runtime polymorphism can be achieved).
 For Code Reusability.
alarm clock

Types of inheritance in java
On the basis of class, there can be five types of inheritance in java: single, multilevel and
hierarchical multiple and hybrid
Abstraction
Hiding internal details and showing functionality is known as abstraction. For
example: phone call, we don't know the internal processing. We use abstract class and
interface to achieve abstraction.
 Abstraction is the concept of hiding irrelevant details.In other words make complexsystem simple byhiding the
unnecessarydetail from the user.
 Abstract class specifies whatfunctionalityis provided but not how that functionalityis provided.
 For example one does not want to understand how engine works.Similarlyone does not have to understand the
internal implementation ofthe software objects.
 Abstraction provides a way to hide the less essential properties so as to reduce complexity and increase efficiency.
Abstraction advantage
Abstraction main advantage is that every user will get data according to their exact requirement.User will notget
confused with unnecessarydata.
Abstraction in Java or Object oriented programming is a wayto segregate implementation from interface.
Abstraction in Java is achieved by using interface and abstractclass in Java.
An interface or abstractclass is something which is notconcrete , something which is incomplete.
stopwatch

Encapsulation
Binding (or wrapping) code and data together into a single unit is known as
encapsulation. For example: capsule, it is wrapped with different medicines.
Encapsulation: Is hiding unwanted/un-expected/propriety implementation details from the
actual users of object
A java class is the example of encapsulation. Java bean is the fully encapsulated class
because all the data members are private here
Encapsulation in java is a process of wrapping code and data together into a single unit ,
for example capsule i.e. mixed of several medicines.
We can create a fully encapsulated class in java by making all the data members of the
class private. Now we can use setter and getter methods to set and get the data in it.
 Encapsulation is the technique ofmaking the fields in a class private and providing access to the fields through
public methods.Encapsulation is also called as data hiding.
 The benefits of encapsulation:
 The ability to modify our implemented code withoutbreaking the code of others who use our code
 Encapsulation gives maintainability,flexibility, and extensibility to our code.
 The fields of a class can be made read-onlyor write-only.
 A class can have total control over of whatis stored in its fields.
 A class can change the data type of a field,and users ofthe class do notneed to the changes anyo f theircode.
Advantage of Encapsulation in java
By providing only setter or getter method, you can make the class read-only or write-
only.
countdown

It provides you the control over the data. Suppose you want to set the value of id i.e.
greater than 100 only, you can write the logic inside the setter method.
Abstraction : Abstraction means to show What part of functionality.
Encapsulation : Encapsulation means to hide the How part of the functionality.
Encapsulation is the packing of data and functions operating on that data into a single
component and restricting the access to some of the object's components.
Encapsulation means that the internal representation of an object is generally hidden from
view outside of the object's definition.
Abstraction is a mechanism which represent the essential features without including
implementation details.
Encapsulation:-- Information hiding.
Abstraction:-- Implementation hiding.
Encapsulation is wrapping up complexity in one capsule
Example:
class foo{
private:
int a, b;
public:
foo(): a(0), b(0)
{ }
foo(int x, int y): a(x), b(y)
{ }
int add()
{
return a+b;
}
}
Internal representation of any object of foo class is hidden outside the class. -->
Encapsulation.
foo foo_obj(3, 4);
int sum = foo_obj.add();
Implementation of method add is hidden. --> Abstraction.
Use of foo_obj object above is also an example of abstraction as it is used without any
details of its implementation.
Abstraction--- Hiding Implementation--at Design---Using Interface/Abstract classes
Encapsulation--Hiding Data --At Development---Using access modifiers(public/private)
new year countdown

Encapsulation is -
 Hiding Complexity,
 Binding Data and Function together,
 Making Complicated Method's Private,
 Making Instance Variable's Private,
 Hiding Unnecessary Data and Functions from End User.
Encapsulation implements Abstraction.
And Abstraction is -
 Showing What’s Necessary,
 Data needs to abstract from End User,
Encapsulation is the ability to treat something as a single thing, even though it may be
composed of many complex parts or ideas. For example, I can say that I'm sitting in a
"chair" rather than referring to the many various parts of that chair each with a specific
design and function, all fitting together precisely for the purpose of comfortably holding my
butt a few feet away from the floor.
Abstraction is enabled by encapsulation. Because we encapsulate objects, we can think
about them as things which relate to each other in some way rather than getting bogged
down in the subtle details of internal object structure. Abstraction is the ability to consider
the bigger picture, removed from concern over little details. The root of the word is abstract
as in the summary that appears at the top of a scholarly paper, not abstract as in a class
which can only be instantiated as a derived subclass.
I can honestly say that when I plop my butt down in my chair, I never think about how the
structure of that chair will catch and hold my weight. It's a decent enough chair that I don't
have to worry about those details. So I can turn my attention toward my computer. And
again, I don't think about the component parts of my computer. I'm just looking at a part of a
webpage that represents a text area that I can type in, and I'm communicating in words,
barely even thinking about how my fingers always find the right letters so quickly on the
keyboard, and how the connection is ultimately made between tapping these keys and
posting to this forum. This is the great power of abstraction. Because the lower levels of the
system can be trusted to work with consistency and precision, we have attention to spare
for greater work.
week number

Data Encapsulation simply means wrapping and controlling access of logically grouped
data in a class. It is generally associated with another keyword
A simple example would be defining a private variable and giving access to it using getter
and setter methods or making a method private as it's only use is withing the class. There is
no need for user to know about these methods and variables.
Note : It should not be misunderstood that encapsulation is all about data hiding only. When
we say encapsulation, emphasis should be on grouping or packaging or bundling related
data and behavior together.
Data Abstraction on the other hand is concept of generalizing so that the underneath
complex logic is not exposed to the user. In Java this is achieved by
using interfaces and abstract classes.
Example -
Lets say we have an interface Animal and it has a function makeSound(). There are two
concrete classes Dog and Cat that implement this interface. These concrete classes have
separate implementations of makeSound() function. Now lets say we have a animal(We get
this from some external module). All user knows is that the object that it is receiving is some
Animal and it is the users responsibility to print the animal sound. One brute force way is to
check the object received to identify it's type, then typecast it to that Animal type and
then call makeSound() on it. But a neater way is to abstracts thing out. Use Animal as
a polymorphic reference and call make Sound() on it. At runtime depending on what the
real Object type is proper function will be invoked.
Abstractionis generalized term.i.e.Encapsulationissubsetof Abstraction.
day factscalculator

weekdays calculator

Difference Between Abstraction and Encapsulation.
Abstraction Encapsulation
1. Abstraction solves the problem in
the design level.
1. Encapsulation solves the problem
in the implementation level.
2. Abstraction is used for hiding the
unwanted data and giving relevant
data.
2. Encapsulation means hiding the
code and data into a single unit to
protect the data from outside world.
3. Abstraction lets you focus on
what the object does instead of how
it does it
3. Encapsulation means hiding the
internal details or mechanics of how
an object does something.
4. Abstraction- Outer layout, used
in terms of design.
4. Encapsulation- Inner layout,
used in terms of implementation.

For Example:-
Outer Look of a Mobile Phone, like
it has a display screen and keypad
buttons to dial a number.
For Example:- Inner
Implementation detail of a Mobile
Phone, how keypad button and
Display Screen are connect with
each other using circuits.
Abstraction refers to the act of representing essential features without including the
background details or explanations.
Encapsulation is a technique used for hiding the properties and behaviors of an object and
allowing outside access only as appropriate. It prevents other objects from directly altering
or accessing the properties or methods of the encapsulated object.
Difference between abstraction and encapsulation
1.Abstraction focuses on the outside view of an object (i.e. the interface) Encapsulation
(information hiding) prevents clients from seeing it’s inside view, where the behavior of the
abstraction is implemented.
2.Abstraction solves the problem in the design side while Encapsulation is the
Implementation.
3.Encapsulation is the deliverable of Abstraction. Encapsulation barely talks about grouping
up your abstraction to suit the developer needs
Abstraction : Abstraction is process in which you collect or gather relevant data and
remove non-relevant data. (And if you have achieved abstraction, then encapsulation also
achieved.)
Encapsulation: Encapsulation is a process in which you wrap of functions and members in
a single unit. Means You are hiding the implementation detail. Means user can access by
making object of class, he/she can't see detail.
Difference between Abstraction and Encapsulation :-
Abstraction
1. Abstraction solves the problem in the design level.
2. Abstraction is used for hiding the unwanted data and giving relevant data.
3. Abstraction lets you focus on what the object does instead of how it does it.
4. Abstraction- Outer layout, used in terms of design. For Example:- Outer Look of a
Mobile Phone, like it has a display screen and keypad buttons to dial a number.
business days calculator

Encapsulation
1. Encapsulation solves the problem in the implementation level.
2. Encapsulation means hiding the code and data into a single unit to protect the data
from outside world.
3. Encapsulation means hiding the internal details or mechanics of how an object does
something.
4. Encapsulation- Inner layout, used in terms of implementation. For Example:- Inner
Implementation detail of a Mobile Phone, how keypad button and Display Screen are
connect with each other using circuits
Real Life Difference Between Encapsulation and Abstraction
Encapsulate means to hide. Encapsulation is also called data hiding.You can think
Encapsulation like a capsule (medicine tablet) which hides medicine inside it. Encapsulation
is wrapping, just hiding properties and methods. Encapsulation is used for hide the code
and data in a single unit to protect the data from the outside the world. Class is the best
example of encapsulation.
Abstraction refers to showing only the necessary details to the intended user. As the name
suggests, abstraction is the "abstract form of anything". We use abstraction in programming
languages to make abstract class. Abstract class represents abstract view of methods and
properties of class.
Implementation Difference Between Encapsulation and Abstraction
1. Abstraction is implemented using interface and abstract class while Encapsulation is
implemented using private and protected access modifier.
2. OOPS makes use of encapsulation to enforce the integrity of a type (i.e. to make sure
data is used in an appropriate manner) by preventing programmers from accessing
data in a non-intended manner. Through encapsulation, only a predetermined group of
functions can access the data. The collective term for datatypes and operations
(methods) bundled together with access restrictions (public/private, etc.) is a class.
date duration calculator

DIFFERENCE BETWEEN ENCAPSULATION AND
ABSTRACTION
 Abstraction and Encapsulation in Java are two important Object oriented programming
concept and they are completely different to each other.
 Encapsulation is a process of binding or wrapping the data and the codes that
operates on the data into a single entity. This keeps the data safe from outside
interface and misuse.
age calculator

 Abstraction is the concept of hiding irrelevant details. In other words make complex
system simple by hiding the unnecessary detail from the user.
 Abstraction is implemented in Java using interface and abstract class while
Encapsulation is implemented using private, package-private and protected access
modifier.
Polymorphism can be achieved through overriding. Put in short words, polymorphism refers
to the ability of an object to provide different behaviors (use different implementations)
depending on its own nature. Specifically, depending on its position in the class hierarchy.
Inheritance
 Polymorphism is an importantObjectOriented conceptand widelyused in all Object Oriented Programming
Language.
 Polymorphism word comes from ancientGreek where poly means many.Polymorphism means manyform.
 Polymorphism in Java means same objectbehave differentlyin different place.
 For e.g Lady is one of the example polymorphism.Same Ladyobjectwill be behave differently when she is sister,
wife and mother.
Polymorphism in java is a concept by which we can perform a single action by different
ways. Polymorphism is derived from 2 Greek words: poly and morphs. The word "poly"
means many and "morphs" means forms. So polymorphism means many forms.
There are two types of polymorphism in java: compile time polymorphism and runtime
polymorphism. We can perform polymorphism in java by method overloading and method
overriding.
If you overload static method in java, it is the example of compile time polymorphism. Here,
we will focus on runtime polymorphism in java.
Polymorphism means more than one form, same object performing different operations
according to the requirement.
Polymorphism can be achieved by using two ways, those are
1. Method overriding
2. Method overloading
date calculator

Method overloading means writing two are or more methods in the same class by using
same method name, but passing the parameters is different.
Method overriding means we use the method names in the different classes, that means
parent class method is used in the child class.
Actually, there are multiple forms of polymorphism and there is quite some controversy over
it; you may even see CS professors who cannot define it properly. I am aware of three
types:
 ad-hoc polymorphism (looks like a duck and walks like a duck => is a duck). Can be
seen in Haskell and Python for example.
 generic polymorphism (where a type is an instance of some generic type). Can be seen
in C++ for example (vector of int and vector of string both have a member function
size).
 subtype polymorphism (where a type inherits from another type). Can be seen in most
OO programming languages (i.e. Triangle is a Shape).
ad hoc polymorphism
ad hoc polymorphism is the act of providing multiple implementations of the same method
for different parameter types. In OOP, it's generally known as method overloading. For
example:
public String format(int a) {
return String.format("%2d", a);
}
public String format(Date a) {
return new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'").format(a);
}
Both format methods share a single interface but work on entities of different types.
Parametric polymorphism
Parametric polymorphism is the act of making a class (or method) work on a type that is
itself a parameter of the class (or method). It's often referred to as generics.
For example, Java's List[T] expects a parameter T at instantiation time, and this parameter
defines the type of the resulting object.
Note for purists that I'm purposefully ignoring raw types as I feel they'd just muddy the
waters in this context.
List[String] and List[Date] share a single interface, but work on (and are) different types.
Subtype polymorphism
Subtype polymorphism is probably what you initially meant in your question: it's the act of
providing a single interface to multiple implementations of the same type.
To use the customary example: Animal provides a contract that all implementations must
respect. Dog is an Animal, and as such supports all operations that Animal declares.
According to the Liskov substitution principle, this allows you to use an instance
of Dog where an instance of Animal is expected (but not the other way around).

If Cat and Dog are both subclasses of Animal, then they share a single interface but are in
fact different types.
I'm going off in a bit of a tangent here, but subtype polymorphism is (I think) the only one
that allows overriding: the act of redefining the behavior of a method defined by a parent
class. This is often confused with overloading which, as we saw before, is a type of
polymorphism and doesn't in fact need sub classing (nor does it need classes, really).
There are two kinds of polymorphism :
1. Compile Time (Static) Polymorphism or (Ad Hoc) Polymorphism.
that is simply Method Overloading and Operator overloading
2. Run Time or (Dynamic) Polymorphism.
The first Term is inherited from The java and C++ terminology.
But in the .Net terminology only the second one (I mean Run Time Polymorphism) is
really supposed as Polymorphism and simply called as Polymorphism.
And as far as I know there are three methods for implementing (Run Time) Polymorphism.
1. Parametric Polymorphism or simply the use of Generics(Templates in c++).
2. Inheritance-Based Polymorphism or Subtyping.
3. Interface-Based Polymorphism.
 There are two kind of polymorphism
 Compile time polymorphism (static binding or method overloading)
 Runtime polymorphism (dynamic binding or method overriding)
 Compile time polymorphism (static binding or method overloading)
 In this flow of the method will be decided the compile time ofthe code.
 Method Overloading
o When Java Programmer declare two methods ofthe same name butwith differentsignature in a same class,this
conceptis called as Method overloading.
Different signature means change in number ofarguments or change in type of arguments.
o System.out.println() is popular example ofmethod overloading because printly() method takes string,int,floator any
other data type.
 Few points Method Overloading
o Overloaded method are loaded and bonded at compile time.
o Overloaded methods are fastbecause they bonded at compile time.
hijrahi holidays

 What do you mean by different method signature for method Overloading in Java
o If number ofargumentis different.
o If type of argumentis different.
o If sequence ofargumentis different,only when arguments ofdifferenttypes
Runtime Polymorphism in Java
Class A{
void method(int a, string x){
}
void method(string x,int a){
}
Runtime polymorphism or Dynamic Method Dispatch is a process in which a call to an
overridden method is resolved at runtime rather than compile-time.
In this process, an overridden method is called through the reference variable of a
superclass. The determination of the method to be called is based on the object being
referred to by the reference variable.
Runtime Polymorphism with data member
Method is overridden not the data members, so runtime polymorphism can't be achieved
by data members.
In the example given below, both the classes have a data member speed limit, we are
accessing the data member by the reference variable of Parent class which refers to the
subclass object. Since we are accessing the data member which is not overridden, hence
it will access the data member of Parent class always.
christian holidays

Runtime Polymorphism with Multilevel Inheritance
1. class Animal{
2. void eat(){System.out.println("eating");}
3. }
4.
5. class Dog extends Animal{
6. void eat(){System.out.println("eating fruits");}
7. }
8.
9. class BabyDog extends Dog{
10. void eat(){System.out.println("drinking milk");}
11.
12. public static void main(String args[]){
13. Animal a1,a2,a3;
14. a1=new Animal();
15. a2=new Dog();
16. a3=new BabyDog();
17.
18. a1.eat();
19. a2.eat();
20. a3.eat();
21. }
22. }
Chinese holidays

Object oriented programming tutorial

More Related Content

What's hot

Similar to Object oriented programming tutorial

Recently uploaded

Object oriented programming tutorial