What is Data Types: A Guide to Primitive, Composite, and User-Defined

Updated on August 21, 2024

Article Outline

What are Data Types in Programming?Why are Data Types Important in Programming?Common Primitive Data Types in Programming Common Composite Data Types Common User-Defined Data Types Dynamic vs Static Typing in Programming Type Casting in Programming Type Safety in Programming Conclusion FAQs

Data types are essential in programming. They determine the kind of data a variable can hold, such as numbers, text or more complex structures. Studying these data types helps to avoid errors and enables correct usage of data.

In this blog post, we will discuss what data types are, why they are important in programming and how they influence your code. Basic data types (primitive), composite, user-defined and include concepts on dynamic vs static typing, type casting and type safety.

What are Data Types in Programming?

The kinds of data that variables can hold are taken care of by the concept known as data types in computer programming. These define what operations can be performed on the data. For example, ‘+’ is an operator that can be used with two numbers to produce their sum. It is also used to merge two strings in some programming languages like JavaScript.

For example, if you want to keep integers only in your variable then you will use an integer which holds whole number values. The same applies when you need to store characters whereby string comes into play. Every operation has its data types which it must work with exclusively, for instance you cannot just join strings together but not add them up numerically without converting them accordingly.

Get curriculum highlights, career paths, industry insights and accelerate your data science journey.

Download brochure

Why are Data Types Important in Programming?

Memory Management: This entails the allocation of resources optimally by determining how much memory each variable consumes relative to others.
Prevention of Errors: Data types assist programmers in identifying mistakes early enough such as trying to perform wrong operations with incompatible data types.
Code Clarity: It becomes easy to read and understand your code by specifying its intended contents by naming its variables appropriately using specific names.
Performance Optimization: Good utilisation of available memory eases the task of computer systems, thus making them work more efficiently.
Functionality Control: By using data types in programming a programmer can easily limit the operations that can be performed on certain variables, thus preventing errors which may arise from trying to perform unwanted operations on such entities.
Interoperability: Uniformly defined data types are important in transferring and integrating data between different systems or across languages.

Common Primitive Data Types in Programming

Primitive data types are the basic building blocks of data in programming. They represent simple, single values and are fundamental to understanding how data is stored and manipulated. Different languages might have slight variations, but the core types are generally the same across most programming languages. Below is a table summarising the most common primitive data types:

Data Type	Description	Range	Example
byte	Stores small integers	-128 to 127	byte age = 25;
short	Stores small integers	-32,768 to 32,767	short year = 2023;
int	Stores whole numbers	-2,147,483,648 to 2,147,483,647	int population = 1000000;
long	Stores large whole numbers	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807	long distance = 9876543210L;
float	Stores decimal numbers	1.4E-45 to 3.4E+38	float price = 19.99f;
double	Stores large decimal numbers	4.9E-324 to 1.7E+308	double temperature = 98.6;
char	Stores a single character	0 to 65,535 (Unicode characters)	char initial = ‘A’;
boolean	Stores true or false values	true or false	boolean isOpen = true;
Date	Stores date values	Varies	Date today = new Date();
Time	Stores time values	Varies	Time now = LocalTime.now();
DateTime	Stores both date and time	Varies	DateTime event = LocalDateTime.now();

int

The int data type is commonly used to store whole numbers without decimals. It occupies 32 bits of memory and can represent a wide range of integer values, from negative to positive. It’s often the default choice for storing numeric values when there’s no need for larger ranges.

Example:

public class IntExample {

public static void main(String[] args) {

// Declare an integer variable to store the population

int population = 1000000;
 

// Print the population value

System.out.println("Population: " + population);

}

}

Output:

	
Population: 1000000

long

Here, ‘long’ is a data type that can store whole numbers greater than the range of int and it uses 64 bits of memory. This implies that this data type is necessary when working with large values such as astronomical distances or financial calculations.

Example:

	
public class LongExample {

public static void main(String[] args) {

// Declare a long variable to store a large distance value

long distance = 9876543210L;

 

// Print the distance value

System.out.println("Distance: " + distance);

}

}

Output:

	
Distance: 9876543210

double

The double data type is used to store decimal numbers which have double precision. Double occupies 64 bits of memory and is fit for work requiring highly accurate results like scientific computations or financial analysis.

Example:

public class DoubleExample {

public static void main(String[] args) {

// Declare a double variable to store the temperature

double temperature = 98.6;

 

// Print the temperature value

System.out.println("Temperature: " + temperature);

}

}

Output:

	
Temperature: 98.6

boolean

The boolean data type is used to store only two possible values: true or false. It occupies minimal memory and is widely used in decision-making processes, such as controlling the flow of a program based on conditions. Example:

	
public class BooleanExample {

public static void main(String[] args) {

// Declare a boolean variable to check if the store is open

boolean isOpen = true;
 

// Print the status of the store

System.out.println("Is the store open? " + isOpen);

}

}

