Java – Theory

What is Java?
Java is a 3rd Generation Object Oriented programming Language, developed by James Gosling in the year 1995. It was initially codenamed as Green and hypothetically called Oak named after the Oak tree outside Gosling’s house.
It is case sensitive and has a unique two step translation process that includes both Compilation and Interpretation which makes Java Platform independent.

What is Procedure Oriented Programming Language?
Pop is a Procedural Oriented Programming Language. In this, the stress is laid on function rather than data. Data may be kept floating throughout the Programming. Hence by scanning the whole program from beginning to the end and we can rectify any error caused. E.g. of POP based language are GW-BASIC, C, etc…
Characteristics of POP
1) Emphasis is laid on functions (Logical steps).
2) Functions share global data.
3) Data values can keep floating from one function to another.
4) Uses top down approach of programming.

Drawbacks of POP
1) As Data values are global to all the functions, you may require making necessary changes in the functions due to change in the data values.
2) It is not suitable to solve complex problems in real situations.

What is Object Oriented Programming Language?
OOP is an Object Oriented Programming Language. It is a modular approach to programming in which equal stress is given to data as well as methods and it allows the data be applied within the stipulated program area. It also provides reusability features to develop productivity logic.

Features of OOP
1. It gives equal stress on data and function.
2. It makes the program simple by dividing it into a number of objects.
3. The objects can be used as a bridge to have data flow from one function to another.
4. Data can be easily modified without any change in the function.

Advantages of OOP
1) We can extend the use of existing class through inheritance.
2) Using the concept data hiding can generate secured program.
3) We can create different modules in our project through objects.
4) Multiple instances of an object can be generated to co-exist without any interference.
5) It is highly beneficial to solve complex problems.
6) It is easy to modified and maintain software complexity.

Examples of OOP based languages are Simula, C++, Java, Python, and Smalltalk etc…

Basic Principles of OOP
1) Encapsulation – Binding up of data members and member functions together into a single unit called (class) is called Encapsulation.
2) Data Abstraction – Act of representing only essential features without including its background details is called Data Abstraction.
3) Polymorphism – The ability of a method to behave in more than one form is called polymorphism. Function Overloading is a way to implement it, in which more than one function has the same name but different argument list.
4) Inheritance – The ability of a class to derive the properties from another class is called Inheritance. The class that inherits is called the Derived / Sub / Daughter class and the class from which it is derived is called Base / Super / Parent class. The keyword used to implement Inheritance is ‘extends’.
5) Object – It is an identifiable entity with some characteristics and behaviour.
6) Class – It is a blueprint that represents a set of objects which share common characteristics and behaviour.

Related Terms :
Data binding – is the process to link to the function call with function signature at run-time i.e., during execution of a program.

Attribute:-The characteristics which make every object having its identity make them distinguished is called attribute.

Behaviour – The behaviour of any class or object is represented through various functions and methods.

Message Passing – When object need to interact with one another they do so by passing information to and from one another, this is called Message Passing

Data Hiding – is the data which cannot be accessed directly outside, class premises although they are available in the same program

Garbage Collection – The Garbage-collected Heap is where the objects in Java programs are stored. Whenever we allocate an object using new operator, the heap comes into picture and memory is allocated from there. Java does this automatically using Garbage collection mechanism, using an algorithm named Mark & Sweep logic. Remember that the local object reference resides on Stack but the actual object resides in Heap only. Also, arrays in Java are objects, hence they also resides in Garbage-collected Heap.

Different Types of Java Programs
1) Standalone Application – An application program that is developed by programmers which consists of various methods and these methods being invoked from within a ‘main ( )’ method is called standalone application.
2) Internet Applets – These are small java programs that are embedded in a web page and which requires a web browser to be run/executed.
3) Servlets – They extend the functionality of web browser.
Source Code – The High level language code written by programmers which is not understandable by the computer is known as Source Code. It has an extension of *.java
Byte Code – is an intermediate code that consists of a set of pseudo machine language instructions that are understood by the JVM and are independent of the underlying hardware. It is called byte code because each chunk of code is of 8 BITS (1 byte = 8 Bits).

The byte code files have an extension of *.class

Object Code – The interpreter of Java named JVM (which stands for Java Virtual Machine) then converts the intermediate Byte Code into machine specific executable which runs on the host machine.
API (Application Programming Interface) – consists of libraries of pre compiled code that programmers can use in their application and programs for designing softwares. Hence we can say that Java API consists of functions and variables that programmers can reuse.

Java Packages – Packages are collection of similar nature classes. A package can be created by using the keyword ‘package’ and the keyword used to include a package in our program is ‘import’. Java contains an extensive library of pre-written classes grouped together into packages –
 java.lang.* It is a default package containing String, Math, Integer, thread etc.
 java.io.* It is the basic Input Output package of Java
 java.util.* The java utility package
 java.applet.* The applet package
 java.net.* The Networking package of Java
 java.awt.* It stands for Abstract Windows Toolkit, for designing Windows based applications.

Basic Features of Java:- 
1) Write once run anywhere(WORA)
2) Platform Independent
3) Offers many security features to make its program safe and secure
4) Built in graphics & supports multimedia
5) Light Weight code
6) Open Product… i.e., freely available to all.

Blue – J 
Blue-J is an Integrated Development Environment (IDE)for writing, editing, compiling, testing, executing and debugging the Java programming language, developed mainly for educational purposes, but also suitable for small-scale software development. Blue J was initially designed at University of Kent by David Barns andMichael Kollins

The main screen graphically shows the class structure of an application under development (in an UML-like diagram), and objects can be interactively created and tested. This interaction facility, combined with a clean, simple user interface, allows easy experimentation with objects under development.

Features of Blue – J
1. Simplicity of the interface – The GUI user friendly interface is simpler than in full-scale professional environments, and thus easier to learn.
2. The “Code Pad” – The code pad is a tool that instantly evaluates arbitrary Java expressions and statements.
3. Regression testing
4. Provision for syntax highlighting
5. Built in debugger.
6. Program input/output i.e. In Blue-J both the parameter values for and the return values from method calls can be entered / inspected directly.
7. Java ME support – Java ME (Micro Edition) projects can be developed and deployed from Blue-J.

IDE for Java (other than Blue J) 
Sl IDE Brief Description
1 Eclipse Free, open source IDE. The most popular of the Java IDEs, but harder to set up and configure than the commercial ones.
2 J Builder Lots of J2EE support including UML and app server integration.
3 Emacs This is a powerful, free editor that does color syntax highlighting, automatic indentation, and parenthesis/brace balancing.
4 M7 Nitro X Expensive but very powerful J2EE IDE based on Eclipse.

