Object-Oriented Programming in Lua (অবজেক্ট ওরিয়েন্টেড প্রোগ্রামিং)

লুয়া (Lua) একটি স্ক্রিপ্টিং ভাষা যা মূলত ফাংশনাল ও প্রেডিক্টিভ পারডিগমে কাজ করলেও, আপনি এতে অবজেক্ট ওরিয়েন্টেড প্রোগ্রামিং (OOP) ধারণা প্রয়োগ করতে পারেন। লুয়া ভাষা সোজাসুজি অবজেক্ট ওরিয়েন্টেড স্টাইল সমর্থন না করলেও, টেবিল (tables), মেটাটেবিল (metatables), এবং মেটামেথড (metamethods) ব্যবহার করে আপনি অবজেক্ট তৈরি এবং তাদের আচরণ কাস্টমাইজ করতে পারবেন।

এই টিউটোরিয়ালে আমরা দেখব কিভাবে লুয়া ভাষায় অবজেক্ট ওরিয়েন্টেড প্রোগ্রামিং (OOP) কনসেপ্ট বাস্তবায়ন করা যায়।

১. অবজেক্ট তৈরি (Creating an Object)

লুয়া ভাষায় অবজেক্ট সাধারণত একটি টেবিল (table) হিসেবে তৈরি করা হয়। আপনি টেবিলের মাধ্যমে অবজেক্টের প্রপার্টি এবং ফাংশন (methods) তৈরি করতে পারেন।

উদাহরণ:

Person = {}  -- অবজেক্টের টেমপ্লেট

-- কনস্ট্রাক্টর ফাংশন
function Person:new(name, age)
    local obj = {name = name, age = age}  -- অবজেক্টের প্রপার্টি
    setmetatable(obj, self)  -- মেটাটেবিল সেট করা
    self.__index = self  -- মেটাটেবিলের ইনডেক্স পয়েন্টিং
    return obj
end

-- একটি নতুন অবজেক্ট তৈরি
local person1 = Person:new("Alice", 30)
print(person1.name)  -- আউটপুট: Alice
print(person1.age)   -- আউটপুট: 30

এখানে, Person হলো একটি টেমপ্লেট, যার মধ্যে name এবং age প্রপার্টি আছে। Person:new ফাংশনটি একটি কনস্ট্রাক্টর হিসেবে কাজ করছে এবং setmetatable দিয়ে এটি মেটাটেবিল সেট করা হয়েছে, যাতে OOP সিস্টেমের মতো আচরণ করে।

২. মেথড (Methods)

অবজেক্টে ফাংশনগুলোকে মেথড বলা হয়। আপনি টেবিলের মধ্যে ফাংশন রেখে তা অবজেক্টের মেথড হিসেবে ব্যবহার করতে পারেন।

উদাহরণ:

Person = {}

function Person:new(name, age)
    local obj = {name = name, age = age}
    setmetatable(obj, self)
    self.__index = self
    return obj
end

function Person:speak()
    print("Hello, my name is " .. self.name .. " and I am " .. self.age .. " years old.")
end

local person1 = Person:new("Alice", 30)
person1:speak()  -- আউটপুট: Hello, my name is Alice and I am 30 years old.

এখানে, speak একটি মেথড যা Person অবজেক্টের name এবং age প্রপার্টি ব্যবহার করে আউটপুট দেয়।

৩. ইনহেরিট্যান্স (Inheritance)

লুয়া ভাষায় ইনহেরিট্যান্স বাস্তবায়ন করতে মেটাটেবিল ব্যবহার করা হয়। একটি অবজেক্টের ফিচার বা মেথড অন্য একটি অবজেক্টে উত্তরাধিকারসূত্রে পাওয়া যায়।

উদাহরণ:

Person = {}

function Person:new(name, age)
    local obj = {name = name, age = age}
    setmetatable(obj, self)
    self.__index = self
    return obj
end

function Person:speak()
    print("Hello, my name is " .. self.name)
end

-- ইনহেরিটেন্স
Employee = Person:new()  -- Person থেকে Employee ক্লাস তৈরি করা

function Employee:new(name, age, position)
    local obj = Person.new(self, name, age)  -- Person ক্লাসের কনস্ট্রাক্টর কল
    obj.position = position
    return obj
end

function Employee:work()
    print(self.name .. " is working as " .. self.position)
end

local emp1 = Employee:new("Bob", 25, "Software Engineer")
emp1:speak()  -- আউটপুট: Hello, my name is Bob
emp1:work()   -- আউটপুট: Bob is working as Software Engineer

এখানে, Employee অবজেক্টটি Person থেকে ইনহেরিট করেছে। Employee:new ফাংশন Person.new কনস্ট্রাক্টর ব্যবহার করে অভ্যন্তরীণভাবে Person ক্লাসের প্রপার্টি গ্রহণ করে এবং অতিরিক্ত প্রপার্টি position যোগ করে।

৪. পলিমরফিজম (Polymorphism)

লুয়া ভাষায় পলিমরফিজম অর্জন করা যায় বিভিন্ন ফাংশন ও মেথডের মাধ্যমে, যেখানে একাধিক ক্লাসের মধ্যে একই নামের ফাংশন ব্যবহার করা হয়, তবে তাদের কার্যকারিতা আলাদা হতে পারে।

