UNIT-I

By Neha Gulati
OVERVIEW
 Java Programming:  Inheritance:
 Introduction  Super class
 Data types  Sub class
 Access specifiers  this and super operator
 Operators  Method overriding
 Control statements  Use of final
 Arrays.  Packages
 Abstract class
 Classes:  Interface.
 Fundamentals
 Objects
 Polymorphism:
 Method overloading
 Methods
 Constructor overloading
 Constructors.
INTRODUCTION
 Java is an object oriented programming language that makes you do
anything you can do with any other programming language.
 Java is related to C++ which is direct descendent of C. Much of its
characteristics java derive from these two languages.
 Java derives its syntax from C, and its OOPs features were
influenced by C++.
 Primary motivation behind java was need of platform independent
language.

Java
C++ CC
HISTORY
 Java is a general purpose, object oriented programming language platform
developed by Sun Microsystems in 1991, originally called “Oak”, but
renamed “java” in 1995.
 Java was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed
frank and Mike Sheridan at Sun Microsystems.
 The idea is to create a platform independent language that could be used to
produce code that would run on a variety of CPUs under differing
environments.
• It is designed for the development of software for consumer electronics
devices like TV,VCRs, toasters and such other electronic machine.
• This new language is based on C and C++ but removed features of C and C++
that were considered as problems in these languages and this makes java
reliable , simple and robust language.
• Java is not replacement of C++, They both are designed to solve different set
of problems , so can coexist for many years.
• Most striking features of java is “Platform neutral” language. Java is first
programming language that is not tied to any particular hardware, OS or
platform. Programs developed in java can be executed anywhere on any
system.
JAVA VS C++
 C++ is platform dependent but java is platform independent
 No More header files, Typedefs, Defines, or Preprocessor -Packages
 No More Structures or Unions –Instance variables, No Enums
 No More Multiple Inheritance but can be achieved using interfaces
 Java does not support global variable
 No More Goto Statements
 No More Operator Overloading
 No More Pointers
 Java does not have template class as in C++
 Java had replaced the destructor function with a finalize() function.
JAVA FEATURES
• Java is simple, small and familiar :
• Because java inherits the C/C++ syntax and many of OOPS features of
C++.
• Java does not use pointers, preprocessor header files, goto statement
and many more.
• It also eliminates operator overloading and multiple inheritance.
• It is modeled on C and C++ , so syntax is familiar.
• Complied and Interpreted:
• Java is two stage system that combines both compilation and
interpretation.
• Firstly java compiler translate source code into bytecode instruction,
then java interpreter converts bytecode into machine code and run java
program.
• Object Oriented:
• Java is true object oriented.
• All program code and data reside within objects and classes.
• Even the main function is inside a class.
CONTD…
 Platform Independent and Portable:
 Java programs can be easily moved from one computer system to
another, anywhere and anytime.
 Changes in OS, processor and system resources will not force and
changes in java program. Why?
 Because:
 Java compiler generates bytecode not machine language which is machine
independent.
 Size of primitive data types are machine independent.
 Java is secure and robust:
 Java program is secure by confining a java program to java execution
environment and not allowing it access to other parts of the computer.
 Java programs are robust as they are build for multiplatform
environment. Moreover a program is said to be robust if it handles
memory management and exception condition.
CONTD…
• Java is distributed :
• Java is distributed because the program of java is compiled onto one
machine can be easily transferred to machine and executes them on
another machine. So java is specially designed for internet users which
uses the Remote Computers for executing the programs on local
machine after transferring the programs from remote computers or
either from internet.
• Java is multithreaded:
• Means handling multiple tasks simultaneously. This means we need not
wait for the application to finish one tasks before beginning another.
• Java is dynamic:
• Java is capable of dynamically linking in new class libraries , methods
and objects. Java can also determine the type of class through a query,
making it possible to either dynamically link or abort the program,
depending on the response.
WHY JAVA IS PLATFORM INDEPENDENT?
WORKING OF JAVA
 Java solves the problem of platform-independence by using byte code.
 The Java compiler does not produce native executable code for a particular
machine like a C compiler would. Instead it produces a special format
called byte code.
 Java byte code is exactly the same on every platform.
 This byte code fragment means the same thing on a Solaris workstation as it
does on a Macintosh.
 Java programs that have been compiled into byte code still need an
interpreter to execute them on any given platform.
 The interpreter reads the byte code and translates it into the native language
of the host machine on the fly.
 Since the byte code is completely platform independent, only the interpreter
and a few native libraries need to be ported to get Java to run on a new
computer or operating system.
 The rest of the runtime environment including the compiler and most of the
class libraries are written in Java.
 All these pieces, the javac compiler, the java interpreter, the Java
programming language, and more are collectively referred to as Java.
BYTECODE
 The key that solves both security and portability problems is the
Bytecode, output of java compiler which is not executable code.
 It is highly optimized set of instructions designed to be executed by
the java runtime system, which is called the java Virtual
Machine(JVM). JVM is an interpreter for bytecode.
 Translating a java program into bytecode makes it much easier to
run a program in a wide variety of environments because only the
JVM needs to be implemented for each platform.
 Once a runtime package exists for given system, any java program
can run on it.
 Although the details of JVM will differ from platform to platform ,
all understand the same java bytecode. Thus , the execution of
bytecode by the JVM is the easiest way to create truly portable
programs.
CONTD…
 The fact that a java program is executed by JVM also helps to make
it secure because the JVM is in control, it contain the program and
prevent it from generating side effects outside the system.
 When a program is complied to an intermediate form and the
interpreted by a virtual machine, it runs slower than it would run if
complied to executed code.
 But in case of java the difference is not so great because bytecode is
highly optimized, the use of bytecode enables the JVM to execute
programs much faster that you might expect.
JAVA VIRTUAL MACHINE (JVM)
 JVM (Java Virtual Machine) is an abstract machine. It is called a
virtual machine because it doesn't physically exist.
 It is a specification that provides a runtime environment in which
Java bytecode can be executed.
 It can also run those programs which are written in other languages
and compiled to Java bytecode.
CONTD…
 JVMs are available for many hardware and software platforms.
JVM, JRE, and JDK are platform dependent because the
configuration of each operating system is different from each other.
 However, Java is platform independent.
 The JVM performs the following main tasks:
 Loads code
 Verifies code
 Executes code
 Provides runtime environment
JAVA RUNTIME ENVIRONMENT (JRE)
 JRE is an acronym for Java Runtime Environment. It is also written
as Java RTE.
 The Java Runtime Environment is a set of software tools which are
used for running Java applications.
 It is used to provide the runtime environment. It is the
implementation of JVM.
 It physically exists.
 It contains a set of libraries + other files that JVM uses at runtime.
JAVA DEVELOPMENT KIT (JDK)
 JDK is an acronym for Java Development Kit. The Java
Development Kit (JDK) is a software development environment
which is used to develop Java applications and applets.
 It physically exists.
 It contains JRE + development tools.
 The JDK contains a private Java Virtual Machine (JVM) and a few
other resources such as an interpreter/loader (java), a compiler
(javac), an archiver (jar), a documentation generator (Javadoc), etc.
to complete the development of a Java Application.
DIFFERENCE BETWEEN JDK, JRE, AND JVM
 To develop and run a java program we need the environment JDK.
 Only to run a java program we need JRE environment.
 So, I can say as a software developer I need to develop JAVA
application, I need JDK but on the client side, he/she needs JRE
only as it has to run the application not develop.
 JVM is responsible to run java programs line by line as an
interpreter.
JAVA ARCHITECTURE
 Java's architecture arises out of four distinct but interrelated
technologies:
 the Java programming language
 the Java class file format
 the Java Application Programming Interface
 the Java virtual machine

 When you write and execute java program , all these technologies
are used in following way:
 You write source file in java programming language.
 Java compiler(javac) compile java source file into java class file.
 Your program accesses system resources by calling methods in the
classes that implements java API , this is done by invoking methods in
class file that implements java API.
 JVM is responsible to execute class files generated by java compiler.

 Together JVM and java API form a platform for which all java
programs are executed.
JAVA PROGRAMMING ENVIRONMENT
JAVA PROGRAM RUN ON TOP OF JAVA
PLATFORM
 the combination of the Java virtual machine and Java API is called
the Java Platform.
 Java programs can run on many different kinds of computers because
the Java Platform can itself be implemented in software.
 Java program can run anywhere the Java Platform is present.
JVM ARCHITECTURE
 JVM is the heart of Java architecture and supports all three features
of java:
 platform independence, security and network mobility.
EXPLANATION
 Class Loader Sub-System: It performs the task in a sequential
way:
 It loads a class file.
 It checks the correctness of the class file. If any one has manipulated the
class file, then the class file can not be executed.
 It allocates the memory for static variables.
 It sets the default value of all static variable.

 Method Area:
 It is a logical memory component of JVM.
 This logical section of memory holds the information about classes and
interfaces.
 Static variables are treated as class variables, because they take memory
from method area.
CONTD…
 Heap:
 When object or array is created, memory is allocated to them from
heap.
 JVM through the use of new operator allocates memory from the heap
for an object.
 The JVM has a daemon thread known as Garbage Collector whose task
is to free those objects from heap whose reference is not alive in stack.
 Java Stack:
 Method codes are stored inside method area.
 For execution, a method needs memory because of local variables and
the arguments it has taken.
 This purpose is fulfilled by java stack.

 Program Counter:
 It keeps track of the sequence of the program.
 PC register holds the address of the instructions to be executed next.
CONTD…
 Native Method Stack:
 When a java application invokes a native method, that application does
not only use java stack but also use the native method stack for the
execution of native methods.
 The libraries required for the execution of native methods are available
to the JVM through Java Native Interface.
 Execution Engine:
 Generate and executes the java byte code.
 It contains an interpreter and Just In Time compiler.

 Java Native interface:

 JNI is used when the programmer has already developed the code in C/
C++ and wishes to make it accessible to java code.
 JNI never imposes any restriction on JVM.
 JVM can add support to JNI without affecting other parts of virtual
machine.
 Native methods accesses JVM features by calling JNI functions.
BASIC JAVA PROGRAM
PATH AND CLASSPATH IN JAVA
 PATH:
 PATH environment variable is used by operating system to find any
binary or command typed in shell, this is true for both Windows and
Linux environment.
 It is an environment variable which is used to locate JDK binaries like
"java" or "javac" command used to run java program and compile java
source file.

 CLASSPATH:
 It is only used by Java Class Loaders to load class files.
 CLASSPATH environment variable is used by System or Application
ClassLoader to locate and load compile Java bytecodes stored in .class
file.
HOW TO SET PATH IN JAVA?
 There are two ways to set the path in Java:
 Temporary
 Permanent

 How to set the Temporary Path of JDK in Windows?

 To set the temporary path of JDK, you need to follow the following
