Primitive Types

Question 1

What are primitive types?

Answer 1

Primitive types are the simplest, indivisible data values stored directly in memory. In computing, they represent basic hardware-level data (like numbers or single characters). In Java, primitive types are built-in, non-object values with fixed sizes and efficient storage.

Question 2

What are the three types of primitive data?

Answer 2

Depends on the programming language, but usually:

Numeric (int, float)

Character (char)

Boolean (true/false)

Question 3

How many bits does each primitive type use?

Answer 3

A (Java — fixed sizes except boolean):

byte — 8 bits (−128 to 127)
short — 16 bits (signed)
int — 32 bits (signed)
long — 64 bits (signed)
float — 32 bits (IEEE 754)
double — 64 bits (IEEE 754)
char — 16 bits (UTF-16 code unit; may form surrogate pairs for some Unicode characters)
boolean — size not specified by Java; conceptually 1 bit, but actual storage depends on the JVM/implementation (often 1 byte in arrays, promoted to int for operations)

B (General computing — common conventions):

boolean — conceptually 1 bit (true/false)
integer sizes vary by language/platform (common modern conventions): byte 8, short 16, int 32, long 64
floating point: float 32-bit, double 64-bit (IEEE 754)
character storage depends on encoding: ASCII/UTF-8 uses 8-bit code units; UTF-16 uses 16-bit code units; Unicode code points may require more than one unit.

Question 4

What are the numeric primitive data types in Java?

Answer 4

A: Java has 6 numeric primitive types:

Integral types (whole numbers):
byte — 8 bits
short — 16 bits
int — 32 bits
long — 64 bits

Floating-point types (decimal numbers):
float — 32 bits (IEEE 754)
double — 64 bits (IEEE 754)

Question 5

What is the boolean data type?

Answer 5

Boolean = primitive logical type with two values: true/false. Conceptually 1 bit, but Java does not define its size. Used for conditions and control flow.

Question 6

Example of using a byte in Java and how many bits does the Java byte use?

Answer 6

```java
byte b = 100;
System.out.println(b); // prints 100
~~~
- Size: 8 bits
- Range: -128 to 127

Question 7

Example of using a short in Java and how many bits does the Java short use?

Answer 7

```java
short s = 20000;
System.out.println(s); // prints 20000
~~~
- Size: 16 bits
- Range: -32,768 to 32,767

Question 8

Example of using an int in Java and how many bits does the Java int use

Answer 8

```java
int i = 100000;
System.out.println(i); // prints 100000
~~~
- Size: 32 bits
- Range: -2,147,483,648 to 2,147,483,647

Question 9

Example of using a long in Java and how many bits does the Java long use

Answer 9

```java
long l = 10000000000L;
System.out.println(l); // prints 10000000000
~~~
- Size: 64 bits
- Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

Question 10

Example of using a float in Java and how many bits does the Java float use

Answer 10

```java
float f = 3.14f;
System.out.println(f); // prints 3.14
~~~
- Size: 32 bits
- Single-precision decimal numbers

Question 11

Example of using a double in Java and how many bits does the Java double use

Answer 11

```java
double d = 3.14159265359;
System.out.println(d); // prints 3.14159265359
~~~
- Size: 64 bits
- Double-precision decimal numbers

Question 12

Example of using a char in Java and how many bits does the Java char use

Answer 12

```java
char c = ‘A’;
System.out.println(c); // prints A
~~~
- Size: 16 bits
- Stores a single Unicode character

Question 13

Example of using a boolean in Java and how many bits does the Java boolean use

Answer 13

```java
boolean flag = true;
System.out.println(flag); // prints true
~~~
- Values: true or false

Question 14

What are the 8 primitive data types in Java?

Answer 14

Type Size Range / Values Description
byte 8 bits -128 to 127 Small integers
short 16 bits -32,768 to 32,767 Larger integers than byte
int 32 bits -2³¹ to 2³¹-1 Standard integer type
long 64 bits -2⁶³ to 2⁶³-1 Large integers
float 32 bits Approx. ±3.4e38, 7 decimal digits Single-precision floating-point
double 64 bits Approx. ±1.7e308, 15 decimal digits Double-precision floating-point
char 16 bits ‘\u0000’ to ‘\uffff’ (Unicode) Single character
boolean 1 bit* true or false Logical values

