Ppt on java basics

Control statements
Introduction to classes
Closure look at classes and methods

Any language uses control
statements to cause the flow of
execution to advance and
branch based on the state of
the program.
Why do we
need control
statements?

 Selection : to choose
different paths of execution
based on outcome or state
of the variable.
 Iterative : to repeat one or
more statements.
 Jump : to execute in non-
linear fashion.
Control
Statements
categories

If statement is conditional branch
statement.
If Syntax:
if(condition)statement1;
else statement2;
Ex : if(a>b)a=0;
else b=0;
Java’s
selection
statements
oIf
oswitch

Switch is multi-way branch
statement.
Syntax : switch(expression){
Case value1:
//statement sequence;
break;
Case value2:
//statement sequence;
break;
default:
//default statement sequence}
Switch
case

Java’s iterative
statements
o while
o do-while
o for
Iterative statements create what
we commonly call loops which
repeatedly executes the same set
of instructions until a termination
condition is met.
while syntax:
While(condition){
//body of loop
}

If the conditional expression controlling
a while loop is initially false , then the
body of the loop will not be executed at
all.
Sometimes it is desirable to execute the
body of loop at least once even if the
conditional expression is false.
Condition is checked at the end of the
loop.
syntax:
do{
//body of loop
}while(condition);
do- while
case

Syntax:
for(initialization ; condition ; iteration)
{ //body of loop
}
When loop starts the initialization
portion of the loop executes . Here
initialization expression is executed only
once.
Next condition is evaluated.
If the condition is true the body of the
loop is executed. If false then loop
terminates.
Then iteration is executed i . e
increments or decrements the loop
control variable
for loop
case

Used to transfer control to
another part of your program
Break statement has 3 uses:
1. Terminates a statement
sequence in switch
statement
2. To exit a loop
3. Civilized form of goto
Java’s jump
statements
o break
o continue
o return

// Using break as a civilized form of goto.
class Break {
public static void main(String args[]) {
boolean t = true;
first: {
second: {
third: {
System.out.println("Before the break.");
if(t) break second; // break out of second block
System.out.println("This won't execute");
}
System.out.println("This won't execute");
}
System.out.println("This is after second block.");
}
}
}
break as
civilized form
of goto

continue
jump
statement
Skips the current iteration of a
for , while or do-while loop.
The unlabeled form skips to
the end of the innermost loop’s
body and evaluates Boolean
expression that controls the
loop.
break leaves the loop.
continue jumps to the next
iteration.

The return statement is used
to explicitly return from a
method. That is, it causes
program control to transfer back
to the caller of the method.
// Demonstrate return.
class Return {
boolean t = true;
System.out.println("Before the return.");
if(t) return; // return to caller
System.out.println("This won't execute.");
}
}
The output from this program is shown here:
Before the return.
Return jump
statement