steps:
 Open the command prompt
 Copy the path of the JDK/bin directory
 Write in command prompt: set path=copied_path

 For Example:
 set path=C:\Program Files\Java\jdk1.6.0_23\bin
CONTD…
 How to set Permanent Path of JDK in Windows?
 For setting the permanent path of JDK, you need to follow these
steps:
 Go to MyComputer properties -> advanced tab -> environment
variables -> new tab of user variable -> write path in variable name ->
write path of bin folder in variable value -> ok -> ok -> ok
JAVA CODE EXECUTION
 Java code can be executed using notepad and command prompt.
 Java code cab be executed using any IDE Eclipse, NetBeans.
GETTING STARTED WITH JAVA PROGRAMMING
 A Simple Java Application
 Compiling Programs
 Executing Applications
ENTERING A PROGRAM
 For most of the programs the name of the file that holds the source
code to a program is immaterial. However, this is not the case with
java. the first thing that you must learn about java is that name you
give to a source file is very important.
 In java a source file is a compilation unit. It is a text file that
contains one or more class definitions. The java compiler requires
that a source file use the .java filename extension.
 In java all code must reside inside a class. By convention, the name
of that class should match the name of the file that holds the
program. You should also make sure that the capitalization of the
filename matches the class name. the reason for this is that java is
case sensitive . At this point , the convention that filename
correspond to class names may seem arbitrary. However, this
convention makes it easier to maintain and organize your program.
CONTD…
 To compile the program use javac filename. java.
 The javac compiler creates a file called filename.class that contains
the byte code version of the program. As we know that java byte
code is the intermediate representation of your program that
contains instructions that JVM (Java Virtual Machine) will execute.
Thus, the output of the javac is not code that can be directly
executed.
 To run the program you have to use java application launcher ,
called (JVM). For execution use: java filename
RULES FOR WRITING JAVA PROGRAM
 Always start with class keyword
 After type the program, save the file in the name of the class. ( ex:
test.java)
 Source file name and class name should be same(even case also).
 Extension must be .java
 Compile the file using javac compiler
 C:\>javac test.java
 Running we must use java interpreter
 C:\>java test
CREATING AND COMPILING PROGRAMS
Create/Modify Source Code
 On command line for
compilation
 javac Welcome.java
Source Code
 On command line for
execution Compile Source Code
i.e. javac Welcome.java
 java Welcome If compilation errors

Bytecode

Run Byteode
i.e. java Welcome

Result

If runtime errors or incorrect result

FIRST JAVA PROGRAM
1.class test
2./* this is a first program */
3. {
4. public static void main (String args[])
5. {
6. system.out.println(“welcome to the world of java”);
7. }
8. }

 save this file as test.java

 To compile:
 javac test.java
 To execute:
 java test
DETAILS FOR THE PROGRAM
 First line uses to declare a new class is being defined.
 Second –Comments. We can use
 // - Single line Comment
 /* ……… */ -multiple line comment
 Fourth line:
 public – It is an access specifier. main() must be declared as public,
since it must be called by code outside of its class when the program is
started.
 static – to be called without creating the object of that class. This is
necessary since main() is called by JVM before any object are made.
 void – simply tells the compiler that main does not return any value.
 main() – Line at which the program will begin executing. Main() is
different from main(), since java is case sensitive.
 String args[] –Parameter named args is passing to main method. It is an
array of instances of the class String. In normal case args receive any
command line arguments present when the program is executed.
CONTD…
 Sixth line – Output to the screen.
 System – class
 out – static member of system class. represents output stream that is
connected to the console.
 println() – method
WHAT IS SYSTEM.OUT.PRINTLN() ?
 System.out.println prints the argument passed, into the System.out
which is generally stdout.
 System – is a final class and cannot be inherited. As per javadoc,
“…Among the facilities provided by the System class are standard
input, standard output, and error output streams;
 out – is a static member field of System class and is of
type PrintStream. Its access specifiers are public final. This gets
instantiated during startup and gets mapped with standard output
console of the host. This stream is open by itself immediately after
its instantiation and ready to accept data.
 println – println prints the argument passed to the standard console
and a newline. There are multiple println methods with different
arguments (overloading). Every println makes a call to print method
and adds a newline. print calls write() and the story goes on like
that.
DATA INPUT IN JAVA
 There are various ways to accept input from user in java program, one of the easiest ways is
using scanner class of util package.
 This class has following functions to accept different types of data from user:
 Public String next()
Finds and returns the next complete token from this scanner.
 Public boolean nextBoolean()
Scans the next token of the input into a boolean value and returns that value.
 Public byte nextByte()
Scans the next token of the input as a byte.
 Public double nextDouble()
Scans the next token of the input as a double.
 Public float nextFloat()
Scans the next token of the input as a float.
 Public int nextInt()
Scans the next token of the input as an int.
 Public String nextLine()
Advances this scanner past the current line and returns the input that was skipped.
 Public long nextLong()
Scans the next token of the input as a long.
 Public short nextShort()
Scans the next token of the input as a short.
DATA TYPES
 Data types specify the different sizes and values that can be stored
in the variable. There are two types of data types in Java:
 Primitive data types: The primitive data types include boolean,
char, byte, short, int, long, float and double.
 Non-primitive data types: The non-primitive data types include
Classes, Interfaces, and Arrays.

 Java defines eight primitive (or elemental) types of data: byte,

short, int, long, char, float, double, and boolean.
 These can be put in four groups:
 Integers: This group includes byte, short, int, and long, which are for
whole valued signed numbers.
 Floating-point numbers: This group includes float and double, which
represent numbers with fractional precision.
 Characters: This group includes char, which represents symbols in a
character set, like letters and numbers.
 Boolean: This group includes Boolean, which is a special type for
representing true/false values
DATA TYPES
 INTEGERS
 Java defines four integer types: byte, short, int, and long. All of these
are signed, positive and negative values.
 long 64, int 32, short 16, byte 8

 BYTE
 The smallest integer type is byte. This is a signed 8-bit type that has a
range from –128 to 127.
 Variables of type byte are especially useful when you’re working with a
stream of data from a network or file. They are also useful when you’re
working with raw binary data that may not be directly compatible with
Java’s other built-in types.
CONTD…
 short
 short is a signed 16-bit type. It has a range from –32,768 to 32,767. It is
probably the least-used Java type, since it is defined as having its high
byte first
 int
 The most commonly used integer type is int. It is a signed 32-bit type
that has a range from –2,147,483,648 to 2,147,483,647. In addition to
other uses, variables of type int are commonly employed to control
loops and to index arrays.
 long
 long is a signed 64-bit type and is useful for those occasions where an
int type is not large enough to hold the desired value.
 The range of a long is quite large. This makes it useful when big, whole
numbers are needed.
CONTD…
 Floating-Point Types
 Floating-point numbers, also known as real numbers, are used when
evaluating expressions that require fractional precision.
 float
 The type float specifies a single-precision value that uses 32 bits of
storage.
 Single precision is faster on some processors and takes half as much
space as double precision, but will become imprecise when the values
are either very large or very small
 double
 Double precision, as denoted by the double keyword, uses 64 bits to
store a value.
 Double precision is actually faster than single precision on some
modern processors that have been optimized for high-speed
mathematical calculations.
 All math functions, such as sin( ), cos( ), and sqrt( ), return double
values.
CONTD…
 Characters
 In Java, the data type used to store characters is char. However, C/C++
programmers beware: char in Java is not the same as char in C or C++.
 In C/C++, char is an integer type that is 8 bits wide. This is not the case
in Java.
 Instead, Java uses Unicode to represent characters. Unicode defines a
fully international character set that can represent all of the characters
found in all human languages, in Java char is a 16-bit type.
 Booleans
 Java has a simple type, called boolean, for logical values. It can have
only one of two possible values, true or false.
DEFAULT VALUES OF DATA TYPES
WHY CHAR USES 2 BYTE IN JAVA AND
WHAT IS \U0000 ?
 It is because java uses Unicode system not ASCII code system.
The \u0000 is the lowest range of Unicode system.

WHY JAVA USES UNICODE SYSTEM?

 Before Unicode, there were many language standards: ASCII ,ISO 8859-1,KOI-
8,GB18030 and so on.
 This caused two problems:
 A particular code value corresponds to different letters in the various language
standards.
 The encodings for languages with large character sets have variable length. Some
common characters are encoded as single bytes, other require two or more byte.
 To solve these problems, a new language standard was developed i.e. Unicode System.
In Unicode, character holds 2 byte, so java also uses 2 byte for characters.
 lowest value:\u0000, highest value:\uFFFF
JAVA VARIABLES
 Variable is name of reserved area allocated in memory. In other
words, it is a name of memory location.
 It is a combination of "vary + able" that means its value can be
changed.

int data=10;//Here data is variable

DECLARING AND INITIALIZING A VARIABLE:
 DECLARING VARIABLES
 In Java, all variables must be declared before they can be used. The
basic form of a variable declaration is shown here:
type identifier [ = value][, identifier [= value] ...] ;
 The type is one of Java’s atomic types, or the name of a class or
interface. The identifier is the name of the variable. You can
initialize the variable by specifying an equal sign and a value.
 Some examples:
 int a, b, c; // declares three ints, a, b, and c.
 int d = 3, e, f = 5; // declares three more ints, initializing d and f.
 byte z = 22; // initializes z.
 double pi = 3.14159; // declares an approximation of pi.
 char x = 'x'; // the variable x has the value 'x'.
CONTD…
 Dynamic Initialization:
 Initialization is the process of providing value to a variable at
declaration time.
 A variable is initialized once in its life time. Any attempt of setting a
variable's value after its declaration is called assignment.
 To use a local variable you have to either initialize or assign it
before the variable is first used. But for class members, the
compulsion is not so strict.
 If you don't initialize them then compiler takes care of the
initialization process and set class members to default values.
 Java allows variables to be initialized dynamically, using any
expression valid at the time the variable is declared.
CONTD…
 Example- Here variable dynSqrt is initialized dynamically .The
program uses another of Java’s built-in methods, sqrt( ), which is a
member of the Math class, to compute the square root of its
argument.
TYPES OF VARIABLES
 There are three types of variables in java:
 local variable
 instance variable
 static variable
LOCAL VARIABLES
 Local variables are declared in methods, constructors, or blocks.
 Local variables are created when the method, constructor or block is
entered and the variable will be destroyed once it exits the method,
constructor, or block.
 Access modifiers cannot be used for local variables.
 Local variables are visible only within the declared method,
constructor, or block.
 Local variables are implemented at stack level internally.
 There is no default value for local variables, so local variables
