Java data types

Variables, Data Type in JAVA
Dr. Kuppusamy .P
Associate Professor / SCOPE

Package
• Collection of classes and interfaces
Java API
• Application programming interface(API) is a collection of prewritten packages,
classes, and interfaces with their respective methods, fields and constructors
• The Java API describes the function of each of its components
• In Java programming, many of these components are pre-created and commonly
used
Java Features
• Object-Oriented
• Supports encapsulation, inheritance, abstraction, and polymorphism
• Distributed
• Libraries for network programming
• Remote Method Invocation
• Architecture neutral
• Java Bytecodes are interpreted by the JVM
Dr. Kuppusamy P

Java Advantages
• Secure
• Difficult to break Java security mechanisms
• Java Bytecode verification
• Portable
• Primitive data type sizes and their arithmetic behavior specified
by the language
• Libraries define portable interfaces
• Multithreaded
• Threads are easy to create and use
Dr. Kuppusamy P

Keywords in Java
Dr. Kuppusamy P

Primitive Data Types
Dr. Kuppusamy P

Types of Variables in JAVA
• Local Variables
• Tied to a method
• Scope of a local variable is within the method
• Instance Variables (Non-static)
• Tied to an object
• Its an object at specific moment
• Scope of an instance variable is the whole class
• Static Variables
• Tied to a class
• Shared by all instances of a class
Dr. Kuppusamy P

Java – Types of Operators
• Operators are used to manipulate operations.
Types of operators in java are,
• Arithmetic Operators
• Unary Operator
• Relational Operators
• Logical Operators
• Simple Assignment Operator
• Bitwise Operators
Dr. Kuppusamy P

Arithmetic Operators
Dr. Kuppusamy P

Arithmetic Operators
/* Arithmetic operations */
class Example
{
public static void main(String[ ] args )
{
int a = 10;
int b = 3;
System.out.println("a + b = " + (a + b) );
System.out.println("a - b = " + (a - b) );
System.out.println("a * b = " + (a * b) );
System.out.println("a / b = " + (a / b) );
System.out.println("a % b = " + (a % b) );
}
}
Dr. Kuppusamy P

Unary Operators
Dr. Kuppusamy P

Unary Operators
/* Unary operator */
class SampleUnary
{
public static void main(String args[])
{
int a = 10;
int b = 20;
System.out.println("++a = " + (++a) );
System.out.println("--b= " + (--b) );
}
}
Dr. Kuppusamy P

Quiz
• What will be the output, if compile and execute the following
code?
class Quiz1
{
public static void main(String [ ] args)
{
int a=15;
int b=25;
System.out.println(++a + (--b));
}
}
Dr. Kuppusamy P

Relational Operators
Dr. Kuppusamy P

Relational Operators
/* Relational operations */
class SampleRelation
{
public static void main(String[] args )
{
int a = 25;
int b = 45;
System.out.println("a == b = " + (a == b) );
System.out.println("a != b = " + (a != b) );
System.out.println("a > b = " + (a > b) );
System.out.println("a < b = " + (a < b) );
System.out.println("b >= a = " + (b >= a) );
System.out.println("b <= a = " + (b <= a) );
}
}
Dr. Kuppusamy P

