Étape 3: Object Oriented programmation Primer - Classes et objets
Fonctions en bref :
Une fonction est essentiellement un morceau de code que vous pouvez réutiliser plusieurs fois. Décomposer un dessin complex en fonctions plus petites assurer la lisibilité (le code est plus facile à lire, puisque tout le code complex obtient abstrait ; plus facile à déboguer à ce stade), modularité (transforme le code en pièces modulaires, comme des legos) et empêche le code d’avoir sec (peuplements secs pour ne pas répéter vous-même ; moyens extensibles manuellement copier/coller code plusieurs fois).
Voici la structure générique d’une fonction :
data_type_of_returned_value"'void' si elle retourne nothing"functionName(parameters) {}
la définition de fonction
}
Nous allons mettre en place une fonction qui affiche notre cercle et une autre fonction pour son mouvement (qui est, branlement) :
float x = 200 ;
float y = 200 ;
void setup() {}
Size(400,400) ;
Smooth() ;
}
{} void draw()
Background(255) ;
Display() ; appel d’une fonction
Move() ; appel de la fonction seconde
}
les fonctions
display() Sub {}
noStroke() ;
Fill(140) ;
ellipse(x,y,80,80) ;
}
move() Sub {}
x = x + random(-5,5) ;
y = y + random(-5,5) ;
}
Même si le code fait exactement la même chose qu’avant, regardez comment organisé la boucle draw() est maintenant ! Notez comment j’ai « appelée » ou « appelé » les fonctions respectives de dans la boucle de draw().
Fonctions peuvent avoir des « paramètres » trop. Paramètres sont allumées « titulaires de lieu » pour les valeurs que vous pouvez « passer » à une fonction. En recevant les valeurs, la fonction peut les calculer conformément à la façon dont vous l’avez défini. Par exemple, voici une fonction qui prend deux paramètres (x et y) et utilise les arguments passés à rendre cette forme bizarre :
void drawShape (float x, float y) {}
noStroke() ;
Fill(140) ;
ellipse(x,y,80,80) ;
ellipse(x-151,y+2,44,44) ;
Fill(68,234,66) ;
Rect(x-131,y-5,92,18) ;
}
Voir l’image ci-dessus (première photo).
Dans la fonction ci-dessus, nous avons utilisé x et y comme référence et définir les paramètres pour toutes les autres formes « relatives » à x et y. Cette technique est appelée « positionnement relatif ». Par exemple, si référence x est 400, et la valeur x de la forme est 89, puis la position de cette forme par rapport à la référence x est "x-311" (400-89 = 311).
Fonctions peuvent aussi « retourner » des valeurs, mais c’est pour un autre jour !
Un scénario de classe et un objet :
Comme nous l’avons vu tout à l’heure, fonctions de susciter un certain niveau d’organisation à notre code. Cependant, en utilisant des objets dans notre code est une stratégie d’organisation efficace jusqu'à maintenant.
Un objet essentiellement lie ensemble des données (variables) et functionality(functions) d’une entité donnée dans un emballage soigné. Afin de créer des objets, il faut un blue-print pour elle. C’est ce qu’on appelle la classe.
Au lieu de baratiner sur tous les concepts plus complexes, nous allons créer une classe pour générer des objets jiggly circle :
classe Circle {}
variables de classe (également appelées variables d’instance)
float x ;
float y ;
flotteur d ;
c de couleur ;
le constructeur de l’objet
Cercle (float x, float y, float d, couleur c) {}
This.x = x ;
This.y = y ;
This.d = d ;
This.c = c ;
}
les méthodes
display() Sub {}
noStroke() ;
Fill(c) ;
ellipse(this.x,this.y,this.d,this.d) ;
}
void jiggle() {}
This.x = this.x + random(-2,2) ;
This.y = this.y + random(-2,2) ;
}
}
Choses à noter :
- Il n’y a cette chose bizarre dans le code a appelé le « constructeur ». Le constructeur est la fonction qui crée un objet, en conjonction avec le mot-clé « new » (plus sur cela dans un peu). La définition de constructeur doit contenir du code sur la façon de construire des objets. Le nom du constructeur doit être le même que le nom de la classe.
- le mot clé « this » est utilisé pour accéder aux variables du appartient à la classe et que la classe ! Vous pouvez voir que j’ai utilisé les mêmes noms de variables pour les variables de classe et les paramètres du constructeur. En utilisant « ce », j’ai autoriser le traitement d’établir une distinction entre les deux. Par conséquent, "this.x = x" indique : stocker la valeur passée à x, tout en faisant l’objet de « this.x », la variable de classe.
- Les mêmes fonctions que nous avons vu avant est utilisé dans la classe. Une fonction associée à une classe est appelée une « méthode ».
C’est une bonne pratique de tenir vos Classes dans un fichier séparé, afin que votre code principal semble soigné. Vous pouvez faire cela en créant un second onglet sur l’environnement de traitement. Notez, nom de l’onglet doit être identique à celui de la classe. (voir photo ci-dessus ; troisième photo).
À l’aide de la classe pour fabriquer des objets :
déclarer des objets
Cercle c ;
Cercle d ;
void setup() {}
Size(400,400) ;
Smooth() ;
l’initialisation d’objets
c = new Circle(200,200,80,color(100)) ;
d = new Circle(344,355,20,color(62,177,137)) ;
}
{} void draw()
Background(255) ;
l’utilisation d’objets
c.Display() ;
c.Jiggle() ;
d.Display() ;
d.Jiggle() ;
}
voir les résultats ci-dessus (seconde photo).
Déclarer des objets - tout en déclarant des objets, il est plus facile d’envisager la classe comme un type de données nouvellement créée. « Cercle c » signifie donc, déclarez une variable « c » de type « Cercle » (comparer avec « int c »).
Lors de l’initialisation des objets - voir comment nous avons appelé le constructeur via le mot clé "new" ? Étant donné que la définition de constructeur de cercle avait des paramètres, il faut passer des arguments pour initialiser l’objet. Ces arguments sont assignés aux variables de l’objet (x, y, c etc..). Cela nous permet d’utiliser la même classe pour créer des objets avec des propriétés différentes. Dans l’exemple ci-dessus, d et c cercles sont différents les uns des autres en taille et en couleur.
En outre, Notez que les objets sont initialisés à setup(). C’est logique, puisque nous n’avons pas l’intention de l’initialisation de l’objet même maintes et maintes fois dans draw().
Utilisation d’objets - nous utilisons le point "." opérateur pour accéder aux méthodes de l’objet, comme indiqué ci-dessus.