should be declared and an initial value should be assigned before the
first use.
EXAMPLE
 Here, age is a local variable. This is defined inside pupAge() method
and its scope is limited to only this method.
INSTANCE VARIABLES
 Instance variables are declared in a class, but outside a method,
constructor or any block.
 When a space is allocated for an object in the heap, a slot for each
instance variable value is created.
 Instance variables are created when an object is created with the use
of the keyword 'new' and destroyed when the object is destroyed.
 Instance variables can be declared in class level before or after use.
 Access modifiers can be given for instance variables.
 The instance variables are visible for all methods, constructors and
block in the class. Normally, it is recommended to make these
variables private (access level). However, visibility for subclasses
can be given for these variables with the use of access modifiers.
CONTD…
 Instance variables have default values. For numbers, the default value is 0, for
Booleans it is false, and for object references it is null. Values can be assigned
during the declaration or within the constructor.

OUTPUT:
name : Manisha
salary :5000.0
CLASS/STATIC VARIABLES
 Class variables also known as static variables are declared with the
static keyword in a class, but outside a method, constructor or a block.
 There would only be one copy of each class variable per class,
regardless of how many objects are created from it.
 Static variables are rarely used other than being declared as constants.
Constants are variables that are declared as public/private, final, and
static. Constant variables never change from their initial value.
 Static variables are stored in the static memory. It is rare to use static
variables other than declared final and used as either public or private
constants.
 Static variables are created when the program starts and destroyed when
the program stops.
 Visibility is similar to instance variables. However, most static variables
are declared public since they must be available for users of the class.
 Default values are same as instance variables.
CONTD…
 Static variables can be accessed by calling with the class
name ClassName.VariableName.
EXAMPLE TO UNDERSTAND THE TYPES OF VARIABLES IN
JAVA
SCOPE AND LIFETIME OF VARIABLES
 Scope of a variable refers to in which areas or sections of a program
can the variable be accessed and lifetime of a variable refers to how
long the variable stays alive in memory.
 General convention for a variable’s scope is, it is accessible only
within the block in which it is declared. A block begins with a left
curly brace { and ends with a right curly brace }.
 As we know there are three types of variables:
 1) instance variables
 2) class variables and
 3) local variables

 we will look at the scope and lifetime of each of them now.

CONTD…
 Instance Variables:
 General scope of an instance variable is throughout the class
except in static methods.
 Lifetime of an instance variable is until the object stays in
memory.
CONTD…
 Class Variables:
 General scope of a class variable is throughout the class and
the lifetime of a class variable is until the end of the program or as
long as the class is loaded in memory.
CONTD…
 Local Variables:
 Scope of a local variable is within the block in which it is declared
and the lifetime of a local variable is until the control leaves the
block in which it is declared
NESTED SCOPE
 All the local variables in the outer block are accessible within the inner
block but vice versa is not true i.e., local variables within the inner block
are not accessible in the outer block. Consider the following example:

NOTE: As you can see in the above program, line 14 generates an error as the variable y is not
visible in the outer block and therefore cannot be accessed.
TYPE CONVERSION AND CASTING
 When you assign value of one data type to another, the two types
might not be compatible with each other.
 If the two types are compatible, then Java will perform the
conversion automatically known as Automatic Type Conversion or
Implicit Coversion. For example, it is always possible to assign an
int value to a long variable.
 However, not all types are compatible, and thus, not all type
conversions are implicitly allowed. For instance, there is no
conversion defined from double to byte.
 Fortunately, it is still possible to obtain a conversion between
incompatible types. To do so, you must use a cast, which performs
an explicit conversion between incompatible types.
IMPLICIT CONVERSION OR COERCION
 Implicit conversion takes place when two data types are
automatically converted. This happens when:
 The two data types are compatible.
 When we assign value of a smaller data type to a bigger data type.

 For example, Java will automatically convert a value

of byte into int type in expressions since they are both compatible
and int is larger than byte type.
 Since a smaller range type is converted into a larger range type this
conversion is also known as widening conversion. Characters can
never be converted to boolean type. Both are incompatible.
EXAMPLE-
EXPLICIT CONVERSION OR NARROWING
 There may be situations where
you want to convert a value
having a type of size less than
the destination type size.
 In such cases Java will not help
you.
 You have do it on your own
explicitly.
 That is why this type of
conversion is known as explicit
conversion or casting as the
programmer does this manually.
EXAMPLE-
class Conversion {
public static void main(String args[]) {
byte b;
int i = 257;
double d = 323.142;
System.out.println("\nConversion of int to byte.");
b = (byte) i;
System.out.println("i and b " + i + " " + b);
System.out.println("\nConversion of double to int.");
i = (int) d;
System.out.println("d and i " + d + " " + i);
System.out.println("\nConversion of double to byte.");
b = (byte) d;
System.out.println("d and b " + d + " " + b);
}
}
CONTD…
 In the last example, I am forcing an integer value to be converted
into a byte type. For type casting to be carried out both the source
and destination types must be compatible with each other. For
example, you can’t convert an integer to Boolean even if you force
it.
 In the last example, size of source type int is 32 bits and size of
destination type byte is 8 bits. Since we are converting a source type
having larger size into a destination type having less size, such
conversion is known as narrowing conversion.
 A type cast can have unexpected behavior. For example, if
a double is converted into an int, the fraction component will be
lost.
EXAMPLE-
CONTD…
 This program generates the following output:

Conversion of int to byte.

i and b 257 1
Conversion of double to int.
d and i 323.142 323
Conversion of double to byte.
d and b 323.142 67
ARRAYS
 An array is a structure that holds multiple values of the same type .
 Arrays can be one dimensional or more.
 The length of an array is established when the array is created (at
runtime).
 After creation, an array is a fixed-length structure.
 An array element is one of the values within an array and is
accessed by its position within the array.
 Arrays can hold reference types as well as primitive types
CONTD…
 Advantages:
 Code Optimization: It makes the code optimized, we can retrieve or
sort the data efficiently.
 Random access: We can get any data located at an index position.

 Disadvantages:
 Size Limit: We can store only the fixed size of elements in the array. It
doesn't grow its size at runtime. To solve this problem, collection
framework is used in Java which grows automatically.

 Types of Array in java:

 There are two types of array.
 Single Dimensional Array
 Multidimensional Array
HOW TO CREATE AN ARRAY?(1-DIMESIONAL)
1. Declare the Array
2. Create memory location
3. Put values into the memory Location

Declare the Array:

 An array declaration has two components: the array's type and the array's
name.
 datatype arrayname[];
 datatype[] arrayname;
 ex : int marks[]; int[] marks;
 In java it is required to allocate memory to an array using new operator.
 Till declaration just array variable is there, no array exists.
 For the physical allocation of memory it is required to use new operator or
directly assign values to array location.
 After initialization all the elements of an array will be automatically
initialized to 0.
 Remember we do not enter the size of arrays in the declaration.
CONTD…
Creating Memory location:
 You create an array explicitly using Java's new operator.

 Arrayname = new type[];

 Eg: marks = new int[10]; // create an array of integers

 It is possible to combine declaration and creation in one step like :

 int number = new int[5];

Initialization of Arrays:
 An array initializer is a list of comma separated expressions
surrounded by curly braces.
 Arrayname [subscript] = value;

 Marks[i] =100;

 int marks[] = {70,80,56,78};

EXAMPLE OF 1-D ARRAY
AGGREGATE ARRAY OPERATIONS:
 You can perform same operation on arrays as we do on a series of
input values.
 To perform an operation on all elements in an array, we use a loop
to perform the operation on each element.
 Example to print all elements in an array:
for(int i=0;i<arr.length;i++)
{
System.out.println(arr[i]);
}
EXAMPLE TO SORT AN ARRAY IN ASCENDING ORDER
class sort
{
public static void main(String args[]) {
int number[]={100,45,78,56,72};
int len;
len=number.length;
System.out.println(“Unsorted list”);
for(int i=0;i<len;i++) {
System.out.println(“ “ + nmber[i]);
}
for(int i=0;i<len-1;i++) {
for(j=i+1;j<len;j++) {
if(number[i]>number[j]) {
int temp=number[i];
number[i]=number[j];
number[j]=temp; } } }
System.out.println(“\n Ascending order”);
for (int i=0;i<len;i++) {
System.out.println(“ “ + number[i]); }
System.out.println(“Descending order”);
for (int i=len-1;i>=0;i--)
System.out.println(“ “ + number[i]);
}

}
EXAMPLE TO SUM ELEMENTS OF ARRAY
class SummingArrayElements
{
public static void main(String args[])
{
double total=0.0;
double []scores=new double[6];
scores[0]=12.2;
scores[1]=33.90;
scores[2]=16.00;
scores[3]=22.90;
scores[4]=11.00;
scores[5]=134.90;
for(int i=0;i<scores.length;i++)
total+=scores[i];
System.out.println(“Scores total=” + total);
}
}
THE FOREACH LOOPS
 JDK 1.5 introduced a new for loop known as foreach loop or
enhanced for loop, which enables you to traverse the complete array
sequentially without using an index variable.
COPYING ARRAYS
 Arrays are reference types, so by declaring a reference and
assigning it to an existing array, you are not creating two objects,
you are just creating two references that point to the same array.
 Manipulation of one these objects will affect the other.
EXAMPLE-
OTHERWAYS TO MAKE COPY OF AN ARRAY
 Iterating over an array
 Using Clone()
 Using System.arraycopy()
1)ITERATING OVER AN ARRAY
2)USING CLONE()
3)USING ARRAYCOPY()
MULTIDIMENSIONAL ARRAY
 In java multidimensional arrays are actually arrays of arrays. To
declare a multidimensional array variable, specify each additional
index using another set of square brackets.
int two_array [] [] = new int [4][5]
 In above declared two dimensional array, left index determines row
and right index determines column.

Ex : int marks[][] = new int[3][3]

CONTD…
 When you allocate memory for a multidimensional array, you need
only specify the memory for the first (leftmost) dimension. You can
allocate the remaining dimensions separately.
 For example, this following code allocates memory for the first
dimension of marks when it is declared. It allocates the second
dimension manually.
 int marks[][] = new int[4][];
 marks[0] = new int[5];
 marks[1] = new int[5];
 marks[2] = new int[5];
 marks[3] = new int[5];
CONTD…
 Manually allocate differing size second dimensions.
ALTERNATIVE ARRAY DECLARATION SYNTAX
 Datatype name_of_array [ ] ;
 Datatype [ ] name_of_array;
int a1[ ] = new int[3];
int [ ] a1 = new int[3];
int a1[ ][ ] = new int [4][5];
int [ ][ ]a1 = new int [3][4];
int [ ] a1,a2,a3;
int a1[ ], a2[ ],a3[ ];
COMMAND LINE ARGUMENTS
 A command-line argument is the information that directly follows