String Comparison
/* String Comparison*/
class Sample3
{
{
String s1=new String(“come");
String s2=" Welcome ";
String s3=" Welcome ";
System.out.println(s2==s3);
System.out.println(s2.equals(s3));
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
}
}
Dr. Kuppusamy P

Logical Operators
Dr. Kuppusamy P

Logical Operators
/* Logical Operations*/
class Sample4
{
{
boolean a = true;
boolean b = false;
System.out.println("a && b = " + (a && b) );
System.out.println("a || b = " + (a || b) );
System.out.println("!(a && b) = " + !(a && b) );
}
}
Dr. Kuppusamy P

Assignment Operator
• = Simple assignment operator assigns right hand side value to
left hand side variable
• Ex: int a;
a = 10;
• String name;
name = ‘Akhil’
Dr. Kuppusamy P

Quiz
What will be the output, if we compile and execute the below code?
public class Sample5
{
public static void main()
{
int i= 50, j= 78;
boolean chk;
chk = i > j;
System.out.println("chk value: “ +chk);
}
}
Dr. Kuppusamy P

Shift Operators
• Two types.
o Right shift (>>)
o Left shift (<<)
• The shift operators (<< and >>) shift the bits of a given number to the left or
right, resulting a new number.
• They are used only on integer numbers i.e. decimals (not on floating point
numbers).
• Right shift operator(>>) is used to divide a number in the multiples of 2.
• Left shift operator(<<) is used to multiply a number in the multiples of 2.
Dr. Kuppusamy P

Right Shift (>>) Operators
• Let’s use right shift operator with the following example :
• int x = 16;
• x = x >> 3;
• When apply the right shift operator >>, the value gets divided by 2 to the
power of number specified after the operator.
• In this case, 3 is the value after the right shift operator.
• So, 16 will be divided by the value 2 to the power of 3. (16 / 23 = 2)
• The result is 2.
Dr. Kuppusamy P

Right Shift (>>) Operators
• Represent 16 in binary form as follows:
0 0 0 1 0 0 0 0
• When apply >> right shift operator, every bit moves by 3 positions to the right
(represented by the number after the right shift operator).
• After shifting the binary digits:
0 0 0 0 0 0 1 0
x = 2
Dr. Kuppusamy P
class ShiftExample1 {
public static void main(String[] args) {
int x = 16;
System.out.println("The original value of x is "+x);
x = x >> 3;
System.out.println("After using >> 3, the new value is "+x);
} }

Left Shift (<<) Operators
• Let’s use left shift operator with the following example :
• int x = 4;
• x = x << 2;
• When apply the left shift operator <<, the value gets multiplied by 2 to the
power of number specified after the operator.
• In this case, 2 is the value after the left shift operator.
• So, 4 will be multiplied by the value 2 to the power of 2. (4 * 22 = 16)
• The result is 16.
Dr. Kuppusamy P

Left Shift (<<) Operators
• Represent 4 in binary form as follows:
0 0 0 0 0 1 0 0
• When apply << left shift operator, every bit moves by 2 positions to the left
(represented by the number after the left shift operator).
• After shifting the binary digits:
0 0 0 1 0 0 0 0
x = 16
Dr. Kuppusamy P
class ShiftExample2 {
public static void main(String[] args) {
int x = 4;
System.out.println("The original value of x is "+x);
x = x << 2;
System.out.println("After using << 2, the new value is "+x);
} }

Bitwise Operators
• The bitwise operators take two bit numbers, use OR/AND to determine the
result on a bit by bit basis.
• The 3 bitwise operators are :
• & (which is the bitwise AND)
• | (which is the bitwise inclusive OR)
• ^ (which is the bitwise exclusive OR)
Dr. Kuppusamy P

Bitwise Operators
class BitwiseExample1
{
public static void main(String[] args)
{
int x = 7;
int y = 9;
System.out.println(x & y);
System.out.println(x | y);
System.out.println(x ^ y);
}
}
Dr. Kuppusamy P
Output:
1
15
14
Explanation: AND
7 = 0 1 1 1
9 = 1 0 0 1
___________
& = 0 0 0 1
OR
7 = 0 1 1 1
9 = 1 0 0 1
_________
| = 1 1 1 1
NOT
7 = 0 1 1 1
9 = 1 0 0 1
_________
^ = 1 1 1 0

References
Dr. Kuppusamy P
Herbert Schildt, “Java: The Complete Reference”, McGraw-Hill Education, Tenth edition,
2017.

Java data types

More Related Content

What's hot (20)

Similar to Java data types (20)

More from Kuppusamy P (20)

Recently uploaded (20)

Java data types