Java is a general purpose, object oriented programming language developed by Sun MicroSystems in 1991. Originally called OAK by James gosling , one of the inventors of the language. But was renamed as java in 1995.
The primary motivation of java was not the internet. It was designed to be embedded in various consumer electronic devices such as Microwave ovens, washing machines and remote controls etc.
The trouble with C and C++ is that they are designed to be compiled for specific target i.e, we require a full C++ compiler targeted for the CPU working in a specific environment. The problem is that compilers are expensive and time consuming to create.
So Gosling and his team began to work on a portable, platform independent language that could be used to produce code that would run on variety of CPUs under different environments. The effort ultimately lead to creation of ‘java’
C is familiar for its syntax, C++ is familiar for its object oriented features. So java came with good features of both these languages but not the enhanced version of C or C++.
Java Magic (Byte Code)
The magic of java is the security and portability. Problems are just solved by its byte code i.e output of java compiler is byte code not executable code.
Again this byte code is executed by java runtime system, which is called JVM (Java Virtual Machine). JVM is an interpreter for byte code. Transforming the java program into byte code makes it much easier to run a program in a wide variety of environments. Although if JVM differs from platform to platform, all the machines understand the same byte code.
Java Buzzwords(Features) (S S P OR MAC HDD)
Simple: Java was designed to be easy for professional programmers to learn, if he already knows C &C++. Java includes syntaxes from C and object oriented concepts from C++. The confusing concepts in both C & C++ are leftover here. So java is easy to learn and it is simple language.
Secure: Security becomes an important issue for a language that is used for programming on internet. Threat of viruses and abuse of resources are everywhere. Java systems not only verify all memory access but also ensure that no viruses are communicated with an applet. The absence of pointers in java ensures that programs can’t gain access to memory locations without proper authorization.
Portable: The most significant contribution of java over other languages is its portability. Java programs can be easily moved from on computer to another, anywhere and anytime. Changes and upgrades in operating systems, processors and system resources will not force any changes in java programs. This is the reason why java has become popular language for programming on internet which interconnects different kinds of systems world wide.
Object Oriented: java is a true object oriented language. Almost everything in java is an object. All program code and data reside with in objects & classes. Java comes with an extensive set of classes, arranged in packages, that we can use in our programs by inheritance. The object Model in java is simple and easy to extend.
Robust: Java is a robust language. It provides many safeguards to ensure reliable code. It has strict compile time and runtime checking for data types. It is designed as a garbage collected language relieving the programmers virtually all memory management problems. Java also incorporates the concept of exception handling which captures serious errors and eliminates any risk of crash the system.
Multithreaded: It means handling multiple tasks simultaneously. Java supports Multithreaded programs. This means that we need not wait for the application to finish one task before another. For eg, we can listen to an audio clip while scrolling a page and at the same time download an applet from a distant computer. This feature greatly improves the interactive performance of graphical applications.
Architectural Neutral: One of the problems facing by programmers was program written today will not be run tomorrow even in the same machine or if the OS or if the processor upgrades. So java designers made it architectural neutral by implementing JVM (Java Virtual Machine)through java runtime environment. The main role of java designers to make it architecture neutral write once, run anywhere, anytime forever.
Compiled & Interpreted: Usually a computer language is either compiled or interpreted. Java combines both these approaches thus making java a two stage system. First java compiler translates source code into what is known as byte code. Byte codes are not machine instructions and therefore, in second stage java interpreter generates machine code that can be directly executed by the machine that is running the java program. So we can say that java is both compiled and interpreted language.
High Performance: Java performance is impressive for an interpreted language, mainly due to the use of intermediate byte code. Java architecture is also designed to reduce overheads during runtime. Further, the incorporation of multithreading enhances the over all execution speed of java programs.
Dynamic: java programs carry with them substantial amount of runtime information that is used to access the objects at runtime. This makes java Dynamic.
Distributed: java is designed for the distributed environment of the internet because it handle TCP/IP protocols. Java supports two computers to support remotely through a package called Remote Method Invocation (RMI)
Data types:
Every variable in java has a datatype. Datatypes specify the size and type of values that can be stored. Java language is rich in its datatypes.
Integer types:
Java supports 4 t ypes of integers, they are byte short , int and long. Java does not support the concept of unsigned types and therefore all java values are signed ,meaning they can be +ve or –ve
Type Size Range
byte 1 byte -128 to 127
short 2 bytes -215 to 215-1
int 4 bytes -231 to 231-1
long 8 bytes -263 to 263-1
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 n/w or file. byte variables are declared by use of ’byte’ keyword.
eg: byte b, c;
short: short is signed 16 b it type. It has range from -215 to 215-1. The short variables are declared by use of short keyword.
eg: short s;
int: The most commonly used integer type is int. It is a signed 32 bit type that a range from -231 to 231-1. In addition to other uses, variables of type int are commonly employed to control loop and to index arrays. ‘int’ type is most versatile & efficient type. int variables are declared by use of ‘int’ keyword.
eg: int a;
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 values. The range of long is quite large. It has range from -263 to 263-1. long variables are declared by use of ‘long’ keyword
eg: long a;
Floating point types:
Floating point numbers are used when evaluating expressions that require fractional precision. There are two kinds of floating point types, float and double. Which represent single and double precision numbers respectively.
Type Size Range
float 4 bytes 1.4e-045 to 3.4e+038
short 8 bytes 4.9e-324 to 1.8e+308
float: the type float specifies a single precision value that uses 32 bits of storage. Single precision is faster on same processors and takes half as much space as double precision. float variables are declared by use of ‘float’ keyword.
eg: float a=1.234;
double: double precision, as denoted by the double keyword, uses 64 bits to store a value. All transcendental math functions such as sin(), cos() and sqrt() return double values. double variables are declared by use of ‘double’ keyword.
eg: double d;
char: In java, the datatype used to store characters is char. 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. Thus in java char is a 16bit type. The range of char is 0 to 65536. There are no negative chars. char variables are declared by use of char keyword.
eg: char c;
boolean: Java has a simple type called boolean, for logical values. It can have only one of two possible values, true or false. This is the type returned by all relational operators such as a<b. Boolean is also the type required by conditional expressions that govern the control statements such as ‘if’ and ‘for’. boolean variables are declared by use of ‘boolean’ keyword.
eg: boolean b; b=false;
Java Virtual Machine:
Generally all language compilers translate source code into machine code for a specific computer. In java, architectural neutral is achieved because compiler produces an intermediate code called Byte code, for a machine is called JVM
A virtual machine code is not machine specific. The code generated by the java interpreter by acting as an intermediary between the virtual machine and real machine.
Implementing a java program:
Implementation of java application program involves a series of steps. They include
- Creating the program
- Compiling the program
- Running the program
Remember that, before we begin creating the program, JDK must be properly installed on our system.
Creating the program:
We can create a program using any text editor
class Sample
{
public static void main(String arg[])
{
System.out.println(“Hi friend”);
}
}
We have to save this program with a name like prog.java
A java Application have any no of classes, but only one main class. Main class is nothing but class which contains main() method
Compiling the program:
To compile the program we must run the java compiler javac, with the name of the source file on command line as shown below
C:\> javac prog.java
If everything is OK, java compiler(javac) creates a file called Sample.class (<classname.class>) containing the bytecodes of the program prog.java
Running the program:
We need to use the java interpreter to run stand alone applications. At the command prompt, type…
C:\> java Sample
Now, the interpreter looks for the main method in the program and begins execution from there. When executed our program displays the following
o/p: Hi friend
Java PROGRAM STRUCTURE:
A java program may contain many classes of which only one class defines a main method. Classes contain datamembers and methods that operate on the data members of the class.
Java program may contain one or more sections as shown below.
Documentation section:
This section comprises of a set of comment lines giving the name of program, the author & other details, which the programmer would like to refer at later stage. It is suggested one.
Package statement:
The first statement allowed in java is a ‘package’ statement.
This statement declares a package name and informs the compiler that the classes defined here belong to this package.
Eg: package student;
It is optional section.
Import statement:
This is similar to the #include statement in C
Eg: import java.io.*;
It is optional section.
Interface statement:
An interface is like a class but includes a group of method declarations. It is also optional section and is used only when we wish to implement the multiple inheritance feature in jprogram.
Class Definitions:
A java program may contain multiple class definitions. Classes are the primary & essential elements of a java program.
Main Method Class:
Since every java stand alone program requires a main method as its starting point, this class is the essential part of a java program.The main method creates objects of various classes and establishes communications between them. On reaching the end of main, the program terminates and the control passes back to the operating system.
COMMAND LINE ARGUMENTS:
Sometimes we will need to supply data into a java program when it runs. This type of data will be supplied in the form of command line arguments. The command line arguments will immediately follow the program name on the command line. These command line arguments will be collected into an array of string which is supplied as a parameter to main methods.
Later these command line arguments must be processed and then accessed. The following program takes command line argument and prints them.
Eg: class Display
{
public static void main(String args[])
{
for(i=0;i<args.length();i++)
System.out.println(args[i]);
}
}
c:\> javac file.java
c:\> java Display hi this is ur friend
o/p-> hi
this
is
ur
friend
VARIABLES:
A variable is an identifier that denotes a storage location used to store a data value. All variables have a scope, w hich defines their visibility and a lifetime.
Declaring variable:
All variables must be declared before they can be used. The basic form of a variable declaration is , type identifier[=value][, identifier [=value]… ];
Eg: int value;
float avg;
in the above example, ‘value’ is an integer type variable , where as ‘avg’ is float type variable.
To declare more than one variable of the specified type, use a comma-separated list.
int a,b,c; // declares three integer variables a, b, and c
int d=3,e,f=5; // declares 3 integer variables initializing d and f
Unlike in C, variable can be declared any where in the program, where ever they are needed.
Dynamic Initialization:
Although the preceding examples have used only constants as initializers, java allows variables to be initialized dynamically, using any expression valid at the time the variable is declared.
For example,
Class DynInit
{
Public static void main(String arg[])
{
double a=3.0, b=4.0;
double c=Math.sqrt(a*a+b*b); // c is dynamically initialized
System.out.println(“Hypotenuse is ”+c);
}
}
Here, three local variables a, b, c are declared. The two a and b are initialized by constants. However c is initialized dynamically.
Classification of variables:
Java variables are actually classified into three kinds:
- Instance variables
- Class variables
- Local variables
Instance variables are created when the objects are instantiated and therefore they are associated with the objects.They take different values for each object.
Class variables are global to a class and belong to the entire set of objects that class creates. Only one memory location is created for each class variable.
- Instance and class variables are declared inside a class.
Local variables are declared and used inside methods and program blocks(defined between opening brace { and a closing brace} ). These variables are visible to the program only from the beginning of its program block to the end of the program block.
Scope and lifetime of variables:
Scope of variables: Scope is defined as an area of the program where the variable is accessible. As a general rule, variables declared insid a scope are not visible to code that is defined outside that scope.
Scopes can be nested. For example, each time you create a block of code, you are creating a new, nested scope. When this occurs, the outer scope encloses the inner scope.This means that objects declared in the outer scope will be visible to code within the inner scope. However the reverse is not true. Objects declared with in the inner scope will not be visible outside it.
// program to demostarte block scope
class scope
{
public static void main(String ar[])
{
Int x; // known to all code with in main
x=10;
if(x==10)
{
Int y =20; // known only to this block
System.out.println(“x and y: ”+x+” ”+y);
x=y*2;
}
y = 100; // Error! y not known here
System.out.println(“x is ”+x); // x is still known here
}
}
As the comments indicate, the variable x is declared at the start of main()’s scope and is accessible to all subsequent code within main(). y is only visible to the code in if block .
Lifetime of variables:
Varaibles are created when their scope is entered, and destroyed when their scope is left. This means that a variable will not hold its value once it has gone out of scope. Therefore, variables declared within a method will not hold their values between calls to that method. Also a variable declared within a block will lose its values when the block is left. Thus, the lifetime of a variable is confined to its scope.
class Lifetime
{
public static void main(String ar[])
{
int x;
for(x=0; x<3; x++)
{
int y=-1; // y is initialized each time block is entered
System.out.println(“y is : ”+y); // this always prints -1
Y=100;
System.out.println(“y is now : ”+y);
}
}
}
The output of above program is :
y is : -1
y is now: 100
y is : -1
y is now: 100
y is : -1
y is now: 100
Arrays
An array is a collection of homogeneous data items that share a common name. Arrays of anytype can be created and may have one or more dimensions. A specific element in an array is accessed by its index.
One-Dimensional Arrays:
general form of a one-dimensional array declaration is
type var-name[];
eg: int marks[];
and we must use new operator to allocate memory. So the general form of new as it applies to one-dimensional arrays appears as follows.
type var-name[]=new type[size];
eg: int marks[] = new int[20];
//Demonstrate a one-dimensional array
class Array
{
public static void main(String ar[])
{
int month_days[]=new int[12];
month_days[0] = 31;
month_days[1] = 28;
month_days[2] = 31;
month_days[3] = 30;
month_days[4] = 31;
month_days[5] = 30;
month_days[6] = 31;
month_days[7] = 31;
month_days[8] = 30;
month_days[9] = 31;
month_days[10] = 30;
month_days[11]= 31;
System.out.println(“October has ”+month_days[9]);
}
}
We can also write above program as below…
class Array
{
public static void main(String ar[])
{
int month_days[]={31,28,31,30,31,30,31,31,30,31,30,31};
System.out.println(“October has ”+month_days[9]+” days”);
}
}
}
Two (Multi)-Dimensional Arrays:
In java, multidimensional arrays are actually arrays of arrays.
example:
int twoD[][] = new int[4][5];
eg program:
class Matrix
{
public static void main(String ar[])
{
int mat[][]=new int[3][4];
for(int i=0;i<3;i++)
{
for(int j=0;j<4;j++)
{
mat[i][j]=i;
System.out.print(mat[i][j]+” ”);
}
System.out.println();
}
}
}
the above program inserts values into a matrix ‘mat’ of order 3×4 and prints
// Manually allocate differing size second dimensions
class Traingle
{
public static void main(String ar[])
{
int t[][] = new int[4][];
t[0] = new int[1];
t[1] = new int[2];
t[2] = new int[3];
t[3] = new int[4];
for(int i=0;i<4;i++)
{
for(int j=0;j<i+1;j++)
{
t[i][j]=i;
System.out.print(t[i][j]+” ”);
}
System.out.println();
}
}
}
Operators
Java supports a rich set of operators. Operators are used in programs to manipulate data and variables. Java operators can be classified into a number of related categories as below:
- Arithmetic operators
- Increment & Decrement operators
- Relational operators
- Bitwise operators
- Logical operators
- Assignment Operator
- Conditional Operator
1)Arithmetic operators:
These are used in mathematical expressions in the same way that they are used in algebra. The following are the list of arithmetic operators:
Operator Meaning
+ Addition
– Subtraction
* Multiplication
/ Division
% Modulo division (Remainder)
+= Addition assignment
-= Subtraction assignment
*= Multiplication assignment
/= Division assignment
%= Modulus assignment
Arithmetic operators are used as shown below:
a-b a+b
a*b a/b
a%b -a*b
- here a and b are operands
2)Increment & Decrement operators:
The ++ and the – are java’s increment and decrement operators. The increment operator increases its operand by one. The decrement operator decreases its operand by one.
for example,
x=x+1; can be written like x++; using increment operator
similarly,
x=x-1; can be written like x–; using decrement operator
3)Relational operators:
The relational operators determine the relationship that one operand has to the other. The outcome of these operators is a boolean value. The relational operational operators are most frequently used in the expressions that control the if statement and the various loop statements. The following are the list of Relational operators:
Operator Meaning
= = Equal to
! = Not equal to
> Greater than
< Less than
> = Greater than or equal to
< = Less than or equal to
As stated, the result produced by a relational operator is a Boolean value. For example,
int a=4;
int b=1;
boolean c=a>b;
- in this case, the result of a<b(which is true) is stored in c
if(a>b)
{
}
- in this case, a>b results true, so if statement will be executed
Bitwise operators:
Java defines several bitwise operators which can be applied to the integer types, long, int, short, char, and byte. These operators act upon the individual bits of their operands. The following are the list of Bitwise operators:
Operator Meaning
& bitwise AND
! bitwise OR
^ bitwise XOR
~ bitwise unary NOT
< < shift left
> > shift right
> > > shift right with zero fill
Logical operators:
Logical operators are also called as Boolean Logical operators. They operate on boolean operands. All of the binary logical operators combine two boolean values to form a resultant boolean value.
Operator Meaning
&& logical AND
|| logical OR
^ logical XOR
! logical NOT
The logical operators && and || are used when we want to form compound conditions by combining two or more relations.
for example,
if( a>b && x ==10) { }
A B A&&B A||B A^B !A
true true true true false false
true false false true true false
false true false true true true
false false false false false true
Assignment Operator (=):
The assignment operator is the single equal sign, = . It has general form:
var =expression;
Here, the type of var must be compatible with the type of expression.
the assignment operator allows to create a chain of assignments.
For example,
int x, y, z;
x = y = z = 100; // set x, y and z to 100
Conditional Operator( ?:)
The character pair ?: is a ternary operator available in Java. This operator is used to construct conditional expressions of the form
exp1 ? exp2 : exp3
exp1 is evaluated firt. It it is nonzero (true), then the exp2 is evaluated and becomes the value of the conditional expression. if exp1 is false, exp3 is evaluated and its value becomes the value of the conditional expression.
For example,
a=10 , b=20;
x = ( a > b )? a : b ;
x will be assigned the value of b. This can be achieved using the if…else statement as follows:
if(a > b)
x = a;
else
x = b;
Expressions
When operands and operators are combined, an expression is formed. The execution of an expression will produce a value.
Arithmetic expression:
If we use arithmetic operators in an expression, that is treated as an Arithmetic expression. Eg: a+b-c;
Increment or Decrement Expression.
If we use Increment or Decrement operators in an expression, that is treated as Increment or Decrement expression. Eg: a++; b- -;
Relational expression:
If we use Relational operators in an expression, that is treated as a Relational expression: Eg: a>b;
Logical expression:
If we use Boolean logical operators in an expression, that is treated as a logical expression: Eg: a&&b;
Conditional expression:
If we use arithmetic operators in an expression, that is treated as an Conditional expression. Eg: a>b? a: b;
… like this, we have some other expressions.
Control Statements
A Control statement is a statement that controls the flow of execution of the program. Java’s program control statements are divided into 3 categories
- Selection Statements
- Iteration Statements
- Jump Statements
1)Selection Statements:
Selection statement controls the flow of the program depending on the result of the conditional expression or the state of a variable. There are two selection statements : if and switch
‘if’ is a selection statement that is used to choose two choices in a program.
Syntax:
if(condition)
statement1;
else
statement2;
‘condition’ is any expression that returns a Boolean value (i.e., true/false). Statement is a single or multiple statements.
If the condition is true then the control goes to the statement1 and it is executed. Otherwise, the statement2 is executed.
It means an if statement under another if statement.
Syntax:
if(condition)
{
if(condition)
statement;
}
if-else-if statement is a sequence of if-else statements.
Syntax:
if(condition)
statement1;
else if(condition)
statement2;
else if(condition)
statement3;
.
.
else statement2;
In if-else-if ladder if a condition is not met then the control flows from top to bottom until the last if statement.
It provides more than one choice to choose. It’s a better alternative to if-else-if ladder.
Syntax:
switch(expression)
{
case value1: statement1;
break;
case value2: statement2;
break;
case value3: statement3;
break;
.
.
.
case valueN: statementN;
break;
default : statement;
}
here, the expression may be of type byte, short, int or char only. the case values must be of type expression and each value should be unique. when control comes to the switch statement then the value of the expression is compared with the case values, if a match is found then the statement(s) corresponding to that case is executed. If none of the case is matched then the default statement is executed.
2)Iteration Statements:
These statements allows the part of the program to repeat one or more times until some condition becomes true. There are 3 iteration statements: while, do-while and for
‘while’ is an iteration statement, that repeats a statement or block of statements until some condition is true.
Syntax:
while(condition)
{
// body of the loop
}
where the condition may be any boolean expression. The body of the loop will be executed as long as the condition is true. Once the condition becomes false, the control passes to the statement immediately after the while loop.
‘do-while’ statement is very much similar to while statement with little difference. In while statement, if the condition is initially false then the body of loop will not be executed at all. Where as in do-while statement, body of the loop will be executed at least once since the condition of do-while is at the bottom of the loop.
Syntax:
do
{
// body of the loop
} while(condition);
Each iteration of do-while executes the body of loop first and evaluates the condition later. If condition is true, the loop repeats. Otherwise, the loop terminates.
‘for’ statement also repeats the execution of statements while its condition is true.
Syntax:
for(initialization; condition; iteration)
{
// body of the loop
}
where initialization portion of the loop sets the value of the variable that acts as a counter. This portion is executed first when the loop starts. And it is executed only once. when the control goes to condition, condition is evaluated. If condition is true, the body of loop is executes. Otherwise the loop terminates.Next iteration portion is executed. This helps to increment or decrement the control variable.
The loop then iterates evaluating condition, then executing the body and then executing the iteration portion each time it iterates.
2) Jump Statements:
Jump statements allows the control to jump to a particular position. There are 3 types of jump statements.
in java, there are 3 uses of break statement.
- It helps to terminate a statement sequence in switch
- It can be used to exit or terminate the loop
- It can be used as another form of goto
Eg:
class A
{
public static void main(String arg[])
{
for(int i=0; i<100; i++)
{
if(i==10)
break; // terminates loop if i is 10
System.out.println(“i :”+i);
}
}
}
The continue statement starts the next iteration of the immediately enclosing iteration statements(while, do-while or for). When the control goes to continue statement, then it skips the remaining statements and starts the next iteration of enclosing structure.
Eg:
class A
{
public static void main(String arg[])
{
for(int i=0; i<100; i++)
{
System.out.println(“i :”+i);
if(i%2==0)
continue;
System.out.println(“ “);
}
}
}
This is used to return from a method. When the control reaches to return statement, it causes the program control to transfer back to the caller of the method.
Eg:
class A
{
public static void main(String arg[])
{
boolean t=true;
if(t)
return;
System.out.println(“Hi”); // This won’t execute
}
}
In this example, return statement returns to the java run time system, since the caller of main() is runtime system.
Type Conversion & Costing
We can assign a value of a variable of one type to a variable of another type. This process is known as casting. If two types are compatible with each other, then the type conversion is done implicitly by Java. This is known as automatic (implicit) type conversion.
Eg:
int a=10;
double b=a;
As shown in above example, it is always possible to assign the value of int variable ‘a’ to double variable ‘b’. This is done implicitly by the system as both variable’s datatypes are compatible
conversion of larger datatype to smaller datatype is known as Narrowing
conversion of smaller datatype to larger datatype is known as Widening.
Automatic Type conversion:
The system performs automatic type conversion when one type of data is assigned to another type of variable only if following rules are satisfied.
- The types are compatible
- The destination type is larger than the source type.
A widening conversion took place when these 2 rules are satisfied. Example, widening conversion takes place between int and byte as int is larger than byte to hold its all valid values.
Casting incompatible types:
What if we want to assign an int value to a byte variable? This conversion will not be performed automatically, because a byte is smaller than an int. This kind of conversion is called narrowing conversion. To create a conversion between two incompatible types, we must use a cast. A cast is simply an explicit type conversion. It has this general form:
(target-type) value
Here, target-type specifies the desired type to convert the specified value to.
The following program demonstrates some type conversions that require casts:
class conversion
{
public static void main(String arg[])
{
byte b;
int i= 257;
double d=323.142;
System.out.println(”Conversion of int to byte”);
b=(byte) i;
System.out.println(“i and b ”+i+” ”+b);
System.out.println(”Conversion of double to int”);
i=(int) d;
System.out.println(“i and b ”+i+” ”+b);
System.out.println(”Conversion of double to byte”);
b=(byte) d;
System.out.println(“i and b ”+i+” ”+b);
}
}
this program generates the following result
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
In above eg, When the value 257 is cast into a byte variable, the result is the remainder of the division of 257 by 256(range of byte), which is 1 in this case. When the d is converted to an int, its fractional component is lost. When d is converted to a byte, its fractional component is lost, and the value is reduces modulo 256, which in this case is 67.
Classes & objects:
Concept of Classes
A class is defined as an encapsulation of data and methods that operate on the data. When we are creating a class we are actually creating a new datatype. This new datatype is also called ADT.
–diagram-
When we define a class we can easily create a no of instances of that class
Creating class in java:
In java, a class can be defined through the use of class keyword. The general definition of a class is given below:
class classname
{
type instance_variable1;
type instance_variable1;
.
.
.
returntype method name(parameter list)
{
// body of method
}
.
.
.
}
Here,
- class is a keyword used to define class
- class name is the identifier that specifies the name of the class
- type specifies the datatype of the variable
- instance_variable1, . . . are the variable defined in the class
- method name is the method defined in the class that can operate on the variables in the class
Example:
class sample
{
int x, y;
setXY()
{
x=10; y=20;
}
}
The variables defined in the class are called member variables/data members
The functions defined in the class are called member functions/member methods.
Both data members and member methods together called members of class.
Concept of Objects
Objects are instances of a class. Objects are created and th is process is called “Instantiation”. In java objects are created through the use of new operator. The new operator creates an object and allocates memory to that object. Since objects are created at runtime, they are called runtime entities.
In java object creation is a two step process.
Step1: create a reference variable of the class
Eg: Sample s;
When this declaration is made a reference variable is created in memory and initialized with null.
Step2: create the object using the new operator and assign the address of the object to the reference variable created in step1.
Eg: Sample s=new Sample();
The step2 creates the object physically and stores the address of the object in the reference variable.
Accessing members of an object:
Once an object of a class is created we can access the members of the class through the use of object name and ‘.‘ (dot) operator.
Syntax: objectname. member;
Example:
class sample
{
int x, y;
setXY()
{
x=10; y=20;
}
printXY()
{
System.out.print(“=”+x);
System.out.print(“=”+y);
}
}
class Demo
{
public static void main(String ar[])
{
Sample s;
s=new String();
s.setXY();
s.printXY();
}
}
Constructors
A constructor is a special kind of method that has the same name as that of class in which it is defined. It is used to automaticallyl initialize an object when the object is created. Constructor gets executed automatically at the time of creating the object. A constructor doesn’t have any return type.
Example:
// program to demonstrate constructor
class Student
{
int number;
String name;
Student() // default constructor
{
number=569;
name=”satyam”;
}
Student(int no, String s) // parameterized constructor
{
number=no;
name=s;
}
void showStudent()
{
System.out.println(“number =”+number);
System.out.println(“name =”+name);
}
}
class Demo
{
public static void main(String ar[])
{
Student s1=new Student();
Student s2=new Student(72,”raju”);
s1.showStudent();
s1.showStudent();
}
}
output:number= 569
name= satyam
number= 72
name= raju
// and explain about above program
‘this’ keyword
‘this’ keyword refers to the current object. sometimes a member method of a class needs to refer to the object in which it was invoked. In order to serve this purpose java introduces “this keyword”.
By using ‘this’ keyword we can remove name space conflict.
Name Space Conflict:
When the parameters of a member method have the same name as that of instance variables of the class, local variables take the priority over the instance variable. This leads to conflict called ‘name space conflict’. It can be resolved through use of “this”
eg:
class Student
{
int number;
String name;
void setStudent(int number, String name)
{
this.number=number;
this.name=name;
}
void showStudent()
{
System.out.println(“number=”+number);
System.out.println(“name=”+name);
}
}
class Display
{
public static void main(String ar[])
{
Student s=new Student(); // object creation for class Student
s.setStudent(1,”Rama”);
s.showStudent();
}
}
Understanding static keyword:
In java , static keyword can be used for the following purposes.
- To create static data members
- To define static methods
- To define static blocks
Static variables:
When a datamember of a class, is declared static only one copy of it is created in memory and is used by all the objects of the class. Hence static variables are essentially global variables.
When a modification is performed on a static variable the change will be reflected in all objects of the class for which the static variable is a member.
Static Methods:
- A static method can call other static methods only
- A static method can access static variables only
- Static methods cant have access to this/ super keyword.
Static Blocks:
Just like static variables and static methods we can also create a static block . this static block is used to initialize the static variables.
Example program:
class UseStatic
{
static int a=3;
static int b;
static void meth(int x)
{
System.out.println(“x=” + x);
System.out.println(“a=” + a);
System.out.println(“b=” + b);
}
static
{
System.out.println(“static block initialized”);
}
public static void main(String args[])
{
meth(69);
}
}
output:
static block initialized
x = 69
a = 3
b = 12
// and explain about program
Access Control:
Java’s access specifiers are public, private and protected. Java also defines a default access level. protected applies only when inheritance is involved.
When a member of a class is specified as public, then that member can be accessed by anyother code.
When a member of class is specified as private, then that member can only be accessed by other members of its class, but not anyother class members.
Garbage Collection
Objects are dynamically allocated using the ‘new’ operator and their memory must be released after reallocation. In C++, they are manually released by the use of delete operator. Java deallocates memory automatically and it is called “Garbage Collection”. When no references to an object exist the object is assumed to be no longer needed and the memory occupied by the object can be reclaimed and t his is how “garbage collection” is done.
Finalize() Method :
In some situations an object will lead to perform some action when it is destroyed. Suppose for example an object is holding some non-java resource such as file-handling. We must have to free the resources after the object is destroyed.
To handle these situations java provides finalization using finalize() method
Syntax: protected void finalize()
{
// finalization code here
}
protected prevents to access finalize method by code defined outside the class.
void is used because it doesn’t return anything.
Overloading methods
In java, it is possible for a class, to contain two or more methods with the same name as long as the method signatures are different. That is the method should have different number of parameters or different type of parameters when this is the case the methods are said to be overloaded and the mechanism is called method overloading.
Example:
class Student
{
int no ,marks;
String name;
void setStudent()
{
no=1;
marks=89;
name=”rama”;
}
void setStudent(int no, int marks, String name)
{
this.no=no;
this.marks=marks;
this.name=name;
}
void showStudent()
{
System.out.println(“number=”+no);
System.out.println(“marks=”+marks);
System.out.println(“name”+name);
}
}
class MethodOverload
{
public static void main(String ar[])
{
Student s=new Student();
s.setStudent();
s.showStudent();
s.setStudent(69,81,”ramu”);
s.showStudent();
}
}
output:
number=1
marks=89
name=rama
number=69
marks=81
name=ramu
Overloading Constructors
Just like member methods constructors can also be overloaded. the following example demonstrates this,
class Student
{
int no;
String name;
Student()
{
no=70;
name=”ram”;
}
Student(int n, String s)
{
no=n;
name=s;
}
void show()
{
System.out.println(“Number=”+no);
System.out.println(“Name=”+name);
}
}
class Display
{
public static void main(String ar[])
{
Student s1= new Student();
Student s2= new Student(69,”satya”);
s1.show();
s2.show();
}
}
output:
number=70
name=ram
number=69
name=satya
Parameter passing
There are two ways that a computer language can pass an argument to a subroutine (method).
- call by value
- call by reference
In the first way, the change made to the parameter of the subroutine have no effect on the argument.
In the second way, the changes made to the parameter will effect the argument used to call the subroutine.
In java when you pass a primitive type it is pass by value. when you pass an object(reference) to a method, it is done through pass by reference
Example:
// call by value
class Test
{
void meth(int i , int j)
{
i+=2;
j*=2;
}
}
class CallByValue
{
public static void main(String arg[])
{
Test ob= new Test();
int a=10 , 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);
}
}
output:
a and b before call: 10 20
a and b after call: 10 20
Recursion
Java supports recursion. It is the process of defining something interms of itself. It is the attribute that allows a method to call itself. The method that calls itself is said to be recursive method.
The classic example of recursion is the computation of the factorial of a number.
class Factorial
{
int fact(int n)
{
if(n==1) return 1;
return (fact(n-1)*n);
}
}
class Recursion
{
public static void main(String ar[])
{
Factorial f=new Factorial();
System.out.println(“Factorial of 5 is”+ f.fact(5));
}
}
output above program:
Factorial of 5 is 120
Nested & inner classes:
It is possible to define a class with in another class. Such classes are known as nested classes. The scope of nested class is bounded by the scope of its enclosing class. Thus, if class B is defined with in class A, then B is known to A, but not outside of A. A nested class has access to the members, including private members, of the class in which it is nested. However, the enclosing class does not have access to the members of the nested class.
There are two types of nested classes: static and non-static. A static nested class is one which has the static modifier applied. Because it is static, it must access the members of its enclosing class through an object. That is, it can not refer to members of its enclosing class directly.
The most important type of nested class is the inner class. An inner class is a non-static nested class. It has access to all of the variable and methods of its outer class and may refer to them directly.
Example:
class Outer
{
int outer_x=10;
void outerMethod()
{
System.out.println(“In Outerclass Method”);
Inner in=new Inner();
In.innerMethod();
}
class Inner
{
void innerMethod()
{
System.out.println(“In Innerclass Method”);
System.out.println(“outer class variable:”+outer_x);
}
}
}
class Display
{
public static void main(String ar[])
{
Outer out=new Outer();
Out.outerMethod();
}
}
output:
In Outerclass Method
In Innerclass Method
outer class variable: 10
String Handling
A String is a sequence of characters. In java , Strings are class objects and implemented using two classes, namely, String and StringBuffer. A java string is an instantiated object of the String class.A java String is not a character array and is not NULL terminated. Strings may be declared and created as follows:
String stringname= new String(“string”);
String name=new String(“kanth”); is same as
String name=”kanth”;
like arrays, it is possible to get the length of string using the length method of the String class.
int len = name.length();
Java string can be concatenated using the + operator.
eg: String firstname = ”sri”;
String lastname = ”kanth”;
String name = firstname+lastname;
( or )
String name = ”sri”+”kanth”;
String Arrays:
we can also create an use arrays that contain strings. The statement,
String names[]=new String[3];
will create an names array of size 3 to hold three string constants.
String Methods: (Methods of String class)
The String class defines a number of methods that allow us to accomplish a variety of string manipulation tasks.
Method Task
s2=s1.toLowerCase() converts the String s1 to all lowecase
s2=s1.toUpperCase() converts the String s1 to all Uppercase
s2=s1.replace(‘x’,’y’); Replace all appearances of x with y
s2=s1.trim(); Remove white spaces at the beginning and end of String s1
s1.equals(s2); Returns ‘true’ if s1 is equal to s2
s1.equalsIgnoreCase(s2) Returns ‘true’ if s1=s2, ignoring the case of characters
s1.length() Gives the length of s1
s1.CharAt(n) Gives nth character of s1
s1.compareTo(s2) Returns –ve if s1<s2, positive if s1>s2, and zero if s1 is equal s2
s1.concat(s2) Concatenates s1 and s2
s1.indexOf(‘x’) Gives the position of the first occurrence of ‘x’ in string s1
s1.indexOf(‘x’,n) Gives the position of ‘x’ that occurs after nth position in the- string s1
//Alphabetical ordering of strings
class StringOrdering
{
public static void main(String args[])
{
String names[]={“india”,”usa”,”australia”,”africa”,”japan”};
int size=names.length;
String temp;
for(int i=0;i<size;i++)
{
for(int j=i+1;j<size;j++)
{
if(names[j].compareTo(names[i])<0)
{
temp=names[i];
names[i]=name[j];
names[j]=temp;
}
}
}
for(int i=0;i<size;i++)
System.out.println(names[i]);
}
}
above program produces the following result
africa
australia
india
japan
usa
String Buffer Class :
StringBuffer is a peer class of String. While String creates string of fixed length, StringBuffer creates strings of flexible length that can be modified in terms of both length and content. We can insert characters and substrings in the middle of a string, or append another string to the end.
Below, there are some of methods that are frequently used in string manipulations.
Method Task
s1.setCharAt(n,’x’) Modifies the nth character to x
s1.append(s2) Appends the string s2 to s1 at the end
s1.insert(n,s2) Inserts the string s2 at the position n of the string s1
s1.setLength(n) sets the length of the string s1 to n. if n<s1.length() s1 is
truncated .if n>s1.length() zeros are added to s1
Important questions in this unit:
1a) With an example, explain scope and lifetime of variables. [10M]
- b) Describe the methods to modifying a string. [10M]
2.a) Briefly describe the type conversion mechanisms.[10M]
- b) Explain with a java program about reference variables? [10M]
3)a) Describe java garbage collection mechanism? [8M]
- b) What is a constructor? Describe its special properties.[12M]
4 a)What is the difference between public member and private member of a class[5M]
b)Explain about static keyword[15M]
5 a)Explain about Constructor overloading?[10M]
b)Explain about Method Overriding[10M]
6 a) Explain about Command line arguments[10M]
- b) Briefly explain about classes and objects[10M]
java 