the program’s name on the command line when it is executed.
 To access the command-line arguments inside a Java program is
quite easy—they are stored as strings in the String array passed to
main( ).
 For example, the following program displays all of the command-
line arguments that it is called with:
CONTD…
OPERATORS
 Java provides a rich operator environment. Most of its operators can
be divided into the following four groups:
 Arithmetic
 Bitwise
 Relational
 Logical
THE ARITHMETIC OPERATORS
 Arithmetic operators are used in mathematical expressions in the same way
that they are used in algebra.
 The following table lists the arithmetic operators (Assume integer variable
A holds 10 and variable B holds 20)
THE RELATIONAL OPERATORS
 The relational operators determine the relationship that one operand
has to the other. Specifically, they determine equality and ordering.
 Assume variable A holds 10 and variable B holds 20
THE BITWISE OPERATORS
 Java defines several bitwise operators, which can be applied to the
integer types, long, int, short, char, and byte.
 Bitwise operator works on bits and performs bit-by-bit operation.
Assume if a = 60 and b = 13; now in binary format they will be as
follows −
a = 0011 1100
b = 0000 1101
 a&b = 0000 1100
 a|b = 0011 1101
 a^b = 0011 0001
 ~a = 1100 0011
 The following table lists the bitwise operators −
CONTD…
 Assume integer variable A holds 60 and variable B holds 13
THE LOGICAL OPERATORS
 Assume Boolean variables A holds true and variable B holds false
THE ASSIGNMENT OPERATORS
CONTD…
MISCELLANEOUS OPERATORS
 There are few other operators supported by Java Language.
 Conditional Operator ( ? : )
 Conditional operator is also known as the ternary operator. This
operator consists of three operands and is used to evaluate Boolean
expressions. The goal of the operator is to decide, which value
should be assigned to the variable. The operator is written as −
 variable x = (expression) ? value if true : value if false
CONTD…
 instanceof Operator
 This operator is used only for object reference variables. The
operator checks whether the object is of a particular type (class type
or interface type). instanceof operator is written as −
 ( Object reference variable ) instanceof (class/interface type)
 If the object referred by the variable on the left side of the operator
passes the IS-A check for the class/interface type on the right side,
then the result will be true.
 Following is an example
CONTD…
PRECEDENCE OF JAVA OPERATORS
CONTROL STATEMENTS
 In Java, control statements can be divided into the following three
categories:
 Selection Statements
 Iteration Statements
 Jump Statements
SELECTION STATEMENTS
 Selection statements allow you to control the flow of program
execution on the basis of the outcome of an expression or state of a
variable known during runtime.

 Selection statements can be divided into the following categories:

 The if and if-else statements
 The if-else statements
 The if-else-if statements
 The switch statements
THE IF STATEMENTS
 The first contained statement (that can be a block) of an if statement
only executes when the specified condition is true.
 If the condition is false and there is not else keyword then the first
contained statement will be skipped and execution continues with the
rest of the program.
THE IF-ELSE STATEMENTS
 In if-else statements, if the specified condition in the if statement is
false, then the statement after the else keyword (that can be a block)
will execute.
THE IF-ELSE-IF STATEMENTS
 This statement following the else keyword can be another if or if-
else statement.

That would looks like this:

if(condition)
statements;
else if (condition)
statements;
else if(condition)
statement;
else
statements;

Whenever the condition is true, the associated statement will be

executed and the remaining conditions will be bypassed. If none of
the conditions are true then the else block will execute.
CONTD…
THE SWITCH STATEMENTS
 The switch statement is a multi-way branch statement. The switch statement of Java
is another selection statement that defines multiple paths of execution of a program.
 It provides a better alternative than a large series of if-else-if statements.
ITERATION STATEMENTS
 Repeating the same code fragment several times until a specified
condition is satisfied is called iteration. Iteration statements execute
the same set of instructions until a termination condition is met.

Java provides the following loop for iteration statements:

 The while loop
 The for loop
 The do-while loop
 The for each loop
THE WHILE LOOP
 It continually executes a statement (that is usually be a block) while
a condition is true. The condition must return a boolean value.
THE DO-WHILE LOOP
 The only difference between a while and a do-while loop is that do-while
evaluates its expression at the bottom of the loop instead of the top.
 The do-while loop executes at least one time then it will check the expression
prior to the next iteration.
THE FOR LOOP
 A for loop executes a statement (that is usually a block) as long as the boolean
condition evaluates to true. A for loop is a combination of the three elements
initialization statement, boolean expression and increment or decrement
statement.

Syntax:

for(<initialization>;<condition>;<increment or decrement statement>){

<block of code>
}

The initialization block executes first before the loop starts. It is used to
initialize the loop variable.

The condition statement evaluates every time prior to when the statement (that
is usually be a block) executes, if the condition is true then only the statement
(that is usually a block) will execute.

The increment or decrement statement executes every time after the statement
(that is usually a block).
EXAMPLE-
THE FOR EACH LOOP
 This was introduced in Java 5. This loop is basically used to traverse
the array or collection elements.
NESTED LOOPS
 Java allows loops to be nested (i.e., loops within loops) like all the
other programming languages allows.
 Nested loops means loops within loops. In other words, nested loops
means, loop inside loop inside loop and so on.
CONTD…
 Let's look at one more example which also demonstrate the nested
loops:
JUMP STATEMENTS
 Jump statements are used to unconditionally transfer the program
control to another part of the program.

 Java provides the following jump statements:

 break statement
 continue statement
 return statement
BREAK STATEMENT
 The break statement immediately quits the current iteration and goes
to the first statement following the loop. Another form of break is
used in the switch statement.
 The break statement has the following two forms:
 Labeled Break Statement
 Unlabeled Break Statement

 Unlabeled Break Statement: This is used to jump program control

out of the specific loop on the specific condition.
CONTD…
 Labeled Break Statement: This is used for when we want to jump
the program control out of nested loops or multiple loops.
CONTINUE STATEMENT
 The continue statement is used when you want to continue running
the loop with the next iteration and want to skip the rest of the
statements of the body for the current iteration.
 The continue statement has the following two forms:
 Labeled Continue Statement
 Unlabeled Continue Statement

 Unlabeled Continue Statement: This statement skips the current

iteration of the innermost for, while and do-while loop.
CONTD…
CONTD…
 Labeled Continue Statement: This statement skips the current
iteration of the loop with the specified label.
RETURN STATEMENT
 The return statement is used to immediately quit the current method
and return to the calling method. It is mandatory to use a return
statement for non-void methods to return a value.
CLASSES & OBJECTS
 An object in Java is the physical as well as logical
entity whereas a class in Java is a logical entity
only.

 What is an object in Java?

 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 an intangible object is
the banking system.
 An object has three characteristics:
 State: represents the data (value) of an object.
 Behavior: represents the behavior (functionality) of
an object such as deposit, withdraw, etc.
 Identity: An object identity is typically implemented
via a unique ID. The value of the ID is not visible to
the external user. However, it is used internally by
the JVM to identify each object uniquely.
CONTD…
 For Example, Pen is an object. Its name is Reynolds; color is white,
known as its state. It is used to write, so writing is its behavior.
 An object is an instance of a class. A class is a template or blueprint
from which objects are created. So, an object is the instance(result) of
a class.
 Object Definitions:
 An object is a real-world entity.
 An object is a runtime entity.
 The object is an entity which has state and behavior.
 The object is an instance of a class.
 Let's take few examples:
 Lamp is an object
 It can be in on or off state.
 You can turn on and turn off lamp (behavior).
 Bicycle is an object
 It has current gear, two wheels, number of gear etc. states.
 It has braking, accelerating, changing gears etc. behavior.
CONTD…
 What is a class in Java?
 A class is a group of objects which have common properties. It is a
template or blueprint from which objects are created. It is a logical
entity. It can't be physical.
 A class in Java can contain:
 Fields
 Methods
 Constructors
 Blocks
 Nested class and interface
DEFINING CLASS
 The general form of class is:
class classname{
type instance-variable1;
type instance-variable1;
Type methodname1(parameterlist)
{//method body}
Type methodname1(parameterlist)
{//method body}}
 A class is declared by use of “class” keyword.

 Minimal class declaration consist of :

class myclass
{
}
CONTD…
 Variables declare within class are called instance variable because
each instance of class has its own copy of these variables.
 Code to operate on these variables is contained in methods. Nothing
can written outside methods.
 Together instance variable and methods are called members.
DECLARING OBJECTS
 When you create a class, you are creating a new data type. You can
use this type to declare objects of that type.
 However, obtaining objects of a class is a two-step process.
 First, you must declare a variable of the class type. This variable
does not define an object.
 Instead, it is simply a variable that can refer to an object.
 Second, you must acquire an actual, physical copy of the object and
assign it to that variable.
 You can do this using the new operator. The new operator
dynamically allocates (that is, allocates at run time) memory for an
object and returns a reference to it. This reference is, more or less,
the address in memory of the object allocated by new.
 Thus, in Java, all class objects must be dynamically allocated.
CONTD…
 Creation of Object involves two steps –
 Declaration
 Allocation and Assigning

this statement is used to create an object we are going to break down this
statement in two separate statements –
STEP 1 : DECLARATION OF VARIABLE OF TYPE CLASS
 Above Declaration will just declare a variable of class type.
 Declared Variable is able to store the reference to an object of
Rectangle Type.
 As we have not created any object of class Rectangle and
we haven’t assigned any reference to myrect1 , it will
be initialized with null.
STEP 2 : ALLOCATION AND ASSIGNING OBJECT TO VARIABLE
OF CLASS TYPE

•Above Statement will create physical copy of an object.

•This Physical Copy is then assigned to an variable of Type Class i.e
myrect1.
•Note : myrect1 holds an instance of an object not actual object. Actual
Object is created elsewhere and instance is assigned to myrect1.
CONSIDER AN EXAMPLE FOR CLASS & OBJECT
class Box {
double width;
double height;
double depth;
}
// This class declares an object of type Box.
class BoxDemo {
public static void main(String args[]) {
Box mybox = new Box();
double vol;
// assign values to mybox's instance variables
mybox.width = 10;
mybox.height = 20;
mybox.depth = 15;
// compute volume of box
vol = mybox.width * mybox.height * mybox.depth;
System.out.println("Volume is " + vol);
}
}
CONTD…
 Box mybox = new Box();
CONTD…
 Assigning object reference variables
Box b1 = new Box();
Box b2 = b1;
 After this fragment executes, b1 and
b2 will both refer to the same object.
The assignment of b1 to b2 did not
allocate any memory or copy any part
of the original object. It simply makes
b2 refer to the same object as does b1.
Thus, any changes made to the object
through b2 will affect the object to
which b1 is referring, since they are
the same object.
 This situation is depicted here:
ADDING A METHOD TO A CLASS
class Box {
double width;
double height;
double depth;
// display volume of a box
void volume() {
System.out.print("Volume is ");
System.out.println(width * height * depth);
}}
class BoxDemo3 {
public static void main(String args[]) {
Box mybox1 = new Box();
Box mybox2 = new Box();
// assign values to mybox1's instance variables
mybox1.width = 10;
mybox1.height = 20;
mybox1.depth = 15;
/* assign different values to mybox2's instance variables */
mybox2.width = 3;
mybox2.height = 6;
mybox2.depth = 9;
// display volume of first box
mybox1.volume();
// display volume of second box
mybox2.volume();
}}
EXPLAINATION
 This program generates the following output, which is the same as
the previous version.
Volume is 3000.0
Volume is 162.0
 The first line here invokes the volume( ) method on mybox1. That
is, it calls volume( ) relative to the mybox1 object, using the
object’s name followed by the dot operator.
 Thus, the call to mybox1.volume( ) displays the volume of the box
defined by mybox1,and the call to mybox2.volume( ) displays the
volume of the box defined by mybox2.
 The first line here invokes the volume( ) method on mybox1. That
is, it calls volume( ) relative to the mybox1 object, using the
object’s name followed by the dot operator.
 Thus, the call to mybox1.volume( ) displays the volume of the box
defined by mybox1, and the call to mybox2.volume( ) displays the
volume of the box defined by mybox2.
RETURNING A VALUE
// Now, volume() returns the volume of a box.
class Box {
double width;
double height;
double depth;
// compute and return volume
double volume() {
return width * height * depth;
} }
class BoxDemo4 {
public static void main(String args[]) {
Box mybox1 = new Box();
double vol;
// assign values to mybox1's instance variables
mybox1.width = 10;
mybox1.height = 20;
mybox1.depth = 15;
// get volume of first box
vol = mybox1.volume();
System.out.println("Volume is " + vol);
}}
EXPLANATION
 As you can see, when volume( ) is called, it is put on the right side
of an assignment statement. On the left is a variable, in this case vol,
that will receive the value returned by volume( ). Thus, after
vol = mybox1.volume();
 the value of mybox1.volume( ) is 3,000 and this value then is stored
in vol.
 There are two important things to understand about returning
values:
 The type of data returned by a method must be compatible with the
return type specified by the method. For example, if the return type of
some method is boolean, you could not return an integer.
 The variable receiving the value returned by a method (such as vol, in
this case) must also be compatible with the return type specified for the
method.
PARAMETERIZED METHOD
 Parameters allow a method to be generalized. That is, a parameterized
method can operate on a variety of data and/or be used in a number of
slightly different situations
// This program uses a parameterized method.
import java.util.*;
class Box {
double width;
double height;
double depth;
// compute and return volume
double volume() {
return width * height * depth;
}
// sets dimensions of box
void setDim(double w, double h, double d) {
width = w;
height = h;
depth = d;
}}
CONTD…
class BoxDemo5 {
public static void main (String args[]) {
double a, b, c;
Box mybox1 = new Box();
Box mybox2 = new Box();
double vol;
Scanner sc= new Scanner(System.in);
System.out.println(“enter three values”);
a= sc.nextDouble();
b= sc.nextDouble();
c= sc.nextDouble();
// initialize each box
mybox1.setDim(a, b, c);
mybox2.setDim(3, 6, 9);
// get volume of first box
vol = mybox1.volume();
System.out.println("Volume is " + vol);
// get volume of second box
vol = mybox2.volume();
System.out.println("Volume is " + vol); } }
EXPLANATION-
 As you can see, the setDim( ) method is used to set the dimensions
of each box. For example, when
 mybox1.setDim(10, 20, 15);
 is executed, 10 is copied into parameter w, 20 is copied into h, and
15 is copied into d.
 Inside setDim( ) the values of w, h, and d are then assigned to
width, height, and depth, respectively.
CONSTRUCTORS
 Java allows objects to initialize themselves when they are created.
This automatic initialization is performed through the use of
constructors.
 A constructor initializes an object immediately upon its creation. It
is called automatically when object is created before new operator
completes.
 Class constructor has no return type, not even void because the
implicit return type of a constructor is the class type itself.
 When is a constructor called?
 Every time an object is created using new() keyword, at least one
constructor is called. It calls a default constructor.
 Note: It is called constructor because it constructs the values at the
time of object creation. It is not necessary to write a constructor for
a class. It is because java compiler creates a default constructor if
your class doesn't have any.
CONTD…
 Rules for creating Java constructor
 Constructor name must be the same as its class name
 A Constructor must have no explicit return type
 A Java constructor cannot be abstract, static, final, and synchronized

 Java allows two types of constructors namely −

 No argument Constructors
 Parameterized Constructors
NO ARGUMENT CONSTRUCTOR
 As the name specifies the no argument constructors of Java does not
accept any parameters instead, using these constructors the instance
variables of a method will be initialized with fixed values for all
objects.
 Example-
Public class MyClass {
int num;
MyClass() { num = 100; }
}
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass();
MyClass t2 = new MyClass();
System.out.println(t1.num + " " + t2.num); }
}
PARAMETERIZED CONSTRUCTORS
 Most often, you will need a constructor that accepts one or more
parameters. Parameters are added to a constructor in the same way that
they are added to a method, just declare them inside the parentheses after
the constructor's name.
 Example-
 // A simple constructor.
class MyClass {
int x;
// Following is the constructor
MyClass(int i )
{ x = i; }
}
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass( 10 );
MyClass t2 = new MyClass( 20 );
System.out.println(t1.x + " " + t2.x); }
}
CONSTRUCTOR OVERLOADING IN JAVA
 In Java, a constructor is just like a method but without return type. It
can also be overloaded like Java methods.
 Constructor overloading in Java is a technique of having more than
one constructor with different parameter lists. They are arranged in a
way that each constructor performs a different task. They are
differentiated by the compiler by the number of parameters in the
list and their types.
 Example on next page-
//Java program to overload constructors in java
class Student5{
int id;
String name;
int age;
//creating two arg constructor
Student5(int i,String n){
id = i;
name = n;
}
//creating three arg constructor
Student5(int i,String n,int a){
id = i;
name = n;
age=a;
}
void display(){System.out.println(id+" "+name+" "+age);}
public static void main(String args[]){
Student5 s1 = new Student5(111,"Karan");
Student5 s2 = new Student5(222,"Aryan",25);
s1.display();
s2.display();
}
}
JAVA COPY CONSTRUCTOR
 There is no copy constructor in java. However, we can copy the values from one object to another like
copy constructor in C++.
 //Java program to initialize the values from one object to another
class Student6{
int id;
String name;
//constructor to initialize integer and string
Student6(int i,String n){
id = i;
Like c++, java also supports copy constructor.
name = n; But in c++ it is created by default. While in
} java we Define a copy constructor on our own.
//constructor to initialize another object
Student6(Student6 s){
id = s.id;
name =s.name;
}
void display(){System.out.println(id+" "+name);}
public static void main(String args[]){
Student6 s1 = new Student6(111,"Karan");
Student6 s2 = new Student6(s1);
s1.display();
s2.display();
}
}
THIS KEYWORD IN JAVA
 There can be a lot of usage of java this keyword. In java, this is
a reference variable that refers to the current object.
USAGE OF JAVA THIS KEYWORD
 Here is given the 6 usage of java this keyword.
1. this can be used to refer current class instance variable.
2. this can be used to invoke current class method (implicitly)
3. this() can be used to invoke current class constructor.
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 can be used to return the current class instance from the
method.
1) THIS: TO REFER CURRENT CLASS INSTANCE VARIABLE
 The this keyword can be used to refer current class instance
variable. If there is ambiguity between the instance variables and
parameters, this keyword resolves the problem of ambiguity.
 Understanding the problem without this keyword
 Let's understand the problem if we don't use this keyword by the
example given on next slide:
class Student{
int rollno;
String name;
float fee;
Student(int rollno,String name,float fee){
rollno=rollno;
name=name;
fee=fee;
}
void display(){System.out.println(rollno+" "+name+" "+fee);}
}
class TestThis1{
public static void main(String args[]){
Student s1=new Student(111,"ankit",5000f);
Student s2=new Student(112,"sumit",6000f);
s1.display();
s2.display();
}}
CONTD…

 In the above example, parameters (formal arguments) and instance variables are same. So, we are
using this keyword to distinguish local variable and instance variable.
 Solution of the above problem by this keyword
class Student{
int rollno;
String name;
float fee;
Student(int rollno,String name,float fee){
this.rollno=rollno;
this.name=name;
this.fee=fee;
}
void display(){System.out.println(rollno+" "+name+" "+fee);}
}

class TestThis2{
public static void main(String args[]){
Student s1=new Student(111,"ankit",5000f);
Student s2=new Student(112,"sumit",6000f);
s1.display();
s2.display();
}}
2)THIS: TO INVOKE CURRENT CLASS METHOD
 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.
 Let's see the example
CONTD…
class A{
void m(){System.out.println("hello m");}
void n(){
System.out.println("hello n");
//m();//same as this.m()
this.m();
}
}
class TestThis4{
public static void main(String args[]){
A a=new A();
a.n();
}}
3) THIS() : TO INVOKE CURRENT CLASS CONSTRUCTOR
 The this() constructor call can be used to invoke the current class
constructor. It is used to reuse the constructor. In other words, it is
used for constructor chaining.
 Calling parameterized constructor from default constructor:

Rule: Call to this() must be the first statement

in constructor.
4) THIS: TO PASS AS AN ARGUMENT IN THE METHOD
 The this keyword can also be passed as an argument in the method.
It is mainly used in the event handling. Let's see the example:
5) THIS: TO PASS AS ARGUMENT IN THE CONSTRUCTOR CALL

 We can pass the this keyword in the constructor also. It is useful if

we have to use one object in multiple classes. Let's see the example:
6) THIS KEYWORD CAN BE USED TO RETURN CURRENT CLASS
INSTANCE

 We can return this keyword as an statement from the method. In

such case, return type of the method must be the class type (non-
primitive). Let's see the example:
 Syntax of this that can be returned as a statement
GARBAGE COLLECTION
 In C/C++, programmer is responsible for both creation and
destruction of objects.
 Usually programmer neglects destruction of useless objects.
 Due to this negligence, at certain point, for creation of new objects,
sufficient memory may not be available and entire program will
terminate abnormally causing OutOfMemoryErrors.
 But in Java, the programmer need not to care for all those objects
