বেনাম শ্রেণীর একাধিক উত্তরাধিকার

Question 1

একজন বেনাম শ্রেণি কীভাবে দুটি (বা আরও) ইন্টারফেস প্রয়োগ করতে পারে? বিকল্পভাবে, এটি উভয়ই কীভাবে একটি শ্রেণি বাড়িয়ে এবং একটি ইন্টারফেস প্রয়োগ করতে পারে ? উদাহরণস্বরূপ, আমি বেনাম শ্রেণীর একটি বস্তু তৈরি করতে চাই যা দুটি ইন্টারফেস প্রসারিত করে:

    // Java 10 "var" is used since I don't know how to specify its type
    var lazilyInitializedFileNameSupplier = (new Supplier<String> implements AutoCloseable)() {
        private String generatedFileName;
        @Override
        public String get() { // Generate file only once
            if (generatedFileName == null) {
              generatedFileName = generateFile();
            }
            return generatedFileName;
        }
        @Override
        public void close() throws Exception { // Clean up
            if (generatedFileName != null) {
              // Delete the file if it was generated
              generatedFileName = null;
            }
        }
    };

তারপরে আমি এটিকে AutoCloseableঅলস-সূচনাযুক্ত ইউটিলিটি শ্রেণি হিসাবে একটি-চেষ্টা-সংস্থানসমূহ ব্লকে ব্যবহার করতে পারি :

        try (lazilyInitializedFileNameSupplier) {
            // Some complex logic that might or might not 
            // invoke the code that creates the file
            if (checkIfNeedToProcessFile()) {
                doSomething(lazilyInitializedFileNameSupplier.get());
            }
            if (checkIfStillNeedFile()) {
                doSomethingElse(lazilyInitializedFileNameSupplier.get());
            }
        } 
        // By now we are sure that even if the file was generated, it doesn't exist anymore

আমি কোনও অভ্যন্তরীণ শ্রেণি তৈরি করতে চাই না কারণ আমি নিশ্চিত যে এই ক্লাসটি যে পদ্ধতিতে আমার এটি ব্যবহার করতে হবে তা বাদ দিয়ে কোথাও ব্যবহার করা হবে না (এবং আমি সেই পদ্ধতিতে ঘোষিত স্থানীয় ভেরিয়েবলগুলিও ব্যবহার করতে চাইব varটাইপ হতে হবে )।

Question 2

বেনাম শ্রেণীর অবশ্যই অন্য জাভা শ্রেণীর মতো কিছু প্রসারিত বা বাস্তবায়ন করতে হবে , যদিও তা ঠিক java.lang.Object।

উদাহরণ স্বরূপ:

Runnable r = new Runnable() {
   public void run() { ... }
};

এখানে, rএকটি বেনাম শ্রেণীর একটি অবজেক্ট যা প্রয়োগ করে Runnable।

একটি বেনাম শ্রেণি একই বাক্য গঠন ব্যবহার করে অন্য শ্রেণি বাড়িয়ে দিতে পারে:

SomeClass x = new SomeClass() {
   ...
};

আপনি যা করতে পারবেন না তা হ'ল একাধিক ইন্টারফেস বাস্তবায়ন। এটি করার জন্য আপনার একটি নামী বর্গ দরকার। অজ্ঞাতনামা কোনও অভ্যন্তরীণ শ্রেণি বা একটি নামী শ্রেণি অবশ্য একাধিক শ্রেণি প্রসারিত করতে পারে না।

Question 3

একটি বেনাম শ্রেণি সাধারণত একটি ইন্টারফেস প্রয়োগ করে:

new Runnable() { // implements Runnable!
   public void run() {}
}

JFrame.addWindowListener( new WindowAdapter() { // extends  class
} );

আপনার যদি মনে হয় আপনি 2 বা ততোধিক ইন্টারফেস বাস্তবায়ন করতে পারেন কিনা , আমার মতে এটি সম্ভব নয়। এরপরে আপনি একটি ব্যক্তিগত ইন্টারফেস তৈরি করতে পারেন যা দুটির সাথে একত্রিত হয়। যদিও আপনি অনামী বর্গ কেন চান তা আমি সহজেই ভাবতে পারি না:

 public class MyClass {
   private interface MyInterface extends Runnable, WindowListener { 
   }

   Runnable r = new MyInterface() {
    // your anonymous class which implements 2 interaces
   }

 }

Question 4

বেনামে ক্লাস সবসময় সুপারক্লাস বা প্রয়োগ করে ইন্টারফেস প্রয়োগ করে। উদাহরণ স্বরূপ:

button.addActionListener(new ActionListener(){ // ActionListener is an interface
    public void actionPerformed(ActionEvent e){
    }
});

তদুপরি, যদিও বেনামী শ্রেণি একাধিক ইন্টারফেস প্রয়োগ করতে পারে না, আপনি এমন একটি ইন্টারফেস তৈরি করতে পারেন যা অন্য ইন্টারফেসকে প্রসারিত করে এবং আপনার বেনাম শ্রেণিকে এটি প্রয়োগ করতে দেয়।

Question 5

আমি অনুমান করি যে কেউই প্রশ্নটি বুঝতে পারেনি। আমার ধারণা, এই লোকটি যা চেয়েছিল তা এমন কিছু ছিল:

return new (class implements MyInterface {
    @Override
    public void myInterfaceMethod() { /*do something*/ }
});

কারণ এটি একাধিক ইন্টারফেস প্রয়োগের মতো জিনিসগুলিকে মঞ্জুরি দেয়:

return new (class implements MyInterface, AnotherInterface {
    @Override
    public void myInterfaceMethod() { /*do something*/ }

    @Override
    public void anotherInterfaceMethod() { /*do something*/ }
});

সত্যিই এটি দুর্দান্ত লাগবে; তবে জাভাতে এটি অনুমোদিত নয় ।

আপনি যা করতে পারেন তা হল মেথড ব্লকগুলির মধ্যে স্থানীয় ক্লাসগুলি ব্যবহার :

public AnotherInterface createAnotherInterface() {
    class LocalClass implements MyInterface, AnotherInterface {
        @Override
        public void myInterfaceMethod() { /*do something*/ }

        @Override
        public void anotherInterfaceMethod() { /*do something*/ }
    }
    return new LocalClass();
}

Question 6

// The interface
interface Blah {
    void something();
}

...

// Something that expects an object implementing that interface
void chewOnIt(Blah b) {
    b.something();
}

...

// Let's provide an object of an anonymous class
chewOnIt(
    new Blah() {
        @Override
        void something() { System.out.println("Anonymous something!"); }
    }
);

Question 7

একটি বেনাম শ্রেণি তার অবজেক্ট তৈরি করার সময় প্রসারিত বা প্রয়োগ করছে উদাহরণস্বরূপ:

Interface in = new InterFace()
{

..............

}

এখানে বেনাম শ্রেণি ইন্টারফেস প্রয়োগ করছে।

Class cl = new Class(){

.................

}

এখানে বেনাম ক্লাস একটি বিমূর্ত ক্লাস প্রসারিত করছে।