Essayer de simuler le comportement de fil en classe orher avec Java

Question

J'ai cette classe:

public class MyThread { 
    public static void main(String[] args) { 
     Thread thread = new Thread() { 
      public void run() { 
       System.out.print("Test from Anonymous Class!"); 
      } 
     }; 
     Thread newThread = new Thread(thread); 
     newThread.run(); 
    } 
} 

Quand je lance ce programme, je reçois Test from Anonymous Class!.

Maintenant, je suis en train de simuler ce comportement avec une autre classe comme ceci:

interface MyInterface { 
    public void doTest(); 
} 

class MyClass implements MyInterface { 
    public MyClass() {} 

    public MyClass(MyInterface myInterface) {} 

    public void doTest() { 
     System.out.println("Test from MyClass!"); 
    } 
} 

public class Test { 
    public static void main(String[] args) { 
     MyClass myClass1 = new MyClass() { 
      public void doTest() { 
       System.out.println("Test from Anonymous Class!"); 
      } 
     }; 

     MyClass myClass2 = new MyClass(myClass1); 
     myClass2.doTest(); 
    } 
} 

Quand je lance ce programme, je reçois Test from MyClass!. Pourquoi dans le premier exemple d'impression Test from Anonymous Class!? Comment puis-je obtenir le même comportement avec la classe MyClass?

Merci d'avance!

Answer 1

Il semble que vous souhaitez mettre en œuvre une délégation d'une classe qui prend en paramètre du constructeur une interface.

Le constructeur Thread utilise l'instance Runnable fourni en tant que paramètre comme cible de l'exécution lorsque vous invoquez Thread#start() pendant que votre classe personnalisée ne reproduit pas ce comportement. Vous ne fait rien avec le paramètre MyInterface passé:

public MyClass(MyInterface myInterface) {} 

Pour mettre en œuvre une délégation, vous devez ajouter un champ MyInterface dans MyClass et de la valeur dans le constructeur.
Ensuite, utilisez-le dans la méthode doTest().

public MyClass(MyInterface myInterface) {} 

    private MyInterface myInterface; 
    ... 
    public MyClass(MyInterface myInterface) { 
    this.myInterface = myInterface; 
    } 

    public void doTest() { 
     // do some processing 
     .. 
     // then delegate 
     myInterface.doTest(); 
    } 
} 

Answer 2

C'est parce que vous faites rien avec votre

param myClass1

public MyClass(MyInterface myInterface) {} 

Vous obtenez le paramètre, alors quoi? si vous voulez faire ce que le paramètre faire, vous devez appeler la méthode:

myClass1.doTest() 


>"Test from Anonymous Class!" 

Ce que vous faites est rare, mais si vous invoquez la méthode de l'objet correct, vous obtiendrez ce que vous voulez :)

une autre façon, rare mais valide, est d'avoir une variable d'instance, et l'appeler:

class MyClass implements MyInterface { 
    MyClass myOtherClass; 

    public MyClass() {} 

    public MyClass(MyInterface myInterface) { 
     this.myOtherClass = myInterface; 
    } 

    public void doTest() { 
     System.out.println("Test from MyClass!"); 
    } 
} 

Ensuite, vous appelez la méthode à l'intérieur:

public class Test { 
    public static void main(String[] args) { 
     MyClass myClass1 = new MyClass() { 
      public void doTest() { 
       System.out.println("Test from Anonymous Class!"); 
      } 
     }; 

     MyClass myClass2 = new MyClass(myClass1); 
     myClass2.myOtherClass.doTest(); // calling method from myClass1 
    } 
} 

Answer 3

Vous devez initialiser votre cible, il appellera la méthode dans votre classe

class MyClass implements MyInterface { 
     MyInterface myInterface; 
     public MyClass() {} 

     public MyClass(MyInterface myInterface) { 
      this.myInterface=myInterface; 
     } 

     public void doTest() { 
      if(myInterface !=null){ 
       myInterface.doTest(); 
       return; 
      } 
      System.out.println("Test from MyClass!"); 
     } 
    } 

Answer 4

La réponse est simple. La méthode run() dans Thread est redéfinie et elle sera toujours celle à exécuter.

Dans le second exemple, myClass2 utilise la méthode doTest() de l'instance et myClass1 n'est jamais utilisée, sauf dans constuctor.