উদাহরণ:

Person = {}

function Person:new(name, age)
    local obj = {name = name, age = age}
    setmetatable(obj, self)
    self.__index = self
    return obj
end

function Person:speak()
    print("Hello, my name is " .. self.name)
end

Employee = Person:new()

function Employee:speak()
    print("Hello, I am " .. self.name .. " and I work here!")
end

local person1 = Person:new("Alice", 30)
local emp1 = Employee:new("Bob", 25)

person1:speak()  -- আউটপুট: Hello, my name is Alice
emp1:speak()     -- আউটপুট: Hello, I am Bob and I work here!

এখানে, Person এবং Employee ক্লাসে একই speak মেথড রয়েছে, তবে তাদের কার্যকারিতা আলাদা। এটি পলিমরফিজমের উদাহরণ, যেখানে একাধিক ক্লাসে একই নামের মেথড হলেও তাদের আচরণ আলাদা।

৫. অবজেক্ট ধ্বংস (Object Destruction)

লুয়া ভাষায় অবজেক্ট ধ্বংস করতে __gc মেটামেথড ব্যবহার করা হয়। এটি একটি গারবেজ কালেকশন মেথড, যা অবজেক্টের অবস্থা শেষ হওয়ার পর কল করা হয়।

উদাহরণ:

Person = {}

function Person:new(name, age)
    local obj = {name = name, age = age}
    setmetatable(obj, self)
    self.__index = self
    return obj
end

function Person:destroy()
    print(self.name .. " is being destroyed.")
end

-- গারবেজ কালেকশন
Person.__gc = function(obj)
    obj:destroy()
end

local person1 = Person:new("Alice", 30)
person1 = nil  -- অবজেক্টটি ধ্বংস করা হবে
collectgarbage()  -- গারবেজ কালেকশন কল করা

এখানে, Person ক্লাসের মধ্যে একটি __gc মেটামেথড ব্যবহার করা হয়েছে যা অবজেক্ট ধ্বংসের পর কল হয়।

সারসংক্ষেপ

লুয়া ভাষায় অবজেক্ট ওরিয়েন্টেড প্রোগ্রামিং (OOP) কনসেপ্ট বাস্তবায়ন করা সম্ভব এবং এর জন্য টেবিল, মেটাটেবিল, মেটামেথড ব্যবহার করা হয়। অবজেক্ট তৈরি করতে টেবিল ব্যবহার করা হয় এবং ইনহেরিট্যান্স, পলিমরফিজম, মেথডস সহ একাধিক OOP কনসেপ্ট বাস্তবায়ন করা সম্ভব। এই ফিচারগুলো ব্যবহার করে আপনি লুয়া ভাষায় কার্যকরী এবং নমনীয় কোড লিখতে পারবেন।

লুয়া (Lua) ভাষা প্রাথমিকভাবে একটি স্ক্রিপ্টিং ভাষা হলেও এটি অবজেক্ট-ওরিয়েন্টেড প্রোগ্রামিং (OOP) ধারণা সমর্থন করে। যদিও লুয়া ভাষায় বিল্ট-ইন ক্লাস এবং অবজেক্ট ব্যবস্থা নেই, তবুও টেবিল (tables) এবং মেটাটেবিল (metatables) ব্যবহার করে আপনি OOP কনসেপ্ট বাস্তবায়ন করতে পারেন। এটি লুয়া ভাষার নমনীয়তা এবং শক্তি প্রমাণ করে, যেখানে আপনি নিজের মতো কোডের কাঠামো তৈরি করতে পারেন।

OOP এর মাধ্যমে কোডের পুনঃব্যবহারযোগ্যতা, ডেটা এনক্যাপসুলেশন, এবং ইনহেরিট্যান্সের সুবিধা পাওয়া যায়। এই টিউটোরিয়ালে আমরা লুয়া ভাষায় OOP ধারণা এবং তার প্রয়োগ নিয়ে আলোচনা করব।

১. OOP এর মৌলিক ধারণা

OOP এর প্রধান চারটি বৈশিষ্ট্য:

1. এনক্যাপসুলেশন (Encapsulation): ডেটা এবং কার্যাবলী একত্রিত করে একক ইউনিট তৈরি করা।
2. ইনহেরিট্যান্স (Inheritance): একটি অবজেক্ট অন্য অবজেক্ট থেকে বৈশিষ্ট্য এবং আচরণ ধারণ করে।
3. পলিমরফিজম (Polymorphism): একই নামের ফাংশন বিভিন্ন ধরনের আর্গুমেন্ট নিয়ে কাজ করতে পারে।
4. এবস্ট্র্যাকশন (Abstraction): জটিলতা লুকিয়ে রেখে সিস্টেমের সহজ ইন্টারফেস প্রদান করা।

লুয়া ভাষায় OOP কনসেপ্টগুলো মেটাটেবিল ও টেবিলের মাধ্যমে বাস্তবায়ন করা হয়।

২. এনক্যাপসুলেশন (Encapsulation) - অবজেক্ট তৈরি করা

