Cette section décrit ce qu'est la programmation orientée objet. Avant de parler de la programmation orientée objet, il faut mentionner la programmation orientée processus.Le langage C est un langage orienté processus.Quelle est la différence entre les deux? On peut imaginer un scénario-cuisine en cuisine:
Pour expliquer sous une forme orientée processus, la première étape: préparer les matériaux, la deuxième étape: allumer un feu, la troisième étape: faire sauter, la quatrième étape: servir; orientée processus consiste à écrire une fonction, chaque fonction effectue une partie de l'opération, Enfin, selon cet ensemble de fonctions, il s'agit de mettre en œuvre une exigence globale.
Quant à la cuisine orientée objet, nous expliquons la cuisine de la même manière, la première étape: il doit y avoir un chef, un poêle et un serveur, la deuxième étape: le chef prépare les matériaux, la troisième étape: le poêle prend feu, la quatrième étape: le chef Sauté, cinquième étape: le serveur sert les plats. La méthode de programmation orientée objet organise les fonctions indépendantes d'origine avec les objets auxquels elles appartiennent et les encapsule dans des méthodes (la "fonction" en mode orienté objet a une nouvelle méthode appelée Méthode). Bien que la quantité de code augmente en fait, ce type de réflexion sur la programmation est raisonnable, réaliste et plus facile à comprendre, car les responsabilités de chaque objet sont claires, de sorte que la maintenance ultérieure deviendra plus pratique.
Ci-dessous, au niveau du code, démontrez la différence entre orienté objet et orienté processus:
Procéduralisation:
#include "stdio.h"
void Prepare(){
printf("准备食材。\n");
}
void Fire(){
printf("起火\n");
}
void Cooking(){
printf("炒菜，\n");
printf("炒完了\n");
}
void Serve(){
printf("请享用。");
}
main(){
Prepare();
Fire();
Cooking();
Serve();
}
Objectivation:
//创建三个对象
//厨师
class Cook
{
//准备食材的方法
public void Prepare()
{
Console.WriteLine("厨师准备食材。");
}
//做饭的方法
public void Cooking()
{
Console.WriteLine("厨师正在做饭...");
Console.WriteLine("厨师做好了。");
}
}
//灶台工具类
static class CookingBench
{
//静态工具方法:起火
public static void Fire()
{
Console.WriteLine("灶台生火。");
}
}
//服务员
class Waiter
{
//上菜方法
public void Serve()
{
Console.WriteLine("请享用。");
}
}Appelé dans la méthode principale:
Cook cook=new Cook();
Waiter waiter=new Waiter();
cook.Prepare();
CookingBench.Fire();
cook.Cooking();
waiter.Serve();
L'orientation objet a trois caractéristiques: l'encapsulation, l'héritage et le polymorphisme. Parlons-en en détail ci-dessous:
Paquet:
Chacun a ses propres secrets. Il en va de même dans le code orienté objet. Parmi les objets, il y a des objets qui peuvent être visualisés par le monde extérieur, et certains ne sont pas visualisés par le monde extérieur. Cette idée de cacher certains membres est l'encapsulation. Pour réaliser l'encapsulation, vous devez d'abord Découvrez les quatre modificateurs d'accès: public, privé, protégé, interne
Les modificateurs d'accès peuvent modifier des classes, des propriétés et des méthodes. Utilisez des modificateurs pour modifier des classes ou des propriétés et des méthodes, avec différents niveaux d'accès. Le modificateur d'accès doit être écrit en premier lors de la déclaration:
public class publicClass{}//声明一个类
private bool isPublic;//声明一个属性public: public, ce niveau d'accès est le plus bas.
private: privé, comme son nom l'indique, ce niveau d'accès est le plus élevé et n'est accessible que dans le cadre de la déclaration.
protect: Protégé et accessible uniquement sur la chaîne d'héritage. Pour le dire franchement, seule une classe est héritée pour accéder aux membres protégés de cette classe.
interne: interne, accessible uniquement dans le même ensemble. Il peut être étroitement compris comme étant accessible sous le même espace de noms.
Il existe également une combinaison de poinçon: protéger interne, qui consiste à répondre au même assemblage, mais aussi à hériter de la relation d'accès.
Grâce à ces mots-clés, nous pouvons réaliser l'encapsulation. Lors du développement, il vous suffit de spécifier le type d'autorisations d'accès attribuées aux classes ou propriétés, méthodes, etc. que vous écrivez.
hériter:
Le concept d'héritage est également facile à comprendre. C'est comme dans la vraie vie, un enfant hérite de la propriété du parent, puis le contenu du parent devient celui de l'enfant. En C #, l'héritage entre les classes est réalisé par ":" de.
public class Father{}
public class Chlid:Father{}//Child类继承了FatherNotez que C # est un langage d'héritage unique, ce qui signifie qu'une classe ne peut hériter que d'une classe parente.
Les sous-classes peuvent hériter de propriétés ou de méthodes non privées dans la classe parente. Si des propriétés ou des méthodes privées sont accessibles, il n'y aura pas de mot clé de protection. Grâce à l'héritage, nous pouvons extraire le code répétitif partagé par les sous-classes dans la classe parente, de sorte que toutes les sous-classes n'aient pas besoin de déclarer ces membres, ce qui réduit beaucoup de code. Dans la structure d'héritage de C #, la classe d'objets est la classe parente de toutes les classes et toute classe hérite d'un objet par défaut. La classe d'objets nous fournit certains des membres les plus basiques de la classe, tels que notre méthode tostring () couramment utilisée.
Il y a un principe en orienté objet appelé le principe d'ouverture-fermeture. Ce principe stipule qu'il est fermé à la modification et ouvert à l'extension. C'est-à-dire qu'après avoir écrit une classe et l'avoir utilisée pendant un certain temps, nous devons modifier cette classe en raison de mises à niveau du projet ou pour d'autres raisons. (Ajouter de nouvelles choses) Pour le moment, selon le principe de l'ouverture et de la fermeture, nous ne pouvons pas la modifier directement. Au lieu de cela, nous devons écrire une autre classe, l'hériter et ajouter une nouvelle logique métier à la sous-classe. C'est également un objectif d'héritage.
Dans l'héritage, il existe un autre concept appelé remplacement de méthode, c'est-à-dire qu'une méthode de la sous-classe porte le même nom que la méthode de la classe parent héritée, de sorte que la méthode de la sous-classe écrase la méthode de la classe parente. Ce processus est en cours de réécriture. Ce concept sera développé en détail dans la section qui présente spécifiquement les classes et les méthodes.
Polymorphisme:
Le polymorphisme dépend de l'héritage, seul l'héritage peut réaliser le polymorphisme. La même classe a des formes différentes est le polymorphisme. Par exemple, les chiens ont différentes formes: huskies, chiens pastoraux, corgis, etc. La manifestation dans le code est que la classe parente peut recevoir la sous-classe pour lui attribuer des valeurs. Reprenez l'exemple ci-dessus, le code suivant est un exemple de polymorphisme:
Father f=new Chlid();La base du polymorphisme est le principe de transformation de Richter: la classe enfant hérite de la classe parent, alors, la scène qui s'appliquait à l'origine à la classe parent doit s'appliquer à la classe enfant, car la classe enfant hérite de toutes les fonctions explicites de la classe parente, et la classe parente peut le faire Oui, les sous-classes peuvent également le faire. Ce principe est de définir l'existence de cette théorie. Les sous-classes peuvent remplacer directement la classe parente et convertir toutes les classes parentes en sous-classes. Il n'y a aucune différence de comportement du programme.
Le polymorphisme est également une pierre angulaire très importante dans la programmation orientée objet. Nous utilisons généralement des interfaces autant que possible dans la programmation, orientées vers l'abstraction et réduisons le couplage. En raison du polymorphisme, nous pouvons implémenter des opérations d'instance via des interfaces ou des structures de données abstraites. .
Enfin, un exemple est utilisé pour démontrer le polymorphisme (certaines connaissances liées aux classes et aux méthodes seront expliquées en détail dans la section suivante des classes et méthodes):
public class Dog
{
public string name { get; set; }
public Dog(string name)
{
this.name = name;
}
public void introduce()
{
Console.WriteLine("这是一只：" + name);
}
}
public class Husky : Dog
{
//调用父类的构造方法，为name赋值
public Husky():base("Husky"){}
}
public class Koji : Dog
{
public Koji() : base("Koji"){}
}
class DogStore
{
public Dog dog { get; set; }
public DogStore(Dog dog)
{
this.dog = dog;
}
public void wantBuy()
{
Console.WriteLine("Do u want this "+dog.name+"?");
}
}Il y a une classe de chien commune dans le code ci-dessus, et il y a deux huskies respectivement, dont Corgi a hérité. Il existe également une boutique de chiens pour animaux de compagnie, qui nécessite l'attribut Chien.
Jetons un coup d'œil au code dans la méthode principale:
DogStore dogStore=new DogStore(new Husky());
dogStore.wantBuy();
dogStore=new DogStore(new Koji());
dogStore.wantBuy();
Nous recevons des sous-classes plus spécifiques via la classe parent, ce qui est une très bonne incarnation du polymorphisme, qui est également une méthode de programmation très élégante et efficace.
Compte public personnel, amour à partager, la connaissance n'a pas de prix.