Java Tokens & Character Set
It is a set of valid characters that a language can recognize. The character set of Java is UNICODE. This has been selected due its vastness of characters. It is 2 byte character code. The first 128 characters of Unicode are identical to the ASCII character set.
Tokens are smallest individual units of a Java program. There are 5 different types of tokens in Java –
1. Keywords
2. Identifiers
3. Literals
4. Operators
5. Separators Hint: Try to remember KILOS

Keywords are the reserved words which convey a special meaning to a language compiler. They can not be used for any other purpose like function name, variable name or object names.
There are around 48 keywords, of which const and goto have been reserved even though they are not currently being used for any purpose true, false and null might appear to be keywords but actually they are literals, and hence are reserved words.

Identifiers are fundamental building blocks of a program. They are named memory locations or simply names given to variables, objects, classes, functions, arrays etc… They are case sensitive.

There are certain Identifier naming rules –
1. They can consist of infinite number of alphabets and digits
2. They must start with an alphabet and not with a digit
3. They can not be a keyword or reserved word
4. They cannot have any spaces
5. They cannot contain any special character other than _(underscore), $(dollar)

While naming identifiers there are certain conventions that make them identifiable
1. Class names begins with an Uppercase character
2. Identifiers having multiple words, the first character of 2nd and subsequent words are in Uppercase
3. Constants are in all CAPITALS

Comments (Remarks):- refers to statements which are ignored by the java compiler and increase the readability of a program. These are used to state a purpose of the instructions used in a program.

Literal are the fixed values that are assigned to variables which do not change its values during program execution. They are of 5 types –
1.Integer Literal
i.Decimal
ii.Octal
iii.Hexadecimal

To represent Decimal Integers we simply use the integer type number as literal, e.g. int p = 45; So, System.out.println (p); // Shows 45 as output

To represent Octal Integers however we precede the number with a 0 (zero) as literal, e.g. int p = 045; System.out.println (p); // Shows 37 as output coz, (45) in octal is 37 in decimal number system.

Moreover to represent any Hexadecimal Integer we use 0x (Zero and lowercase letter x) preceding the number as hexadecimal literal e.g. int p = 0x45;
System.out.println (p); // Shows 69 as output coz, (45) in hexadecimal is 69 in decimal number system.

2. Real Literals
i. Floating point literals have 7 digits of precision after the decimal point
ii. Double literals have 16 digits of precision after decimal point

3. Character Literals are enclosed within a pair of single quotes
char ch = ‘A’;
Character type user inputs are taken in the following way –
e.g. char ch = (char) in.read ( ) ;

4. Boolean Literal
There are only 2 types of boolean literals i.e. true & false the default being false.

5. Null Literal
Operator – are the entities or symbols that tell the compiler that what operation has to be performed with one, two or three number of operands within a given expression.
There are approximately a set of 37 different operators that Java uses
Operators can either operate on 1, 2 or 3 operands and accordingly named as –

 Unary (works on 1 operand) e.g. + + and – –
 Binary (works on 2 operands) e.g. +, – , * , / , >, , = , > , << )
 Special Operators (this , dot (.) , new, (type) , instanceof )

Data types – are the entities that tell the compiler that which variable will hold what kind of values.
Primitive data types – Also called as Basic Data type. They are pre defined or built in data types because they are already built in java. E.g. byte, short, int, long, float, double, char, boolean.
Non Primitive Data Types: Directly or indirectly dependent on primitive data types. They store the data values with reference to the address or locations. So, they are called as Reference Data Types. E.g. array, classes interfaces etc…

Range, Size and hierarchy of various primitive data types
Type ….Size…. Range
boolean 1 byte (uses 1 bit) true and false
byte 8 bits (1 bytes) – 128 to + 127
char 16 bits (2 bytes) 0 to 65,535
short 16 bits (2 bytes) – 32768 to +32767
int 32 bits (4bytes) – 2 31 to + 231 – 1
long 64 bits (8bytes) – 2 63 to + 263 – 1
float 32 bits (4bytes) – 3.4E+38 to +3.4E+38
double 64 bits (8bytes) – 1.7E +308 to 1.7E+308

Type conversion The process of convert one primitive datatype to another either from lower precision to higher or vice versa I known as type conversion. This can be achieved in two ways –
Implicit Data Type Conversion – Such Type of conversion is performed by the compiler without programmer’s intervention. In this type of conversion a datatype of lower precision gets converted to a datatype with higher precision.
e.g. int a = 10;
double d = a;
System.out.println(d);
The above code snippet gives 10.0 as output; this clearly indicates that the int datatype got automatically converted to double.

Explicit data type Conversion – Such type of conversion is user defined conversion which forces an expression to be converted into specific type. Generally this is done to force a conversion from higher precision data type to lower.
e.g. double pi = 3.1415;
int i = pi;

The above statement is considered illegal and hence gives an ERROR message “POSSIBLE LOSS OF PRECISION”
Hence the above code should be Type Casted in the following manner –
int i = (int) pi;
System.out.println(i);
Now, the output to the above code will be 3

Potential problems with Type Casting
1. When a datatype is converted from double to float results in loss of precision i.e. a double datatype has 16 digits after decimal point which gets truncated to 7 digits.
2. When a datatype is converted from double or float to integer type results in loss of entire fractional part leaving behind only the integral part.
3. When a higher order integer datatype like int or long is converted to byte or short might result in the data going out of range.

Take an example
int a = 130;
byte b = (byte) a;
System.out.println(b);

The output for the above code is – 126

Explanation for the above –
The above code tries to type cast int to byte, the data range for int is – 2 31 to + 231 – 1 whereas that of byte is – 128 to + 127, hence think in terms of a Number Line, when we start filling 130 in the number line starting from 0 (zero) we reach the end of the line at 127 and so the filling process continues from the –ve end and finally reaches – 126, hence the output…

Operators in Java

Operator – are the entities or symbols that tell the compiler that what operation has to be performed with one, two or three number of operands within a given expression.

There are approximately a set of 37 different operators that Java uses

Operators can either operate on 1, 2 or 3 operands and accordingly named as –

1. Unary (works on 1 operand) e.g. + + and – –
2. Binary (works on 2 operands) e.g. +, – , * , / , >, <, == etc…
3. Ternary (works on 3 operands) e.g. ? :

Operators can categorized as –

1. Arithmetic Operators (+ , – , * , / , %)
2. Relational Operators (> , < , >= , <= , == , !=)
3. Logical Operators (&&, || , !)
4. Conditional Operators (? : )
5. Bitwise Operators (&, | , ~ , ^)
6. Shift Operators (>> , << )
7. Special Operators (this , dot (.) ,  new, (type) , instanceOf )

Shortcut Operations in Java

Java implements shortcut methods to work with basic arithmetic operators like

+, – , * , / and %

Hence, a = a + 5; can be written as a + = 5;