লুয়া ভাষায় আপনি টেবিল ব্যবহার করে অবজেক্ট তৈরি করতে পারেন। টেবিলটি অবজেক্টের প্রপার্টি এবং মেথড ধারণ করে।

উদাহরণ:

-- Class definition: Person
Person = {}
Person.__index = Person

-- Constructor
function Person.new(name, age)
    local self = setmetatable({}, Person)  -- Create a new instance
    self.name = name
    self.age = age
    return self
end

-- Method: greet
function Person:greet()
    print("Hello, my name is " .. self.name .. " and I am " .. self.age .. " years old.")
end

-- Create an object (instance of Person)
local john = Person.new("John", 25)
john:greet()  -- Output: Hello, my name is John and I am 25 years old.

এখানে:

• Person একটি ক্লাস (অবজেক্টের রূপরেখা) হিসেবে কাজ করছে।
• Person.new() একটি কনস্ট্রাক্টর ফাংশন, যা একটি নতুন অবজেক্ট তৈরি করে।
• greet() একটি মেথড, যা অবজেক্টের তথ্য ব্যবহার করে আউটপুট প্রদান করে।

৩. ইনহেরিট্যান্স (Inheritance) - বৈশিষ্ট্য উত্তরাধিকার

লুয়া ভাষায় ইনহেরিট্যান্স অর্জন করতে মেটাটেবিল ব্যবহার করা হয়। আপনি একটি ক্লাস থেকে আরেকটি ক্লাসের বৈশিষ্ট্য (প্রপার্টি ও মেথড) উত্তরাধিকার নিতে পারেন।

উদাহরণ:

-- Parent class: Person
Person = {}
Person.__index = Person

function Person.new(name, age)
    local self = setmetatable({}, Person)
    self.name = name
    self.age = age
    return self
end

function Person:greet()
    print("Hello, my name is " .. self.name .. " and I am " .. self.age .. " years old.")
end

-- Child class: Employee (inherits from Person)
Employee = setmetatable({}, Person)  -- Employee inherits Person

function Employee.new(name, age, position)
    local self = Person.new(name, age)  -- call Person constructor
    setmetatable(self, Employee)  -- Set the metatable to Employee
    self.position = position
    return self
end

function Employee:greet()
    Person.greet(self)  -- call Person's greet method
    print("I work as a " .. self.position)
end

-- Create an object of Employee
local jane = Employee.new("Jane", 30, "Engineer")
jane:greet()  -- Output: Hello, my name is Jane and I am 30 years old. I work as a Engineer.

এখানে:

• Employee ক্লাসটি Person ক্লাস থেকে ইনহেরিট করেছে।
• Employee ক্লাসে নতুন একটি মেথড greet যুক্ত করা হয়েছে, যা Person ক্লাসের greet মেথডকে কল করে এবং অতিরিক্ত তথ্য প্রদর্শন করে।

৪. পলিমরফিজম (Polymorphism) - একাধিক রূপের ফাংশন

লুয়া ভাষায় পলিমরফিজম অর্জন করা যায় একাধিক মেথডের মাধ্যমে, যেখানে একই নামের মেথড বিভিন্ন ধরনের আর্গুমেন্ট নিয়ে কাজ করতে পারে।

উদাহরণ:

-- Parent class: Animal
Animal = {}
Animal.__index = Animal

function Animal.new(name)
    local self = setmetatable({}, Animal)
    self.name = name
    return self
end

function Animal:speak()
    print(self.name .. " makes a sound")
end

-- Child class: Dog
Dog = setmetatable({}, Animal)

function Dog.new(name)
    local self = Animal.new(name)
    setmetatable(self, Dog)
    return self
end

function Dog:speak()
    print(self.name .. " barks")
end

-- Child class: Cat
Cat = setmetatable({}, Animal)

function Cat.new(name)
    local self = Animal.new(name)
    setmetatable(self, Cat)
    return self
end

function Cat:speak()
    print(self.name .. " meows")
end

-- Create objects of Dog and Cat
local dog = Dog.new("Rex")
local cat = Cat.new("Whiskers")

-- Demonstrate Polymorphism
dog:speak()  -- Output: Rex barks
cat:speak()  -- Output: Whiskers meows

এখানে, speak মেথডটি Dog এবং Cat ক্লাসে আলাদা আচরণ প্রদর্শন করে, যা পলিমরফিজমের উদাহরণ।

৫. অ্যাবস্ট্র্যাকশন (Abstraction) - জটিলতা লুকানো

অ্যাবস্ট্র্যাকশন হল কোডের জটিলতা লুকিয়ে রাখা এবং সহজভাবে ব্যবহারের জন্য একটি পরিষ্কার ইন্টারফেস প্রদান করা। লুয়া ভাষায় এটি মেটাটেবিল এবং মেথড ব্যবহার করে করা হয়।

উদাহরণ:

-- Class: BankAccount
BankAccount = {}
BankAccount.__index = BankAccount

function BankAccount.new(owner, balance)
    local self = setmetatable({}, BankAccount)
    self.owner = owner
    self.balance = balance
    return self
end

function BankAccount:getBalance()
    return self.balance
end

function BankAccount:deposit(amount)
    self.balance = self.balance + amount
end