Question 15

What is the size and range of byte in Java?

Answer 15

Size: 8 bits
Range: -128 to 127

Question 16

What is the size and range of short in Java?

Answer 16

Size: 16 bits
Range: -32,768 to 32,767

Question 17

What is the size and range of int in Java?

Answer 17

Size: 32 bits
Range: -2,147,483,648 to 2,147,483,647

Question 18

What is the size and range of long in Java?

Answer 18

Size: 64 bits
Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

Question 19

What is the size and range of float in Java?

Answer 19

Size: 32 bits
Range: approximately ±3.40282347E+38F
Single-precision decimal numbers

Question 20

What is the size and range of double in Java?

Answer 20

Size: 64 bits
Range: approximately ±1.79769313486231570E+308
Double-precision decimal numbers

Question 21

What is the size and valid values of char in Java?

Answer 21

Size: 16 bits
Range: 0 to 65,535 (Unicode characters)
Example: ‘A’, ‘Ω’, ‘\n’

Question 22

What is the size and valid values of boolean in Java?

Answer 22

Size: JVM dependent (typically 1 bit)
Values: true or false

Question 23

Primitive Data Type (Definition)

Answer 23

The most basic, fundamental data type built into a programming language, representing a single, simple value.

Question 24

Alternative Definition for what is primitive data type.

Answer 24

Small blocks of data that are fundamental to the Data Structures.

Question 25

What is the relationship between primitive types and Data Structures

Answer 25

They are the fundamental building blocks used to construct all complex data structures (like arrays, lists, and objects).

Question 26

Explain Primitive Type Category: Integers

Answer 26

Represent whole numbers (positive, negative, or zero). Examples: int, long, short.

Question 27

Explain Primitive Type Category: Floating-Point

Answer 27

Represent real numbers with a fractional/decimal part. Examples: float, double.

Question 28

Explain Primitive Type Category: Character

Answer 28

Represents a single character (letter, digit, or symbol). Example: char.

Question 29

Explain Primitive Type Category: Logical

Answer 29

Represents a truth value; can only be true or false. Example: boolean (or bool).

Question 30

Example of an Integer value

Answer 30

100, -5, or 0

Question 31

Example of a Floating-Point value

Answer 31

3.14159 or -0.001

Question 32

Example of a Character value

Answer 32

'A', '7', or '?'

Question 33

Example of a Boolean value

Answer 33

true or false

Question 34

Are strings (like "Hello") primitive types?

Answer 34

Not always. In many languages (like Java or Python), they are technically objects or composite types (an array of chars), even if they feel like primitives.

Question 35

What does 'Blocks of data' imply?

Answer 35

It suggests a fixed, contiguous area of memory of a specific size (e.g., 4 bytes for an integer).

Question 36

What is the opposite of a primitive type?

Answer 36

Composite, Complex, or Non-Primitive types (also called Reference types), such as Objects, Arrays, and Classes.

Question 37

Why are primitives memory efficient?

Answer 37

They usually correspond directly to basic hardware operations and store only the value, not extra metadata or references.

Question 38

What is Data Structure: Linked List Node

Answer 38

Contains primitive data (like an int value) and a reference (pointer) to the next node.

Question 39

What is Data Structure: Class/Object

Answer 39

A collection of fields, many of which are primitive types (e.g., int age, boolean isActive).

Question 40

What is the Hardware Connection with the primitive types.

Answer 40

Operations on primitive types often map directly to instructions for the computer's processor (CPU).

Question 41

What does 'atomic' mean in the primitive type context?

Answer 41

Indivisible. A primitive type cannot be broken down into smaller data components.

Question 42

What is the Storage Location (Commonly) for primitive types.

Answer 42

Primitive types are often stored on the 'stack', which is very fast for access and management.

Question 43

What is the Non-Primitive Storage (Commonly)?

Answer 43

