Data types

Before using a variable, we should specify what type of variable it is.

When we specify the datatype, the system can understand the memory requirements
and the operations allowed on the corresponding variables.

Ex: to store age of a person, then we specify the variable as an integer.

to store temperature of a city, then we define the it as double.

An integer occupies 4 bytes of memory where as a double occupy 8 bytes of

memory.

Integer data types are:

 Byte 1 byte -128 to 127

 short 2 bytes -32,768 to 32,767
 int 4 bytes -2,147,483,648 to 2,147,483,647
 long 8 bytes
 -9,223,372,036,854,775,808 to 9,223,372,036,854,775,80

datatype variable = initial value;

ex : int a = 100;

Data Type
 Size: 32 bit i.e n = 32 0 to 31
Value: -232 to 232 – 1 -2n to 2n -1
 8 bits - 28 to 28-1 -128 to 127
16 bits -216 to 216-1 -32,768 to 32,767
32 bits -232 to 232-1 -2,147,483,648 to 2,147,483,647

64 bits -264 to 264-1

-9,223,372,036,854,775,808 to 9,223,372,036,854,775,808

Java actually uses Unicode, which includes ASCII and other characters from
languages around the world.

ASCII Table has 127 chrs.

Byte 8-bit signed two's complement integer

save space in large arrays, mainly in place of integers, since a byte is
four times smaller than an integer.

Byte - 1 char – 8 bits of info

short a 16-bit signed two's complement integer

int a 32-bit signed two's complement integer.

int – 4 bytes 4x 8 bits = 32 bits

long Long data type is a 64-bit signed two's complement integer

float to save memory in large arrays of floating point numbers

double

Boolean represents one bit of information

char a single 16-bit Unicode character

BYTE

As it occupies 1 byte of memory, we can store a value between -128 to 127.

If we try to store a value bigger than that we will get a compilation error.

byte b=25; is valid

Byte c=225; is not valid ✕

To work with single characters (ASCII values up to 127), we can use byte type as it uses only 1
byte of memory (against char which takes 2 bytes of memory).

SHORT

To store integers in the range -32768 to 32767.

Any value out of this range cannot be kept as short.
INT

Default integer type.

Most of the times we use int type only to work
We can use up to a 10 digit number (up to 200 crores nearly) with int type.

LONG

To store a value bigger than int range, we should use long type.

With long, we can store up to a 19 digit number.

When using a constant bigger than int range, we should suffix it with ‘l’ or ‘L’ to indicate it to be
a long value.

long c=123456789012345L;

CHAR

char type takes 2 bytes of memory to support UniCode characters

As per UniCode, we have 65536 (216) characters numbered from 0 to 65535.

The char type cannot take negative values.

Numeric type can take both positive and negative values.

The first 256 (numbered from 0 to 255) characters of UniCode are the ASCII set of characters
only.

So UniCode is compatible with ASCII.

So both in ASCII and UniCode ‘A’ is 65, ‘B’ is 66, ‘C’ is 67, ‘ a’ is 97, ‘b’ is 98, ‘0’ is 48, ‘1’ is
49, ‘\n’ is 10, ‘\t’ is 9.
Eg: char a=55; is valid

FLOAT

numbers with a fractional part, we can use float type

 float b=3.6f
 float c=(float)3.6
 DOUBLE

This is the default datatype to store decimal (real numbers) values

double a=3.9;
double b=834;
double c=’A’;

Boolean

to store logical values

boolean a=true

boolean g=10<20;

boolean d=false

Package in Java is a mechanism to encapsulate a group of classes, sub packages and

interfaces.

Packages are used for:

 Preventing naming conflicts.
Example:
There can be two classes by the name Employee
in two packages,
 1) cse.Employee and
2) ee.Employee

CSE IS A PACKAGE.
EMPLOYEE IS A CLASS
class employee
{

College – technical—department – CSE---EMPLOYEE

College – technical—department – EE- EMPLOYEE

CSE
EE

 Providing controlled access:

 Protected and default have package level access control.
 A protected member is accessible by classes in the same package and its
subclasses.
 A default member (without any access specifier) is accessible by classes
in the same package only.
 Packages can be considered as data encapsulation (or data-
hiding).
  Put related classes into packages.
 After that we can simply write
import a class from existing packages and
use it in our program.
 A packages is a container for a group of related classes
 We can reuse existing classes
from the Java packages
written by vendors
as many times as we need it in our program.

Adding a class to a Package

We can add more classes to a

 Created package

i.e. by using package name at the top of the program and saving it in the package directory.

Naming Conventions

Packages are named in reverse order.

Ex: in a college, the recommended convention is

 college.tech.cse.Employee
 college.tech.ee.Employee
Packages are
Built-in Packages

User-defined packages

Built-in Packages consist of a large number of classes which are a part of Java API.

Commonly used built-in packages are

java.lang

java.io

java.util

java.applet

java.awt ---

java.net

import java.applet.addApplet.class3; // number of classes n

which you have created

import java.applet.addApplet.*;

import java.lang
java.lang Contains language support classes (e.g classed which defines primitive data types,
math operations). This package is automatically imported.

java.io Contains classed for supporting input / output operations.

import java.io // all print functions defined in a package;

println(“Welcome to Java” );

println(“Iam from India”);

println(“Hello World!”);

println( ) // its in a class // class is in java.io package

java.util Contains utility classes which implement data structures like Linked List,
Dictionary and support ; for Date / Time operations.

java.applet Contains classes for creating Applets.

java.awt Abstract window toolkit

Contain classes for implementing the components for graphical user interfaces (like button ,
menus ).

java.net Contain classes for supporting networking operations.

User-defined packages
These are the packages that are defined by the user.

First we create a directory by the name myPackage (name should be same as the name of the
package).

Then create the MyClass inside the directory with the first statement being the package name.
package mypackage ;

public class myclass // data members + functions

public void getNames(String s) ///String is a class now

//s is an object for the String class

System.out.println(s);

}
Note :

Name of the package must be same as the directory under which this file is
saved

Now we can use the MyClass class in our program

import myPackage.MyClass;

import java.io;

// import MyClass class from names package

public class printName

public static void main(String args[ ] )

{

String name = “My Name is B.M.Rao”; // initializing string name

String name = “My Name is Jaya”; // initializing string name

String name = “My Name is Nagamani”; // initializing string name

String name = “My Name is Eswari”;

// create instance of class we have created in the package

MyClass object = new MyClass( );

Object.getNames (name);

System.out.println(“welcome”)

Note :

MyClass.java must be saved inside the myPackage directory since it is a part of

the package.

//import java.io.myPackage.MyClass;
import java.io;
import myPackage.*;

c:> user/b/jdk/java/bin/ bin is a directory

Subpackages

Packages that are inside another package are the subpackages.

These are not imported by default, they have to be imported explicitly

Ex: import java.util.* ;

util is a subpackage created inside java package.

 import java.util.vector ;

// to import Vector class from util package which is contained

inside java.

Class vector
{
Public static void main(string args[ ]

}
import java.util.*;

// imports all the classes from util package.

Variables are reserved memory locations to store values.

i.e. when you create a variable you reserve some space in the memory.

Based on the data type of a variable, the operating system allocates memory and decides what
can be stored in the reserved memory.

By assigning different data types to variables, you can store integers, decimals, or characters in
these variables.

There are two data types available in Java −

 Primitive Data Types - eight primitive data types supported by Java

 Reference/Object Data Types