function BankAccount:withdraw(amount)
    if amount <= self.balance then
        self.balance = self.balance - amount
    else
        print("Insufficient funds!")
    end
end

-- Create a BankAccount object
local account = BankAccount.new("Alice", 1000)
account:deposit(500)
print("Balance: " .. account:getBalance())  -- Output: Balance: 1500
account:withdraw(2000)  -- Output: Insufficient funds!

এখানে, BankAccount ক্লাসটি ব্যাঙ্ক অ্যাকাউন্ট পরিচালনার জন্য কাস্টম মেথডগুলো প্রদান করে, যেখানে তার ভেতরের ডেটা সঠিকভাবে পরিচালিত হয় এবং বাইরে থেকে শুধু প্রয়োজনীয় ফাংশনগুলোর মাধ্যমে অ্যাক্সেস করা হয়।

সারসংক্ষেপ

লুয়া ভাষায় অবজেক্ট-ওরিয়েন্টেড প্রোগ্রামিং (OOP) একটি শক্তিশালী এবং নমনীয় কনসেপ্ট, যা এনক্যাপসুলেশন, ইনহেরিট্যান্স, পলিমরফিজম, এবং অ্যাবস্ট্র্যাকশন এর মতো গুরুত্বপূর্ণ বৈশিষ্ট্যগুলিকে বাস্তবায়ন করার জন্য টেবিল এবং মেটাটেবিল ব্যবহার করে। এর মাধ্যমে কোড আরও পুনঃব্যবহারযোগ্য, পরিষ্কার এবং পরিচালনাযোগ্য হয়।

• এনক্যাপসুলেশন: টেবিল ব্যবহার করে ডেটা এবং কার্যাবলী একত্রিত করা।
• ইনহেরিট্যান্স: মেটাটেবিল ব্যবহার করে এক ক্লাস থেকে আরেক ক্লাসের বৈশিষ্ট্য উত্তরাধিকার করা।
• **পলিমরফিজম

**: একাধিক ক্লাসে একই নামের মেথডের ভিন্ন আচরণ প্রদান।

• অ্যাবস্ট্র্যাকশন: কোডের জটিলতা লুকিয়ে রাখা এবং সঠিক ইন্টারফেস প্রদান করা।

এই ধারণাগুলো লুয়া ভাষায় OOP প্রোগ্রামিংকে সহজ, মডুলার এবং শক্তিশালী করে তোলে।

লুয়া (Lua) ভাষা একটি ডাইনামিক এবং নমনীয় ভাষা, যেখানে কোনো বিল্ট-ইন ক্লাস বা অবজেক্ট ধারণা নেই। তবে, আপনি মেটাটেবিল (metatables) এবং টেবিল ব্যবহার করে নিজস্ব ক্লাস এবং অবজেক্ট তৈরি করতে পারেন। ক্লাস এবং অবজেক্ট তৈরি করতে লুয়া টেবিলের পদ্ধতি ব্যবহার করা হয়, এবং মেটামেথডসের মাধ্যমে তাদের আচরণ কাস্টমাইজ করা হয়।

এই টিউটোরিয়ালে আমরা লুয়া ভাষায় ক্লাস এবং অবজেক্ট তৈরি করার পদ্ধতি দেখব।

১. ক্লাস তৈরি করা

লুয়া ভাষায় ক্লাস তৈরি করতে সাধারণত একটি টেবিল ব্যবহার করা হয়। টেবিলকে মেটাটেবিলের সাথে অ্যাসোসিয়েট করা হয়, যা ক্লাসের ফাংশনগুলো সংরক্ষণ করে।

উদাহরণ: একটি সাধারণ Person ক্লাস তৈরি করা

Person = {}
Person.__index = Person  -- ক্লাসের জন্য __index সেট করা

-- Constructor ফাংশন
function Person.new(name, age)
    local self = setmetatable({}, Person)  -- নতুন অবজেক্ট তৈরি এবং মেটাটেবিল অ্যাসোসিয়েট করা
    self.name = name
    self.age = age
    return self
end

-- Method: greet
function Person:greet()
    print("Hello, my name is " .. self.name .. " and I am " .. self.age .. " years old.")
end

এখানে:

• Person টেবিলটি ক্লাস হিসেবে ব্যবহৃত হচ্ছে।
• Person.new ফাংশনটি কনস্ট্রাকটর হিসেবে কাজ করছে, যা নতুন অবজেক্ট তৈরি করে এবং মেটাটেবিল অ্যাসোসিয়েট করে।
• Person:greet একটি মেথড যা অবজেক্টের বৈশিষ্ট্য ব্যবহার করে একটি মেসেজ প্রিন্ট করে।

২. অবজেক্ট তৈরি করা

ক্লাস তৈরি করার পর, আপনি Person.new ফাংশন ব্যবহার করে ক্লাসের অবজেক্ট তৈরি করতে পারেন।

উদাহরণ: Person ক্লাসের অবজেক্ট তৈরি এবং ব্যবহার

-- একটি Person অবজেক্ট তৈরি
local person1 = Person.new("John", 30)

-- অবজেক্টের মেথড কল করা
person1:greet()  -- আউটপুট: Hello, my name is John and I am 30 years old.

