Quelle est la différence entre l'Abstraction et le Polymorphisme

Ces deux-là sont parmi les caractéristiques les plus importantes de paradigme Orienté Objet.

L'Abstraction.

L'orientation de l'objet des modèles du logiciel comme de véritables objets du monde. Cependant, il serait trop difficile ( et inutile ) pour le modèle de TOUTES les propriétés d'un Client peut être, ou toutes les propriétés d'un Employé.

En listant uniquement les attributs intéressants d'un objet OO peut effectivement utiliser cet objet pour un domaine spécifique. C'est l'abstraction.

Par exemple, un Employé dans un système de RH peuvent avoir des attributs très différents qu'une Librairie en Ligne. Nous avons résumé les détails pour faire est utile.

Polymorphisme.

Objets peuvent se comporter différemment en fonction du "type" tout en gardant la même interface.

Ce que cela veut dire?

Par exemple une boutique en ligne peut avoir deux sous-classes de l'Employé

A) les employés Internes.

B) Les Entrepreneurs

Et une méthode de calcul de la réduction pour les internes achats

La remise d'un employé interne est calculé comme suit: 10% + 2% pour chaque année de la société + 2% pour chaque.. mmhh enfant

La remise d'un entrepreneur est de 10%

Le code suivant pour calculer le montant à payer:

 public Amount getAmountToPay( Product product, Employee internalCustomer ) { 
      Amount amount = product.getPrice();
      amount.applyDiscount( internalCustomer.getDiscount() );
      return amount;
 }

Serait de produire des résultats différents pour les deux types d'Employé-e 's

class Employee { 
    public int getDiscount();
}


class InternalEmployee extends Employee { 
     public int getDiscount() { 
        return 10 + 2 * getWorkedYears() + 2 * getNumberOfChilds();
     }
 }

 class Contractor extends Employee { 
      public int getDiscount() { 
          return 10;
     }
 }

C'est le polymorphisme. Au lieu d'avoir quelque chose comme

 Amount amount = product.getPrice();

 if( employee.isContractor() ) { 
      amount.applyDiscount( 10 );
 } else if( employee.isSomthingElse() ) {
      amount.applyDiscount( 10 * 2 * getYrs() + 2 * getChilds() );
 } else if ( employee.contidions, condigions, conditions ) {
      amount.applyDiscount( getSomeStrageRuleHere() );
 }

Nous laisser l'exécution de choisir celui à calculer. C'est comme le programme se comporte différemment selon le type:

      Amount amount = product.getPrice();
      amount.applyDiscount( internalCustomer.getDiscount() );
      return amount;

Par la façon dont, dans cet exemple, le "Montant" est une abstraction d'un véritable concept, qui pourrait également être représenté comme un double ou un Entier, mais nous avons peut-être interestion méthodes à l'intérieur que ce serait mieux si dans sa propre classe.

J'espère que cette aide.

L'Abstraction se réfère à l'acte de représenter l'essentiel des caractéristiques sans fond y compris des détails ou des explications. Classes d'usage de la notion d'abstraction et sont définies par une liste d'attributs abstraits.

Un exemple d'un logiciel d'abstraction est de Java Object.equals(Object o) méthode. Vous savez qu'il va comparer cet objet à celui transmis en tant que paramètre, mais vous ne savez pas, ni avez-vous besoin de savoir exactement comment il sera mis en place (sauf si vous êtes de le responsable de l'implémentation de la classe).

Polymorphisme signifie que la capacité à prendre plus d'une forme. Une méthode peut avoir des comportements différents dans les différentes instances. Le comportement dépend des types de données utilisées dans l'opération.

L'un des exemples classiques de polymorphisme utilise un arbre d'héritage ancré dans l'Animal de la classe. Tous les Animaux ont un makeNoise() méthode, mais le Chien de la classe et de la classe Chat en œuvre différemment. Cela vous permet de consulter n'importe quel Chien et du Chat à l'aide d'un Animal de type référence.

Animal a = new Dog();
Animal b = new Cat();

Maintenant, vous pouvez appeler makeNoise() sur un Animal d'instance et de savoir qu'il va faire du bruit. Ceci est particulièrement utile si vous avez une Collection d'Animaux, et vous ne savez pas au moment de l'exécution exactement ce type de chacun d'eux est vraiment.

réponse courte: l'abstraction est conceptuel, le polymorphisme est comportementale

P. S: récemment commencé à apprendre le java réponse se fonde sur mon observation s'il vous plaît corrigez-moi si je me trompe.

L'Abstraction et le Polymorphisme de coeur profond de ne presque le même travail dans la programmation .

Prenons une voiture par exemple..

il n'a pas d'importance si c'est une Ford mini-van, Ferrari exotiques, Land-Rover SUV ou une berline BMW ils suivent tous une conception de base d'une voiture, j'.e un moteur, un volant , une boîte de vitesse , des feux , des indicateurs et la liste continue . elles se distinguent par leurs implémentations spécifiques comme Ferrari pourrait avoir un moteur plus puissant qu'un mini-van, un suv pourrait avoir une autre boîte de vitesse
donc Une voiture (super-classe ici) a été mis en œuvre par les sous-classes (berline, suv , mini-van, exotique)
C'est polymorphisme, une idée de base hérités ou mis en œuvre par l'ajout d'autres spécifications. un 4 roues véhicule (super-classe), mis en œuvre sous des formes diverses (sous-classes)