Output

	
Is the store open? true

Date

The Date Data Type is involved in storing date and time values. It’s part of the Java util package, widely utilised in applications dealing with dates and times like event scheduling or logging.

Example:

import java.util.Date; 
public class DateExample {

public static void main(String[] args) {

// Create a new Date object to store the current date and time

Date today = new Date();
 

// Print the current date and time

System.out.println("Today's Date: " + today);

}

}

Output:

	
Today's Date: [current date and time]

Common Composite Data Types

Composite data types are more complex than primitive data types as they are made up of multiple values. These data types can hold collections of data or combine various data types into a single structure. They are essential for managing more sophisticated data and building structured programs.

Data Type	Description	Example	Use Case
Array	A collection of elements, all of the same type	int[] numbers = {1, 2, 3, 4, 5};	Storing multiple values in a single variable
String	A sequence of characters (in some languages, a composite type)	String name = “Alice”;	Managing text data
List	An ordered collection that can contain duplicate elements	List<String> names = new ArrayList<>();	Dynamically sized collections
Map	A collection of key-value pairs	Map<String, Integer> ageMap = new HashMap<>();	Storing and accessing data via keys
Set	A collection that contains no duplicate elements	Set<String> uniqueNames = new HashSet<>();	Storing unique elements
Tuple	A fixed-size collection of elements of possibly different types	Pair<String, Integer> person = new Pair<>(“Alice”, 30);	Grouping related items together

Array

An array refers to a fixed-size collection of elements which are all of the same type. Arrays are usually used in storing many values within one variable making it easier to handle collections of data.

Example:

public class ArrayExample {

public static void main(String[] args) {

// Declare an array of integers

int[] numbers = {1, 2, 3, 4, 5};

 

// Print the first element of the array

System.out.println("First number: " + numbers[0]);

}

}

Output:

	
First number: 1

String

Though String can be seen as a primitive data type in some languages, it is technically a composite data type since it is a sequence of characters. Such strings are often used for storage purposes or manipulation of text.

Example:

	
public class StringExample {

public static void main(String[] args) {

// Declare a string variable

String name = "Alice"; 

// Print the string value

System.out.println("Name: " + name);

}

}

Output:

	
Name: Alice

List

The list refers to dynamic collections whose sizes can be increased or decreased accordingly. The list enables duplication among the elements, while still maintaining insertion order, thereby, forming powerful structures for managing information.

Example:

	
import java.util.ArrayList;

import java.util.List; 

public class ListExample {

public static void main(String[] args) {

// Create a list of strings

List<String> names = new ArrayList<>(); 

// Add elements to the list

names.add("Alice");

names.add("Bob");

 

// Print the list elements

System.out.println("Names: " + names);

}

}

Output:

	
Names: [Alice, Bob]

Map

A Map is a collection that associates keys with values. Each key in a Map must be unique, and it allows for efficient data retrieval based on the key.

Example:

	
import java.util.HashMap;

import java.util.Map; 

public class MapExample {

public static void main(String[] args) {

// Create a map with string keys and integer values

Map<String, Integer> ageMap = new HashMap<>();

 

// Add key-value pairs to the map

ageMap.put("Alice", 30);

ageMap.put("Bob", 25);

 

// Print a value from the map using a key

System.out.println("Alice's age: " + ageMap.get("Alice"));

}

}

Output:

	
Alice's age: 30

Set

A Set is a collection that does not allow duplicate elements. It is used when you need to ensure that all elements in the collection are unique.

Example:

	
import java.util.HashSet;

import java.util.Set; 

public class SetExample {

public static void main(String[] args) {

// Create a set of strings

Set<String> uniqueNames = new HashSet<>(); 

// Add elements to the set

uniqueNames.add("Alice");

uniqueNames.add("Bob");

uniqueNames.add("Alice"); // Duplicate entry

 

// Print the set elements

System.out.println("Unique names: " + uniqueNames);

}

}

Output:

	
Unique names: [Alice, Bob]

Common User-Defined Data Types

These are custom data structures created by programmers to represent specific entities not covered by primitive types and composites. These data types enable programs to be more flexible and structured, thus helping group together related data into meaningful chunks. They are most useful in object-oriented programming where they help create objects that model real-world things.

Data Type	Description	Example	Use Case
Class	A blueprint for creating objects, encapsulating data and behaviour	class Car { … }	Modelling real-world entities
Enum	A special data type that defines a set of named values	enum Day { MONDAY, TUESDAY, … }	Representing a fixed set of constants
Interface	A contract that classes can implement, defining methods without implementations	interface Animal { void sound(); }	Enforcing a common structure across classes
Struct	A composite type (similar to classes) often used in languages like C/C++	struct Point { int x, y; };	Grouping related variables
Union	A data structure in C/C++ that can hold one of several types at a time	union Data { int i; float f; char c; };	Saving memory by reusing the same space

