Generics এর বেসিক ধারণা

জাভা জেনেরিক্স (Java Generics) একটি শক্তিশালী ফিচার যা জাভার Collections Framework এবং অন্যান্য অনেক জায়গায় ব্যবহৃত হয়। এটি কম্পাইল টাইমে টাইপ চেকিং সুনিশ্চিত করে এবং টাইপ কাস্টিংয়ের প্রয়োজনীয়তা কমায়। জেনেরিক্স মূলত type-safety এবং reusability নিশ্চিত করার জন্য ব্যবহৃত হয়।

বেসিক ধারণা:

Generics আপনাকে ক্লাস, ইন্টারফেস এবং মেথডগুলিকে একটি নির্দিষ্ট ডেটা টাইপের জন্য সাধারণভাবে কাজ করতে দেয়। এটি ডেটা টাইপ নির্ধারণের সময় নমনীয়তা প্রদান করে এবং রানটাইম ত্রুটি কমায়।

কেন জেনেরিক্স ব্যবহার করবেন?

1. Type-safety: ডেটার টাইপ মিসম্যাচ হওয়ার সম্ভাবনা কমায়।
2. Code Reusability: একাধিক টাইপের জন্য একই ক্লাস বা মেথড পুনরায় ব্যবহার করা যায়।
3. Compile-time Checking: টাইপ সংক্রান্ত ত্রুটি কম্পাইল করার সময় ধরা পড়ে, রানটাইমে নয়।
4. Type Casting প্রয়োজন নেই: জেনেরিক্স ব্যবহার করলে টাইপ কাস্টিংয়ের প্রয়োজন হয় না।

উদাহরণ:

১. জেনেরিক ক্লাস:

// একটি জেনেরিক ক্লাস
class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setItem("Hello Generics");
        System.out.println(stringBox.getItem());

        Box<Integer> intBox = new Box<>();
        intBox.setItem(123);
        System.out.println(intBox.getItem());
    }
}

আউটপুট:

Hello Generics
123

২. জেনেরিক মেথড:

public class GenericMethodExample {
    // একটি জেনেরিক মেথড
    public static <T> void printArray(T[] elements) {
        for (T element : elements) {
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4};
        String[] stringArray = {"A", "B", "C"};

        printArray(intArray);
        printArray(stringArray);
    }
}

আউটপুট:

1
2
3
4
A
B
C

জেনেরিক্স সম্পর্কিত গুরুত্বপূর্ণ কনসেপ্ট:

1. Wildcard (?): এটি বিভিন্ন টাইপের জন্য আরও নমনীয়তা প্রদান করে।

   • ? extends T: T বা T এর সাবক্লাস গ্রহণ করে।
   • ? super T: T বা T এর সুপারক্লাস গ্রহণ করে।
   • ?: যেকোনো টাইপ গ্রহণ করে।

   উদাহরণ:

   public static void printList(List<? extends Number> list) {
       for (Number num : list) {
           System.out.println(num);
       }
   }
   

2. Bounded Type Parameters:

   • একটি টাইপ প্যারামিটার সীমাবদ্ধ করতে extends ব্যবহার করা হয়।

   class GenericExample<T extends Number> {
       private T value;
   
       public GenericExample(T value) {
           this.value = value;
       }
   
       public T getValue() {
           return value;
       }
   }
   

3. Raw Types: জেনেরিক টাইপ সরাসরি ব্যবহার না করে Raw Type ব্যবহার করা হলে টাইপ সেফটি লঙ্ঘিত হয়।

   List list = new ArrayList(); // Raw Type
   list.add("String");
   list.add(123); // Allowed but unsafe
   

Collections Framework এ Generics:

List, Set, Map ইত্যাদি Collections Framework এর ক্লাসে Generics ব্যবহার করা হয়:

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
// names.add(123); // কম্পাইল টাইম ত্রুটি

জেনেরিক্স ব্যবহারে সতর্কতা:

1. প্রিমিটিভ টাইপ (e.g., int, double) সরাসরি জেনেরিক্সে ব্যবহার করা যায় না। Autoboxing এর মাধ্যমে Integer, Double ইত্যাদি ব্যবহার করতে হয়।
2. টাইপ প্যারামিটার রানটাইমে Type Erasure এর কারণে মুছে যায়, ফলে Generics টাইপ চেকিং কেবল কম্পাইল টাইমে ঘটে।

Generics ব্যবহারে আপনার কোড আরও সুনির্দিষ্ট, পুনঃব্যবহারযোগ্য এবং ত্রুটিমুক্ত হবে।

