7. VARIABLEs presentation in java programming. Pdf

Java Variables
•Variables are containers for storing data
values.
•In Java, there are different types of variables, for
example: String - stores text, such as "Hello".
String values are surrounded by double quotes.
int - stores integers (whole numbers), without
decimals, such as 123 or -123.

In Java, there are different types of variables, for
example:
•String - stores text, such as "Hello". String values
are surrounded by double quotes
•int - stores integers (whole numbers), without
decimals, such as 123 or -123

•float - stores floating point numbers, with
decimals, such as 19.99 or -19.99
•char - stores single characters, such as 'a' or 'B'.
Char values are surrounded by single quotes
•boolean - stores values with two states: true or
false

Task
•Define the term data type.
•Explain briefly each of the following data
types and give examples:
oPrimitive
oNon-primitive

Declaring (Creating) Variables
•To create a variable, you must specify the type and
assign it a value:
Syntax
type variableName = value;
Where data type is one of Java's types (such as int or
String), variableName is the name of the variable
(such as x or name), and value is the actual value
assigned to the variable (such as 15 or John).

Note:
•Variable name should begin with a lowercase
letter.
•In mixed case, the first letter of each internal
word should be uppercase

Example 1 (To create a variable that
should store text)
Create a variable called name of type String and
assign it the value "John":

Example 2 (To create a variable that should
store a number)
Create a variable called myNum of type int and
assign it the value 15:

Example 3 (You can also declare a variable
without assigning the value)

Example 4
Note:
•If you assign a new value to an existing variable,
it will overwrite the previous value.

Final Variables
•If you don't want others (or yourself) to
overwrite existing values, use the final keyword
(this will declare the variable as "final" or
"constant", which means unchangeable and read-
only)

Other Types
A demonstration of how to declare variables of
other types.

Java Print
Variables
Display Variables

Example 1
•The println() method is often used to display
variables.
•To combine both text and a variable, use the +
character:

Example 2
•You can also use the + character to add a variable
to another variable.

Example 3
•For numeric values, the + character works as a
mathematical operator (notice that we use int
(integer) variables here).

Activity
Carryout the operation for the stored values of x
and y
•x stores the value 5
•y stores the value 6

Java Declaration
of Multiple
Variables

Declare Many Variables
•To declare more than one
variable of the same type, you
can use a comma-separated list.

One Value to Multiple Variables
•You can also assign the same value to multiple
variables in one line.

Types of Variables
There are three types of variables in Java:
•local variable
•instance variable
•static variable

Local Variable
•A variable declared inside the body of the
method is called local variable
•The variable can only be accessed/ used within
that method, and the other methods in the class
aren't even aware that the variable exists

•A local variable cannot be defined with "static"
keyword

• A local variable is accessed directly
class Variable {
public static void main(String args[]) {
int b = 20; //local variable
System.out.println (b); /* The code runs,
and 20 is displayed*/
}
}

• Does not get a default value
class Variable {
int b; //local variable
System.out.println (b); /* The code does not run,
"variable b might not have been initialized“
is displayed*/
}
}

Instance Variable
•It is variable that has a value that is specific to a
particular case/ occasion and is not shared among
instances.

•A variable declared inside the class but outside
the body of the method is called an instance
variable
•Cannot be defined with "static" keyword

•Cannot be reinitialized directly within the class
class Variable1 {
int a = 10; //instant variable
a=15; // error
}

•However, an instant variable can be reinitialized
inside methods or constructors
class Variable {
void someMethod(){
int a = 15; // allowed
}
}

• Variable cannot be accessed directly, but
through objects
class Variable {
System.out.println (a); /* code does not
run because an object is not created*/
}

How to create an object
class_name object_name = new class_name();
System.out.println (object_name.variable_name);

• But can be accessed through objects
class Variable {
Variable obj = new Variable (); // object creation
System.out.println (obj.a); /* The code runs, and
10 is displayed*/
}
}

•Always get a default value, and the default is 0/
null, unless they are assigned with another value.
int data;
data=0;