And the above + = operator is called Addition Assignment operator.

Similarly we have –

• Subtraction Assignment – =
• Multiplication Assignment *=
• Division Assignment /=
• Modulus Assignment %=

 Unary Operators

Post/Pre – Increment and Post/Pre – Decrement Operators

a = a + 1 can also be written as either a++ (Post Increment) or ++a (Pre Increment)

a = a – 1 can also be written as either a– – (Post Decrement) or – –a (Pre Decrement)

The difference between Pre and Post is –

In a Postfix operator like Post Increment or Post Decrement the value of the operand is first used and then increased or decreased as the case may be for e.g.

int a = 5;

System.out.println(a++);

Gives 5 as output as the value of ‘a’ is first used and then increased to 6, so if we have one more print statement after the above stated line will give 6 as output.

System.out.println(a);          // Output is 6

In a Prefix operator like Pre Increment or Pre Decrement the value of the operand is first increased or decreased as the case may be and then used for e.g.

int a = 5;

System.out.println(++a);

Gives 6 as output as the value of ‘a’ is first incremented and then displayed.

Relational Operators are used to find the relationship between two quantities, whether they are equal, un-equal, greater than less than etc…

Symbol	Relationship
>	Greater than
<	Less than
>=	Greater than or equal to
<=	Less than or equal to
==	Equal to
!=	Not equal to

 Logical Operators are used to join 2 or more relational operators and of 3 types –

1. && (and) returns true when both or all the relations are true
2. || (or) returns true when any one of the relations are true
3. ! (not) inverts true to false and false to true

Say if the value of a=4, b=6 then…

if(a>5 && b>5) will return false coz both the conditions are not true

if(a>5 || b>5) will return true coz one of the conditions is true

if(!true) will return false

It is not mandatory to have a relation always inside an ‘if’, even without any ‘if’ clause we can check the return of any relation like –

Say the value of x=7; then

System.out.println(x==7); will give the output as true, and if we place (!) in front of the relation, System.out.println( ! (x==7)); will invert the output from true to false.

 Bitwise and Shift Operators

Operator	Name	Description	Example	Result
a & b	and	1 if both bits are 1 and 0 in all other cases	3 & 5	1
a | b	or	0 if both the bits are 0, rest all other cases 1	3 | 5	7
a ^ b	xor	1 if two bits are different and 0 in all other cases	3 ^ 5	6
~a	not	Inverts the bits, after transforming the entire number into full bit representation	~3	-4
n << p	left shift	Shifts the bits of n towards left by p positions thereby adding Zeros to the extreme LHS	3 << 2	12
n >> p	right shift	Shifts the bits of n towards right by p positions resulting in loss of bits from LHS	5 >> 2	1

In all the above examples the operands (values) must be converted to Binary and then implemented with respective operators except for Right and Left Shift operators where only the variable ‘n’ is converted to binary and not ‘p’

Don’t confuse &&, which is the logical and, with &, which is the uncommon bitwise and. Although the bitwise andcan also be used with boolean operands, this is extremely rare and is almost always a programming error.

 Conditional Operator

The only Ternary operator of Java is the Conditional Operator, ? : which can be used as an alternative to if…else

Syntax: variable = condition ? true : false ;

e.g. int n = 100>50 ? 1 : 0;

In the above code the value of ‘n’ becomes 1 as the condition 100>50 is true, had it been wrong the value of ‘n’ would have been 0;

Special Operators

q     [ ] this operator is used to assign the size for an array and to access any particular element within an array.

q     ( ) the parenthesis operator is used to enclose the arguments to a function in the function prototype line and invoke a function by enclosing the list of arguments.

q     Dot (.) the dot operator is used to access the instance/class members of a class through an object or class name.

q     new – the new operator is used to assign and allocate memory to new objects and arrays.

q     instanceof – this operator checks whether the first argument is an instance of the second argument or not.

e.g. str instanceof String                  // will return true ifstr is a String variable

Precedence Table 

Operator Precedence
The entire list 1.      ( ) . [] (args) post ++ -- 2.      ! ~ unary + - pre ++ -- 3.      (type) new 4.      */ % 5.      + - 6.      << >> >>> 7.      < <= > >= instanceof 8.      == != 9.      & 10.  ^ 11.  | 12.  && 13.  || 14.  ?: 15.  = += -= etc	Try to Remember only these ( ) unary operators * / % + – comparisons && || ? : = assignments

Math class functions in Java (The Math class belongs to the default package of Java named java.lang)

Sl	Function Name	Description
1	Math.sin(r)	Returns sine of angle ‘r’ given in radians
2	Math.cos(r)	Returns cosine of angle ‘r’ given in radians
3	Math.tan(r)	Returns tangent of angle ‘r’ given in radians
4	Math.asin(x)	Returns the angle in radians whose sine value is ‘x’
5	Math.acos(x)	Returns the angle in radians whose cosine value is ‘x’
6	Math.atan(x)	Returns the angle in radians whose tangent value is ‘x’
7	Math.toDegrees(r)	Converts Radians to Degrees
8	Math.toRadians(d)	Converts Degrees to Radians
9	Math.min(a, b)	Returns the smaller among a and b
10	Math.max(a, b)	Returns the larger among a and b
11	Math.abs(a)	Convert -ve magnitude to +ve magnitude.
12	Math.sqrt(x)	Returns the square root of ‘x’
13	Math.pow(x, y)	Returns x to the power of y
14	Math.exp(x)	Returns ‘e’ to the power of ‘x’ where e=2.718 called Euler’s  Constant just like pi
15	Math.cbrt(x)	Returns the cube root of ‘x’
16	Math.log(x)	Returns the Natural logarithm of ‘x’
17	Math.floor(x)	Returns the integral value of x less than or equal to ‘x’ but datatype returned is double, hence Math.floor(7.9) will give 7.0
18	Math.ceil(x)	Returns the integral value of x greater than or equal to ‘x’ but datatype returned is double, hence Math.ceil(7.9) will give 8.0

19	Math.rint(x)	Returns the integral value of x by rounding off the fractional part to the nearest integer , but data type returned is double, hence Math.rint(7.9) will give 8.0
20	Math.round(x)	Returns the integral value of x by rounding off the fractional part to the nearest integer, but datatype returned is int, hence Math.round(7.9) will give 8
21	Math.random()	Generates a double type random number between 0 to 1
22	Math.PI	This returns the 16 digits precise value of PI(Note that it is not a function)

Comment Lines in Java
 // comments — single line comment
After the two // characters, Java ignores everything to the end of the line. This is the most common type of comment.
 /* … */ comments — multiple line comment
