Variable

● A variable is a container which holds the value while the Java

Program is executed
● A variable is assigned with a data type
● Variable is a name of memory location
● It is the basic unit of storage in a program
● The value stored in a variable can be changed during program
execution.
● In Java, all the variables must be declared before use
● Also called as identifiers
● It can be used as class name, method name, interface name
and package name
Declaring a variable

Syntax
default
private
public Name of the
protected variable

Access-modifier data-type variable_name;

Access-modifier data-type variable_name=value;
Variable/Identifier naming rules

● Begin with a letter (A to Z or a to z), currency character ($) or an

underscore (_).
● After the first character, identifiers can have any combination of
characters
● A keyword cannot be used as an identifier
● Most importantly, identifiers are case sensitive
● Examples of legal identifiers: age, $salary, _value, _ _1_value
● Examples of illegal identifiers: 123abc, -salary
Example of variable declaration and initialization

int ivar; int ivar=10 ;

private double dvar; private double dvar=12.34;
public char cvar; public char cvar=’c’;
protected String svar; protected String svar=”java”;
Types of variable (based on scope)

Three types

● Local variable

● Instance variable

● Class variable
Local variable
● variable defined within a block or method or constructor is called local variable.
● Created when the block in entered or the function is called
● Destroyed after exiting from the block or when the call returns from the
function.
● Initialization of the variable is mandatory
● The scope of these variables exists only within the block in which the variable is
declared. i.e. we can access these variable only within that block .
Instance variable
● A variable declared inside the class but outside the body of the method,
is called instance variable
● Instance variables are non-static variables
● Created when an object of the class is created
● Destroyed when the object is destroyed.
● Initialization is not mandatory. Its default value is 0
● Instance Variable can be accessed only by objects
Class or Static variables
● Variable which is declared as static is called static variable.

● It cannot be local.

● Only one copy of a static variable per class

● Variables are created at the start of program execution

● Destroyed automatically when execution ends

● Initialization of static Variable is not Mandatory. Its default value is 0

● Static variable can be accessed through either with class or an object

Example public class A
{
static int m=100;//static variable
class Variable {
void method()
int amount = 100; // instance
{
variable
int n=90;//local variable
static int pin = 2315; // static variable }
public static void main(String[ ] args) { public static void main(String args[])
int age = 35; // local variable {
int data=50;//instance variable
}
}
}
}//end of class
Methods

Method statement can be

● Method declaration

● Method definition

● Method invocation/Call
Method Declaration

Syntax
default
private
public Type of input
protected Identifier
variable

access-specifier return-type methodName(data type of arguments);

Data type
Example- 1

void show();

● access-specifier – default
● return-type – void
● methodName – show
● data type of arguments – nil
Example- 2

void show(String);

● access-specifier – default
● return-type – void
● methodName – show
● data type of arguments – String
Example- 3

public int addValues(int, int);

● access-specifier – public
● return-type – int
● methodName – addValues
● data type of arguments – int, int
Method Definition

Syntax
default
private
public Declaration of
protected Data type Identifier
input variable

access-specifier return-type methodName(arguments){

method body;

}
Method example
Method example - 1

void show(){
System.out.println(“Object oriented programming”);
}
● access-specifier – default
● return-type – void
● methodName – show
● arguments – nil
Method example - 2

void show(String str){

System.out.println(str);
}
● access-specifier – default
● return-type – void
● methodName – show
● arguments – String str
Method example - 3
int addValues(int v1, int v2){
int v3 = v1 + v2
return v3;
}
● access-specifier – default
● return-type – int
● methodName – addValues
● arguments – int v1, int v2
Method definition
Method Invocation/Call

Syntax

Identifier input values for the

method

methodName(argument value(s));
Example

show();

show(“Java Programming”);

int sum=addValues(3, 4);

int large=max(7, 3);

Object

● Object is an instance of a class

● It is an real world entity

● Each object have state, behaviour and identity

Creating objects
Object in Java

Syntax

Name of Construct
the class or
ClassName object_name=new ClassName();

keyword
Example of an Object
Class with Object
Constructors

