Une super classe peut-elle renvoyer une sous-classe? Par exemple pour une fonction Marry?

Question

Dites que j'ai une méthode où je veux avoir avec le type de retour le même que la classe. par exemple. Cat:Marry(Cat y) ou Dog:Marry(Dog y) mais je ne veux pas qu'un chat se marie avec un chien!

Existe-t-il un langage de programmation qui me permet d'exprimer ceci et donne une erreur de compilation si vous essayez d'épouser un chat et un chien? par exemple.

class Animal{ 
    void Marry(Animal X){ 
     Console.Write(this+" has married "+X); 
    } 
} 
class Cat:Animal{} 
class Dog:Animal{} 

Ainsi je veux (new Cat()).Marry(new Cat()) d'être autorisés, mais pas (new Cat()).Marry(new Dog())

En d'autres termes, je veux le type d'argument de Marry pour correspondre à sa catégorie. Est-ce que les langues le font? (Sans avoir à écrire plus d'une fonction Marry?) J'envisage quelque chose comme ceci:

void Marry(caller X){ 
    Console.Write(this+" has married "+X); 
} 

Answer 1

Vous pouvez le faire en Java en utilisant les génériques:

class Animal<T extends Animal> { 
    void marry(T other) { 
    ... 
    } 
} 

class Cat extends Animal<Cat> { ... } 
class Dog extends Animal<Dog> { ... } 

Voici un morceau de code que je suis fonctionne correctement en Java 8, pour ceux qui voudraient une réponse plus précise:

public class Test { 
    public static void main(String[] args) { 
     final Dog dog = new Dog(); 
     final Cat cat = new Cat(); 
     cat.marry(cat); 
     dog.marry(dog); 
    } 
} 

class Animal <T extends Animal> { 
    void marry(T other) { 

    } 
} 

class Dog extends Animal<Dog> { 

} 

class Cat extends Animal<Cat> { 

} 

Answer 2

Vous pourriez probablement y parvenir en C++ en utilisant le CRTP:

template <typename Derived> 
class Animal{ 
    void Marry(Derived X) 
    { 
     //code here 
    } 
} 

class Dog : Animal<Dog> 
{ 
} 

class Cat : Animal<Cat> 
{ 
}