After the /* characters, Java will ignore everything until it finds a */. This kind of comment can cross many lines, and is commonly used to “comment out” sections of code — making Java code into a comment while debugging a program.
Always write braces. It is good programming style to always write the curly braces, {}, although they are not needed if the clause contains only a single statement. There are two reasons this is good.
• Reliability. When code is modified, the indentation is such a strong indicator of structure that the programmer may not notice that the addition of a statement at the “correct” indentation level really isn’t included in the scope of the if statement. This is a surprisingly common error.
• Readability. It is faster to read code with the braces because the reader doesn’t have to keep in mind whether they are dealing with an un-braced single statement or a braced block.
Whitespace (e.g., a blank line, spaces)
Insert blank lines to separate sections of your program. It’s like starting a new paragraph in English. The compiler ignores them — it’s for us humans.

Exception Handling in Java
Exception refers to any contradictory or unusual situation which can be encountered during a program execution. In Java Exceptions (or Errors) has been categorized broadly under three heading –

1. Syntax Errors – A Syntax error occurs when the programmer writes a grammatically incorrect code that does not support the rules of programming of that particular language. This type of error gets detected by the compiler. E.g. missing semicolon, using keywords as identifier name, unmatched pair of { }, undefined functions, undeclared and un-initialized variables etc…

2. Logical Errors – A Logical error is born out of a programmer who misunderstands the logic of the program and writes a syntactically correct code but which does not comply to the algorithm of the problem. E.g. The program demanded squaring of an integer type number but the programmer writes a code that determines the square root of the number.

3. Runtime Errors – A Runtime error is shown when a syntactically and logically correct program with a set of inputs which is invalid for a given expression. The same expression is valid for another set of values. E.g. int quo = div / n, the expression is valid for all sets of positive values of n but not if n = 0.

Exception handling is ideal for –
1. Processing exceptional situations.
2. Processing exceptions for components which cannot handle them directly.
3. Processing exceptions for widely used components that should not process their own exceptions.
4. Large Projects that requires uniform error processing.

Advantages of exception handling:-
1. It separates error handling code from the normal code.
2. It enhances the readability.
3. It makes clear and strong program code.
The process of exception handling is implemented using a try … catch block, in which the try block contains the code which has probability of having errors during runtime and the catch block contains code to handle the situation.

Common Errors
0 < x < 100
Comparison operators can be used with two numbers. Although you can write 0 < x = or <= instead of ==. For example, because the decimal number 0.1 can not be represented exactly in binary, (0.1 + 0.1 + 0.1) is not equal to 0.3

String issues using = = and equals ( )
Usually you want to know if the two Strings have the same value, for e.g.
if (name == “Californication”) // Legal, but SURELY WRONG
Reason is the = = operator is not comparing the values of name and Californication instead it is just comparing the references i.e. it is checking whether both of them are strings or not and hence returns true and to the programmer it reveals to be perfectly LEGAL. To prove this we can take another e.g. say, –
String name = “Californication”;
System.out.println (name. substring (0,3)); // Gives the output as Cal
But when they are compared using = = gives the output as Un-Equal
if (name. substring (0,3) = = “Cal”)
System.out.println (“Equal”);
else
System.out.println (“Un-Equal”);
Hence always use equals ( ) method of String class to compare the values of String class objects.

NaN
No exceptions are generated by floating-point operations. Instead of an interruption in execution, the result of an operation may be positive infinity, negative infinity, or NaN (not a number). Division by zero or overflow produces infinity. Subtracting two infinities produces a NaN.
Infinity
Similarly no exceptions are generated for statements like Math.pow(0,–1) and such statements will result in Infinity as output

Flow Control in Java Programs

if Statement
The purpose of the if statement is to make decisions, and execute different parts of your program depending on a boolean true/false value.
The ‘if’ statement has this form, where condition is true or false
if (condition)
{
… // Do this clause if the condition is true.
}

Alternative forms of if statements –
if (condition)
{
… // Do this clause if the condition is true
}
else
{
… // Do this clause if the condition is false
}

Always make sure that the number of if clause should not exceed the number of else clause, because it will result in ‘dangling else problem’, in such case make use of if…else if…else construct as shown below –
if (condition 1)
{
… // Do this clause if the condition is true
}
else if (condition 2)
{
… // Do this clause if the condition is false
}
else
{
… // Do this clause if the condition is false
}

switch…case Statement
The if statement allows you to select one of two sections of code to execute based on a boolean value (only two possible values). The switch statement allows you to choose from many statements based on an integer (including char)
switch (expr)
{
case c1: … break;
case c2: … break;
…
default:
}
switch
The switch keyword is followed by a parenthesized integer expression, which is followed by the cases, all enclosed in braces.. The switch statement executes the case corresponding to the value of the expression. Normally the code in a case clause ends with a break statement, which exits the switch statement and continues with the statement following the switch. If there is no corresponding case value, the default clause is executed. If no case matched and there is no default clause, execution continues after the end of the switch statement.

case
The case keyword is followed by an integer constant and a colon. This begins the statements that are executed when the switch expression has that case value.

default
If no case value matches the switch expression value, execution continues at the default clause. This is the equivalent of the “else” for the switch statement. It is written after the last case be convention, and typically isn’t followed by break because execution just continues out the bottom of switch if this is the last clause.

break
The break statement causes execution to exit to the statement after the end of the switch. If there is no break, execution falls through into the next case. Flowing directly into the next case is almost always an error.

A switch statement can often be rewritten as a substitute for ‘if’ statement in a straightforward manner. For example, the preceding switch statement could be written as follows. When one of a number of blocks of code is selected based on a single value, the switch statement is generally easier to read. The choice of if or switch should be based on which is more readable.

Limitations of switch case
Java’s switch statement, which was taken directly from C++ to increase its attractiveness to C++ programmers, is not well loved.

• No ranges. It doesn’t allow ranges, eg case 90-100:. Many other languages do.
• Integers only. It requires integers and doesn’t allow useful types like String. Many other languages do.
• Error-prone. It is error-prone and a common source of bugs – forgetting break or default silently ignores errors. Some languages have eliminated these dangerous situations.
• Fall through. Another disadvantage of switch…case is that in absence of break statement in the respective cases will cause the flow control to cascade down and execute all the cases that does not contain ‘break’ statements until it reaches end of switch or a case that implements a break. This is called fall through.

Iteration through Loops

The purpose of loop or iterative statements is to repeat a block of Java statements several times depending upon the condition mentioned within the loop. There are two kinds of looping statements in Java.
1. Entry Controlled Loop
2. Exit Controlled

An Entry Controlled loop which is also known as Pre Tested Loop the condition of the loop is first checked and then the loop body is executed, which means if the condition is false the loop doesn’t get executed even for once.
E.g. a. for LOOP
b. while LOOP