Class
fundamentals :
General form
of class
Class syntax:
Class classname{
type instancevariable1;
type instancevariable2;
Type methodname1(parameter
list){//body of method}
Type methodname2(parameter
list){//body of method}

Class name
convention
class name should be nouns ,
in mixed cases with the first
letter of each internal word
capitalized.
Ex : class CamelCase{
}

what is
instance
variable?
 Instance variables are declared in
a class, but outside a method,
constructor or any block.
 When a space is allocated for an
object in the heap, a slot for each
instance variable value is created.
 Instance variables are created
when an object is created with the
use of the keyword 'new' and
destroyed when the object is
destroyed.

instance
variable
example
Public class vehicle
{
//instance variables of class
private int doors;
private int speed;
private string color;
}

simple
class
class box{
int width;
int height;
int depth;
}

Declaring
objects
class Box {
int width;
int height;
int depth;
}
// This class declares an object of type Box.
class BoxDemo {
Box mybox = new Box();
int vol;
// assign values to mybox's instance variables
mybox.width = 10;
mybox.height = 20;
mybox.depth = 15;
// compute volume of box
vol = mybox.width * mybox.height * mybox.depth;
System.out.println("Volume is " + vol);
}
}

Declaring
objects
Box mybox=new Box();
This statement has 2 steps:
1. Box mybox;
//mybox is reference variable
1. mybox= new Box();
//allocate a box object

Assigning
object
reference
variable
Box b1=new box();
Box b2=b1;

Introducing
methods
Why use
methods?
Methods are how we
communicate with objects.
When we call or invoke a method
we are asking the objects to carry
out a task
 For reusable code
 To simplify
 For top-down programming
 To create conceptual units
 To parameterize code

Method name
convention
Method name should be
verbs , in mixed case with the
first letter lowercase , with the
first letter of each internal
word capitalized.
Ex : class CamelCase{
Void runFast()
}

General form of
methods
type-name(parameters list)
{
//body of the method
}
Ex: void voulme()
{
System.out.println(“volume is”);
System.out.println(width*height*
depth);
]

Constructor and
its purpose
Constructor is a special type of
method that is used to initialize
the object.
It is invoked at the time of
object creation.
It constructs the values i.e
provides data for the object that
is why it is known as
constructor.

Rules for
creating
constructors
1. Constructor name must be
same as it class name
2. Constructor must have no
explicit return type.

Types of
Constructors
1. Default constructor(no-arg
consuctor)
2. Parameterized constructor.
A constructor that has no
parameters is known as default
constructor.
Class bike(){
Bike(){system.out.println(“bike
constructor”);}
Public static void main(){
bike b=new bike(); } }

Parameterized
constructors
A constructor that has parameters is
known as parameterized constructor.
Class student(){
Int id;
String name
student(int i, string n) { id=i; name=n;
}
Void display(){ system.out.println(id+“
”+name);}
student s=new student(1,”karan”);
s.display();} }

this keyword
this is a reference variable that refers to the
current object.
 this can be used to refer current class
instance variable.
 this can be used to invoke current class
constructor
 Used to invoke current class method
(implicitly)
 this can be passed as an argument in the
constructor call
 this can be passed as an argument in the
method call.
 this can also be used to return the current
class instance

Class student(){
Int id;
String name;
student(int id, string name) { id=id;
name=name; }
Void display(){
system.out.println(id+“ ”+name);}
s.display();} }
In this example , parameter and
instance variables are same that is
why we are using this keyword to
distinguish between local and
instance variable.
student(int id, string name)
{
this.id=id;
this.name=name;
}

this keyword used
for current class
instance variable
and constructor
Class student(){
Int id;
String name;
Student();{system.out.println(“default”)
;}
student(int id, string name) {
this();
this(id, name);
this.id=id; this.name=name; }
Void display(){ system.out.println(id+“
”+name);}
s.display();} }

Garbage
collection and its
advantages
Garbage collection is a process of
reclaiming the runtime unused memory
automatically i.e destroying unused
objects.
 It makes java memory efficient
because it removes the unreferenced
objects from heap.
 It is automatically done by the
garbage collector so we don’t need to
make extra efforts.

How can objects
be unreferenced?
There are many ways:
 By nulling the reference variable
 By assigning a reference to another.
 By anonymous object etc.
//Nulling the reference
student s=new student();
s=null;
//Assign reference to another
student s1=new student();
student s2=new student();
s1=s2;//s1 is available for gc
//anonymous object
new student();

 The finalize() method is invoked each
time before the object is garbage
collected.
 This method can be used to perform
cleanup processing.
 This method is defined in object class
as:
Protected void finalize(){ }
 Garbage collector of JVM collects
only those objects created by ‘new’
keyword.so any objects without new
use finalize method to cleanup
processing
finalize( )
method

Ppt on java basics

More Related Content

What's hot

Viewers also liked

Similar to Ppt on java basics

Recently uploaded

Ppt on java basics