Quelle est la différence entre 'extend' et 'implements' dans TypeScript

Question

J'aimerais savoir ce que l' homme et l' enfant ont en commun et en quoi ils diffèrent.

 class Person {
  name: string;
  age: number;
}
class child extends Person {}
class man implements Person {}
 

Answer 1

Version courte

• extends moyen:

La nouvelle de la classe est un enfant. Il obtient les avantages de l'héritage. Il a toutes les propriétés, les méthodes que son parent. Il peut remplacer certains de ces et de mettre en œuvre de nouvelles, mais le parent truc est déjà inclus.

• implements moyen:

La nouvelle classe peut être considérée comme la même "forme", alors que ce n'est pas un enfant. Il peut être transmis à un mode où l' Person est nécessaire, indépendamment du fait divers, le parent qu' Person

De plus ...

Dans la programmation orientée objet (langages tels que C#, Java) , nous utiliserions

extends de profit sur les droits de succession (voir wiki). Petite cite:

... L'héritage dans la plupart de la classe de base des langages orientés objet est un mécanisme dans lequel un objet acquiert toutes les propriétés et les comportements de l'objet parent. L'héritage permet aux programmeurs de créer des classes qui sont construits sur des classes existantes ...

implements sera plus pour le polymorphisme (voir wiki). Petite cite:

... le polymorphisme est la mise à disposition d'une interface unique pour les entités de différents types...

Donc, nous pouvons avoir vraiment différente de l'arbre de l'héritage de notre - class Man.

class Man extends Human ...

mais si nous déclarons aussi que nous pouvons faire semblant d'être d'un type différent - Person:

class Man extends Human 
          implements Person ...

.. alors, on peut l'utiliser n'importe où, où l' Person est requis. Nous avons juste à remplir les Personnes de l' "interface" (c'est à dire de mettre en œuvre tous ses publics trucs).

implement autres classe? C'est vraiment des trucs cool

Javascript nice face (l'une des prestations) est la prise en charge intégrée de la Duck-typing (voir wiki). Petite cite:

"Si ça marche comme un canard et il charlatans comme un canard, il doit etre un canard."

Donc, en Javascript, si deux objets différents... aurait une méthode similaire (par exemple, render()) ils peuvent être transmis à une fonction qui attend que ça:

function(engine){
  engine.render() // any type implementing render() can be passed
}

Pour ne pas perdre que nous pouvons en caractères d'imprimerie fait de même avec la plus typée de soutien. Et c'est là que

class implements class

a son rôle, où il fait sens

En programmation orientée objet, les langues comme l' C# ... pas moyen de le faire...

Aussi La documentation de l'aide ici:

Les Interfaces De L'Extension Des Classes

Quand un type d'interface s'étend un type de classe hérite des membres de la classe, mais pas de leur mise en œuvre. C'est comme si l'interface a a déclaré l'ensemble des membres de la classe sans fournir une la mise en œuvre. Interfaces hériter même le privé et protégé les membres d'une classe de base. Cela signifie que lorsque vous créez une interface qui étend la classe avec des membres privés ou protégés, cette interface le type ne peut être implémentée par la classe ou une sous-classe.

Ceci est utile lorsque vous avez un grand hiérarchie d'héritage, mais que vous voulez pour spécifier que votre code fonctionne uniquement avec des sous-classes qui ont certaines les propriétés. Les sous-classes n'ont pas à être liés en plus d'hériter à partir de la classe de base. Par exemple:

class Control {
    private state: any;
}

interface SelectableControl extends Control {
    select(): void;
}

class Button extends Control {
    select() { }
}

class TextBox extends Control {
    select() { }
}

class Image extends Control {
}

class Location {
    select() { }
}

Ainsi, alors que

• extends signifie - il obtient tout de son parent
• implements dans ce cas est presque comme la mise en oeuvre d'une interface. Objet enfant peut prétendre que c'est parent... mais il ne reçoit pas de mise en œuvre

Answer 2

En caractères d'imprimerie (et quelques autres langages à objets) vous avez les classes et les interfaces.

Une interface n'a pas de mise en œuvre, c'est juste un "contrat" de ce que les membres/méthode de ce type a.
Par exemple:

interface Point {
    x: number;
    y: number;
    distance(other: Point): number;
}

Instances qui mettent en œuvre cette Point interface doit avoir deux membres du numéro de type: x et y, et une méthode distance qui reçoit un autre Point instance et renvoie un number.
L'interface n'est pas de mettre en œuvre l'un de ceux-ci.

Les Classes sont les implémentations:

class PointImplementation implements Point {
    public x: number;
    public y: number;

    constructor(x: number, y: number) {
        this.x = x;
        this.y = y;
    }

    public distance(other: Point): number {
        return Math.sqrt(Math.pow(this.x - other.x, 2) + Math.pow(this.y - other.y, 2));
    }
}

(code de l'aire de jeux)

Dans votre exemple vous traiter votre Person classe comme une classe à l'étendre et à la fois comme une interface lorsque vous la mettre en œuvre.
Votre code:

class Person {
    name: string;
    age: number;
}
class Child  extends Person {}

class Man implements Person {}

A une erreur de compilation en disant:

La classe "Homme" de manière incorrecte implémente l'interface "Homme".
La propriété 'name' est absente du type "Homme".

Et c'est parce que les interfaces de l'absence de mise en œuvre.
Donc, si vous implement d'une classe alors de ne prendre que son "contrat" sans la mise en œuvre, de sorte que vous aurez besoin de faire cela:

class NoErrorMan implements Person {
    name: string;
    age: number;
}

(code de l'aire de jeux)

Ligne de fond est que, dans la plupart des cas vous souhaitez extend d'une autre classe, et non pas à l' implement il.

Answer 3

Grande Réponse de @nitzan-tomer! M'a beaucoup aidé... j'ai étendu sa démonstration un peu avec:

IPoint interface;
Point implements IPoint;
Point3D extends Point;

Et comment ils se comportent dans les fonctions attend à une IPoint type.

Donc ce que j'ai appris jusqu'à présent et utilisé comme un pouce règle: si vous êtes à l'aide de classes et de méthodes attend types génériques, l'utilisation des interfaces que l'on en attend types. Et assurez-vous que le parent ou de la classe de base utilise cette interface. De cette façon, vous pouvez utiliser toutes les sous-classes dans ceux aussi loin qu'ils implémentent l'interface.

Hier, l' étendue de démonstration