জাভা জেনেরিক্স (Java Generics) জাভার একটি শক্তিশালী ফিচার যা ক্লাস, ইন্টারফেস এবং মেথডকে টাইপ (type) নির্ধারণ করতে সাহায্য করে। এটি কোডকে আরও নিরাপদ এবং সহজপাঠ্য করে তোলে। Generics এর মাধ্যমে, আপনি compile-time টাইপ চেকিং নিশ্চিত করতে পারেন এবং runtime টাইপ কাস্টিং (type casting) থেকে মুক্তি পেতে পারেন।

Generics Syntax

Generics এর ক্ষেত্রে, < এবং > চিহ্ন ব্যবহার করে টাইপ প্যারামিটার নির্ধারণ করা হয়।

1. Generics ক্লাস

// Generic Class Example
public class Box<T> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

// Usage:
Box<Integer> integerBox = new Box<>();
integerBox.set(10);
System.out.println(integerBox.get());

উপরের উদাহরণে, T হল একটি টাইপ প্যারামিটার যা compile-time এ নির্ধারিত হবে।

2. Generics মেথড

// Generic Method Example
public static <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}

// Usage:
Integer[] intArray = {1, 2, 3};
String[] stringArray = {"Hello", "World"};
printArray(intArray);
printArray(stringArray);

উপরের মেথডে <T> টাইপ প্যারামিটার হিসেবে কাজ করছে, যা মেথড কল করার সময় নির্ধারিত হয়।

3. Generics ইন্টারফেস

// Generic Interface Example
public interface Pair<K, V> {
    K getKey();
    V getValue();
}

// Implementation
public class OrderedPair<K, V> implements Pair<K, V> {
    private K key;
    private V value;

    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() { return key; }
    public V getValue() { return value; }
}

// Usage:
Pair<String, Integer> pair = new OrderedPair<>("One", 1);
System.out.println(pair.getKey() + " = " + pair.getValue());

Type Parameters

Generics টাইপ প্যারামিটার হিসাবে ব্যবহার করা যায়। সাধারণ টাইপ প্যারামিটারগুলোর সংক্ষেপে নামকরণ করা হয়:

• T → Type
• E → Element (collection-এর জন্য)
• K → Key
• V → Value
• N → Number

Bounded Type Parameters

Generics এ টাইপ প্যারামিটারকে সীমাবদ্ধ (bounded) করা যায়।

// Bounded Type Parameter Example
public <T extends Number> void addNumbers(T a, T b) {
    System.out.println(a.doubleValue() + b.doubleValue());
}

// Usage:
addNumbers(5, 10); // Valid
addNumbers(5.5, 10.5); // Valid
// addNumbers("5", "10"); // Compile-time Error

Wildcard in Generics

Wildcard (?) ব্যবহার করে বিভিন্ন টাইপের ডেটা হ্যান্ডেল করা যায়।

// Wildcard Example
public void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

// Usage:
List<Integer> intList = List.of(1, 2, 3);
List<String> stringList = List.of("A", "B", "C");
printList(intList);
printList(stringList);

Generics এর সুবিধা

1. Compile-Time টাইপ চেকিং: এটি টাইপ মিসম্যাচ সংক্রান্ত runtime errors প্রতিরোধ করে।
2. Type Casting-এর প্রয়োজন নেই: Generics ব্যবহার করলে টাইপ কাস্টিং করতে হয় না।
3. কোড পুনঃব্যবহারযোগ্য করা যায়: একই কোড বিভিন্ন ডেটা টাইপের জন্য ব্যবহার করা যায়।
4. Enhanced Readability: কোড আরও পরিষ্কার এবং পড়তে সহজ হয়।

Generics ব্যবহার সংক্রান্ত সীমাবদ্ধতা

1. Primitive ডেটা টাইপ (যেমন int, double) সরাসরি Generics এ ব্যবহার করা যায় না। তবে Wrapper ক্লাস (যেমন Integer, Double) ব্যবহার করতে হয়।
2. Generics টাইপ ইনফরমেশন runtime এ মুছে ফেলা হয় (type erasure), যার ফলে কিছু লিমিটেশন থাকে।

Generics ব্যবহার করলে কোড নিরাপদ, কার্যকর এবং রক্ষণাবেক্ষণ করা সহজ হয়।

জাভা জেনেরিক্স (Java Generics) জাভার একটি শক্তিশালী ফিচার যা টাইপ (data type) নিরাপত্তা এবং কোড পুনর্ব্যবহারযোগ্যতা বৃদ্ধি করে। এটি আমাদের এমন ক্লাস বা মেথড তৈরিতে সাহায্য করে যা একাধিক ডেটা টাইপের সাথে কাজ করতে পারে, তবে টাইপ নির্ধারণ কম্পাইল টাইমে করে।