An Exit Controlled loop which is also known as Post Tested Loop the condition is checked at the end of the loop body, which means even if the condition is false the loop gets executed at least for once.
E.g. a. do…while LOOP

If the body of a loop has more than one statement, you must put the statements inside braces. If there is only one statement, it is not necessary to use braces { }. However, many programmers think it is a good idea to always use braces to indicate the scope of statements. Always using braces allows the reader to relax and not worry about the special single statement case.
while statement

The while statement is used to repeat a block of statements while some condition is true. The condition must become false somewhere in the loop, otherwise it will never terminate.
Syntax:
initialization;
while (condition)
{
Body;
update;
}
//… While loop to display squares of natural nos. less than 10
int i = 1;
while (i <=10)
{
System.out.println(i*i);
i++;
}

for statement
Many loops consist of three operations surrounding the body:
(1) initialization of a variable,
(2) testing a condition, and
(3) updating a value before the next iteration.

The for loop groups these three common parts together into one statement, making it more readable and less error-prone than the equivalent while loop. For repeating code a known number of times, the for loop is the right choice.

There are three clauses in the ‘for’ statement.
1. The initialization statement is done before the loop is started, usually to initialize an iteration variable.
2. The condition/test expression is tested before each time the loop is done. The loop isn’t executed if the boolean expression is false (the same as the while loop).
3. The update statement is done after the body is executed. It typically increments an iteration variable.
Syntax:
for (initialization ; condition/test expression; update)
{
body
}

//… For loop to to display squares of natural nos. less than 10
for (int i = 1; i <= 10; i++)
{
System.out.println(i*i);
}

do…while statement
When you want to test at the end to see whether something should be repeated, the do…while statement is the natural choice
Syntax
do
{
. . .
} while (condition);

Always remember that a do…while statement has a semi-colon at its end.
The for loop is shorter, and combining the initialization, test, and increment in one statement makes it easier to read and verify that it’s doing what you expect. The for loop is better when you are counting something. If you are doing something an indefinite number of times, while loop may be the better choice.

Functions in Java

A function is a block or portion of code within a larger program which consists of some declarations and executable statements, which performs a specific task and is relatively independent of the remaining code.

The term method is used alternatively with function and means the same in Java programming language. A larger block of code is broken down into smaller and simpler modules called ‘member methods’ this is how the OOP language Java implements ‘Modularity’.

Advantages of using Functions –
1. To cope with the complexity of code by breaking down complex bigger code into smaller and simpler ones.
2. Hiding details (thus implementing Abstraction)
3. Reusability of Code
4. Makes debugging of errors easy.

Anatomy of a function

FUNCTION NAME ( )
{
Body of the function…
}

Let us now see all the components individually –
1. These are keywords which define the accessibility of the function, if nothing is mentioned then by default it is ‘friendly’ friendly is not a keyword. They are of 4 types
a. Public
b. private
c. protected
d. friendly this is not a keyword and hence cannot be written explicitly.

2. These are keywords which redefines the functionality within the methods. They can be final, native, static, synchronized, transient, volatile etc…

3. They specify what type of value a function can return, hence they can be of any primitive of reference data types like int, byte, float, char, String or even class types. In case the function doesn’t return any value the keyword ‘void’ is used.

4. Function name – This can be any valid identifier, but it is always advisable to take logical and meaningful names, it should conventionally begin with a lowercase letter and in case of multiple words join the words and begin each word in Uppercase except for the first word.
e.g. toUpperCase( )

5. This is a comma separated list of variables along with associated data types. This list can also be empty which indicates the function is non–argumentative.
e.g.
public static void add(int a, int b)
{
…
}

Function prototype
The first line of a function that consists of access specifier, modifier, return type, function name and list of parameters enclosed within a pair of parenthesis is called function prototype.
A function prototype describes the function interface to the compiler, by giving details of number and type of arguments, return type etc…
e.g.
public static void compute(int a, int b)
{
…
…
}

Function signature
The function signature is a part of function prototype; it basically refers to the argument list i.e. number, order and type of arguments.
e.g.
public static void compute(int a, int b)
{
…
…
}

Understanding the keywords public & private
In a function the access specifier indicate the scope of visibility of that particular function, this means whether the data members and member methods are accessible only within the class, or other classes within the same package or other classes in other packages.

Public members are accessible everywhere, within the same class as well as inside other classes that inherits the base class or by creating objects of the former class in the latter one even if they do not inherit, but private members are accessible only within the same class.

Understanding the keyword static
A static data member is also known as a class variable, such variables have only one instance inside the class and we can not create multiple instances through multiple objects.
On the other hand if a member is non-static then such members are called instance variables, which mean we can have multiple instances of such variables through multiple objects.
e.g.
class Exmp1
{
int x; // non-static or instance variable which can have multiple instances
static int y; // static variable or class variable which has only one instance

public static void main( )
{
Exmp1 obj1 = new Exmp1( );
Exmp1 obj2 = new Exmp1( ); // three different objects through which we can
Exmp1 obj3 = new Exmp1( ); // have three different values of ‘x’

obj1.x=10;
obj2.x=20; // the same variable ‘x’ has three different values simultaneously
obj3.x=30;

y = 100; // the variable ‘y’ being static is accessed directly and can have only
// one value

obj1.y=100;
obj2.y=200; // even if we try to access the variable ‘y’ through different objects
obj3.y=300; // the same ‘y’ gets overwritten and finally the last value prevails
}}
So, we see that if a member is static in nature it will have only one copy in the physical memory of the computer, which can be accessed directly without the need of creating objects. But if it is non-static then we need to create objects to specify which instance we are referring to as it has multiple occurrences.

How to access a function?
A function can be accessed or invoked from other functions by simply writing the name of the function along with the argument list (if any) otherwise the argument list is kept empty.
e.g.
class ABCD
{
public static void main( )
{
int x = 10, y = 20;
add (x, y);  function call
}

public static void add(int x, int y)
{
System.out.println(x+y);
}
}

Actual & Formal Parameters / Arguments
The actual parameters are those that appear at the point of function invocation or function call are called Actual parameters.

The formal parameters are those that appear at the point of function declaration or function signature are called Formal parameters.

e.g.
public static void main( )
{
int x = 10, y = 20;
add (x, y);  actual parameters
}

public static void add(int x, int y)  formal parameters
{
System.out.println(x+y);
}
A function be of one of the four types depending on its argument list and return type –

1. Non-argumentative & non-return type
Example
class ABCD
{
public static void main( )
{
display( );
}
public static void display( )
{
System.out.println(“Loyola School”);
}
}

2. Argumentative & non-return type
Example
class ABCD
{
public static void main( )
{
int x = 10;
display(x);
}
public static void display(int x)
{
System.out.println(“The value of x =” + x);
}
} // Note that a function which is void cannot return any value