এখানে, person1 একটি অবজেক্ট যা Person ক্লাসের একটি উদাহরণ। এরপর person1:greet() মেথড কল করা হয়েছে, যা ওই অবজেক্টের তথ্য দেখাবে।

৩. একাধিক অবজেক্ট তৈরি করা

একাধিক অবজেক্ট তৈরি করার জন্য আপনি Person.new ফাংশনটি একাধিক বার কল করতে পারেন এবং প্রতিটি অবজেক্টের জন্য আলাদা বৈশিষ্ট্য প্রদান করতে পারেন।

উদাহরণ: একাধিক অবজেক্ট তৈরি

local person2 = Person.new("Alice", 25)
local person3 = Person.new("Bob", 40)

-- অবজেক্টের মেথড কল করা
person2:greet()  -- আউটপুট: Hello, my name is Alice and I am 25 years old.
person3:greet()  -- আউটপুট: Hello, my name is Bob and I am 40 years old.

এখানে, দুটি নতুন অবজেক্ট person2 এবং person3 তৈরি করা হয়েছে, এবং তাদের পৃথক greet মেথড কল করা হয়েছে।

৪. ইনহেরিট্যান্স (Inheritance)

লুয়া ভাষায় ইনহেরিট্যান্স (Inheritance) বাস্তবায়ন করা যেতে পারে মেটাটেবিল ব্যবহার করে, যা একটি ক্লাসকে আরেকটি ক্লাসের বৈশিষ্ট্য দিতে সহায়তা করে।

উদাহরণ: Employee ক্লাস তৈরি এবং ইনহেরিট করা

-- Base class: Person
Person = {}
Person.__index = Person

function Person.new(name, age)
    local self = setmetatable({}, Person)
    self.name = name
    self.age = age
    return self
end

function Person:greet()
    print("Hello, my name is " .. self.name .. " and I am " .. self.age .. " years old.")
end

-- Derived class: Employee (inherits from Person)
Employee = setmetatable({}, Person)  -- Employee inherits Person

function Employee.new(name, age, job)
    local self = Person.new(name, age)  -- Calling the constructor of Person
    setmetatable(self, Employee)
    self.job = job
    return self
end

function Employee:work()
    print(self.name .. " is working as a " .. self.job)
end

এখানে:

• Employee ক্লাসটি Person ক্লাস থেকে ইনহেরিট করেছে।
• Employee.new ফাংশনটি Person.new ফাংশনটি কল করে এবং অতিরিক্ত job বৈশিষ্ট্য যোগ করে।

উদাহরণ: ইনহেরিট্যান্স ব্যবহার

local employee1 = Employee.new("Alice", 28, "Engineer")

employee1:greet()  -- আউটপুট: Hello, my name is Alice and I am 28 years old.
employee1:work()   -- আউটপুট: Alice is working as a Engineer

এখানে, employee1 অবজেক্টটি Employee ক্লাসের একটি উদাহরণ এবং এটি Person ক্লাসের greet মেথড এবং Employee ক্লাসের work মেথড ব্যবহার করছে।

সারসংক্ষেপ

লুয়া ভাষায় ক্লাস এবং অবজেক্ট তৈরি করতে টেবিল এবং মেটাটেবিল ব্যবহার করা হয়:

• ক্লাস একটি টেবিল হিসাবে তৈরি করা হয়, যেখানে কনস্ট্রাকটর এবং মেথড থাকে।
• অবজেক্ট তৈরি করার জন্য new ফাংশন ব্যবহার করা হয়, যা টেবিলের মেটাটেবিলের সাথে অ্যাসোসিয়েট থাকে।
• ইনহেরিট্যান্স মেটাটেবিলের মাধ্যমে একটি ক্লাসকে অন্য ক্লাসের বৈশিষ্ট্য দেওয়া যায়।

এটি লুয়া ভাষায় অবজেক্ট-ওরিয়েন্টেড প্রোগ্রামিং (OOP) পদ্ধতি ব্যবহার করতে সাহায্য করে।

লুয়া (Lua) একটি অবজেক্ট-ওরিয়েন্টেড প্রোগ্রামিং ভাষা নয়, তবে এটি মেটামেথডস এবং মেটাটেবিলের সাহায্যে অবজেক্ট-ওরিয়েন্টেড ধারণা, যেমন ইনহেরিট্যান্স এবং পলিমরফিজম, বাস্তবায়ন করতে সক্ষম। এখানে, আমরা লুয়া ভাষায় ইনহেরিট্যান্স এবং পলিমরফিজম কিভাবে কাজ করে এবং কিভাবে এগুলির বাস্তবায়ন করা যায় তা আলোচনা করব।

১. ইনহেরিট্যান্স (Inheritance)

ইনহেরিট্যান্স হল একটি অবজেক্ট-ওরিয়েন্টেড প্রোগ্রামিং কৌশল যা একটি ক্লাস বা অবজেক্টের গুণাবলী অন্য ক্লাস বা অবজেক্টের মধ্যে উত্তরাধিকার সূত্রে প্রদান করে। লুয়া ভাষায়, মেটামেথডস এবং মেটাটেবিল ব্যবহার করে ইনহেরিট্যান্স কাস্টম ডেটা টাইপের মধ্যে বাস্তবায়িত করা যায়।