which are no longer in use. Garbage collector destroys these objects.
 Garbage Collection is process of reclaiming the runtime unused
memory automatically. In other words, it is a way to destroy the
unused objects.
ADVANTAGE OF GARBAGE COLLECTION
 It makes java memory efficient because garbage collector removes
the unreferenced objects from heap memory.
 It is automatically done by the garbage collector(a part of JVM) so
we don't need to make extra efforts.
HOW CAN AN OBJECT BE UNREFERENCED?
 There are many ways:
 By nulling the reference
 By assigning a reference to another
 By anonymous object etc.
WAYS:
 By nulling a reference:

 By assigning a reference to another:

 By anonymous object:
FINALIZATION
 Sometimes an object will need to perform some action when it is
destroyed.
 For example, if an object is holding some non-Java resource such as
a file handle or window character font, then you might want to make
sure these resources are freed before an object is destroyed.
 To handle such situations, Java provides a mechanism called
finalization.
CONTD..
 Just before destroying an object, Garbage Collector
calls finalize() method on the object to perform cleanup activities.
 Once finalize() method completes, Garbage Collector destroys that
object.
 This method is defined in Object class as:
protected void finalize(){}
 Here, the keyword protected is a specifier that prevents access to
finalize( ) by code defined outside its class.
 Based on our requirement, we can override finalize() method for
perform our cleanup activities like closing connection from
database.
 The finalize() method called by Garbage Collector not JVM.
Although Garbage Collector is one of the module of JVM.
 The finalize() method is never invoked more than once for any
given object.
WAYS FOR REQUESTING JVM TO RUN GARBAGE
COLLECTOR
 Once we made object eligible for garbage collection, it may not
destroy immediately by garbage collector. Whenever JVM runs
Garbage Collector program, then only object will be destroyed. But
when JVM runs Garbage Collector, we can not expect.

 We can also request JVM to run Garbage Collector. There are two
ways to do it :
 Using System.gc() method : System class contain static method gc() for
requesting JVM to run Garbage Collector.
 Using Runtime.getRuntime().gc() method : Runtime class allows the
application to interface with the JVM in which the application is
running. Hence by using its gc() method, we can request JVM to run
Garbage Collector.
// Java program to demonstrate requesting
// JVM to run Garbage Collector
public class Test
{
public static void main(String[] args) throws InterruptedException
{
Test t1 = new Test();
Test t2 = new Test();

// Nullifying the reference variable

t1 = null;

// requesting JVM for running Garbage Collector

System.gc();

// Nullifying the reference variable

t2 = null;

// requesting JVM for running Garbage Collector

Runtime.getRuntime().gc();

}
}
CONTD…
 Note :
 There is no guarantee that any one of above two methods will definitely
run Garbage Collector.
 The call System.gc() is effectively equivalent to the call
Runtime.getRuntime().gc()
OVERLOADING
 In Java it is possible to define two or more methods within the same
class that share the same name, as long as their parameter
declarations are different.
 When this is the case, the methods are said to be overloaded, and the
process is referred to as method overloading.
 Method overloading is one of the ways that Java implements
polymorphism.
 When an overloaded method is invoked, Java uses the type and/or
number of arguments as its guide to determine which version of the
overloaded method to actually call.
 Thus, overloaded methods must differ in the type and/or number of
their parameters.
 While overloaded methods may have different return types, the
return type alone is insufficient to distinguish two versions of a
method.
CONTD…
 Advantage of method overloading:
 Method overloading increases the readability of the program.

 Different ways to overload the method:

 By changing number of arguments
 By changing the data type
EXAMPLES:
 Method Overloading: changing no. of arguments
CONTD…
 Method Overloading: changing data type of arguments
Q) WHY METHOD OVERLOADING IS NOT POSSIBLE BY
CHANGING THE RETURN TYPE OF METHOD ONLY?

 In java, method overloading is not possible by changing the return

type of the method only because of ambiguity.
 Let's see how ambiguity may occur:
Q) CAN WE OVERLOAD JAVA MAIN() METHOD?
 Yes, by method overloading. You can have any number of main
methods in a class by method overloading. But JVM calls main()
method which receives string array as arguments only.
 Let's see the simple example:
METHOD OVERLOADING AND TYPE
PROMOTION

•As displayed in the above diagram, byte can be promoted to short, int, long, float or double.
•The short datatype can be promoted to int,long,float or double.
•The char datatype can be promoted to int,long,float or double and so on.
EXAMPLE OF METHOD OVERLOADING WITH
TYPEPROMOTION
EXAMPLE OF METHOD OVERLOADING WITH TYPE
PROMOTION IF MATCHING FOUND

 If there are matching type arguments in the method, type promotion

is not performed.
EXAMPLE OF METHOD OVERLOADING WITH TYPE
PROMOTION IN CASE OF AMBIGUITY

 If there are no matching type arguments in the method, and each

method promotes similar number of arguments, there will be
ambiguity.
OVERLOADING CONSTRUCTORS
 In Java, a constructor is just like a method but without return type.
 It can also be overloaded like Java methods.
 Constructor overloading in Java is a technique of having more than
one constructor with different parameter lists.
 They are arranged in a way that each constructor performs a
different task.
 They are differentiated by the compiler by the number of parameters
in the list and their types.
EXAMPLE-
USING THIS() IN CONSTRUCTOR OVERLOADING
 this() reference can be used during constructor overloading to call
default constructor implicitly from parameterized constructor.
 Please note, this() should be the first statement inside a constructor.
EXAMPLE-
CONTD…

 Important points to be taken care while doing Constructor

Overloading :
 Constructor calling must be the first statement of constructor in Java.
 If we have defined any parameterized constructor, then compiler will
not create default constructor. and vice versa if we don’t define any
constructor, the compiler creates the default constructor(also known as
no-arg constructor) by default during compilation.
 Recursive constructor calling is invalid in java.
DIFFERENCE BETWEEN CONSTRUCTOR AND
METHOD IN JAVA
ARGUMENT PASSING IN JAVA
 Java supports call by value and call by reference .
 Call by value: this method copies value of an argument into the
formal parameter of the subroutine. Changes made to the parameter
of the subroutine have no effect on argument. In Java, when you
pass a simple type to a method, it is passed by value. Thus, what
occurs to the parameter that receives the argument has no effect
outside the method.

 Call be reference: a reference to an argument is passed to the

parameter. This reference is used to access the actual argument
specified in the call. Changes made to the parameter will effect the
argument specified in the call.
CALL BY VALUE
// Simple types are passed by value.
class Test {
void meth(int i, int j) {
i *= 2;
j /= 2;
}
}
class CallByValue {
public static void main(String args[]) {
Test ob = new Test();
int a = 15, b = 20;
System.out.println("a and b before call: " + a + " " + b);
ob.meth(a, b);
System.out.println("a and b after call: " + a + " " + b);
}
}
CONTD..
 The output from this program is shown here:
a and b before call: 15 20
a and b after call: 15 20
 As you can see, the operations that occur inside meth( ) have no
effect on the values of a and b used in the call; their values here did
not change to 30 and 10.
CALL BY REFERENCE
 When you pass an object to a method, the situation changes
dramatically, because objects are passed by reference.
 Keep in mind that when you create a variable of a class type, you
are only creating a reference to an object.
 Thus, when you pass this reference to a method, the parameter that
receives it will refer to the same object as that referred to by the
argument.
 This effectively means that objects are passed to methods by use of
call-by-reference.
 Changes to the object inside the method do affect the object used as
an argument.
 For example, consider the following program:
EXAMPLE-
// Objects are passed by reference.
class Test {
int a, b;
Test(int i, int j) {
a = i;
b = j;
}
// pass an object
void meth(Test o) {
o.a *= 2;
o.b /= 2;
}
}
class CallByRef {
public static void main(String args[]) {
Test ob = new Test(15, 20);
System.out.println("ob.a and ob.b before call: " +
ob.a + " " + ob.b);
ob.meth(ob);
System.out.println("ob.a and ob.b after call: " +
ob.a + " " + ob.b);
}
}
CONTD…
 This program generates the following output:
ob.a and ob.b before call: 15 20
ob.a and ob.b after call: 30 10
 As you can see, in this case, the actions inside meth() have affected
the object used as an argument.


 Note: when an object reference is passed to a method, the reference

itself is passed by use of call-by-value. However, since the value
being passed refers to an object, the copy of that value will still refer
to the same object that its corresponding argument does.
RETURN TYPE AND RECURSION
 Return type: a method can return any type data including class
types that u created.
 Recursion: java supports recursion, recursion is the process of
defining something in term of itself. Recursion is a attribute that
allows a method to call itself.
RETURN TYPE
// Returning an object.
class Test {
int a;
Test(int i) {
a = i;
}
Test incrByTen() {
Test temp = new Test(a+10);
return temp;
}
}
class RetOb {
public static void main(String args[]) {
Test ob1 = new Test(2);
Test ob2;
ob2 = ob1.incrByTen();
System.out.println("ob1.a: " + ob1.a);
System.out.println("ob2.a: " + ob2.a);
ob2 = ob2.incrByTen();
System.out.println("ob2.a after second increase: "
+ ob2.a);
}
}
OUTPUT
 The output generated by this program is shown here:
ob1.a: 2
ob2.a: 12
ob2.a after second increase: 22
RECURSION IN JAVA
 Recursion in java is a process in which a method calls itself
continuously. A method in java that calls itself is called recursive
method.
 It makes the code compact but complex to understand.
JAVA RECURSION EXAMPLE 1: INFINITE TIMES
JAVA RECURSION EXAMPLE 2: FINITE TIMES
INTRODUCING ACCESS CONTROL
 There are two types of modifiers in java: access modifiers and non-
access modifiers.
 The access modifiers in java specifies accessibility (scope) of a data
member, method, constructor or class.
 There are 4 types of java access modifiers:
 private
 default
 protected
 public

 There are many non-access modifiers such as static, abstract,

synchronized, native, volatile, transient etc. Here, we will learn
access modifiers.
PRIVATE ACCESS MODIFIER
 The private access modifier is accessible only within class.
 In this example, we have created two classes A and Simple. A class
contains private data member and private method. We are accessing
these private members from outside the class, so there is compile
time error.
ROLE OF PRIVATE CONSTRUCTOR
 If you make any class constructor private, you cannot create the
instance of that class from outside the class. For example:

Java allows us to declare a

constructor as private. We can
declare a constructor private by
using private access specifier
however if a constructor is
declared private we are not able to
create an object of the class
DEFAULT ACCESS MODIFIER
 If you don't use any modifier, it is treated as default by default. The
default modifier is accessible only within package.
 In this example, we have created two packages pack and mypack.