Generics Class

Generics ক্লাস হল এমন ক্লাস যা টাইপ প্যারামিটার ব্যবহার করে। এটি একাধিক ডেটা টাইপের জন্য একটি সাধারণ টেমপ্লেট হিসাবে কাজ করে।

উদাহরণ:

// একটি জেনেরিক ক্লাস
class Box<T> {
    private T data;

    public void setData(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }
}

// মেইন ক্লাস
public class Main {
    public static void main(String[] args) {
        Box<Integer> intBox = new Box<>();
        intBox.setData(123);
        System.out.println("Integer Value: " + intBox.getData());

        Box<String> strBox = new Box<>();
        strBox.setData("Hello Generics");
        System.out.println("String Value: " + strBox.getData());
    }
}

আউটপুট:

Integer Value: 123
String Value: Hello Generics

কী শিখলাম:

• <T> একটি টাইপ প্যারামিটার। এটি যেকোনো টাইপ ধরে রাখতে পারে।
• একই কোড একাধিক টাইপের সাথে ব্যবহার করা যায়।

Generics Method

Generics মেথড হল এমন মেথড যা টাইপ প্যারামিটার ব্যবহার করে এবং নির্দিষ্ট কোনো টাইপের উপর নির্ভর করে না।

উদাহরণ:

// জেনেরিক মেথড
public class Main {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4};
        String[] strArray = {"Java", "Generics", "Example"};

        System.out.print("Integer Array: ");
        printArray(intArray);

        System.out.print("String Array: ");
        printArray(strArray);
    }
}

আউটপুট:

Integer Array: 1 2 3 4 
String Array: Java Generics Example

কী শিখলাম:

• <T> টাইপ প্যারামিটারকে মেথড লেভেলে ডিক্লেয়ার করা হয়।
• একই মেথড বিভিন্ন ডেটা টাইপের জন্য কাজ করতে পারে।

Generics এর সুবিধা:

1. টাইপ সেফটি (Type Safety): কম্পাইল টাইমে টাইপ চেক করে, ফলে রানটাইম ত্রুটি কমে।
2. কোড পুনর্ব্যবহারযোগ্যতা (Code Reusability): একই কোড বিভিন্ন ডেটা টাইপের জন্য ব্যবহার করা যায়।
3. ডাউনকাস্টিং প্রয়োজন হয় না: Generics ব্যবহার করলে এক্সপ্লিসিট ডাউনকাস্টিং করার দরকার হয় না।

Generics ক্লাস এবং মেথড জাভার টাইপ নিরাপত্তা নিশ্চিত করে এবং কোড আরও ক্লিন ও মেইনটেনেবল করে। এটি বড় এবং জটিল প্রোজেক্টে গুরুত্বপূর্ণ ভূমিকা পালন করে।

জাভা জেনেরিক্স (Java Generics) হল জাভার একটি বৈশিষ্ট্য যা ডেটা টাইপগুলির সাথে কাজ করার জন্য একটি সাধারণ কাঠামো সরবরাহ করে। এটি কম্পাইল টাইমে টাইপ চেকিং সরবরাহ করে এবং রানটাইমে টাইপকাস্টিংয়ের প্রয়োজনীয়তা দূর করে। এটি Single Type Parameter এবং Multiple Type Parameters সমর্থন করে।

১. Single Type Parameter

একটি জেনেরিক ক্লাস বা মেথডে একক টাইপ প্যারামিটার ব্যবহার করা হলে সেটি Single Type Parameter হিসেবে পরিচিত।

উদাহরণ:

// Single Type Parameter উদাহরণ
class GenericClass<T> {
    private T data;

    public GenericClass(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }
}

public class Main {
    public static void main(String[] args) {
        // Integer টাইপ ব্যবহার
        GenericClass<Integer> intObj = new GenericClass<>(10);
        System.out.println("Integer value: " + intObj.getData());

        // String টাইপ ব্যবহার
        GenericClass<String> strObj = new GenericClass<>("Hello");
        System.out.println("String value: " + strObj.getData());
    }
}

২. Multiple Type Parameters

যদি একটি জেনেরিক ক্লাস বা মেথডে একাধিক টাইপ প্যারামিটার ব্যবহৃত হয়, তখন সেটিকে Multiple Type Parameters বলা হয়।

উদাহরণ:

// Multiple Type Parameters উদাহরণ
class GenericPair<K, V> {
    private K key;
    private V value;

    public GenericPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }
}

public class Main {
    public static void main(String[] args) {
        // Integer এবং String টাইপ ব্যবহার
        GenericPair<Integer, String> pair = new GenericPair<>(1, "One");
        System.out.println("Key: " + pair.getKey());
        System.out.println("Value: " + pair.getValue());

        // String এবং Double টাইপ ব্যবহার
        GenericPair<String, Double> pair2 = new GenericPair<>("PI", 3.14);
        System.out.println("Key: " + pair2.getKey());
        System.out.println("Value: " + pair2.getValue());
    }
}

সুবিধাসমূহ:

1. Compile-Time Type Safety: জেনেরিক্স টাইপ সুরক্ষা নিশ্চিত করে, ফলে কম্পাইল টাইমেই টাইপ সংক্রান্ত ত্রুটি ধরা পড়ে।
2. Code Reusability: একই ক্লাস বা মেথড একাধিক টাইপের জন্য ব্যবহার করা যায়।
3. Type Casting এর প্রয়োজন নেই: জেনেরিক্স ব্যবহারে টাইপকাস্টিংয়ের ঝামেলা দূর হয়।

এগুলো ব্যবহার করে আপনি কোডকে আরও বেশি ফ্লেক্সিবল এবং টাইপ-নির্ভর করতে পারবেন।

জেনেরিক্স জাভার একটি শক্তিশালী বৈশিষ্ট্য যা টাইপ-সেইফ কোড লিখতে সহায়তা করে। জেনেরিক ইন্টারফেস ব্যবহার করে এমন ইন্টারফেস তৈরি করা যায় যা বিভিন্ন ধরনের ডেটার জন্য কাজ করতে পারে। এটি টাইপ কাস্টিং কমায় এবং কোডের পুনঃব্যবহারযোগ্যতা বাড়ায়।

Generic Interface সংজ্ঞা

একটি জেনেরিক ইন্টারফেস তৈরি করতে <T> ব্যবহার করা হয়, যেখানে T একটি টাইপ প্যারামিটার।

// Generic Interface Definition
public interface GenericInterface<T> {
    void display(T data);
}

এখানে:

• GenericInterface<T> হল একটি জেনেরিক ইন্টারফেস।
• T টাইপ প্যারামিটার নির্দেশ করে।

Generic Interface Implementation

জেনেরিক ইন্টারফেস বাস্তবায়নের সময়, একটি নির্দিষ্ট টাইপ সরবরাহ করা যেতে পারে।

// Implementing the Generic Interface
public class StringPrinter implements GenericInterface<String> {
    @Override
    public void display(String data) {
        System.out.println("String Data: " + data);
    }
}

public class IntegerPrinter implements GenericInterface<Integer> {
    @Override
    public void display(Integer data) {
        System.out.println("Integer Data: " + data);
    }
}

Generic Interface with Generic Implementation

একটি ক্লাস জেনেরিক ইন্টারফেস বাস্তবায়ন করার সময় নিজেও জেনেরিক হতে পারে।

// Generic Implementation
public class GenericPrinter<T> implements GenericInterface<T> {
    @Override
    public void display(T data) {
        System.out.println("Generic Data: " + data);
    }
}

উদাহরণ ব্যবহার

public class Main {
    public static void main(String[] args) {
        // Specific Type Implementation
        GenericInterface<String> stringPrinter = new StringPrinter();
        stringPrinter.display("Hello, Java Generics!");

        GenericInterface<Integer> integerPrinter = new IntegerPrinter();
        integerPrinter.display(100);

        // Generic Implementation
        GenericInterface<Double> genericPrinter = new GenericPrinter<>();
        genericPrinter.display(3.14);
    }
}

আউটপুট:

String Data: Hello, Java Generics!
Integer Data: 100
Generic Data: 3.14

Generic Interfaces এর সুবিধা:

1. টাইপ সেফটি: টাইপ মিসম্যাচ প্রতিরোধ করে।
2. কোড পুনঃব্যবহারযোগ্যতা: একাধিক টাইপের জন্য একই কোড ব্যবহার করা যায়।
3. কোড পরিষ্কার এবং রিডেবল: টাইপ কাস্টিং এড়ানো যায়।

জেনেরিক ইন্টারফেস জাভায় ফ্লেক্সিবিলিটি এবং টাইপ-সেফ কোডের জন্য অপরিহার্য। এটি বড় আকারের প্রজেক্টে কোডের রিডেবলিটি এবং মেনটেনেন্স সহজ করে।