উদাহরণ: ইনহেরিট্যান্স বাস্তবায়ন

ধরা যাক, আপনি দুটি অবজেক্ট Animal এবং Dog তৈরি করতে চান যেখানে Dog অবজেক্টটি Animal অবজেক্ট থেকে বৈশিষ্ট্যগুলি উত্তরাধিকারসূত্রে গ্রহণ করবে।

-- Animal ক্লাস
Animal = {}
Animal.__index = Animal

function Animal.new(name)
    local self = setmetatable({}, Animal)
    self.name = name
    return self
end

function Animal:speak()
    print(self.name .. " makes a sound")
end

-- Dog ক্লাস, Animal থেকে ইনহেরিট করা
Dog = setmetatable({}, Animal)  -- Dog ক্লাসকে Animal মেটাটেবিল থেকে ইনহেরিট করা
Dog.__index = Dog

function Dog.new(name)
    local self = setmetatable(Animal.new(name), Dog)  -- Animal.new() ফাংশন ব্যবহার করা
    return self
end

function Dog:speak()
    print(self.name .. " barks")  -- Dog এর speak ফাংশন কাস্টমাইজড
end

-- অবজেক্ট তৈরি করা
local myDog = Dog.new("Buddy")
myDog:speak()  -- আউটপুট: Buddy barks

local myAnimal = Animal.new("Animal")
myAnimal:speak()  -- আউটপুট: Animal makes a sound

এখানে:

• Animal হল মূল ক্লাস এবং Dog হল একটি সাবক্লাস যা Animal থেকে ইনহেরিট করেছে।
• Dog ক্লাসে Animal.new(name) মেথড কল করা হয়েছে যা Dog অবজেক্টকে ইনিশিয়ালাইজ করে।
• Dog:speak() মেথডটি Dog ক্লাসের জন্য কাস্টমাইজড হয়েছে, যা মূল Animal:speak() মেথডের ওপর পলিমরফিক আচরণ প্রদর্শন করে।

২. পলিমরফিজম (Polymorphism)

পলিমরফিজম হল একটি ধারণা যার মাধ্যমে একটি ফাংশন বা মেথড বিভিন্ন ধরনের অবজেক্টে ভিন্নভাবে কাজ করতে পারে। লুয়া ভাষায় পলিমরফিজম মেটামেথডস এবং ইনহেরিট্যান্সের মাধ্যমে সহজে বাস্তবায়ন করা যায়।

উদাহরণ: পলিমরফিজম বাস্তবায়ন

লুয়া ভাষায় পলিমরফিজম সাধারণত একই নামের মেথড বিভিন্ন অবজেক্টে বিভিন্ন কার্যকলাপ করতে ব্যবহৃত হয়। উদাহরণস্বরূপ, speak() মেথড দুটি ভিন্ন ক্লাসে আলাদা আলাদা কার্যকলাপ করতে পারে।

-- Animal ক্লাস
Animal = {}
Animal.__index = Animal

function Animal.new(name)
    local self = setmetatable({}, Animal)
    self.name = name
    return self
end

function Animal:speak()
    print(self.name .. " makes a sound")
end

-- Dog ক্লাস, Animal থেকে ইনহেরিট করা
Dog = setmetatable({}, Animal)
Dog.__index = Dog

function Dog.new(name)
    local self = setmetatable(Animal.new(name), Dog)
    return self
end

function Dog:speak()
    print(self.name .. " barks")
end

-- Cat ক্লাস, Animal থেকে ইনহেরিট করা
Cat = setmetatable({}, Animal)
Cat.__index = Cat

function Cat.new(name)
    local self = setmetatable(Animal.new(name), Cat)
    return self
end

function Cat:speak()
    print(self.name .. " meows")
end

-- পলিমরফিজম: একই ফাংশন নাম 'speak' আলাদা আলাদা অবজেক্টে আলাদা কাজ করছে
local myDog = Dog.new("Buddy")
local myCat = Cat.new("Whiskers")

myDog:speak()  -- আউটপুট: Buddy barks
myCat:speak()  -- আউটপুট: Whiskers meows

এখানে, speak() মেথডটি Dog এবং Cat ক্লাসে আলাদা আলাদা আচরণ করছে। এটি পলিমরফিজম কারণ একই নামের ফাংশন ভিন্ন ভিন্ন ক্লাসে আলাদা আচরণ করে। এই প্রক্রিয়াটি সাধারণত ইনহেরিট্যান্সের সাথে মিলিত হয়ে কাজ করে।

৩. মেটামেথডস এবং পলিমরফিজম

পলিমরফিজমকে আরও শক্তিশালী এবং নমনীয় করতে মেটামেথডস ব্যবহার করা যেতে পারে। উদাহরণস্বরূপ, লুয়া টেবিলের মাধ্যমে আপনি __add, __mul ইত্যাদি অপারেটরগুলো কাস্টমাইজ করে পলিমরফিক আচরণ বাস্তবায়ন করতে পারেন।

-- Vector ক্লাস
Vector = {}
Vector.__index = Vector

function Vector.new(x, y)
    local self = setmetatable({}, Vector)
    self.x = x
    self.y = y
    return self