We are accessing the A class from outside its package, since A class
is not public, so it cannot be accessed from outside the package.

In the example, the scope of class A and

its method msg() is default so it cannot be
accessed from outside the package.
PROTECTED ACCESS MODIFIER
 The protected access modifier is accessible within package and
outside the package but through inheritance only.
 The protected access modifier can be applied on the data member,
method and constructor. It can't be applied on the class.
 In the example(next slide), we have created the two packages pack
and mypack.
 The A class of pack package is public, so can be accessed from
outside the package.
 But msg method of this package is declared as protected, so it can
be accessed from outside the class only through inheritance.
EXAMPLE-
PUBLIC ACCESS MODIFIER
 The public access modifier is accessible everywhere. It has the widest scope
among all other modifiers.
UNDERSTANDING ALL JAVA ACCESS MODIFIERS
INTRODUCING FINAL
 In java variable, method and class can be declared as final.
 Final variable:
 when a variable is declared as final, it prevents its contents from being
modified.
 Variables declared as final do not occupy memory on a per instance
basis.
 final variable must be initialized when it is declared.
 a final variable is a constant.

 Final Method:You can declare some or all of a class's

methods final. You use the final keyword in a method declaration to
indicate that the method cannot be overridden by subclasses.
The Object class does this—a number of its methods are final.
 You might wish to make a method final if it has an implementation
that should not be changed.
 Methods called from constructors should generally be declared
final. If a constructor calls a non-final method, a subclass may
redefine that method with surprising or undesirable results.
CONTD..
 Final Class: If you do not want anybody to change the
functionality of the class by extending it , then make a class final
class by using a final keyword.
Final class password
{ // code of password class
}
 You will also find final classes in JDK packages. For example, the
java.lang.String class has been declared final. This is done for
security reasons. It ensures that any method that refers to the String
class gets the actual String class not a modified one.
Example:Final.java
USES OF FINAL KEYWORD
 It is used to create named constant.
 It is used to prevent overriding by prefixing final with method or
variable.
 It is used to prevent inheritance.
INHERITANCE
 A class that is derived from another class is called a subclass (also a
derived class, extended class, or child class). The class from which
the subclass is derived is called a superclass (also a base class or a
parent class).
 Excepting Object, which has no superclass, every class has one and
only one direct superclass (single inheritance). In the absence of
any other explicit superclass, every class is implicitly a subclass
of Object.
 Classes can be derived from classes that are derived from classes
that are derived from classes, and so on, and ultimately derived from
the topmost class, Object.

Inheritance is an important pillar of object oriented programming. It is the

mechanism in Java by which one class is allowed to inherit the features
(fields and methods) of another class.
IMPLEMENTING INHERITANCE IN JAVA
 The extends keyword is used to derive a class from super class or in
other words extends the functionality of a super class.
 Syntax:
Access specifies class subclass name extends super class name

 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.
THE SYNTAX OF JAVA INHERITANCE?

 The extends keyword indicates that you are making a new class
that derives from an existing class. The meaning of "extends" is to
increase the functionality.
 In the terminology of Java, a class which is inherited is called a
parent or superclass, and the new class is called child or subclass.
JAVA INHERITANCE EXAMPLE
TYPES OF INHERITANCE IN JAVA
 On the basis of class, there can be three types of inheritance in java:
single, multilevel and hierarchical.
 In java programming, multiple and hybrid inheritance is supported
through interface only.
CONTD…
 When one class inherits multiple classes, it is known as multiple
inheritance.
 For Example:
SINGLE INHERITANCE EXAMPLE In single inheritance sub classes
inherit the features of one super
class
MULTILEVEL INHERITANCE EXAMPLE
In multi level inheritance a
derive class will be inheriting a
base class and as well as the
derived class also act as the
base class to other class.
HIERARCHICAL INHERITANCE EXAMPLE
In hierarchical inheritance one class
serves as a superclass for more than
one sub class
Q) WHY MULTIPLE INHERITANCE IS NOT
SUPPORTED IN JAVA?
 To reduce the complexity and simplify the language, multiple
inheritance is not supported in java.
 Consider a scenario where A, B, and C are three classes. The C class
inherits A and B classes. If A and B classes have the same method
and you call it from child class object, there will be ambiguity to
call the method of A or B class.
 Since compile-time errors are better than runtime errors, Java
renders compile-time error if you inherit 2 classes. So whether you
have same method or different, there will be compile time error.
EXAMPLE-
ORDER OF CONSTRUCTORS CALLING

 Constructors are called in order of derivation, from superclass to

subclass.
 Further, since super( ) must be the first statement executed in a
subclass’ constructor, this order is the same whether or not super( )
is used.
 If super( ) is not used, then the default or parameter less constructor
of each superclass will be executed. This is because if super
keyword is not used inside a subclass constructor then compiler by
default gives a call to super() which calls the base class parameter
less constructor. The following program illustrates when
constructors are executed:
EXAMPLE-
// Demonstrate when constructors are called.
// Create a super class.
class A {
A() {
Super();
System.out.println("Inside A's constructor.");
}
}
// Create a subclass by extending class A.
class B extends A {
B()
{
Super();
System.out.println("Inside B's constructor.");
}
}
// Create another subclass by extending B.
class C extends B {
C() {
Super();
System.out.println("Inside C's constructor.");
}
}
class CallingCons {
public static void main(String args[]) {
C c = new C();
}
}
CONTD…
 The output from this program is shown here:
Inside A’s constructor
Inside B’s constructor
Inside C’s constructor
SUPER KEYWORD
 The super keyword in Java is a reference variable which is used to
refer immediate parent class object.
 Whenever you 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

 super can be used to refer immediate parent class instance variable.
 super can be used to invoke immediate parent class method.
 super() can be used to invoke immediate parent class constructor.
SUPER IS USED TO REFER IMMEDIATE PARENT CLASS INSTANCE
VARIABLE.
 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.
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.
SUPER IS USED TO INVOKE PARENT CLASS CONSTRUCTOR

 The super keyword can also be used to invoke the parent class
constructor. Let's see a simple example:
 Note: super() is added in each class constructor automatically by
compiler if there is no super() or this().
METHOD OVERRIDING

 In addition to inheriting data members and methods , subclass can

modify the functionality of the super class.
 If the method defined in the sub class has same signature ( name of the
method, list of arguments, data type of arguments, order of arguments ) as that of
super class then the subclass methods override (hides/suppress) the
definition of super class method. This is known as overriding.
 Method overriding occurs when names and type signature of the
two are identical.
 When overridden method is called from within subclass, it always
refers to the version of the method written in subclass.
CONTD…

 Method overriding is one of the way by which java achieve Run Time
Polymorphism. The version of a method that is executed will be determined by the
object that is used to invoke it.
 If an object of a parent class is used to invoke the method, then the version in the
parent class will be executed, but if an object of the subclass is used to invoke the
method, then the version in the child class will be executed.
 In other words, it is the type of the object being referred to (not the type of the
reference variable) that determines which version of an overridden method will be
executed.
UNDERSTANDING THE PROBLEM WITHOUT METHOD
OVERRIDING

 Problem is that I have to provide a specific implementation of run()

method in subclass that is why we use method overriding.
EXAMPLE OF METHOD OVERRIDING
 In this example, we have defined the run method in the subclass as
defined in the parent class but it has some specific implementation. The
name and parameter of the method are the same, and there is IS-A
relationship between the classes, so there is method overriding.
A REAL EXAMPLE OF JAVA METHOD OVERRIDING
 Consider a scenario where Bank is a class that provides
functionality to get the rate of interest. However, the rate of interest
varies according to banks. For example, SBI, ICICI and AXIS banks
could provide 8%, 7%, and 9% rate of interest.
EXAMPLE-
POINTS TO REMEMBER
 Can we override static method?
 No, a static method cannot be overridden. It is because the static
method is bound with class whereas instance method is bound with
an object. Static belongs to the class area, and an instance belongs to
the heap area.

 Can we override java main method?

 No, because the main is a static method.
EXAMPLE-
CONTD..
DIFFERENCE BETWEEN METHOD OVERLOADING
AND METHOD OVERRIDING IN JAVA

Method Overloading Method Overriding

Method overloading is used to increase the Method overriding is used to provide the
readability of the program. specific implementation of the method that is
already provided by its super class.

Method overloading is performed within class. Method overriding occurs in two classes that
have IS-A (inheritance) relationship.

In case of method overloading, parameter In case of method overriding, parameter must

must be different. be same.

Method overloading is the example of compile Method overriding is the example of run time
time polymorphism. polymorphism.

In java, method overloading can't be Return type must be same or covariant in

performed by changing return type of the method overriding.
method only. Return type can be same or
different in method overloading. But you must
have to change the parameter.
EXAMPLES-
 Java Method Overloading example

 Java Method Overriding example

REAL WORLD EXAMPLES OF OVERLOADING &
OVERIDING
 Overloading: Consider the basic human function of speaking!
 Assume, you are supposed just perform the function of talking. Say, you have
to tell the story of your day, to a total stranger. Your function will get over
pretty quickly. Say, now you are telling the same to your beloved. You will go
through more details as compared to the previous one.

 Example-
class You
{
void talk(Stranger obj)
{
sysout("Hi, my day was great!");
}
void talk(Beloved obj)
{
sysout("Hi, my day was great! You won't believe what happened today! Blah!Blah!
Blah!Blah!Blah!Blah!Blah!Blah!Blah!Blah! ");
}
}
CONTD..
 Overriding: Happens in the inheritance hierarchy!
 We learn a lot from our parents! We learn to cook to some extent.
The same delicacy with same ingredients is prepared by your
mother with a different taste and you with a different taste
(assuming). That is overriding, same function (cooking), same
parameters (ingredients), but different algorithms (cooking style).
 Or, your learnt driving from you dad! But you both drive the same
vehicle differently! That is overriding.
JAVA ACCESS MODIFIERS WITH METHOD OVERRIDING
 The access modifier for an overriding method can allow more, but
not less, access than the overridden method.
 For example, a protected instance method in the super-class can be
made public, but not private, in the subclass.
 Doing so, will generate compile-time error.
EXAMPLE-
FINAL METHODS CAN NOT BE OVERRIDDEN
 If we don’t want a method to be overridden, we declare it as final.
Please see Using final with Inheritance .
POLYMORPHISM IN JAVA
 Polymorphism in Java is a concept by which we can perform
a single action in 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 a static method in Java, it is the example of compile
time polymorphism.
 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.
UPCASTING
 If the reference variable of Parent class refers to the object of Child
class, it is known as upcasting.
 For example:
DYNAMIC METHOD DISPATCH
 Dynamic method dispatch is the mechanism by which a call to an
overridden method is resolved at runtime, rather than compile time.
This is how java implements run time polymorphism.
 When an overridden method is called through a super class
reference, java determines which version of that method to execute
based upon the type of the object being referred to at that time.
EXAMPLE-
class A
public class Dynamic_Method {
{
void show() /**
{ * @param args
System.out.println("Inside A's method"); */
public static void main(String[] args) {
}}
// TODO Auto-generated method stub
class B extends A
{
void show() A a = new A();
{ B b = new B();
C c = new C();
System.out.println("Inside B's method");
}}
A x;
class C extends A x= a;
{ x.show();
void show() x= b;
{ b.show();
x=c;
System.out.println("Inside C's method");
c.show();
}} }
}
} }
OBJECT CLASS IN JAVA
 There is one special class “Object” in java.
 All other classes are subclass of “Object”.
 Reference variable of type Object can refer to an object of all other classes.
 The Object class provides some common behaviors to all the objects such as
