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

Je voudrais savoir ce que homme et enfant ont en commun et en quoi ils diffèrent.

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

source d'informationauteur davejoem

  1. 33

    Version courte

    • extends signifie:

    La nouvelle 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 signifie:

    La nouvelle classe peuvent être traités comme des la même "forme"tandis que il n'est pas un enfant. Il peut être transmis à un mode où le Person est nécessaire, indépendamment du fait divers, le parent que Person

    Plus ...

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

    extends de tirer profit de l'héritage (voir wiki). Petite cite:

    ... Succession dans la plupart basées sur la classe 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:

    ... 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 nos class Man. 

    class Man extends Human ...

    mais si nous déclarons aussi que nous pouvons faire semblant d'être un autre type de Person:

    class Man extends Human 
          implements Person ...

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

    implement autre classe? C'est vraiment des trucs cool

    Javascript nice face (l'un des avantages) 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 POO langues comme C# ... pas moyen de le faire...

    Également 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 la mise en œuvre
  2. 34

    À la machine (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 yet 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.

    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 dans 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:

    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 une classe alors de ne prendre que son "contrat" sans la mise en œuvre, de sorte que vous aurez besoin pour ce faire:

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

    (code dans l'aire de jeux)

    Ligne de fond est que, dans la plupart des cas, vous voulez extend une autre classe et de ne pas implement.

  3. 2

    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 le étendue de démonstration