ইন্টারফেস

"হ্যালো, অ্যামিগো! আজ আপনি কিছু আবিষ্কার করতে যাচ্ছেন। আজকের বিষয় - ড্রাম রোল, দয়া করে - ইন্টারফেস। "

"হ্যাঁ। একটি দিন এত চমৎকার যে আমি স্নান করতে বাড়িতে যাচ্ছি।"

" একটি ইন্টারফেস হল অ্যাবস্ট্রাকশন এবং পলিমরফিজমের সন্তান। ইন্টারফেসটি অনেকটা বিমূর্ত ক্লাসের মতো যেখানে সমস্ত পদ্ধতি বিমূর্ত। এটিকে ক্লাস হিসাবে একইভাবে ঘোষণা করা হয়, কিন্তু কীওয়ার্ড দিয়ে। এখানে কিছু উদাহরণ দেওয়া হল: interface"

interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}

interface Element extends Drawable, HasValue
{
int getX();
int getY();
}

abstract class ChessItem implements Drawable, HasValue
{
private int x, y, value;

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

"আকর্ষণীয়। কিন্তু কেন আমাদের ইন্টারফেস দরকার? কখন ব্যবহার করা হয়?"

"ক্লাসের তুলনায় ইন্টারফেসের দুটি শক্তিশালী সুবিধা রয়েছে:"

1) পদ্ধতি বাস্তবায়ন থেকে "পদ্ধতি সংজ্ঞা" আলাদা করা।

আমি আপনাকে আগে বলেছিলাম যে আপনি যদি অন্য ক্লাসগুলিকে আপনার ক্লাসের পদ্ধতিগুলি কল করার অনুমতি দিতে চান তবে আপনাকে সেগুলি হিসাবে চিহ্নিত করতে হবেpublic । আপনি যদি কিছু নির্দিষ্ট পদ্ধতি শুধুমাত্র আপনার নিজের ক্লাস থেকে কল করতে চান, তাহলে সেগুলিকে অবশ্যই চিহ্নিত করতে হবে private। অন্য কথায়, আমরা ক্লাসের পদ্ধতিগুলোকে দুটি ভাগে ভাগ করছি: «সবার জন্য» এবং «শুধু আমার জন্য»।

এই বিচ্ছেদকে আরও শক্তিশালী করতে আমরা ইন্টারফেস ব্যবহার করতে পারি। আমরা একটি বিশেষ "সকলের জন্য ক্লাস" তৈরি করব যা একটি দ্বিতীয় "শুধু-আমার জন্য-শ্রেণী" উত্তরাধিকারী হবে। এটি এই মত দেখতে হবে:

class Student
{
 private String name;

 public Student(String name)
 {
  this.name = name;
 }

 public String getName()
 {
  return this.name;
 }

 private void setName(String name)
 {
  this.name = name;
 }

interface Student
{
 public String getName();
}

class StudentImpl implements Student
{
 private String name;
 public StudentImpl(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return this.name;
 }
 private void setName(String name)
 {
  this.name = name;
 }
}

public static void main(String[] args)
{
 Student student =
               new Student("Alibaba");
 System.out.println(student.getName());
}

public static void main(String[] args)
{
 Student student =
               new StudentImpl("Ali");
 System.out.println(student.getName());
}

আমরা আমাদের ক্লাসকে দুটি ভাগে বিভক্ত করেছি: একটি ইন্টারফেস এবং একটি ক্লাস যা ইন্টারফেসটি প্রয়োগ করে।

"তাহলে লাভ কি?"

"একই ইন্টারফেস (উত্তরাধিকারী) বিভিন্ন শ্রেণীর দ্বারা প্রয়োগ করা যেতে পারে। এবং প্রতিটি শ্রেণীর নিজস্ব আচরণ থাকতে পারে। ঠিক যেমন ArrayList এবং LinkedList হল তালিকা ইন্টারফেসের দুটি ভিন্ন বাস্তবায়ন। "

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

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

2) একাধিক উত্তরাধিকার।

জাভাতে, প্রতিটি ক্লাসে শুধুমাত্র একটি প্যারেন্ট ক্লাস থাকতে পারে। অন্যান্য প্রোগ্রামিং ভাষায়, ক্লাসে প্রায়শই বেশ কয়েকটি অভিভাবক ক্লাস থাকতে পারে। এটি খুব সুবিধাজনক, তবে এটি প্রচুর সমস্যাও তৈরি করে।

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