3. Non-argumentative & return type
Example
class ABCD
{
public static void main( )
{
int x = display( );
System.out.println(“The value of x =” + x);
}

public static int display( )
{
int x = 10;
return x;
}
} // Note that the return type of the function and the variable associated
// with the keyword return must be identical, also note that the function
// at the point of invocation gets equated with a similar datatype.

4. Argumentative & return type
Example
class ABCD
{
public static void main( )
{
int x = 10;
int y = display( x );
System.out.println(“The square value of x =” + y);
}

public static int display(int x)
{
int y = x * x;
return y;
}
}

The return statement
A function terminates as soon as the last statement of the function is encountered or the return keyword is encountered.
It is not necessary that return keyword should be used only in functions that has a return type, even functions that are void can use the return keyword to terminate the function and shift the program control to the calling function but make sure that the return statement does not have anything preceding the keyword ‘return’.
e.g.
class ABCD
{
public static void main( )
{
call( );
}

public static void call( )
{
System.out.println(“Inside the method call”);
return ; // return statement has nothing following it
}
}

Three types of functions:

1. Computational functions – The functions that computes or calculates certain values or quantities and returns the answer to the calling method is called Computational function.
e.g. Math.pow(a,b);

2. Manipulative functions – The functions which manipulates the data and returns information to the calling function as success or failure code in the form of 0 & 1 or true & false.
e.g. Character.isLetter( )

3. Procedural Functions – The functions that perform certain tasks like reading from source files, reading from terminals, displaying data to the terminal are called procedural functions. They generally do not have any return type.
e.g. System.out.println( );

Pure & Impure functions
A pure function is one that takes objects and/or primitive data as arguments but does not modify the objects hence the return value of such functions are either primitive data or an entirely new object created inside the function. They are also known as Accessor methods.

An impure function on the other hand modifies the state of its objects or arguments. They are also known as Modifier methods.

public static int maximum(int a, int b)  Pure Function
{
int c = Math.max(a,b);
return c;
}

public static int product(int a)  Impure Function
{
a = a * a;
return a;
}

Function Overloading
A function name having several definitions in the same scope that are differentiated on the basis of function signature i.e. number of arguments, order of arguments, type of arguments is said to be an overloaded function and the process of creating such functions is called Function Overloading.

Function overloading implements Polymorphism.

e.g.
class Overload
{
public static void area(int s)
{
System.out.println(“Area of square =” + (s*s));
}

public static void area(int l, int b)
{
System.out.println(“Area of rectangle =” + (l*b));
}

public static void area(double r)
{
System.out.println(“Area of circle =” + (3.1415 * r * r));
}
}

Constructors in Java

A Constructor is a member method of a class which has same name as that of a class; has no return type not even void, used to initialize the instance variables of a class, and gets invoked automatically as soon as the object of the class is created.

class Constr
{
int n;
Constr( )
{
n = 0;
}                                                                                   // invokes the constructor

public static void main( )
{
Constr obj = new Constr( );
System.out.println(obj.n);
}
}

Types of Constructors

1. Non Parameterized Constructors
2. Parameterized Constructors

A constructor that accepts no parameters are called non parameterized constructors, non parameterized constructors that initialize the instance variables to zero, null and empty values are called Default Constructors.Above is an example of default constructor.

A parameterized constructor accepts parameters or values in its argument list which initialize the various instance data members of the class.

 class Constr
{
int n;
Constr(int val)
{
n = val;
}                                                                                   // invokes the constructor

public static void main( )
{     int v = 25;
Constr obj = new Constr(v);
}
}

Exception Handling

An exception in general is any unexpected / contradictory situation of error encountered at the time of program execution is called an Exception.

Types of Errors

1. Compile time errors / Syntax Errors – The errors that occurs as a result of violating the programming rules or syntax are called Compile time errors. They get detected at the time of program compilation.

e.g. int class = 10;     // class is a keyword hence syntactically incorrect

1. Run time errors – The errors that occurs during program execution is called run time errors. These unexpected errors may occur due to array index going out of bound, end of file reached, type mismatch errors at the time of data input etc…

1. Logical Errors – These errors are those which occur due to misinterpretation of the problem / program logic, resulting in design of wrong code by the programmer. Such errors are very difficult to detect, like if the problem says to add two numbers and find their sum and the programmer commits a multiplication on the numbers, such programs might be syntactically totally correct but the logic was misinterpreted.

Exception handling is a transparent and an efficient way of handling run time errors.

Understanding try / catch / finally blocks and throwskeywords

Try block contains the code which might lead to run time errors.

Catch block contains the code to deal with an exception that might arouse due to execution of a try block.

Finally block contains the code that gets executed when no other block is able to handle the exception.

Throws is a keyword which is used to inform that an error has occurred, it is specified in the line of function definition (prototype).

The program below gives an idea as to how an Exception is handled in Java

class Error
{
public void testfunction (int x, int y)    throws Exception
{
int z;
try 
{
z = x / y;
System.out.println( z );
}

catch (exception exp)
{
System.out.println(exp.getMessage( ) );
}

finally
{
System.out.println(“Un–reported exception has occurred…”);
}
}

Wrapper Classes
Java is an object-oriented language and as said everything in java is an object. What about the primitives datatypes? As a solution to this problem, Java allows you to include the primitive datatypes in the family of objects by using what are called wrapper classes.

Wrapper classes wrap the primitive datatypes into respective objects.
There is a wrapper class for every primitive date type in Java. This class encapsulates a single value for the primitive data type. For instance the wrapper class for int is Integer, for float is Float, and so on.
Wrapper classes are a part of Java’s standard default library java.lang

The wrapper classes in the Java API serve two primary purposes:

• To provide a mechanism to “wrap” primitive values in an object so that the primitives can be included in activities reserved for objects, like as being added to Collections, or returned from a method with an object return value.
• To provide an assortment of utility functions for primitives. Most of these functions are related to various conversions: converting primitives to and from String objects, and converting primitives and String objects to and from different bases (or radix), such as binary, octal, and hexadecimal.

 Wrapper Class functions / methods

The wrapper class methods that are static in nature can be directly accessed as –

Class_name.method_name (arguments)                               e.g. Boolean.toString(b);

 Boolean Wrapper class

Function	Description
booleanValue( )	Convert Boolean object to boolean primitive datatype.
valueOf( )	Convert String to Boolean object.
toString( )	Convert Boolean object to String.

Byte Wrapper class

Function	Description
parseByte( )	Converts String to byte primitive datatype.
valueOf( )	Converts String to Byte object.
toString( )	Converts byte primitive to String object.

 Short Wrapper class

Function	Description
parseShort( )	Converts String to short primitive datatype.
valueOf( )	Converts String to Short object.
toString( )	Converts short primitive to String object.