object can be compared, object can be cloned, object can be notified etc.
 Class “Object” defines following methods, which means that they are
available in every object.
METHODS OF OBJECT CLASS
ABSTRACTION IN JAVA
 Abstraction is a process of hiding the implementation details and
showing only functionality to the user.
 Another way, it shows only essential things to the user and hides the
internal details, for example, sending SMS where you type the text
and send the message. You don't know the internal processing about
the message delivery.
 Abstraction lets you focus on what the object does instead of how it
does it.
 Real World Example: When you log into your email, compose and
send a mail. Again there is a whole lot of background processing
involved, verifying the recipient, sending request to the email
server, sending your email. Here you are only interested in
composing and clicking on the send button. What really happens
when you click on the send button, is hidden from you.
WAYS TO ACHIEVE ABSTRACTION
 There are two ways to achieve abstraction in java
 Abstract class (0 to 100%)
 Interface (100%)
ABSTRACT CLASSES
 An abstract class is a class that is declared abstract—it may or may not
include abstract methods. Abstract classes cannot be instantiated, but
they can be subclassed.
 An abstract class cannot be instantiated with new operator, such objects
are not useful because abstract class is not fully defined.
 You can not declare abstract constructor or abstract static method.
 An abstract method is a method that is declared without an
implementation (without braces, and followed by a semicolon), like
this:
 abstract return-type name(List of parameters);
 abstract void show();
 When an abstract class is subclassed, the subclass usually provides
implementations for all of the abstract methods in its parent class.
However, if it does not, the subclass must also be declared abstract
abstract class My_Abst
{
Void show()
{//method body}
abstarct Void disp();
}
CONTD…
EXAMPLES-
 Example of abstract class-

 Example of abstract method-

Rule: If there is an abstract method in a

class, that class must be abstract.
EXAMPLE OF ABSTRACT CLASS THAT HAS AN ABSTRACT
METHOD

 In this example, Bike is an abstract class that contains only one

abstract method run.
 Its implementation is provided by the Honda class.

Output:
ANOTHER EXAMPLE OF ABSTRACT CLASS IN JAVA
PACKAGES
 A java package is a group of similar types of classes, interfaces and
sub-packages.
 Package in java can be categorized in two form, built-in package
and user-defined package.
 There are many built-in packages such as java, lang, awt, javax,
swing, net, io, util, sql etc.
 Here, we will have the detailed learning of creating and using user-
defined packages
 Advantage of Java Package
 Java package is used to categorize the classes and interfaces so that they
can be easily maintained.
 Java package provides access protection.
 Java package removes naming collision.
SIMPLE EXAMPLE OF JAVA PACKAGE
 The package keyword is used to create a package in java.

 How to compile java package?

CONTD…
 How to run java package program?
 You need to use fully qualified name e.g. mypack.Simple etc to run
the class.
CONTD…
 How to access package from another package?
 There are three ways to access the package from outside the
package.
 import package.*;
 import package.classname;
 fully qualified name.
USING PACKAGENAME.*
 If you use package.* then all the classes and interfaces of this
package will be accessible but not sub-packages.
 The import keyword is used to make the classes and interface of
another package accessible to the current package.
USING PACKAGENAME.CLASSNAME
 If you import package.classname then only declared class of this
package will be accessible.
USING FULLY QUALIFIED NAME
 If you use fully qualified name then only declared class of this
package will be accessible.
 Now there is no need to import. But you need to use fully qualified
name every time when you are accessing the class or interface.
 It is generally used when two packages have same class name e.g.
java.util and java.sql packages contain Date class.
CONTD…

If you import a package, all the classes and interface of that package will be
imported excluding the classes and interfaces of the subpackages. Hence, you
need to import the subpackage as well.
SUBPACKAGE IN JAVA
 Package inside the package is called the subpackage. It should be
created to categorize the package further.

 Let's take an example, Sun Microsystem has defined a package

named java that contains many classes like System, String, Reader,
Writer, Socket etc.
 These classes represent a particular group e.g. Reader and Writer
classes are for Input/Output operation, Socket and ServerSocket
classes are for networking etc and so on.
 So, Sun has subcategorized the java package into subpackages such
as lang, net, io etc. and put the Input/Output related classes in io
package, Server and ServerSocket classes in net packages and so on.
CONTD…
CONTD…
 Rule: There can be only one public class in a java source file and it
must be saved by the public class name.
PACKAGE CLASS
 The package class provides methods to get information about the specification and
implementation of a package. It provides methods such as getName(),
getImplementationTitle(), getImplementationVendor(), getImplementationVersion()
etc.

 class PackageInfo{
 public static void main(String args[]){
 Package p=Package.getPackage("java.lang");
 System.out.println("package name: "+p.getName());
 System.out.println("Specification Title: "+p.getSpecificationTitle());
 System.out.println("Specification Vendor: "+p.getSpecificationVendor());
 System.out.println("Specification Version: "+p.getSpecificationVersion());


 System.out.println("Implementaion Title: "+p.getImplementationTitle());

 System.out.println("Implementation Vendor: "+p.getImplementationVendor());
 System.out.println("Implementation Version: "+p.getImplementationVersion());
 System.out.println("Is sealed: "+p.isSealed());
 }
 }
INTERFACE
 An interface in java is a blueprint of a class. It has static constants
and abstract methods.
 The interface in Java is a mechanism to achieve abstraction. There
can be only abstract methods in the Java interface, not method body.
It is used to achieve abstraction and multiple inheritance in Java.
 In other words, you can say that interfaces can have abstract
methods and variables. It cannot have a method body.
 Java Interface also represents the IS-A relationship.
 It cannot be instantiated just like the abstract class.
 Since Java 8, we can have default and static methods in an
interface.
 Since Java 9, we can have private methods in an interface.
WHY USE JAVA INTERFACE?
 There are mainly three reasons to use interface. They are given
below.
 It is used to achieve abstraction.
 By interface, we can support the functionality of multiple inheritance.
 It can be used to achieve loose coupling.
CONTD..
 How to declare an interface?
 An interface is declared by using the interface keyword.
 It provides total abstraction; means all the methods in an interface
are declared with the empty body, and all the fields are public, static
and final by default.
 A class that implements an interface must implement all the
methods declared in the interface.
INTERNAL ADDITION BY THE COMPILER
 The Java compiler adds public and abstract keywords before the
interface method. Moreover, it adds public, static and final
keywords before data members.
THE 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.
JAVA INTERFACE EXAMPLE
 In this example, the Printable interface has only one method, and its
implementation is provided in the A6 class.
JAVA INTERFACE EXAMPLE: BANK
MULTIPLE INHERITANCE IN JAVA BY INTERFACE
 If a class implements multiple interfaces, or an interface extends
multiple interfaces, it is known as multiple inheritance.
EXAMPLE
MULTIPLE INHERITANCE IS NOT SUPPORTED
THROUGH CLASS IN JAVA, BUT IT IS POSSIBLE BY
AN INTERFACE, WHY?
 As we have explained in the inheritance chapter, multiple
inheritance is not supported in the case of class because of
ambiguity.
 However, it is supported in case of an interface because there is no
ambiguity.
 It is because its implementation is provided by the implementation
class.
 For example(on next slide)
CONTD…
INTERFACE INHERITANCE
 A class implements an interface, but one interface extends another
interface.
JAVA 8 DEFAULT METHOD IN INTERFACE
 Since Java 8, we can have method body in interface. But we need to
make it default method. Let's see an example:
WHAT IS MARKER OR TAGGED INTERFACE?
 An interface which has no member is known as a marker or tagged
interface, for example, Serializable, Cloneable, Remote, etc.
 They are used to provide some essential information to the JVM so
that JVM may perform some useful operation.
DIFFERENCE BETWEEN ABSTRACT CLASS AND INTERFACE
WRAPPER CLASSES
 Java is an object-oriented language and can view everything as an
object. A simple file can be treated as an object , an address of a
system can be seen as an object, an image can be treated as an object
and a simple data type can be converted into an object
(with wrapper classes). Wrapper classes are used to convert any
data type into an object.
 The primitive data types are not objects; they do not belong to any
class; they are defined in the language itself.
 Sometimes, it is required to convert data types into objects in Java
language. For example, upto JDK1.4, the data structures accept only
objects to store.
 A data type is to be converted into an object and then added to a
Stack or Vector etc. For this conversion, the designers
introduced wrapper classes
CONTD…
 As the name says, a wrapper class wraps (encloses) around a data
type and gives it an object appearance. Wherever, the data type is
required as an object, this object can be used.
 Wrapper classes include methods to unwrap the object and give
back the data type.
 It can be compared with a chocolate. The manufacturer wraps the
chocolate with some foil or paper to prevent from pollution. The
user takes the chocolate, removes and throws the wrapper and eats
it.
 Observe the following conversion.
 int k = 100;
Integer it1 = new Integer(k);
 The int data type k is converted into an
object, it1 using Integer class. The it1 object can be used in Java
programming wherever k is required an object.
CONTD…
 The following code can be used to unwrap (getting
back int from Integer object) the object it1.
 int m = it1.intValue();
System.out.println(m*m); // prints 10000
 intValue() is a method of Integer class that returns an int data type.
LIST OF WRAPPER CLASSES
 In the above code, Integer class is known as a wrapper class (because it wraps
around int data type to give it an impression of object). To wrap (or to convert)
each primitive data type, there comes a wrapper class. Eight wrapper classes
exist in java.lang package that represent 8 data types. Following list gives.

Primitive data type Wrapper class

byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
HIERARCHY OF WRAPPER CLASSES
 All the 8 wrapper classes are placed in java.lang package so that they
are implicitly imported and made available to the programmer. As you
can observe in the above hierarchy, the super class of all numeric
wrapper classes is Number and the super class
for Character and Boolean is Object. All the wrapper classes are
defined as final and thus designers prevented them from inheritance. -