end

function Vector.__add(v1, v2)
    return Vector.new(v1.x + v2.x, v1.y + v2.y)
end

-- পলিমরফিজম: দুইটি ভেক্টরের যোগফল করা
v1 = Vector.new(1, 2)
v2 = Vector.new(3, 4)
v3 = v1 + v2  -- __add মেটামেথড কল হবে

print(v3.x, v3.y)  -- আউটপুট: 4 6

এখানে, Vector ক্লাসে __add মেটামেথড ব্যবহার করে + অপারেটর কাস্টমাইজ করা হয়েছে, যা দুটি ভেক্টরের যোগফল বের করবে।

সারসংক্ষেপ

• ইনহেরিট্যান্স: লুয়া ভাষায় মেটামেথডস এবং মেটাটেবিল ব্যবহার করে ক্লাসের মধ্যে ইনহেরিট্যান্স বাস্তবায়ন করা হয়।
• পলিমরফিজম: একই নামের মেথড বা অপারেটর বিভিন্ন ক্লাসে ভিন্নভাবে কাজ করতে পারে, যা ইনহেরিট্যান্সের মাধ্যমে সহজে সম্ভব।
• মেটামেথডস: লুয়া ভাষায় অপারেটর ওভারলোডিং এবং পলিমরফিজম কাস্টমাইজ করার জন্য মেটামেথডস ব্যবহার করা হয়।

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

লুয়া ভাষায় Metatables ব্যবহার করে আপনি অবজেক্ট-ওরিয়েন্টেড প্রোগ্রামিং (OOP) ধারণাগুলো ইমপ্লিমেন্ট করতে পারেন, যেমন ক্লাস, ইনহেরিটেন্স, পলিমরফিজম এবং ইনক্যাপসুলেশন। লুয়া একটি প্রোটোটাইপাল ভাষা, তাই এটি সরাসরি ক্লাস এবং অবজেক্ট সমর্থন করে না, তবে Metatables ব্যবহার করে আপনি এই ধারণাগুলো সিমুলেট করতে পারেন।

এখানে, Metatables এর মাধ্যমে একটি সাধারণ Object-Oriented Design তৈরি করার প্রক্রিয়া আলোচনা করা হবে।

১. OOP এর মূল ধারণা এবং Metatables

Metatables:

• Metatables হল বিশেষ টেবিল যা অন্য টেবিলের ওপর অতিরিক্ত আচরণ নির্ধারণ করে।
• আপনি মেটাটেবিলের মাধ্যমে একটি টেবিলকে ক্লাস হিসেবে ব্যবহার করতে পারেন, এবং সেখানে মেথড (functions) যুক্ত করতে পারেন।

OOP এর মূল কনসেপ্ট:

• ক্লাস (Class): একটি টেমপ্লেট বা ব্লুপ্রিন্ট যা অবজেক্ট তৈরি করতে ব্যবহৃত হয়।
• অবজেক্ট (Object): একটি কনক্রিট ইনস্ট্যান্স যা ক্লাসের মধ্যে সংজ্ঞায়িত বৈশিষ্ট্য এবং মেথড ধারণ করে।
• ইনহেরিটেন্স (Inheritance): একটি ক্লাস অন্য ক্লাসের বৈশিষ্ট্য এবং মেথড উত্তরাধিকারসূত্রে পায়।
• পলিমরফিজম (Polymorphism): একাধিক অবজেক্ট একই নামের মেথডের ভিন্ন ভিন্ন বাস্তবায়ন প্রদান করে।
• ইনক্যাপসুলেশন (Encapsulation): তথ্য এবং ফাংশনকে একটি অবজেক্টের মধ্যে আবদ্ধ করা।

২. ক্লাস এবং অবজেক্ট তৈরি করা

লুয়া ভাষায় Metatables ব্যবহার করে একটি ক্লাস তৈরি করা এবং তার ওপর মেথড প্রয়োগ করা হয়।

উদাহরণ:

-- Person ক্লাস তৈরি
Person = {}
Person.__index = Person

-- Person এর কনস্ট্রাকটর (new)
function Person.new(name, age)
    local self = setmetatable({}, Person)  -- মেটাটেবিল সেট করা
    self.name = name
    self.age = age
    return self
end

-- Person এর একটি method (greet)
function Person:greet()
    print("Hello, my name is " .. self.name .. " and I am " .. self.age .. " years old.")
end

-- Person ক্লাসের একটি ইনস্ট্যান্স তৈরি
local person1 = Person.new("Alice", 30)
person1:greet()  -- আউটপুট: Hello, my name is Alice and I am 30 years old.

এখানে, Person একটি ক্লাস হিসেবে কাজ করছে। Person.new ফাংশনটি নতুন অবজেক্ট তৈরি করে এবং Person:greet মেথডটি সেই অবজেক্টের মধ্যে থাকা তথ্য প্রিন্ট করে।

৩. Inheriting from Another Class (Inheritance)

লুয়া ভাষায় Inheritance সিমুলেট করতে, একটি ক্লাসের Metatable আরেকটি ক্লাসের Metatable হিসেবে সেট করা হয়। এই পদ্ধতিতে, একটি ক্লাস তার প্যারেন্ট ক্লাস থেকে বৈশিষ্ট্য এবং মেথড উত্তরাধিকারসূত্রে পায়।