● Similar to method
● Method name is same as Class name
● No return type
● Can have arguments/parameters
● Cannot be invoked explicitly
● It is invoked when an instance of a class is created
● Can be overloaded
● Used to initialize the member of a class
● Two types
○ Default constructor
○ Parameterized constructor
Syntax for constructor

ClassName(argument(s) declaration) {

body of constructor;

}
Example

Class Example{
int ivar;
Example(){ //constructor
ivar=10;
}
public static void main(String[ ] args){
Example e1=new Example();
System.out.println(e1.ivar);
}
}
Types of constructors

● Default constructor
○ Constructor without parameter

● Parameterized constructor
○ Constructor with parameter
Example for Constructor

class Constructor{
Constructor(){
System.out.println(“Default constructor”);
}
Constructor(String str){
System.out.println(“Parameterized constructor”);
}
}
main() method

Syntax

public static void main(String[ ] args){

body of main method;

}
Input statement

Syntax final member

import java.util.*; //package
from System
class of type
Class from InputStream
class lang package
Scanner scan=new Scanner(System.in);

construct
object
or
Output statement
Method from
Syntax PrintStream
Class from class
lang package
System.out.print(“string value”);

final member of
System class of
type PrintStream
static keyword

● Variable
● Method
● Block
● Nested class
static variable

● Variable with static keyword

● Also known as class variable Syntax

● Gets memory only once static data-type

● One memory space for a class variable_name;

● Initialize with 0 Example

● Can be accessed by class name static int var;
static method

Syntax
● Method with static keyword
static return-type
method_name(arguments){
● Can be accessed by class name
method body;
}
● Access only static members
Example
● It will preserve the last value static void show(String str){
System.out.println(str);
● Belongs to class rather than the object of a class
}
static block

Syntax
● Block with static keyword
static{
statement(s);
● Executed prior to main() method
}
● Used to initialize static members
Example
static{
● Executed only once
System.out.println(“static
block ”);
}
Data types
Data types
Data Type Description Default Default size
Value

boolean Stores true or false values false 1 bit

char Stores a single character/letter or ASCII values '\u0000' 2 byte

byte Stores whole numbers from -128 to 127 0 1 byte

short Stores whole numbers from -32,768 to 32,767 0 2 byte

int Stores whole numbers from -2,147,483,648 to 2,147,483,647 0 4 byte

long Stores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 0L 8 byte

float Stores fractional numbers. Sufficient for storing 6 to 7 decimal digits 0.0f 4 byte
3.4e−038 to 3.4e+038.

double Stores fractional numbers. Sufficient for storing 15 decimal digits 0.0d 8 byte
1.7e−308 to 1.7e+308
byte data type

Syntax
byte varname;

public class MyClass {

public static void main(String[] args) {
byte myNum = 100;
System.out.println(myNum);
}
}
Output
100
short data type

Syntax
short varname;

public class MyClass {

public static void main(String[] args) {
short myNum = 1000;
System.out.println(myNum);
}
}
Output
1000
int data type

Syntax
int varname;

public class MyClass {

public static void main(String[] args) {
int myNum = 10000;
System.out.println(myNum);
}
}
Output
10000
long data type

Syntax
long varname;

public class MyClass {

public static void main(String[] args) {
long myNum = 100000L;
System.out.println(myNum);
}
}
Output
100000
float data type

Syntax
float varname;

public class MyClass {

public static void main(String[] args) {
float myNum = 2.56f;
System.out.println(myNum);
}
}
Output
2.56
double data type

Syntax
double varname;

public class MyClass {

public static void main(String[] args) {
double myNum = 12.56d;
System.out.println(myNum);
}
}
Output
12.56
Scientific number
Syntax
float/double varname;

public class MyClass {

public static void main(String[] args) {
float myNum1 = 12e3f;
double myNum2 = 5e4d;
System.out.println(myNum1);
System.out.println(myNum2);
}
}
Output
12000.0
boolean datatype
Syntax
boolean varname;

public class MyClass {

public static void main(String[] args) {
boolean isBlue = true;
boolean isRed = false;
System.out.println(isBlue);
System.out.println(isRed);
}
}
Output
true