 Integer Wrapper class

Function	Description
parseInt( )	Converts String to int primitive datatype.
valueOf( )	Converts String to Integer object.
toString( )	Converts int primitive to String object.

 Long Wrapper class

Function	Description
parseLong( )	Converts String to long primitive datatype.
valueOf( )	Converts String to Long object.
toString( )	Converts long primitive to String object.

 Float Wrapper class

Function	Description
parseFloat( )	Converts String to float primitive datatype.
valueOf( )	Converts String to Integer object.
toString( )	Converts int primitive to String object.

 Double Wrapper class

Function	Description
parseDouble( )	Converts String to double primitive datatype.
valueOf( )	Converts String to Double object.
toString( )	Converts double primitive to String object.

 Character Wrapper class

Function	Description
isLetter( )	Checks whether the specified character is a Letter or not.
isDigit( )	Checks whether the specified character is a Digit or not.
isWhiteSpace( )	Checks whether the specified character is a blank or not.
isUpperCase( )	Checks whether the specified character is in uppercase or not.
isLowerCase( )	Checks whether the specified character is in lowercase or not.
toUpperCase( )	Converts the specified character to Uppercase.
toLowerCase( )	Converts the specified character to Lowercase.
toString( )	Returns a String object representing the specified character as a single character string.

e.g. char ch = ‘A’;

System.out.println(Character.isLetter(ch)); // returnstrue

System.out.println(Character.toLowerCase(ch)); // returns a

String Handling in Java