Class

A Class is a user-defined data type that acts as a blueprint for creating objects. It encapsulates data (fields) and behaviour (methods) into a single unit, allowing for the creation of multiple objects with similar properties and functions. Classes are fundamental to object-oriented programming.

Example:

public class Car {
// Fields to store the car's properties

String model;

int year; 

// Constructor to initialise the car's properties

public Car(String model, int year) {

this.model = model;

this.year = year;

} 

// Method to display the car's details

public void displayDetails() {

System.out.println("Model: " + model + ", Year: " + year);

} 

public static void main(String[] args) {

// Create a new Car object

Car myCar = new Car("Toyota", 2020);

 

// Display the car's details

myCar.displayDetails();

}

}

Output:

	
Model: Toyota, Year: 2020

Enum

In short, an Enum, enumeration is a special user-defined data type whose values do not change during runtime but rather remain fixed. These Enum constants can be used to denote a set of named values such as the days of the week or states in a process.

Example:

public class EnumExample {

// Define an enum to represent days of the week

enum Day {

MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY

} 

public static void main(String[] args) {

// Declare a variable of the enum type and assign a value

Day today = Day.MONDAY; 

// Print the current day

System.out.println("Today is: " + today);

}

}

Output:

	
Today is: MONDAY

Union

A union is a user-defined data type in C/C++ that can hold different types at the same memory location. In other words, only one of its members can contain value at any time and gives us a memory-efficient way for handling variables, which are not used simultaneously.

Example:

	

#include <stdio.h> 

// Define a union that can hold an integer, float, or character

union Data {

int i;

float f;

char c;

}; 

int main() {

// Create a union variable

union Data data;
 

// Assign an integer value to the union

data.i = 10;

printf("Integer: %dn", data.i);
 

// Assign a float value to the union (overwrites the integer)

data.f = 220.5;

printf("Float: %.2fn", data.f);
 

// Assign a character value to the union (overwrites the float)

data.c = 'A';

printf("Character: %cn", data.c); 

return 0;

}

Output:

	
Integer: 10

Float: 220.50

Character: A

A These user-defined data types give programmers the tools to model complex entities and relationships in their programs, enhancing flexibility and maintainability.

Dynamic vs Static Typing in Programming

Dynamic and static typing refer to when type checking is performed in a programming language, either at runtime or during compilation. This fundamental difference impacts how variables are declared and used in a program.

Feature	Dynamic Typing	Static Typing
Type Checking	Performed at runtime	Performed at compile-time
Variable Declaration	No need to specify data type	Requires specifying data type
Flexibility	More flexible, types can change	Less flexible, types are fixed
Error Detection	Errors detected during execution	Errors detected during compilation
Example Languages	Python, JavaScript	Java, C++, C#

Example of Dynamic Typing (Python)

In dynamic typing, the type of a variable is determined at runtime, allowing for more flexibility but also potential runtime errors.

Code:

# Dynamic typing in Python

x = 10  # Initially an integer

print(x)  # Output: 10 

x = "Hello"  # Now x is a string

print(x)             # Output: Hello

Explanation: In the above Python code, the variable x initially holds an integer and later holds a string. The type of x changes based on the value assigned to it.

Example of Static Typing (Java)

In static typing, the type of a variable is explicitly declared and does not change, allowing for early error detection during compilation.

Code:

	

public class StaticTypingExample {

public static void main(String[] args) {

// Static typing in Java

int x = 10;        // Declaring x as an integer

System.out.println(x);  // Output: 10 

// x = "Hello"; // This line would cause a compile-time error

}

}

Explanation: In the Java example, the variable x is declared as an int, and any attempt to assign a different type (like a string) would result in a compile-time error. This ensures type safety but at the cost of some flexibility.

Type Casting in Programming

Type casting in programming refers to the process of converting a variable from one data type to another. This can happen automatically by the compiler or interpreter (implicit casting) or explicitly by the programmer (explicit casting). Type casting is essential when dealing with different data types in a program, allowing for flexibility in operations and data manipulation.

Types of Type Casting

Implicit Casting (Automatic Type Conversion)
Explicit Casting (Manual Type Conversion)

Implicit Casting (Automatic Type Conversion)

Implicit casting occurs automatically when the compiler or interpreter converts a smaller data type to a larger data type. This is generally safe as there’s no loss of data.

Example:

	
public class ImplicitCastingExample {

public static void main(String[] args) {

// Implicit casting from int to double

int a = 10;

double b = a;  // Automatically converts int to double 

// Print the double value

System.out.println("Double value: " + b);  // Output: 10.0

}

}

Explanation: In the above example, the int variable a is automatically converted to a double when assigned to b. This is an example of implicit casting, where a smaller type (int) is converted to a larger type (double) without any loss of information.