Objects and complex types are often stored on the 'heap', and a reference (pointer) to them is stored on the stack.

Question 44

In languages like Java or C#, is the String data type primitive or non-primitive (reference)?

Answer 44

Non-primitive (or Reference). String is a class that represents an object in the memory heap.

Question 45

What is the main reason why String is considered an object and not a primitive type (like int or boolean)?

Answer 45

Because it is a class, it has associated methods (e.g., .length(), .toUpperCase()). Primitive types store the value directly and have no methods.

Question 46

What does the String data type fundamentally represent?

Answer 46

A sequence of characters (char).

Question 47

What is a key characteristic of Strings in most object-oriented programming languages (like Java)?

Answer 47

Immutability. Once created, a String cannot be changed. Any "modification" actually results in the creation of a new String object.

Question 48

What is the default value of a reference data type (like a String) when it is not initialized?

Answer 48

null (which means the variable does not point to any object in memory).

Question 49

In languages like Java, what is the main difference between a primitive type (e.g., int) and a non-primitive / reference type (e.g., String) in terms of functionality and default value?

Answer 49

1. Functionality: Primitive types only store the value and have no methods. Non-primitive types (Objects) are classes and have methods to manipulate data. 2. Default Value: The default value for a primitive is a specific number or boolean (e.g., 0 for int, false for boolean). The default value for a non-primitive is null.

Question 50

How much memory does a boolean variable occupy?

Answer 50

Theoretically: It only needs 1 bit (to store a 0 or 1). Practically: Most systems (like the JVM for Java) reserve 1 byte (8 bits) for it, because it is inefficient for a CPU to access a single bit from byte-addressable memory.

Question 51

Explain the three key concepts that define primitive data types (e.g., int, boolean) in contrast to reference types (objects).

Answer 51

1. Atomic: Primitives represent indivisible values. They are not composed of other types and store only a single, fundamental piece of data. 2. Predefined (Fixed Size): Every primitive type has a fixed, guaranteed size defined by the system (e.g., long is always 64 bits). This ensures their range and memory usage are predictable. 3. Immutable Value: Primitive values cannot be changed. If you have the value 5, it will always be 5. Changing the variable (x = 10;) only makes it point to a new primitive value (10), leaving the old value unaltered.

Question 52

What does it mean that a primitive type is atomic?

Answer 52

Definition: Primitive types represent indivisible values. Explanation: They are not composed of other types and store only a single fundamental piece of data. Example: int x = 42; → 42 is atomic; it cannot be split into smaller components.

Question 53

What does it mean that a primitive type is predefined (fixed size)?

Answer 53

Definition: Each primitive type has a fixed, guaranteed size determined by the system. Explanation: This ensures that their range and memory usage are predictable. Example: int → 32 bits long → 64 bits boolean → JVM-dependent, but logically 1 bit

Question 54

What does it mean that a primitive type has an immutable value?

Answer 54

Definition: Primitive values cannot be changed once created. Explanation: Assigning a new value to a variable does not alter the old value; it just points the variable to a new primitive value. Example: int x = 5; x = 10; // x now points to 10; the original value 5 remains unchanged

Question 55

How do primitive types differ from objects in terms of atomicity?

Answer 55

Primitive: Fixed, predefined size (e.g., int = 32 bits, long = 64 bits) Object: Variable size depending on fields and references

Question 56

How do primitive types differ from objects in terms of size?

Answer 56

Primitive: Yes, each type has a fixed, predefined size (e.g., int = 32 bits, long = 64 bits) Object: No, object size can vary depending on fields and references

Question 57

How do primitive types differ from objects in terms of mutability?

Answer 57

Primitive: Immutable – changing a variable points it to a new value; old value remains unchanged Object: Usually mutable – object fields can be modified after creation

Question 58

How do primitive types and objects differ in memory storage?

Answer 58

Primitive: Usually stored on the stack if local; inside objects, on the heap Object: Stored on the heap, accessed via references on the stack

Question 59

How do primitive types and objects differ in how they store data?

Answer 59

Primitive: Stores raw values directly Object: Stores references; the object contains fields (primitives or objects)