 A String is a collection of characters, in Java String is not a primitive datatype instead is implemented as a class. In Java a String is an immutable object which means it can not be modified. For understanding this we can take a small example of a String class function concat( ) which is used to join two strings.

String s1 = “Computer”;

System.out.println(s1.concat(“Application”); // returnsComputerApplication

But, if we try to print the String s1 after the above implementation we will find that System.out.println(s1); // returns Computer which clearly states that the s1 string was

//not modified…

Strings can be created in two ways –

• As a String Literal
• As a String object

A String Literal can be created as follows –

String str = “Welcome”;

Each time a String literal is created JVM checks theString Constant Pool if the String exists in the pool them no new string will be created instead a reference to the pool is returned.

e.g.

String str1 = “Welcome”; // a new string is created in the String Pool

String str2 = “Welcome”; // no new string is created as “Welcome” already exists in pool

A String Object can be created using a new keyword –

String str = new String (“Welcome”);

In such cases Java will create the String in the Heap Memory

String handling is a way of manipulating strings / string literals / string objects by concatenating strings, comparing strings, extracting characters from string, creating substrings from given strings, replacing characters from within a string, etc…

String class functions

Sl	String Functions	Return	Description
1	length( )	int	Returns length of a string
2	charAt(k)	char	Returns a character at a position k within the string.
3	toUpperCase( )	String	Returns a String which has all the letters in Capitals (uppercase)
4	toLowerCase( )	String	Returns a String which has all the letters in Small Letters (lowercase)
5	startsWith(s)	boolean	Returns true if string starts with a string s
6	startsWith(s, k)	boolean	Returns true if string starts with a string s at index k
7	endsWith(s)	boolean	Returns true if string ends with a string s
8	endsWith(s)	boolean	Returns true if string ends with a string sstarting at an index k
9	indexOf(s)	int	Returns an index of the first occurrence of String s in string
10	indexOf(s, k)	int	Returns an index of String s starting an index k in string
11	lastIndexOf(s)	int	Returns an index of the last occurrence of String s in string
12	substring(k, n)	String	Returns a substring from index k to index n-1 of string
13	substring(k)	String	Returns a substring from index k to the end of string
14	concat( )	String	Joins two strings
15	trim( )	String	Returns a String which has all the spaces removed from the beginning and end without altering any intermediate spaces.
16	equals(s)	boolean	Returns true if the two strings have equal values
17	equalsIgnoreCase(s)	boolean	Same as above ignoring case
18	compareTo(s)	boolean	Compares two strings
19	compareToIgnoreCase(t)	boolean	Same as above ignoring case

Single and Double Dimensional Arrays in Java

Definition of One Dimensional Array
One dimensional array is a list of variables of same datatype that are accessed by a common name. An individual variable in the array is called an array element. The locations in which they are stored is called array index or array subscript hence arrays are also sometimes referred as Subscripted variables.

Declaring an array is the same way of declaring a variable but with extra square brackets to inform the compiler, that the variable represents an array. Array size should be given at the time of creation. Depending upon the size, continuous memory locations are allocated to the elements. Array identifier follows the same rules of Java identifiers.

Declaring, Assigning and Accessing the Array
The following program explains the basic syntax of creating an array in Java. First an integer array by name, marks, is created which is filled with zero values by default.

Creating sized arrays
Syntax:
datatype array_name[ ] = new datatype[size];
Example:
int ARR[ ] = new int[5];
By default all array elements are initialized to ‘zero’.

Creating un-sized array
Syntax:
datatype array_name[ ];
Example:
int ARR[ ];
But such arrays need to be sized later to use them,
arrayname = new datatype[size]; // make sure to use the base address only without[ ]
Example:
ARR = new int[5];

Un-sized array with assignment
datatype array_name[ ] = {value1, value2, value3,… value};
make sure the [ ] remains empty.
Example:
int ARR[ ] = {1,2,3,4,5};

Sample Program implementing a Single Dimensional Array

public class ArrayTest1
{ public static void main(String args[])
{
int marks[] = new int[5];
System.out.println(“Elements are ” + marks.length);

for(int j=0;j<marks.length;j++)
{
System.out.println(“Default value: ” + marks[j]);
}

// Now assign values
marks[0] = 50;
marks[1] = 60;
marks[2] = 70;
marks[3] = 80;
marks[4] = 90;

System.out.println(“Value of 1st element: ” + marks[0]);

System.out.println(“\nPrint the values in a single row”);
for(int i = 0; i < marks.length; i++)
{
System.out.print(marks[i] + “\t”);
}

// Alternative method of printing supported from JDK 1.5
for(int k : marks)
{
System.out.print(k + “\t”);
}

} //closing main()

} // closing class

Application of Arrays
Arrays are broadly used in storing huge list of similar data as they are easy to implement under a single name. And are used for –

1. Searching
o Linear Search
o Binary Search

2.Sorting
o Bubble Sort
o Exchange Selection Sort
o Quick Sort
o Merge Sort

3. Merging Arrays
o Alternate Merge
o End to end Merge
o Similar & Dissimilar sized arrays

Inheritance

Inheritance is a mechanism wherein a new class is derived from an existing class. In Java, classes may inherit or acquire the properties and methods of other classes. A class derived from another class is called a subclass, whereas the class from which a subclass is derived is called a superclass.

 A subclass that has only one superclass is a case of single inheritance.
 Whereas a superclass having one or more subclasses is a case of hierarchical inheritance.
 Classes can be derived from classes that are derived from other classes that are derived from again other classes, and so on, ultimately derived from the topmost class that’s multilevel inheritance.

Object. Such a class is said to be descended from all the classes in the inheritance chain stretching back to Object.
The keyword “extends” is used to derive a subclass from the superclass, as illustrated by the following syntax:

class Name_of_subclass extends Name_of superclass
{
//new fields and methods that would define the subclass go here
}

Example Code of Inheritance
public class Bicycle
{
// the Bicycle class has three fields
public int cadence;
public int gear;
public int speed;

// the Bicycle class has one constructor
public Bicycle(int startCadence, int startSpeed, int startGear)
{
gear = startGear;
cadence = startCadence;
speed = startSpeed; }
// the Bicycle class has four methods
public void setCadence(int newValue)
{
cadence = newValue;
}

public void setGear(int newValue)
{
gear = newValue;
}

public void applyBrake(int decrement)
{
speed – = decrement;
}

public void speedUp(int increment)
{
speed += increment;
}
}

A class declaration for a MountainBike (subclass) that inherits Bicycle (superclass):
public class MountainBike extends Bicycle
{
// the MountainBike subclass adds one field
public int seatHeight;

// the MountainBike subclass has one constructor
public MountainBike(int startHeight, int startCadence, int startSpeed, int startGear)
{
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}

// the MountainBike subclass adds one method
public void setHeight(int newValue)
{
seatHeight = newValue;
}
}
MountainBike inherits all the fields and methods of Bicycle and adds the field seatHeight and a method to set it. Except for the constructor, it is as if you had written a new MountainBike class entirely from scratch, with four fields and five methods.

However, you didn’t have to do all the work. This would be especially valuable if the methods in the Bicycle class were complex and had taken substantial time to debug.

Types of Inheritance

 Single Inheritance –
A subclass that has only one superclass is a case of single inheritance.

 Multilevel Inheritance –
Classes can be derived from classes that are derived from other classes that are derived from again other classes, and so on, ultimately derived from the topmost class that’s multilevel inheritance.

 Multiple Inheritance
When a sub class derives from two or more super class, such an inheritance form is called multiple but in Java it can not be achieved directly and is implemented through Interface.

 Hierarchical Inheritance –
A superclass having one or more subclasses is a case of hierarchical inheritance.

 Hybrid Inheritance –
A combination of two or more of the above forms of Inheritance is called Hybrid Inheritance.

Access Specifier
One of the techniques in object-oriented programming is encapsulation. It concerns the hiding of data in a class and making this class available only through methods. In this way the chance of making accidental mistakes in changing values is minimized. Java allows you to control access to classes, methods, and fields via so-called access specifiers.
Java offers four access specifiers, listed below in decreasing accessibility:
• public
• protected
• default (no specifier)
• private

We look at these access specifiers in more detail.
Public
Public classes, methods, and fields can be accessed from everywhere. The only constraint is that a file with Java source code can only contain one public class whose name must also match with the filename. You use public classes, methods, or fields only if you explicitly want to offer access to these entities and if this access cannot do any harm. An example of a square determined by the position of its upper-left corner and its size.
public class Square
{ // public class
public x, y, size; // public instance variables
}

Protected
Protected methods and fields can only be accessed within the same class to which the methods and fields belong, within its subclasses, and within classes of the same package, but not from anywhere else. You use the protected access level when it is appropriate for a class’s subclasses to have access to the method or field, but not for unrelated classes.
Default (no specifier) also known as friendly
If you do not set access to specific level, then such a class, method, or field will be accessible from inside the same package to which the class, method, or field belongs, but not from outside this package. This access-level is convenient if you are creating packages.

Private
Private methods and fields can only be accessed within the same class to which the methods and fields belong. Private methods and fields are not visible within subclasses and are not inherited by subclasses. So, the private access specifier is opposite to the public access specifier. It is mostly used for encapsulation: data are hidden within the class and accessor methods are provided.
An example, in which the position of the upper-left corner of a square can be set or obtained by accessor methods, but individual coordinates are not accessible to the user.
public class Square
{ // public class
private double x, y // private (encapsulated) instance variables

public setCorner(int x, int y)
{ // setting values of private fields
this.x = x;
this.y = y;
}

public getCorner()
{ // setting values of private fields
return Point(x, y);
}
}

The following table summarizes the access level permitted by each specifier.
Situation public protected default private
Accessible to other class from same package? yes yes yes no
Accessible to classes from different package? yes no, unless it is a subclass no no

So we can conclude the following about Inheritance that –

 It is the mechanism of deriving a new class from an old class
 Old class is called super class or parent class
 The new class is called sub class or daughter class
 It allows subclasses to inherit the data members and member methods of super class
 Inheritance promotes code re-usability
 Constructors of Base class are not inherited by Derived class
 The this keyword can be used to refer to the most current object
 If both sub class and super class has methods with same prototype/signature then methods of sub class overrides the method of the super class this is called overriding.
 The overridden super class methods can be accessed using the keyword super
 The constructor of sub class can be used to invoke the constructor of super class through the keyword super( ) with arguments but ensure this should be the first statement of the sub class constructor.
 Methods declared final in the super class can not be overridden.
 An Abstract class is one that simply represents the concept and whose objects can not be created, it is implemented using the keyword abstract.

Use of final keyword and Abstract in classes and methods

// Using final keyword
public class Base
{
public final double pi = 3.14159;
public final void display( )
{
System.out.println(“Final method in Base”);
}
public void modify( )
{
pi = 3.14159265; // Illegal, as final members can not be modified
}
}
public class Derived extends Base
{
public void display( ) // Illegal function, as it has been declared final in Base
{
System.out.println(“Final method in Derived”);
}
}

Use of abstract keyword
// Use of public abstract class PQR // abstract class
{
…
}
public abstract class PQR
{
int a ;
float f ;
public void display ( ) { } // NOT an abstract method
public void display1 ( ) ; // Abstract method, note the semicolon
}

Use of super keyword
public class Base
{
public int a;
double d;
Base(int val1, double val2)
{
a = val1;
b = val2;
}
public void display( )
{
System.out.println(“Display method in Base”);
}
}

public class Derived extends Base
{
int c ;
Derived (int val1, double val2, int val3)
{
super(v1, v2); // super keyword used to invoke base class //constructor
c = val3;
}

public void display( )
{
System.out.println(“Display method in Derived”);
}

public static void main( )
{
Derived obj = new Derived(15, 3.1415);
obj.display( ) ; // method of sub / derived class is invoked
super.display( ) ; // method of super / base class is invoked
}
}