Maintenant, Abstraction , par définition, il s'agit de cacher les détails et de faire de l'utilisateur de voir ce qui est requis par lui..

Prenons l'exemple de la voiture à nouveau.. Vous utilisez la vitesse, mais vous ne savez pas exactement le mécanisme de la façon dont exactement le fonctionnement du matériel et des changements de vitesse et tout..

Maintenant sur le codage de la Partie.

Les classes abstraites sont incomplets des classes et pour une classe abstraite comme le nom le suggère, ils ont besoin d'avoir un incomplètes méthode qui doit être complété par la sous-classe hérite de la classe mère , S'ils ne terminent pas la méthode abstraite restera incomplète tant que bien.

abstract class car {
  abstract void gear();
}

class sedan extends car {
 public void gear()
 {
  //complete the method
 }
}

aussi vous ne pouvez pas créer des objets de classes abstraites parce que la classe n'est pas complète. Pourtant, ces classes abstraites peuvent avoir des méthodes statiques , des arguments , des méthodes concrètes, MAIS pour eux d'être abstraite, ils ont besoin d'une méthode abstraite. Donc une super-classe abstraite est mis en œuvre dans d'autres sous-classes où ils le compléter
En regardant la déclaration de la méthode, nous pouvons estimer ce qu'est exactement la méthode est en train de faire, ce qu'il va revenir. Mais nous ne savons pas exactement comment la méthode abstraite sera mis en œuvre.

Par l'utilisation de classes abstraites et interfaces , nous pouvons atteindre l'abstraction en Java.
Comme nous le savons tous que les classes abstraites, interfaces contient des méthodes abstraites

Nous ne pouvons qu'estimer comment ils vont travailler . Nous savons comment ils fonctionnent, une fois que nous avons fourni la méthode mise en œuvre dans les classes qui implémentent le correspondant de la classe abstraite ou une interface.

DONC, fondamentalement abstrait permet de polymorphisme.

La confusion quant à la signification réelle de l'abstraction dans le contexte de l'orientation de l'objet est compréhensible: il ajoute peu, si quelque chose, les notions d'héritage, l'encapsulation et même polymorphisme. Si vous maîtrisez ces trois concepts, il n'est pas nécessaire de préoccupation trop avec "l'abstraction" une fois qu'il est naturellement intégré (en particulier l'héritage).

Pour commencer, notez que le terme "abstraction" a plusieurs sens et il n'est pas inexact d'affirmer, par exemple, que l'encapsulation nécessite l'abstraction: lorsque vous utilisez les modificateurs d'accès pour protéger les attributs d'une classe tout en dénonçant les méthodes qui gèrent eux (c'est ce que l'encapsulation est), la catégorie " utilisateur n'a plus besoin de s'inquiéter comment les gérer par elle-même. Donc, dans un sens, lors de la conception d'une classe, vous résumé par l'encapsulation des méthodes et des attributs - tout ce que la classe' utilisateur doit faire est de l'utiliser en invoquant le droit des méthodes, et c'est une forme d'abstraction.

En outre, si vous pensez que tout droit, polymorphisme est aussi une forme d'abstraction: votre code appelle une méthode fournie par un peu de classe et vous n'avez aucune idée de comment il va agir jusqu'à ce que la classe réelle type est déterminé (à l'exécution). Donc, il est correct d'affirmer que le comportement polymorphique est une sorte d'abstraction.

Toutefois, lorsqu'il est utilisé comme une application autonome terme pour décrire les caractéristiques de la programmation orientée objet, abstraction doit être compris que la bonne représentation du système en cours de discussion sous la forme d'une hiérarchie de classe. En tant que tel, l'abstraction est le résultat de la concepteur du processus mentaux qui aboutissent à une conception appropriée pour les classes qui vont être utilisés dans le programme. Pour citer un (excellent!) post qui peut être trouvé à l'javarevisited blog:

... Abstraction des peaux de détails au niveau de la conception, tandis que l'Encapsulation
masque de détails au niveau de l'exécution.

Alors que la déclaration ci-dessus est correct, je trouve le "masque les détails" de la partie erronés - je reformuler comme quelque chose comme

Abstraction des préoccupations avec les détails de conception, de décider comment la hiérarchie de classe, de l'Encapsulation des peaux de détails
la mise en œuvre.

Pour être juste avec l'auteur, cette idée même est magnifiquement mis le long de son article. Le terme "abstraction" avec cette connotation est également vu dans des livres comme La tête la Première Analyse Orientée Objet et Design, et je cite une déclaration à partir de là:

Chaque fois que vous trouvez un comportement commun à deux endroits ou plus, regardez
résumé de comportement dans une classe, puis de réutiliser ce comportement
le commun des classes

Avis l'utilisation de l'abstraction ici: "regarder à l'abstrait que le comportement dans une classe". Maintenant, si à l'abstrait signifie à la conception d'une hiérarchie de classe correctement comme suggéré ci-dessus, l'abstraction peut être défini comme la représentation d'un domaine à l'aide de classes idéalement, profitant des notions d'héritage et de l'encapsulation.

Dans le cas particulier de Java, l'abstraction est mis en œuvre par l'aide de interfaces et les classes abstraites tandis que l'encapsulation est mis en œuvre avec le private, protected et le paquet de modificateurs d'accès.