Have you ever written the same kind of function or class multiple times—just because the data type was different?
That’s where Generics come in — the superhero of reusable and type-safe code!
In this article, you’ll learn what Generics in software are, how to use generics, and even explore examples in Kotlin, C#, and Swift. Let’s make it super simple!
What Are Generics?
Imagine you want a box that can store any type of item — apples, books, or toys — but you still want to know what’s inside it.
That’s what Generics do in programming:
They allow you to write one piece of code that works with different data types, while still being type-safe (no wrong type sneaks in!).
In simple words:
Generics = One code for many types!
Why Use Generics?
Here’s why developers love them:
- Reusability – Write once, use for any type.
- Type Safety – Catch errors at compile time.
- Clean Code – No need to write duplicate methods.
Basic Example: Without and With Generics
Without Generics:
void PrintInt(int value) { Console.WriteLine(value); }
void PrintString(string value) { Console.WriteLine(value); }
You’re repeating the same logic!
With Generics:
void Print<T>(T value) { Console.WriteLine(value); }
Now you can call:
Print(42);
Print("Hello");
Print(3.14);
One method, many types!
Some of the Methods Used in Generics
Generics are often used with:
- Generic Methods – Like
Print<T>(T value) - Generic Classes – Like
List<T>orStack<T> - Generic Interfaces – Define contracts for different data types
- Generic Constraints – Limit what types can be used (e.g., only numbers)
How to Use Generics in Different Languages
Let’s explore how to use generics in Kotlin, C#, and Swift — step by step.
How to Use Generics in Kotlin
fun <T> printItem(item: T) {
println(item)
}
printItem(10)
printItem("Kotlin")
printItem(3.14)
Generic Class Example:
class Box<T>(val value: T)
val intBox = Box(100)
val stringBox = Box("Hello")
Kotlin generics make your functions and classes flexible and reusable!
How to Use Generics in C#
class Box<T>
{
public T Value;
public Box(T value) => Value = value;
}
var intBox = new Box<int>(10);
var strBox = new Box<string>("C# Generics");
Console.WriteLine(intBox.Value);
Console.WriteLine(strBox.Value);
C# Generics are powerful — they’re used everywhere in the .NET world (like List<T>, Dictionary<TKey, TValue>).
How to Use Generics in Swift
func printValue<T>(_ value: T) {
print(value)
}
printValue(42)
printValue("Swift rocks!")
Generic Class Example:
class Box<T> {
var item: T
init(item: T) { self.item = item }
}
let box = Box(item: "Hello Swift!")
print(box.item)
In Swift, generics help you write clean, type-safe code used in many Apple frameworks.
Real-Life Example
Imagine a generic list that can hold any data type:
List<Int>→ NumbersList<String>→ NamesList<User>→ Custom objects
All use the same list class, just with a different type!
Summary
| Concept | Description |
|---|---|
| Generics | Write code that works with any data type |
| Benefits | Reusability, Type Safety, Clean Code |
| Used In | Functions, Classes, Interfaces |
| Languages | Kotlin, C#, Swift (and many others) |
Final Thoughts
Generics may sound advanced at first, but they’re just a clever way to say:
“Let’s make code flexible without breaking safety!”
Whether you’re coding in Kotlin, C#, or Swift, learning how to use Generics in software will make your code more powerful, reusable, and future-proof.