class Variable {
int a; //instant variable
System.out.println (obj.a); /* The code runs,
and 0 is displayed*/
}
}

class Variable {
String a; //instant variable
System.out.println (obj.a); /* The code runs, and
null is displayed*/
}
}

Static variable
•Is a variable that belongs to the class itself rather than
to any specific instance of a class.
•It is used to refer to the common property of all
objects
•It cannot be local
•It makes a program memory efficient (i.e, it saves
memory)

•Always get a default value, and the default is 0/
null, unless they are assigned with another value.
String name;
name = nill;

How it works
Class Employee1{
String org_name;
String emp_name;
int emp_id;
gender;
}

•If there are many employees in the the
organisation, all instance data members will get
memory each time an object is created
•Since all employees have a unique emp_name,
emp_id and gender, instance data is good in such
a case
•Since org_name is a common property for all the
objects/ instances, it is supposed to be made a
static variable so that it is loaded only once in
memory

•You can create a single copy of the static variable
and share it among all the instances of the class.
•Memory allocation for static variables happens
only once when the class is loaded in the
memory.

public class Employee1 {
//Variables declared
String org_name="Chimbuka Enterprises Limited";
String emp_name;
int emp_id;
void display(){
System.out.println(org_name+" "+emp_name+" "+emp_id);
}

public static void main(String[] args) {
//Creating objects
Employee1 e1=new Employee1();
e1.emp_name =“Annita Katuka”;
e1.emp_id=970985777;
e1.gender=‘F’
Employee1 e2=new Employee1();
e2.emp_name =“Edward Dipa”;
e2.emp_id=958777445;
e2.gender=‘M’
//Calling display method
e1.display();
e2.display();
}

Modifiers
•The modifiers in Java specify the accessibility
or scope of a field/ variable, method, constructor,
or class.

•Using the modifiers the scope or accessibility of
classes, methods, constructors, and other
members could be set.
•The access level of fields, constructors, methods,
and class could be changed by applying the
access modifier on it.

Access Modifiers
Access Modifiers: control the access level

Modifiers For Classes
•Default: The class is only accessible by classes
in the same package. This is used when you don't
specify a modifier.
•Public: The class is accessible by any other
class.

Modifiers For Attributes, Methods and
Constructors
There are four types of Java access modifiers:
•Default: The access level of a default modifier is
only within the package. It cannot be accessed
from outside the package. If you do not specify
any access level, it will be the default.
•Private: The access level of a private modifier is
only within the class. It cannot be accessed from
outside the class.

•Protected: The access level of a protected
modifier is within the package and outside the
package through child class. If you do not make
the child class, it cannot be accessed from
outside the package.
•Public: The access level of a public modifier is
everywhere. It can be accessed from within the
class, outside the class, within the package and
outside the package.

Understanding the access modifiers in
Java by a simple table

Non-Access Modifiers
Non-access modifiers: provide/ achieve many
other functionalities.

Non-Access Modifiers For Classes
•final: The class cannot be inherited by other
classes
•abstract: The class cannot be used to create
objects (To access an abstract class, it must be
inherited from another class.)

Non-Access Modifiers For Attributes,
Methods and Constructors
•final: Attributes and methods cannot be
overridden/modified
•Static: Attributes and methods belongs to the
class, rather than an object

•Abstract: Can only be used in an abstract
class, and can only be used on methods.
•The method does not have a body, for example
abstract void run();.
•The body is provided by the subclass (inherited
from).

The Static Modifier
•The static modifiers are used to create class
methods and variables.

Static Variables/ Methods
•The static keyword is used to create variables
and methods that belong to a class rather than an
instance of a class
•A single copy of the static variable is shared
among all the instances of the class

•A static method can be called without
creating an object of the class
•Static variables and static methods are also
known as class variables and class methods
respectively

•Memory allocation for static variables happens
only once when the class is loaded in the
memory.

7. VARIABLEs presentation in java programming. Pdf

More Related Content

Similar to 7. VARIABLEs presentation in java programming. Pdf (20)

Recently uploaded (20)

7. VARIABLEs presentation in java programming. Pdf