Explicit Casting (Manual Type Conversion)

Explicit casting is when a programmer manually converts a larger data type to a smaller one. This process requires care, as it can lead to data loss or unexpected results if not done correctly.

Example:

	
public class ExplicitCastingExample {

public static void main(String[] args) {

// Explicit casting from double to int

double x = 9.78;

int y = (int) x;  // Manually cast double to int 

// Print the integer value

System.out.println("Integer value: " + y);  // Output: 9

}

}

Explanation: Here, the double variable x is explicitly cast to an int when assigned to y. This manual casting results in the loss of the decimal part (0.78), leaving only the integer portion (9). This type of casting must be done with caution to avoid unintentional data loss.

Type Safety in Programming

The concept of type safety in programming refers to the correct use of variables and data types such as integers, strings, etc., which helps avoid errors related to incorrect data type usage. It is a critical aspect in the integrity maintenance of any program.

Prevents Type Errors: Ensures that operations are only performed on compatible data types, avoiding runtime errors.
Compile-Time Checking: Statically typed languages provide type safety that catches errors during compilation leading to more robust code.
Enhanced Code Clarity: A clear meaning of this is by defining what kind of data can be used in different situations, thereby making the code easier to understand.
Memory Safety: This restricts unintended memory access by enforcing type rules hence reducing buffer flow and other related issues chances.
Improves Maintainability: Since the variable’s types are explicitly defined and checked, it becomes easy for anyone to read and maintain such codes due to this principle of type safety compliance.
Reduces Debugging Effort: Time spent on debugging and fixing issues is significantly reduced by early detection of type-related mistakes brought about by typing being safe.
Supports Polymorphism: Object-oriented programming allows for polymorphic behaviour while ensuring that methods invoked are appropriate for given object types; hence typing must be safe here too.

Conclusion

Data types play a crucial role in computer coding. They determine how information is stored or manipulated as well impact on the reliability as well efficiency of software applications. They may range from simple ones like booleans or integers to complex user-defined classes or interfaces aimed at structuring and managing information differently.

Grasping concepts such as type casting, type safety, and the differences between dynamic and static typing give developers the power to write robust code without any errors. As programming languages evolve, so does the intricacy of data types, making continuous learning essential for anyone keen on mastering the art of software development.

FAQs

What is a primitive data type?

In most programming languages, a primitive data type is one of the simple types provided by the language, such as int, char and boolean.

How does dynamic typing differ from static typing?

Dynamic typing performs type checking at runtime, allowing variable types to change, whereas Static typing checks types at compile-time requiring an explicit type declaration.

What is typecasting?

Type casting refers to the conversion of variables from one data type to another either implicitly or explicitly.

Why is type safety important?

Program reliability enhancement can be achieved through the use of this kind of safety measure that stops operations on incompatible data types, hence preventing mistakes.

What is an example of a user-defined data type?

Classes and interfaces are examples of user-defined data types in which developers may create intricate structures adapted for their own specific purposes.

Can you cast any data type to another?

Not all casts are valid. Only compatible casts may be used while there may be a need for an explicit cast to avoid loss of information.

What Is Enum For?

An enumeration defines a collection group of named constants. It represents a fixed set of related values, thus making code more readable and maintainable.

Updated on August 21, 2024

Link

Programs tailored for your success

Popular

IIT Courses

Management

Data Science

Finance

Technology

Future Tech

3 ASSURED INTERVIEWS

Accelerator Program in

Business Analytics and Data Science

With

Part-time · 10 months

Apply by : 23 November, 2024

Financial Analysis, Valuation, & Risk Management

3 ASSURED INTERVIEWS

Certificate Program in

Financial Analysis, Valuation, & Risk Management

With

Part-time · 7 months

Apply by : 23 November, 2024

INTERNSHIP ASSURANCE

Certificate Program in

DevOps & Cloud Engineering

With

Part-time · 7.5 months

Apply by : 23 November, 2024

Upskill with expert articles

View all

Hero Vired is a leading LearnTech company dedicated to offering cutting-edge programs in collaboration with top-tier global institutions. As part of the esteemed Hero Group, we are committed to revolutionizing the skill development landscape in India. Our programs, delivered by industry experts, are designed to empower professionals and students with the skills they need to thrive in today’s competitive job market.

Data Science

Accelerator Program in Business Analytics & Data Science

Integrated Program in Data Science, AI and ML

Accelerator Program in AI and Machine Learning

Advanced Certification Program in Data Science & Analytics

Certification Program in Data Analytics

Technology

Certificate Program in Full Stack Development with Specialization for Web and Mobile

Certificate Program in DevOps and Cloud Engineering

Certificate Program in Application Development

Certificate Program in Cybersecurity Essentials & Risk Assessment

Finance