উদাহরণ: Inheritance

-- Person ক্লাস
Person = {}
Person.__index = Person

function Person.new(name, age)
    local self = setmetatable({}, Person)
    self.name = name
    self.age = age
    return self
end

function Person:greet()
    print("Hello, my name is " .. self.name .. " and I am " .. self.age .. " years old.")
end

-- Student ক্লাস (Person থেকে ইনহেরিট)
Student = setmetatable({}, Person)  -- Student ক্লাস Person থেকে ইনহেরিট হচ্ছে
Student.__index = Student

function Student.new(name, age, school)
    local self = Person.new(name, age)  -- Person ক্লাসের constructor কল করা হচ্ছে
    setmetatable(self, Student)  -- Student ক্লাসের metatable সেট করা
    self.school = school
    return self
end

function Student:greet()
    Person.greet(self)  -- Person এর greet মেথড কল করা
    print("I study at " .. self.school)
end

-- ইনস্ট্যান্স তৈরি করা
local student1 = Student.new("Bob", 22, "XYZ University")
student1:greet()  -- আউটপুট: Hello, my name is Bob and I am 22 years old. I study at XYZ University

ব্যাখ্যা:

• Student ক্লাসটি Person ক্লাস থেকে ইনহেরিট করেছে। এটি Person এর মেথড greet ব্যবহার করছে, এবং তার পর Student এর নিজস্ব greet মেথডটি প্রকাশ করছে, যেখানে স্কুলের নামও যুক্ত করা হয়েছে।

৪. Polymorphism (পলিমরফিজম)

লুয়া ভাষায় Polymorphism সিমুলেট করার জন্য, আপনি একাধিক ক্লাসে একই নামের মেথড ব্যবহার করতে পারেন, তবে তাদের আচরণ ভিন্ন হবে।

উদাহরণ: Polymorphism

-- Person ক্লাস
Person = {}
Person.__index = Person

function Person.new(name)
    local self = setmetatable({}, Person)
    self.name = name
    return self
end

function Person:speak()
    print(self.name .. " is speaking.")
end

-- Student ক্লাস (Person থেকে ইনহেরিট)
Student = setmetatable({}, Person)
Student.__index = Student

function Student.new(name, school)
    local self = Person.new(name)
    setmetatable(self, Student)
    self.school = school
    return self
end

function Student:speak()
    print(self.name .. " is studying at " .. self.school)
end

-- অবজেক্ট তৈরি করা
local person1 = Person.new("Alice")
local student1 = Student.new("Bob", "XYZ University")

person1:speak()  -- আউটপুট: Alice is speaking.
student1:speak()  -- আউটপুট: Bob is studying at XYZ University

এখানে, speak মেথডটি Person এবং Student ক্লাসে দুইটি ভিন্নভাবে কার্যকর হচ্ছে, যা পলিমরফিজমের উদাহরণ।

৫. Encapsulation (ইনক্যাপসুলেশন)

Encapsulation হল অবজেক্টের ডেটা এবং ফাংশনকে একসাথে আবদ্ধ করা। এটি সাধারনত private এবং public প্রপার্টি এবং মেথডস ব্যবহার করে সিমুলেট করা হয়। লুয়া ভাষায়, আপনি local ব্যবহার করে কিছু ফাংশন বা ভ্যারিয়েবলকে private করতে পারেন, যাতে বাইরে থেকে অ্যাক্সেস করা না যায়।

উদাহরণ: Encapsulation

-- Person ক্লাস
Person = {}
Person.__index = Person

function Person.new(name, age)
    local self = setmetatable({}, Person)
    self.name = name
    self.age = age
    return self
end

-- Private method
local function privateMethod(self)
    print(self.name .. " has a private method.")
end

-- Public method
function Person:publicMethod()
    print(self.name .. " has a public method.")
    privateMethod(self)  -- public method থেকে private method কল করা
end

local person1 = Person.new("Alice", 30)
person1:publicMethod()  -- আউটপুট: Alice has a public method. Alice has a private method.

এখানে, privateMethod শুধুমাত্র Person ক্লাসের ভেতরে অ্যাক্সেসযোগ্য, এবং এটি publicMethod এর মাধ্যমে কল করা হচ্ছে। এইভাবে ইনক্যাপসুলেশন সিমুলেট করা হয়েছে।

সারসংক্ষেপ

• Metatables ব্যবহার করে লুয়া ভাষায় OOP ধারণাগুলো সিমুলেট করা যায়, যেমন ক্লাস, ইনহেরিটেন্স, পলিমরফিজম, এবং ইনক্যাপসুলেশন।
• Metatables টেবিলগুলির মধ্যে অতিরিক্ত আচরণ সংজ্ঞায়িত করতে ব্যবহৃত হয়, যা অবজেক্ট-ওরিয়েন্টেড ডিজাইনের ভিত্তি হিসেবে কাজ করে।
• Inheritance, Polymorphism, এবং Encapsulation কাস্টম ডেটা টাইপ এবং মেথডস ব্যবহার করে OOP বাস্তবায়ন করা সম্ভব।