Professional Documents
Culture Documents
Oops Notes
Oops Notes
Uploaded by
Selva612Copyright
Available Formats
Share this document
Did you find this document useful?
Is this content inappropriate?
Report this DocumentCopyright:
Available Formats
Oops Notes
Oops Notes
Uploaded by
Selva612Copyright:
Available Formats
y)
return x; [| ———+ body of the method
else
How to call a Jaya Method?
Now we defined a method, we need to use it. For that, we have to call the method. Here's how:
myMethod();
This statement calls the myMethod() method that was declared earlier.
class Main {
public static void main(string[] args) {
myFunction() 5
, e
private static void myFunction() {<——
Se // function body
1. While Java is executing the program code, it encounters myMethod(); in the code.
2. The execution then branches to the myFunetion() method, and executes code inside
the body of the method.
3. After the codes execu
inside the method body is completed, the program returns
to the original state and executes the next statement.
Department of Computer Science and Engineering 38 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
L.11 Access Specifiers
Java Access Specifiers (also known as Visibility Specifiers ) regulate access to classes,
fields and methods in Java.These Specifiers determine whether a field or method in a class, can
be used or invoked by another method in another class or sub-class. Access Specifiers can be
used to restrict access. Access Specifiers are an integral part of object-oriented programming.
L.1L.1 Types Of Aces Specifiers :
In java we have four Access Specifiers and they are listed below.
1. public (Visible to the world)
2. private (Visible to the class only)
3. protected (Visible to the package and all subclasses)
4, default (no specifier- Visible to the package)
Example
protectedclass Test {}
public classMain (
public static voidmain (String args[]) {
)
1.11.2 Static keyword in java
Department of Computer Science and Engineering 39 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
static is a non-access modifier in Java which is applicable for the following:
1. blocks
2 les
3. methods
4. nested classes
To create a static member(block,variable,method,nested class), precede its declaration with the
keyword static. When a member is declared static, it can be accessed before any objects of its
class are created, and without reference to any object. For example, in below java program, we
are accessing static method m1() without creating any object of Test class.
// Java progzan to demonstrate that a static member can be accesséd béforé
//instantiating a class
clase Test
JI static method
ie void ma ()
‘
Syetem.out.printla ("fom mi");
)
public static voidmain(String(] args)
// calling ml without creating any object “of class Test
mi);
Advantage of static variable: It makes our program memory efficient (ie it saves memory).
Note: main method is static, since it must be accessible for an application to run, before any
instantiation takes place.
1.12 Comments in Java
In a program, comments take part in making the program become more human readable by
placing the detail of code involved and proper use of comments makes maintenance easier and
finding bugs easily. Comments are ignored by the compiler while compiling a code.
In Java there are three types of comments:
Single — line comments.
2. Multi —line comments,
3. Documentation comments.
1. Single-line Comments
Department of Computer Science and Engineering 40 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
‘A beginner level programmer uses mostly single-line comments for describing the code
functionality lis the most easiest typed ‘comments.
Syntax:
{comments ner Text inthis ine only is considered as comment )
Example:
//0ava program to show single Line conments
class
public static void main(String args()
i
// Single Line coment here
Systen.out.printin ("Single line comment above")
?
2. Multi-tine Comments
To describe a full method in a code or a complex snippet single line comments can be tedious
to write, since we have to give ‘/” at every line. So to overcome this multi line comments ean be
used.
Syntax:
Comment starts
continues
continues,
Commnent ends*/
Example:
//3ava program ¢6 show mlti line conments
class Sconnent,
(
public staticvoidmain (String args{1)
(
system.6ut.printin ("Multi line comments below");
yaCorment line 1
Corment line 2
Conment line 3*/
)
'
1.13 Data types in Java
Java has two categories of data:
© Primitive data (e.g., number, character)
Department of Computer Science and Engineering 41 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
‘© Non Primitive data or Object data (programmer created types)
1.13.1 Primitive data
Primitive data are only single values; they have no special capabilities. There are 8 primitive data
types
1. boolean
2 byte
3. short
4. int
5. long
6. float
7. double
8 char
Data Type
Primitive Noe-Pririnive
ae Su [— String
Boolean Numeric [— Array
ee ete
Character Integral
ao,
Intezer Floating-point
LT # *
boolean char byte short int long float. double
1. boolean
boolean data type represents only one bit of information either true or false . Values of
type boolean are not converted implicitly or explicitly (with casts) to any other type. But
the programmer can easily write conversion code.
// & Java program to demonstrate boolean data type
class GeeksforGeeks
(
public static void main(String args(])
Department of Computer Science and Engineering 2 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
boolean ~ true
Lf (b == true)
System.out printin ("Hi Geek"
2. byte
The byte data type is an 8-bit signed two's complement integer:The byte data type is
useful for saving memory in large arrays.
© Size: &-bit
© Value: -128 to 127
// Java program to demonstrate byte data type in Java
class Testbyte
H
public static voidmain(string args{1)
(
bytea - 126;
W/ byte is 8 bit value
System. out .printin (a);
System.out .printin (a);
J/ te overflows here because
// byte can hold values from “128 to 127
System.out .printin(a) +
// Looping back within the range
System. out.printin(a)
126
227
128
“27
3. short
The short data type is a 16-bit signed two's complement integer. Similar to byte, use a short to
save memory in large arrays, in situations where the memory savings actually matters.
Department of Computer Science and Engineering 4B RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Size: 16 bit
‘Value: -32,768 to 32,767 (inclusive)
4. int
It is a 32-bit signed two's complement integer.
Size: 32 bit
Value: -231 t0 231-1
Note: In Java SE 8 and later, we can use the int data type to represent an unsigned 32-bit integer,
which has value in range (0, 232-1]. Use the Integer class to use int data type as an unsigned
integer.
5. long:
The long data type is a 64-bit two's complement integer.
Size: 64 bit
Value: -263 to 263-1
Floating point Numbers : float and double
6. float
The float data type is a single-precision 32-bit. Use a float (instead of double) if we need to
save memory in large arrays of floating point numbers.
Size: 32 bits
Suffix : F/f Example: 9.8f
7. double
The double data type is a double-precision 64-bit, For decimal values, this data type is
generally the default choice.
8. char
‘The char data type is a single 16-bit Unicode character. A char is a single character.
Value: *\u0000" (or 0) to “fi? 65535
Hf sava program to demonstrate
sStchar
mitive data types in Java
public static voldmain (string args(])
// declaring chara
chara = 'G';
J/ Integer data type is generally
7/ used for numeric values
Department of Computer Science and Engineering “4 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
int in89;
byte and short if memory is a con:
45
J/ this will give error as number is a larger than byte range
7/ byte bl = 7888885955;
short s = 56;
J/ his will give error as number is larger than short
V7 short 81 = 8787878787
range’
// by default fraction value is double in java
double d = 4.355453532;
W/ for float use '£" as suffix
float £ = 4.7333434£;
systen.oi
System.
System.
intin("char: "+ a);
printIn("integer: "+ i);
intln("byte: "+ b);
system intin("short: "+ s)7
System-out.printIn("float: "+ £)%
System.out .print1n ("double:/* + @)?
Output:
char: G
integer: 89
byte: 4
short: 56
float: 4.733436
double: 4.355453532
1.13.2 Non Primitive Data Types
Non-primitive data types are created by programmer. It is also called as "Reference
Variables' or ‘Object reference’ because it refers a memory location where data is stored. On the
other hand, primitive data types stores value.
String
It is class in java provided with several methods used to store group of characters.
Department of Computer Science and Engineering 45 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
For example, abed, indial23 ete.
String is not a primitive data type because it has methods and only class can have methods
Primitive data types cannot have methods. So, String is a class which is non-pri
'String’ is used to represent string class.
Example: String s="World”
ive type.
‘Objects and Array
Objects and Array are non-primitive data types because it refers to the memory location
1.14 Java Identifiers
In programming languages, identifiers are used for identification purpose. In Java an
identifier can be a class name, method name, variable name or a label. For example
public class Test
{
public static void main(Stringl] args)
t
int a = 20;
»
»
In the above java code, we have 5 identifiers namely =
Department of Computer Science and Engineering 46 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Test : class name.
main : method name.
String : predefined class name.
args : variable name.
a: variable name,
Rules for defining Java Identifiers
There are certain rules for defining a valid java identifiers. These rules must be followed,
otherwise we get compile-time error.
The only allowed characters for identifiers are all alphanumeric characters({A-Z],[a-2],[0-9])
‘* Identifiers should not start with digits([0-9]), For example “123students” is a not a valid
java identifier.
Java identifiers are ease-sens
There is no limit on the length of the identifier but it is advisable to use an optimum.
length of 4 ~ 15 letters only.
© Reserved Words can’t be used as an identifier. For example “int while = 20:” is an
invalid statement as while is a reserved word.
Variables in Java
A variable is the name given to a memory location. It is the basic unit of storage in a program.
The value stored in a variable can be changed during program execution.
+A variable is only a name given to a memory location, all the operations done on the
variable effects that memory location.
‘© In Java, all the variables must be declared before they can be used.
Department of Computer Science and Engineering 47 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
How to declare variables?
We can declare variables in java as follows:
int age =20;4— value
datatype —_vatiabl
20
Rereried Memorrforvarable
RAM
datatype: Type of data that can be stored in this variable,
variable_name: Name given to the variable.
value: It is the initial value stored in the variable.
Examples:
float simpleinterest; //Declaring float variable
int time = 10, speed = 20; //Declaring and Initializing integer variable
char var = 'h'; // Declaring and Initializing character variable
‘Types of variables
There are three types of variables in Java:
© Local Variables
‘© Instance Variables
* Static Variables
1.15.1 Local Variables: A variable defined within a block or method or constructor is called local
variable.
‘© These variable are created when the block in entered or the function is called and
destroyed after exiting from the block or when the call returns from the function,
‘©The scope of these variables exists only within the block in which the variable is
declared. ie. we can access these variable only within that block.
Department of Computer Science and Engineering 48 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Sample Program 1:
public class StudentDetails
{
public void Studentage ()
{ //lecal variable age
int age
age = age + 5;
System-out.print1n("Student age is : "+ age);
}
public static voidmain (String args[1)
fl
StudentDetails obj = new StudentDetails();
obj .Studentage () ;
Output:
Student age is : 5
In the above program the variable age is local variable to the function StudentAge(). If we use
the variable age outside StudentAge() function, the compiler will produce an error as shown in
below program.
Sample Program 2:
public class Student Detais
(
public void Studentage ()
{ //local variable age
intage = 0:
age ¥ 53
)
public static void main(String args{]}
{
Y/using local variable age outside it's scope
System.out.printin ("Student age is : "+ age);
Department of Computer Science and Engineering 49 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
error: cannot find symbol
“+ age):
1.15.2. Instance Variables:
‘* Instance variables are non-static variables and are declared in a class outside any method,
constructor or block.
© As instance variables are declared in a class, these variables are created when an object of
the class is created and destroyed when the object is destroyed,
© Unlike local variables, we may use access specifiers for instance variables. If we do not
specify any access specifier then the default access specifier will be used.
Sample Program:
Department of Computer Science and Engineering 50 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
import java.io.*;
class Marks
{
//These variables are instance variables
//These variables are in a class and are not inside any function
int engMarks;
int mathstarks;
int phyMarks;
)
class MarksDemo
public static voidmain(String args{])
{1 //£irst object
Marks objl = newMarks();
objl.engMarks = 50;
objl.mathsMarks = 80;
objl.phyMarks = 90;
/{second object
Marks obj2 = newMarks();
obj2.engMarks = 8
obj2.mathsMarks = 60;
obj2.phyMarks = 85;
//displaying marks for first object
System-out.printIn("Marks for first object:");
system.out .print1n(obj1.engMarks);
system. out -printin(obj1.mathsMarks) ;
System. out -print1n(obj1.phyMarks);
/{displayifig marks*for second object
System.out-printin("Marks for second object
System, out print 1n(obj2.engMarks) ;
System-out-print1n(obj2.mathsMarks) ;
System. out+print1n(obj2.phyMarks);
Output:
Marks for first object:
50
80
90
Marks for second object:
Department of Computer Science and Engineering a1 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
60
85
‘AS we can see in the above program the variables, engMarks , mathsMarks , phyMarksare
instance variables. In case we have multiple objects as in the above program, each object will
have its own copies of instance variables. It is clear from the above output that each object will
have its own copy of instance variable.
1.15.3 Static Variables: Static variables are also known as Class variables.
‘© These variables are declared similarly as instance variables, the difference is that static
variables are declared using the static keyword within a class outside any method
constructor or block,
© Unlike instance variables, we can only have one copy of a static variable per class
irrespective of how many objects we create.
‘© Static variables are created at start of program execution and destroyed automatically
when execution ends,
© To access static variables, we need not to create any object of that class, we can simply
access the variable as:
class_name.variable_ name;
Sample Program:
import java.io.
class Emp (
// static variable salary
public static double salary:
public static String name = "Harsh";
)
public class EmpDemo
{
public statievoidmain(String args{]) {
J/aceessing static variable without object
Emp.salary = 1000;
System.out.printIn(Emp.name + "'s average salary:"+ Emp.salary);
output
Harsh’s average salary:1000.0
Department of Computer Science and Engineering 2 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
1.16 Operators
Operator in java is a symbol that is used to perform operations. For example: +, ,*, / te
Operators in Java
g.
bore aa
e
4
Java provides many types of operators which can be used according to the need. They are
classified based on the functionality they provide. Some of the types are-
5.
6
7
Arithmetic Operators,
Unary Operators
Assignment Operators
Relational Operators
Logical Operators
‘Ternary Operators
Bitwise Operators
Shift Operators
Department of Computer Science and Engineering 3 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
1. Arithmetic Operators in Java
Java Arithmetic operators are used for simple math operations, they are
© Addition (+)
© Subtraction (-)
© Multiplication (*
© Division (/)
* Modulo (%)
Example
public class operators
public static void main(Stting[], args)
(
int a= 20, b= 10, ¢
String x = "Thank", y
// + and ~ operator
System.out.printin("a 4 b
System.out .println ("a -\b
// + operator if used with strings
// concatenatés theigiven strings.
System.out.printIn("x + y = "#x + y)i
11 * and { operator
System.out ’printin("a * b = "+(a * b)
System.out.printIn("a / b= "t(a / b)
// modulo operator gives remainder on dividing first operand with
second
System.out.printin("a $b = "+(a 3 b));
// 4£ denominator is 0 in division then Arithmetic exception is
thrown. Uncommenting below line would throw an exception
// System.out.printin (a/c);
}
}
Output
atb
30
Department of Computer Science and Engineering 34 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
a-b = 10
xty = ThankYou
atb = 200
a/b = 2
atb = 0
2. Unary Operator
The Java unary operators require only one operand, Unary operators are used to perform various
operations ie
+ incrementing/decrementing a value by one
+ negating an expression
: inverting the value of a boolean
Example 1: ++ and ~
class OperatorExample{
public static void main(String argstl)
int x=10;
System.out.printin(x++); //10/()),
System.out.printin(++x); //12
System.out.printIn(x--); //12 (LY)
System.out .printIn(--x); //10
Example 2: ++ and —
class OperatorExample(
public static void main(String args[])(
int a=10;
int b=10
System.out.printin(a++ + +a) ;//10+12=22
System. out.printin(b++ + b++);//10+11=21
}
Department of Computer Science and Engineering 35 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Example: ~ and !
class OperatorExample(
public static void main(String args{]){
int a=10;
int b=-10;
boolean c=tru
boolean d-false;
System.out.printIn(~a);//11 (minus of total positive value //whic
h starts from 0)
System.out .printIn(~b);//9 (positive of total ‘minus, positive /
/starts from 0)
System.out.printIn(!c) ;//false (opposit® of“boolean value)
System.out.printIn(!d) ;//true
}
b
Output:
“ll
9
false
true
3. Assignment Operators
Assignment operators are used to assigning values to the left operand.
(Operator Name [Description
(To add the right and left operator and then assigning the result to the left
operator
‘To subtract the two operands on left and right and then assign the value to
the left operand
ae [To multiply the two operands on left and right and then assign the value to
fi the left operand
[To divide the two operands on left and right and then assign the value to the
left operand.
= [To raise the value of left operand to the power of right operator
Department of Computer Science and Engineering 56 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Po= [To apply modulo operator
General format is
variable = value;
Example 1:
class OperatorExample(
public static void main(String args[])(
int a=10;
(a=10+4)
(b=20-4)
System.out.printin(a);
system. out.print1n(b) ;
}
}
Output:
14
16
Example 2:
class OperatorExample(
public static void main(String[] args) (
int a=10;
at=3;//1043
System. out .printIn (a) ;
a=4;//13-4
System.out .printIn(a) ;
a*=2;//942
System. out.print1A(a) ;
a/=2;//18/2
System.out.printin(a);
n
Output:
1
9
18
Example 3:
class OperatorExample{
public static void main(String args[]) (
short,
;//a=atb internally so fine
Department of Computer Science and Engineering
37 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
a-atb;//Compile time error because 10+10=20 now int
System.out.printIn (a);
n
Output:
Compile tine error
After type cast:
class OperatorExample{
public static void main(String args{1){
short a=10;
short b=10;
short) (a+b) ;//20 which is int now converted to short
System.out.printin(a};
n
Output:
20
4. Relational Operators : These operators are used to check for equality and comparison,
They return Boolean (true or false) result after the comparison and are extensively used in
looping statements as well as conditional if else statements. General format is,
variable relation_operator value
[Operator Name [Description
== (equals to) ex. x=y [True if x equals y, otherwise false
(not equal to) ex. [True if x is not equal to y, otherwise false
< (less than) ex. x.... for heading and has been used for creating paragraph
break.
Example
pe
* Hello, World!
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
*
* Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
* @author Author_Name
* @version 1.0
*@since 2018-03-31
g
public class HelloWorld {
public static void main(String{] args) {
/* Prints Hello, World! on standard output.
Department of Computer Science and Engineering 85 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
System.out printin("Hello World!");
+
+
1.20.1 The javadoe Tags
The javadoc tool recognizes the following tags
should no longer be used.
Tag Description Syntax
@author Adds the author of a class. @author name-text
Displays text in code font without
{@eode} interpreting the text as HTML markup or {@code text}
nested javadoc tags.
Represents the relative path to the generated
{@docRoot} | document's root directory from any generated | {@docRoot}
page,
@deprecatea | Adds @ comment indicating that this APL @deprecated deprecatedtext
@exception
Adds a Throws subheading to the generated
documentation, with the classname and
description text.
@exception class-name
description
{@inheritDoc
3
Inherits a comment from
the nearestinheritable class or implementable
interface.
Inherits a comment from the
immediate surperclass
Inserts an in-line link with the visible text
label that points to the documentation for the
{@link
description to the "Parameters" section.
{@linky specified package, cass, or member name of | P&tkege.classi#member
label}
areferenced class.
Identical to {@link}, except the link’s label is | {@linkplain
{@linkplain} | displayed in plain text than code font. package.classi#member
label}
Adds a parameter with the specified a
@param parameter-name followed by the specified param pal
description
Department of Computer Science and Engineering 86 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Adds a "Returns" section with the description
@return ae @retum description
Adds a "See Also" heading with a link or text |
Ce entry that points to reference. selene
@seriat Used in the doc comment for a default @serial field-description |
serializable field.
include | exclude
@serialData
Documents the data written by the
writeObject( ) or writeExtemal( ) methods.
@serialData data-
description
Documents an ObjectStreamField
@serialField field-name
QserialField | component. field-type field-description
‘Adds a "Since" heading with the specified
@since since-text to the generated documentation, | @since release
Pe The @throws and @exception tags are @throws class-name
synonyms. description
When (@value} is used inthe oe comment | vay
{@value} | of astatc fied, it displays the value ofthat] T@valwe |
oe package class#ield}
‘Adds a "Version" subheading with the
ified version-text to the generated d
@version —_| SHecifird versionvtext io the generated docs | @version version-text
when the -version option is used.
© End of Unit — 1 ***
Department of Computer Science and Engineering 87 RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
UNIT — I - INHERITANCE AND INTERFACES
2.1 Inheritance
An important part of OPPs(Object Oriented programming system) is Inheritance.
The process by which one class acquires the properties(data members) and
functionatities(methods) of another class is called inheritance. The keyword used inherit the
propertied of a class is extends.
The idea behind inheritance in java is that we can create new classes that are built upon
existing classes. When we inherit from an existing class, we can reuse methods and fields of
parent class, and we can add new methods and fields also.
Syntax
class subClass extends superClass
{
/imethods and fields
+
Tert
ology
Super Class (Parent Class) : The class whose features are inherited is known as super
class(or a base class or a parent class).
‘Sub Class (Child Class): The class that inherits the other class is known as sub class(or
a derived class, extended class, or child class). The subelass can
add its own fields and methods in addition to the superclass
fields and methods
Reusability : Inheritance supports the concept of “reusability”, ie. when we
want to create a new class and there is already a class that
includes some of the code that we want, we can derive our new
class from the existing class. By doing this, we are reusing the
fields and methods of the existing class.
Example:
In below example of inheritance, class Bicycle is a base class, class MountainBike is a
derived class which extends Bicycle class and class Test is a driver class to run program.
//Java program to illustrate the concept of inheritance
// base class
class Bicycle
i
// the Bicycle class has two fields
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
public int gear,
public int speeds
// the Bicycle class has one constructor
public Bicycle(int gear, int speed)
{
this.gear = gear;
this. speed = speed;
,
// the Bicycle class has three methods
public void applyBrake (int decrement)
fl
speed -= decrement;
,
public void speedup (int increment)
cl
speed ++ increment;
,
// toString() method to print info.of Bicycle
public String toString()
cl
return("No of gears are."+gear
+"\n"
+ "speed of bicycle) isu"+speed) +
}
// derived class
class NcuntainBike extends Bicycle
(
// the HountainBike Subclass adds one more field
publi¢int seatHeight;
/{ the\MountainBike subclass has one constructor
publicMountainBike(int gear, int speed, int startHeight)
cl
/} invoking base-class (Bicycle) constructor
super (cear, speed);
seatHeight = startHeights
,
// the MountainBike subclass adds one more method
public void setHeight (int newValue)
cl
seatHeight = newValue;
,
// overriding toString() method of Bicycle to print more info
Goverride
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
public String toString ()
‘ return (super.toString()+"\nseat height is "+seatHeight);
,
I
// driver class
public class Test
(
public static voidmain(string args{])
(
MountainBike mb = newMountainBike(3, 100, 25);
System. out .print1n (mb. toString ());
b
Output:
No of gears are 3
speed of bicycle is 100
Seat height is 25
In above program, when an object of MountainBike class is created, a copy of the all methods and
fields of the superclass acquire memory in this object. That is why, by using the object of the subclass
‘we can also access the members of a superclass.
Iustrative image of the prograr
int gear
int speed copy of Bicycle methods and
applyBrake()| fields in MountainBike object
speedUp()
toString()
objects of MountainBike class
int seatHeight
setHeight()
toString()
‘The super keyword
‘The super keyword is similar to this keyword. Following are the scenarios where
the super keyword is used.
‘+ It is used to differentiate the members of superclass from the members of
subclass, if they have same names.
+ It is used to invoke the superclass constructor from subclass. RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Important faets about inheritance in Java
Default superclass: Except Object class, which has no superclass, every class has one and only
one direct superclass (s
gle inheritance). In the absence of any other explicit
superclass, every class is implicitly a subclass of Object class,
Superclass can only be one: A superclass can have any number of subclasses, But a subclass can
have only one superclass. This is because Java does not support multiple
inheritance with classes
Although with interfaces, multiple inheritance is
supported by java.
Inheriting Constructo
A subclass inherits all the members (fields, methods, and nested
classes) from its superclass. Constructors are not members, so they are not
inherited by subclasses, but the constructor of the superclass can be invoked
from the subclass,
A subelass does not inherit the private members of its parent class.
However, if the superclass has public or protected methods(like getters and
setters) for ack
ing its private fields, these can also be used by the subclass.
Role of Subclass
In sub-classes we can inherit members as is, replace them, hide them, or supplement them with new
‘members:
‘+ The inherited fields can be used directly, just like any other fields.
‘* Wecan declare new fields in the subclass that are not in the superclass
‘© The inherited methods can be used directly as they are.
We can write a new instance method in the subclass that has the same signature as the one in
the superclass, thus overriding it (as in example above, toString() method is overridden),
‘*) Weccan write a new static method in the subclass that has the same signature as the one in the
superclass, thus hiding it
© We can declare new methods in the subclass that are not in the superclass.
© We can write a subclass constructor that invokes the constructor of the superclass, either
implicitly or by using the keyword super.
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
2.1.1 Types of Inheritance
884 (Please refer UNIT Notes for detailed explanation and examples)
Single Inheritance public lass A ¢
Class A z
}
public lass B extends A {
Class 8 }
‘Maiti Level taheritance
public class A ( )
public class B extends A {....
public dass C extends B {econo}
iorarchical inheritance
public dass A )
puble dass B extends A... }
[tase c | | puttecass Coxtands A (ob
‘Maltiple Inheritance public dass A )
public class B ,
Se public class C extends A,8 {
11 Java does not support mutiple Inheritance
2.1.2 Super Class
The super keyword in java is a reference variable which is used to refer immediate parent
class object. Whenever we create the instance of subclass, an instance of parent class is
created implicitly which is referred by super reference variable.
Usage of java super Keyword
1. super can be used to refer émmediate parent class instance variable.
2. super can be used to invoke immediate parent class method.
3. super() can be used to invoke immediate parent class constructor
1) super is used to refer immediate parent class instance variable..
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
We can use super keyword to access the data member or field of parent class. It is used if
parent class and child class have same fields.
Example
class Animal{
String color="white";
+
class Dog extends Animal{
String color="black"
void printColor()<
System.out.printin(color);//prints color of Dog class
‘System.out.printin(super.color);//prints color of Animal class
}
}
class TestSuper1{
public static void main(String args[]){
Dog d=new Dog();
d.printColor();
}
Output
black
whice
In the above example, Animal and Dog both classes have a common property color. If we
print color property, it will print the color of current class by default. To access the parent
property, we need to use super keyword.
2) 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 if
subclass contains the same method as parent class. In other words, it is used if method is
overridden,
Example
class Animal{
void eat(){
System.out.printin("eating...");
+
o
Department of Computer Science and Enginee RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
class Dog extends Animalt
void eat(){
‘System.out.printin("eating bread...");
void bark(){
System.out.printin("barking
?
void work(){
super.eat();
bark();
,
,
class TestSuper2{
public static void main(String args(]){
Dog d=new Dog);
d.work();
+
Output
eating...
barking
In the above example Animal and Dog both class
18 have eat() method if we call eat() method
from Dog class, it will call the eat() method of Dog class by default because priority is given
to local. To call the parent class method, we need to use super keyword.
3) super is used to invoke parent class constructor,
‘The super keyword can also be used to invoke the parent class constructor.
Example
class Animal{
Animal()
System.out.printin("animal is created");
}
z
class Dog extends Animal{
Dog(){
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
super();
‘System.out.printin("dog is created");
}
}
class TestSuper3{
public static void main(String args[]){
Dog d=new Dos();
}
3
Output
dog is created
Note: super() is added in each class constructor automatically by compiler if there is no
super() or this().
class Bike
class Bike( Bike()t
; compiler
}
Bike java }
Bike.class
As we know well that default constructor is provided by compiler automatically if there is no
constructor. But, it also adds super() as the first statement.
Another example of super keyword where super() is provided by the compiler implicitly.
class Animal{
Animal(){System.out.printin(“animal is created");}
>
class Dog extends Animal{
Dog(){
‘System.out.printin("dog is created");
+
+
class TestSupera{
public static v
main(String args[]){
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Dog
oo
yew Dog);
Output
animal ie created
dog is created
2.1.3 Protected Member
The private members of a class cannot be directly accessed outside the class. Only
methods of that class can access the private members directly. However, sometimes it may be
necessary for a subclass to access a private member of a superclass. If we make a private
member public, then anyone can access that member. So, if'a member of a superclass needs
to be (directly) accessed in a subclass and yet still prevent its direct access outside the class,
you must declare that member protected.
Following table deseribes the difference
Modifier Class Subclass World
public Y Y Y
protected ¥ Y N
private ¥ N. N
Following program illustrates how the methods of a subclass can directly access a protected
‘member of the superclass.
For example, le’s imagine a series of classes to
describe two kinds of shapes: rectangles and
triangles. These two shapes have certain common
properties height and a width (or base).
This could be represented in the world of classes
with a class Shapes from which we would derive
the two other ones : Rectangle and Triangle
Example
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
public class shape
{
protected double height; // To hold height.
protected double width; //To hold width or base
* The setValue method sets the data
* in the height and width field
public void setValues(double height, double width:
this.height = height;
this.width = width;
Rectan;
ye
* This class Rectangle calculates
* the area of rectangle
*
public class Rectangle extend# Shape
t
yee
* The method retufns the area
* of rectangle.
*/
public double getarea ()
(
return height * width; //accessing protected members
}
Triangle.java
ye
* this class Triangle calculates
* the area of triangle
y
public class Triangle extends Shape
{
yee
* The method returns the area
* of triangle.
*/
public double getarea()
ci
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
return height * width / 2; //accessing protected members
‘Testprogram,java
Jan
* This program demonstrates the Rectangle and
* ‘riangle class, which inherits from the Shape class.
“/
public class TestProgram
(
public static void main(String[] args)
fl
{/Create object of Rectangle.
Rectangle rectangle = new Rectangle();
{/Create object of Triangle
Triangle triangle = new Triangle();
(Set values in rectangle object
rectangle.setValues (5,4);
//Set values dn trianlge object
triangle.setValues (5,10);
// Display the/area Of rectangle.
System.out.printin ("Area of rectangle : " +
rectangle.getArea()) 7
//-pisplay the’area of triangle.
System.out.print1n("Area of triangle : " +
triangle.getArea());
Output :
Area of rectangle : 20.0
Area of triangle : 25.0
2.1.4 Constructors in sub classes
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
In Java, constructor of base class with no argument (default constructor) gets automatically
called in derived class constructor. For example, output of following program is:
Example
Main. java
Base()
System.out.println ("Base Class Constructor Called ");
}
class Derived extends Base (
Derived()
System. out.printin ("Derived Class Constructor Called ")
}
publicclass Main {
public static voidmain(String[] args) {
Derived d = new Derived():
t
output
Base Class Constructor Called
Derived Class Constructor Called
But, if we want to call parameterized contructor of base ela
, then we can call it using
ss constructor call must be the first line in derived class
super(). The point to note is base
constructor. For example, in the following program, super(_x) is first line derived class
constructor.
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
// filename: Main. java
class Base {
int x:
Base(int_x) {
}
class Derived extends Base {
int yz
Derived(int x, int_y) {
uper (_x)7
Wi
void Display() {
System.out.println("* = "+x", y =
}
publicclass Main {
public static void main(String[] args)\ {
Derived d = new Derived(10, 20);
d.Display();
}
Run on IDE
Output:
x= 10,y=20
The rules is: sub class constructor has to invoke super class instructor, either explicitly by
programmer or implicitly by compiler. For either way, the invoked super constructor has to be
defined.
2.1.5 The Object Class
Every class in Java is directly or indirectly derived from the Object class. All other classes are
subelasses of Object. The Object class is the parent class of all the classes in java by default.
In other words, it is the topmost class of java. That is, Object is a superclass of all other
classes. This Means that a reference variable of type Object can refer to an object of any other
class. Also, since arrays are implemented as classes, a variable of type Object can also refer
to any array. Object defines the following methods, which means that they are available in
every object.
Note : The Object class, in the java.lang package, sits at the top of the class hierarchy tree
Method Purpose
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
‘Creates a new object that is the same as the
object being cloned.
‘Determines whether one object is equal to
Object clone( )
boolean equals(Object object)
another.
void finalize ) Called before an unused object is recycled.
Class getClass( ) Obtains the class of an object at run time
Returns the hash code associated with the
invoking object.
Resumes execution of a thread waiting on
the invoking object.
Resumes execution of all threads waiting on
the invoking object.
int hashCode( )
void notify)
void notifyA()
String toString() Returns a string that describes the object.
void wait()
void wait(long milliseconds)
void wait(long milliseconds,
int nanoseconds)
Waits on another thread of execution,
‘The methods getClass( ), notify( ), notifyAII( ), and wait( ) are declared as final, You may
override the others.
2.1.6 Abstract Classes
There are situations in which we will want to define a superclass that declares the
structure of a given abstraction without providing a complete implementation of every
method. That is, sometimes we will want to create a superclass that only defines a
generalized form that will be shared by all of its subclasses, leaving it to each subclass to fill
in the details. Such a class determines the nature of the methods that the subclasses must
implement. One way this situation can occur is when a superclass is unable to create a
meaningful implementation for a method.
General form:
abstract type name (parameter-list);
To declare a class abstract, we simply use the abstract keyword in front of the elass keyword
at the beginning of the class declaration.
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Here is a simple example of a class with an abstract method, followed by a class which
implements that method:
// ® Simple demonstration of abstract.
abstract class A {
abstract void callme();
// concrete methods are still allowed in abstract classes
void callmetoo() {
System.out.printin("This is a concrete method."
}
}
class B extends A {
void calime() {
System.out.printin("B's implementation of callme.");
}
}
class AbstractDemo {
public static void main(string args(]) {
Bb = new B(
b.callme(
b.callmetoo() +
y
,
Notice that no objects of class A are declared in the program. As mentioned, it is not
possible to instantiate an abstract class. One other point: class A implements a concrete
‘method called eallmetoo( ).
Although abstract elasses cannot be used to instantiate objects, they can be used to
create object references, because Java’s approach to run-time polymorphism is implemented
through the use of superclass references. Thus, it must be possible to create a reference to an
abstract class so that it can be used to point to a subel
38 object.
Using an abstract class, we can improve the Figure class example. Since there is no
‘meaningful concept of area for an undefined two-dimensional figure, the following program
declares area( ) as abstract inside Figure. This, of course, means that all classes derived from
Figure must override area( ).
// Using abstract methods and classes.
abstract class Figure [
double dim;
double din2;
Figure(double a, double b) {
dim = a;
dim? = b;
)
// area is now an abstract method
abstract double area();
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
,
class Rectangle extends Figure {
Rectangle (double a, double b) {
super(a, b);
}
// override area for rectangle
double area() {
System.out.printin ("Inside Area for Rectangle.");
return dim] * dim2;
}
}
class Triangle extends Figure {
Triangle (double a, double b) {
super (a, b);
}
// override area for right triangle
double area) {
System.out.printin ("Inside Area for Triangle.
return diml * dim2 / 2;
}
}
class Abstractareas {
public static void main(String args (J)
// Figure £ = new Figure(10, 10)%// illegal now
Rectangle r = new Rectangle(9, 5);
Triangle t = new Triangle(10, 8);
Figure figref; // this is OK, no object is created
figref =
system.out .printin ("Area ia." + figref.area());
figref = t;
system.out.p
}
}
ntin ("area is “ + figref.area());
As the comment inside main( ) indicates, it is no longer possible to declare objects of
type Figure, since it is now abstraet, And, all subclasses of Figure class must override area()
Although it is not possible to create an object of type Figure, we can create a reference
variable of type Figure. The variable figref is declared as a reference to Figure class, which
‘means that it can be used to refer to an object of any class derived from Figure class.
2.1.7 Final Methods and Classes
Inheritance is one of the highly useful features in Java, But at times, it may be desired
that a class should not be extendable by other classes to prevent misusing by others. For such
purpose, we have the final keyword. A class declared as final cannot be extended while a
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
method declared as final cannot be overridden in its subclasses. Though a final class cannot
be extended, it can extend other classes. /n simpler words, a final class can be a sub class but
not a super class.
Normally, Java resolves calls to methods dynamically, at run time. This is called fate
binding. However, since final methods cannot be overridden, a call to one can be resolved at
compile time. This is called early binding.
Syntax
final public class A
//code
}
The final keyword can be placed either before or after the access specifier. The following
deck
jon of class A is equivalent to the above.
public final class A
//code
,
final keyword is used in different contexts. First of all, final is a non-access modifier
applicable only to a
© variable,
© amethod
© aclass.
Final Variable:
If we make any variable as final, we cannot change the value of final variable (It will be
constant).
Example of final variable
‘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
class Bike{
al int speediimit=90; //final variable
void run(){
speedlimit=400;
+
public static void main(String args(])<
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
obj.run();
y
}iend of class
output :Compile Time Error
Final Method
If you make any method as final, you cannot override it.
Example
class Bike{
final void run(){
System.out.printin("running");
ba
class Honda extends Bike{
void run(){
System.out.printin("running safely with 100kmph");
+
public static void main(String args[]){
Honda honda= new Honda();
honda.run();
}
¥
outpu
:Compile Time Err!
Final Class
If we make any class as final, we cannot extend it.
Example
final class Bike{}
class Honda extends Bike{
void run(){
System.out.printin("running safely with 100kmph");
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Public static void main(String args[]){
Honda honda= new Honda();
honda.run();
i
+
output :Compile Time Error
Using final to Prevent Inheritance a Class
Sometimes we will want to prevent a class from being inherited. To do this,
precede the class declaration with final. Declaring a class as final implicitly declares all of its
methods as final, too.
It is illegal to declare a class as both abstract and final since an abstract class is
incomplete by itself and relies upon its subclasses to provide complete implementations
final class A {
Was
}
// The following class is illegal.
class B extends A { // ERROR! Can't subclass A
“
}
As the comments imply, itis illegal for B to inherit A since A is declared as final
However final method can be inherited but you cannot override it,
Example
class Bike{
final void run(){
System.out.printin("running...");
}
¥
class Honda extends Bike{
Public static void main(String args{]){
new Honda().run();
+
3
output: running...
abstract class vs final class
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
PROPERTY ABSTRACT CLASS | FINAL CLASS
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Should be subclassed
to override the Can never be
SUBCLASSING functionality of subclassed as final
abstract methods does not permit
Abstract class Final class methods
METHOD methods functionality | cannot be altered and
ALTERATIONS can be altered in should be used as it is
subclass by other classes
Cannot be
INSTANTIATION instantiated Can be instantiated
Overriding concept
OVERRIDING For later use, all the | does not arise as final
CONCEPT abstract methods class cannot be
should be overridden _| inherited
INHERITANCE Can be inherited Cannot be inherited
ABSTRACT Can contain abstract} Cannot contain
METHODS methods abstract methods
‘A few methods can be
ae implemented anda __| All methods should
IMPLEMENTATION few cannot have implementation
Cannot create
IMMUTABLE immutable objects __| Immutable objects can
(CHANGELESS OBJECTS | (infact, no objects can | be created (eg. String
be created) class)
Itisan incomplete _| It is a complete class
class (for this reason _| (in the sense, all
NATURE only, designers do not | methods have
allow to create complete functionality
objects) or meaning)
Extra functionality to | No extra functionality
ADDING EXTRA the methods canbe | can be added and
FUNCTIONALITY added in subclass should be used as it is
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
2.1.8 Interfaces
We discussed abstract class which is used for achieving partial abstraction. Unlike
abstract class an interface is used for full abstraction. Using the keyword interface, we can
fully abstract a class’ interface from its implementation. That is, using interface, we can
specify what a class must do, but not how it does it. Interfaces are syntactically similar to
classes, but they lack instance variables, and their methods are declared without any body.
Onee it is defined, any number of classes can implement an interface. Also, one class can
implement any number of interfaces. To implement an interface, a class: must create the
complete set of methods defined by the interface. However, each class is free to determine the
details of its own implementation. By providing the interface keyword, Jaya allows you to
fully utilize the “one interface, multiple methods” aspect of polymorphism.
Syntax
public interface NameOfinterface {
// Any number of final, static fields
// Any number of abstract method declarations
}
Here is an simple example of an interface definition. It declares an interface that contains one
‘method called calback( ) that takes a single integer parameter.
interface Callback {
void callback (int param);
}
Interfaces have the following properties
«An interface is implicitly abstract. We do not need to use the abstract
keyword while declaring an interface.
+ Each method in an interface is also implicitly abstract, so the abstract
keyword is not needed.
+ Methods in an interface are implicitly public.
Once an interface has been defined, one or more classes can implement that
interface. When a class implements an interface, we can think of the class as signing a
contract, agreeing to perform the specific behaviors of the interface. If a class does not
perform all the behaviors of the interface, the class must declare itself as abstract. A cla
uses
the i
plements keyword to implement an interface. The implements keyword appears in the
class declaration following the extends portion of the declaration,
Department of Computer Science and Enginee RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Understanding relationship between classes and interfaces
As shown in the figure given below, a class extends another class, an interface extends
another interface but a class implements an interface.
class interface interface
*
extends | implements extends
class class interface
Implementing Interfaces
Once an interface has been defined, one or more classes can implement that interface. To
implement an interface, include the implements clause in a class definition, and then create
the methods defined by the interface.
The general form of a class that includes the implements is:
class classname [extends superclass] [implements interface
L,interface...}] {
// ¢lass-body:
)
Example
Interface Bank{
float rateOfinterest();
+
class SBI implements Bank{
public float rateOfinterest(){
return 9.15f;
}
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
class 10B implements Bank<
public float rateOfinterest(){
return 9.7f;
3
+
class Testinterface{
public static void main(String{] args){
Bank b=new SBI);
‘System.out.printin("Rate of Interest: "+b.rateOfinterest());
}
+
Output
Rate of Interest: 9.15
Multiple Interfaces
If a clas
implements multiple interfaces, or an interface extends multiple interfaces i.e
known as multiple inheritance.
interface interface interface interface
* * a ae
class Interface
Multiple Inheritance in Java
Example
interface Printable{
void print();
+
interface Showable{
void show();
+
class A implements Printable, Showable{
public void print(){
‘System.out.printin("Hello");
_)
public void show(){
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
System.out.printin("Welcome");
}
public static void main(String args[]){
A obj = new A();
‘obj.print();
‘obj.show();
Note: Multiple inheritance is not supported through class in java but it is
naccihle hw intarfare
Example
interface Printable{
void print();
}
interface Showable{
void print();
+
class Testinterface implements Printable, Showable{
public void print(){
System.out.printin("Hello");
+
public static void main(String args[]){
TestInterface obj = new Testlnterface();
obj.print();
>
¥
Output
Hello
Nested Interfaces
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
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.
Example
// & nested interface example.
// This class contains a member interface.
class A {
// this is a nested interface
public inte: ice NestedIF {
boolean isNotNegative(int x);
}
}
// B implements the nested interface.
class B implements A.NestedIF {
public boolean isNotNegative(int x) {
return x < 0 ? false : true;
y
}
class NestedIFDemo [
public static void main(string args{]) \{
// use a nested interface reference
A.NestedIF nif = new‘B();
if (nif isNotNegative (10) )
system.out.printin("10 is not negative");
if (nif. isNotNegative(-12))
System.out, printin(
is won't be displayed");
Extending Interfaces (Interface inheritance)
Acclass implements interface but one interface extends another interface.
Example
interface Printable{
Inherits Printable
void print(); tense
2
interface Showable extends Printable{
void show();
}
class Testinterface implements Showable{
public void print(){
System.out.printin("Hello");
3
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
public void show(){
‘System.out.printin("Welcome");
+
public static void main(String args[]){
Testinterface obj = new Testinterface();
obj.print();
0bj.show();
}
}
Output
Hello
Welcome
Variables in Interfaces
We can declare variables in Java interfaces. By default, these are public, final and
static, That is they are available at all places of the program, we cannot change these values.
Only one instance of these variables is created, it means all classes which implement this
interface have only one copy of these variables in the memory.
Example:
i
This is a simple Java program about Interface.
Call this file interfaceVariables.java
W
interface x {
int max = 10;
+
class Example implements X {
public void getMax(){
System. out. printin(max);
}
}
class InterfaceVariables {
public static void main(String args{]){ Uncommenting this will generate
Example ob = new Example(); compile error. Because By
ob.getMax(); default, these are public, final
Hlob.max = 20; and static.
+
:
Output
Department of Computer Science and Engineering RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
10
Difference between Abstract classes and Interfaces
Abstract class
Interface
Abstract class is a class which contain
‘one or more abstract methods, which
has to be implemented by its sub
classes.
Interface is a Java Object containing method
declaration but no implementation. The
classes which implement the Interfaces must
provide the method definition for all the
methods.
Abstract class is a Class prefix with an
abstract keyword followed by Class
definition,
Interface is @ pure abstract class which starts
with interface keyword,
Abstract class can also contain concrete
methods.
Whereas, Interface contains all abstract
methods and final variable declarations.
Abstract classes are useful in a situation
that Some general methods should be
implemented and specialization
behavior should be implemented by
child classes.
Interfaces are useful in a situation that all
properties should be implemented.
2.1.9 Object Cloning
Object cloning refers to the creation of exact copy of an object. It creates a new
instance of the class of current object and initializes all its fields with exactly the contents of
the corresponding fields of this object. The eloneQ method of Object
object.
is used to clone an
To use java object clone method, we have to implement the marker interface
java.lang-Cloneable so that it won't throw CloneNotSupportedException at runtime, Also
Object clone is a protected method, so we will have to override it to use with other classes.
Department of Computer Science and Enginee RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
Advantage
The clone() method saves the extra processing task for creating the exact copy ofan
object. If we perform it by using the new keyword, it will take a lot of processing time to be
performed that is why we use object cloning.
In Java, there is no operator to create copy of an object.
Example of creating an object using assignment operator
// Java program to demonstrate that assignment
// operator only creates a new reference to same
// object
import java.io. *s
// B test class whose objects are cloned
class Test
t
int x, yF
Test 0)
// Driver Class
class Main
i
public static voidmain(string!] args)
c
Test obl = new Test ();
System.outiprintin\obl.x + " "+ obl.y);
4f Creating 2 new reference variable ob?
// pointing to same address as obl
Test Ob2a= ob1;
Yi\Ahy Change made in ob2 will be reflected
{in ob:
ob2.x
00;
System.out.print1n(obl.x+" "tobl.y);
System.out.print1n(ob2.x+" "+ob2.y);
output
1020
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
100 20
100 20
Creating a copy using clone) method
// ® Java program to demonstrate shallow copy
// using clone()
import java.util.Arraybists
// An object reference of this class is
// contained by Test?
class Test
(
int x, yz
}
// Contains a reference of Test and implements
7/ clone with shallow copy.
class Test2 implements Cloneable
t
int as
int b
Test c = newTest();
public Object clone() throws
CloneNotSupportedException
(
return superselone() +
,
,
// Driver class
public class Main
(
public static voidmain(String args[]) throws
CloneNotSupportedException
(
Test2 th = new Test2();
tla = 10;
ehab™= 20;
tl.c.x = 30;
tl.c.y = 407
Test2 t2 = (Test2)tl.clone();
// Creating a copy of object tl and passing
7 it to t2
t2.a = 100;
// Change in primitive type of t2 will not
// be reflected in tl field
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
t2.c.x = 300;
// Change in object type field will be
// reflected in both t2 and t1(shallow copy)
System.out.printin(tl.a +" "+ ti.b +" "+
tle +" "+ tl.c.y);
System.out.printin(t2.a +" "+ t2.b¢" "+
tlc +" "+ t2c.y)s
,
}
Output
10 20 300 40
1100 20 300 40,
Creating a copy using clone() method
The class whose object’s copy is to be made must have a public clone method in it or in one
ofits
parent class.
Every class that implements clone() should call super.clone() to obtain the cloned
object reference.
The class must also implement javaclang.Cloneable interface whose object clone we
want to create otherwise it will throw CloneNotSupportedException when clone
method is called on that class’s object.
// & Java program to demonstrat
// using clone()
import java.util.ArrayList;
shallow copy
// An object reference of this class is
// contained by, Test2
class Test,
r
int xa vy;
)
// Contains a reference of Test and implements
// clone with shallow copy.
ss Test2 implements Cloneable
inta;
int b,
Test new Test ();
public Object clone() throws
CloneNotSupportedException
(
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
return super.clone();
)
// Driver class
public class Main
{
public static voidmain (String args{]) throws
CloneNotSupportedException
(
Test2 tl = newTest2();
tl.a = 10;
t1.b = 20;
tl.c.x = 30;
x
tl.c.y = 40;
Test2 t2 = (Test2)t1.clone();
// Creating a copy of object «tl, and\passing
// it to t2
t2.a = 100;
// Change in primitive type oB\t2) will not
// be reflected intl Field
t2.c.x = 300;
// Change in object typé\field will be
// reflected in both t2 and ti(shallow copy)
System.out.printin(tl.a + ttle" "4
tl.ex +" "4+ tl.c.y);
Systemvoub.printla(t2.a + + t2.b+" "4
c.x “+ t2.c.yi
)
output,
10 20 300.40
1100 20 300 40,
In the above example, t1.clone returns the shallow copy of the object t1. To ob
a deep
copy of the object certain modifications have to be made in clone method after obtaining the
copy.
Shallow Cloning
‘This is default implementation in java, In overridden clone method, if you are not cloning all
the object types (not primitives), then you are making a shallow copy.
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
All above examples are of shallow copy only, because we have not cloned the Department
object on Employee class’s clone method.
Deep cloning
Itis the desired behavior in most the cases. We want a clone which is independent of original
and making changes in clone should not affect original.
2.1.10 Inner Classes
It is possible to define a class within another class; such classes are known as
nested classes. The scope of a nested class is bounded by the scope of its enclosing class.
‘Thus, if class B is defined within class A, then B does not exist independently of A. A non-
static class that is ereated inside a class but outside a method is called member inner class
There are two types of nested classes: static and non-static. ‘The most important
It has aK
type of nested class is the inner class. An inner class is a non-static nested cla 88
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.
Nested classes
Inner classes Static
Nested classes
Method local Anonymous
Inner classes. Inner classes
Inner classes
The following program illustrates how to define and use an inner class. The class named
Outer has one instance variable named outer_x, one instance method named test( ), and
defines one inner class called Inner.
// Demonstrate an inner class.
ss Outer {
int outer_x
void test ()
Inner inner = new Inner();
inner. display ();
t
100;
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
// this is an inner class
class Inner {
void display() {
System. out.printin("displa’
}
outer_x = " + outer_x);
}
class InnerClassDemo {
public static void main(String args(]) [{
Outer outer = new Outer ();
outer. test ();
y
}
Output
display: outer_x = 100
In the program, an inner class named Inner is defined within the scope of class Outer.
Therefore, any code in class Jnner can directly access the variable outer_x. An instance
method named display( ) is defined inside Inner, This method displays outer_x on the
standard output stream, The main() method of InnerClassDemo creates an instance of class
Outer and invokes its test) method. That method creates an instance of class Inner and the
display() method is called,
It is important to realize that an instance of Inner can be created only within the
scope of class Outer. The Java compiler generates an error message if any code outside of
class Outer attempts to instantiate class Inner.
Note : An inner class has access to all of the members of its enclosing class, but the
reverse is not true.
There are basically three advantages of inner classes in java. They are as follows:
1) Nested classes represent a special type of relationship that is it can access all the members
(data members and methods) of outer class including private.
2) Nested classes are used to develop more readable and maintainable code because it
logically group classes and interfaces in one place only.
3) Code Optimization: It requires less code to write.
‘There are three types of Inner classes
1. Member inner class
Department of Computer Science and Enginee! RMK College of Engineering and Technology
RSM Nagar, Puduvoyal-601 206.
2. Anonymous inner class
3. Local inner class
‘Type
Description
Member Inner
Class
A class created within class and outside method.
Anonymous Inner
Class
A class created for implementing interface or extending class. Its
name is decided by the java compiler.
Local Inner Class
A class created within method.
Static Nested Class
A static class created within class.
Nested Interface
An interface created within class or interface.
2.1.11 ArrayList Class
The ArrayList class extends AbstractList and implements the List interface.
ArrayList is a generic class that has this declaration:
class ArrayList
You might also like
- The Subtle Art of Not Giving a F*ck: A Counterintuitive Approach to Living a Good LifeFrom EverandThe Subtle Art of Not Giving a F*ck: A Counterintuitive Approach to Living a Good LifeRating: 4 out of 5 stars4/5 (5823)
- The Gifts of Imperfection: Let Go of Who You Think You're Supposed to Be and Embrace Who You AreFrom EverandThe Gifts of Imperfection: Let Go of Who You Think You're Supposed to Be and Embrace Who You AreRating: 4 out of 5 stars4/5 (1093)
- Never Split the Difference: Negotiating As If Your Life Depended On ItFrom EverandNever Split the Difference: Negotiating As If Your Life Depended On ItRating: 4.5 out of 5 stars4.5/5 (852)
- Grit: The Power of Passion and PerseveranceFrom EverandGrit: The Power of Passion and PerseveranceRating: 4 out of 5 stars4/5 (590)
- Hidden Figures: The American Dream and the Untold Story of the Black Women Mathematicians Who Helped Win the Space RaceFrom EverandHidden Figures: The American Dream and the Untold Story of the Black Women Mathematicians Who Helped Win the Space RaceRating: 4 out of 5 stars4/5 (898)
- Shoe Dog: A Memoir by the Creator of NikeFrom EverandShoe Dog: A Memoir by the Creator of NikeRating: 4.5 out of 5 stars4.5/5 (541)
- The Hard Thing About Hard Things: Building a Business When There Are No Easy AnswersFrom EverandThe Hard Thing About Hard Things: Building a Business When There Are No Easy AnswersRating: 4.5 out of 5 stars4.5/5 (349)
- Elon Musk: Tesla, SpaceX, and the Quest for a Fantastic FutureFrom EverandElon Musk: Tesla, SpaceX, and the Quest for a Fantastic FutureRating: 4.5 out of 5 stars4.5/5 (474)
- Her Body and Other Parties: StoriesFrom EverandHer Body and Other Parties: StoriesRating: 4 out of 5 stars4/5 (823)
- The Sympathizer: A Novel (Pulitzer Prize for Fiction)From EverandThe Sympathizer: A Novel (Pulitzer Prize for Fiction)Rating: 4.5 out of 5 stars4.5/5 (122)
- The Emperor of All Maladies: A Biography of CancerFrom EverandThe Emperor of All Maladies: A Biography of CancerRating: 4.5 out of 5 stars4.5/5 (271)
- The Little Book of Hygge: Danish Secrets to Happy LivingFrom EverandThe Little Book of Hygge: Danish Secrets to Happy LivingRating: 3.5 out of 5 stars3.5/5 (403)
- Devil in the Grove: Thurgood Marshall, the Groveland Boys, and the Dawn of a New AmericaFrom EverandDevil in the Grove: Thurgood Marshall, the Groveland Boys, and the Dawn of a New AmericaRating: 4.5 out of 5 stars4.5/5 (266)
- The World Is Flat 3.0: A Brief History of the Twenty-first CenturyFrom EverandThe World Is Flat 3.0: A Brief History of the Twenty-first CenturyRating: 3.5 out of 5 stars3.5/5 (2259)
- The Yellow House: A Memoir (2019 National Book Award Winner)From EverandThe Yellow House: A Memoir (2019 National Book Award Winner)Rating: 4 out of 5 stars4/5 (98)
- A Heartbreaking Work Of Staggering Genius: A Memoir Based on a True StoryFrom EverandA Heartbreaking Work Of Staggering Genius: A Memoir Based on a True StoryRating: 3.5 out of 5 stars3.5/5 (231)
- Team of Rivals: The Political Genius of Abraham LincolnFrom EverandTeam of Rivals: The Political Genius of Abraham LincolnRating: 4.5 out of 5 stars4.5/5 (234)
- On Fire: The (Burning) Case for a Green New DealFrom EverandOn Fire: The (Burning) Case for a Green New DealRating: 4 out of 5 stars4/5 (74)
- The Unwinding: An Inner History of the New AmericaFrom EverandThe Unwinding: An Inner History of the New AmericaRating: 4 out of 5 stars4/5 (45)
- Ds Lab Manual - 2018Document145 pagesDs Lab Manual - 2018Selva612No ratings yet
- Requirement Elicitation TechniquesDocument16 pagesRequirement Elicitation TechniquesSelva612100% (1)
- StakeholdersDocument12 pagesStakeholdersvigneshkarthik23No ratings yet
- BPO Management System - RecordDocument6 pagesBPO Management System - RecordSelva612No ratings yet
- CS2251 QBDocument7 pagesCS2251 QBSelva612No ratings yet
