[Traitement × Java] Comment utiliser la fonction

Cet article est destiné à comprendre la structure du programme à travers le traitement. Cette fois, j'écrirai sur les fonctions.

table des matières 0. Comment utiliser la fonction

1. Fonctions préparées à l'avance
2. Fonctions que vous définissez et créez
3. Exemple de modularisation de fonction → réutilisation

0. Qu'est-ce qu'une fonction?

0-0. ** Qu'est-ce qu'une fonction **

Les fonctions sont comme des périphériques de sortie. Il prend quelque chose, le convertit et le produit.

0-1. ** Pourquoi utiliser des fonctions **

La raison principale est ① ** Parce que le programme devient plus facile à lire. ** ** ② ** Parce qu'il peut être réutilisé. ** ** (Détails sur la réutilisation plus tard)

0-2. ** Type de fonction **

Il existe deux types de fonctions: «** fonctions prédéfinies » et « fonctions auto-définies **».

Les fonctions fournies à l'avance sont, en particulier, size (), background (), line (), void setup (), void draw () ... etc.

1. ** Fonctions pré-préparées **

Dans Processing, ** de nombreuses fonctions sont préparées à l'avance **. size (), background (), rect (), ellipse () ... etc. Par exemple, dans la fonction size (), size (600,400); affichera une fenêtre avec une largeur de 600px et une hauteur de 400px.

L'important ici est que les fonctions prédéfinies doivent être utilisées selon ** les règles **.

Par exemple, size (600,400,300,200); entraînera une erreur. Vous pouvez trouver les ** règles fixes ** en consultant la [Reference] Processing (https://processing.org/reference/).

(Exemple) Règle fixe de taille ()

2. ** Fonctions que vous définissez et créez **

En programmation, vous pouvez créer vos propres fonctions originales pour simplifier le programme. Tout d'abord, nous simplifierons le programme qui affiche les cercles suivants.

maru.java

void setup(){
  size(200,200);
  background(255);
}

void draw(){
  strokeWeight(3);
  stroke(77,196,224);
  noFill();
  ellipse(100,100,30,30);
}

Pour simplifier le programme ① ** Modulariser ** ② ** Rendez-le réutilisable ** Je le ferai.

① Moduler

maru_module.java

void setup(){
  size(200,200);
  background(255);
}

//Vous pouvez voir en un coup d'œil ce qu'il faut répéter!
void draw(){
  //Exécutez la fonction d'origine que vous avez créée.
  maru();
}

//Résumé ici! !!
void maru(){
  strokeWeight(3);
  stroke(77,196,224);
  noFill();
  ellipse(100,100,30,30);
}

Point : En combinant ** en une seule fonction **, la fonction draw () sera plus propre et le programme sera plus facile à comprendre.

② Rendez-le réutilisable

Réutilisable signifie que ** plusieurs sorties sont possibles **.

maru_reuse.java

void setup(){
  size(200,200);
  background(255);
}

void draw(){
  //Utilisez votre propre fonction définie
  //Vous pouvez facilement afficher plusieurs cercles!
  //maru(coordonnée x,coordonnée y,La taille du cercle);
  maru(100,80,100);
  maru(100,100,50);
}

//Définition des fonctions
//Décidez d'abord quoi prendre comme argument
void maru(float x,float y,float s){
  strokeWeight(3);
  stroke(77,196,224);
  noFill();
  //Il dit quoi utiliser la valeur de l'argument
  ellipse(x,y,s,s);
}

Point : Pour le rendre réutilisable, laissez la valeur de l'argument (paramètre) être déterminée. De cette façon, vous pouvez modifier la valeur de sortie de la fonction.

Dans ce but (1) Décidez de la valeur que vous souhaitez modifier et exprimez-la sous forme de variable.

  ellipse(x,y,s,s);

(2) Définissez l'argument sous la forme de ** variable de type de données **.

void maru(float x,float y,float s){
}

③ Utilisez la fonction selon les règles de la fonction que vous avez définie.

  maru(100,80,100);

□ ** Qu'est-ce qui est nul **

Les données reçues à la suite de l'exécution de la fonction sont appelées la ** valeur de retour **.

La fonction renvoie essentiellement une valeur telle que int ou float. Exemple de fonction qui renvoie un nombre de type flottant ↓

float_function.java

void setup(){
  //Moyenne auto-définie()Utilisez une fonction pour affecter la valeur moyenne à la variable f.
  float f = average(12.0,6.0);
  //Affichez la valeur de f.
  println(f);
}

//Une fonction qui peut calculer la valeur moyenne de deux valeurs moyennes()Est défini.
float average(float num1,float num2){
  //Créez une expression pour que la valeur moyenne de deux valeurs puisse être affectée à la variable av
  float av = (num1 + num2) / 2.0;
  //Renvoie un nombre de type flottant comme valeur de retour
  return av;
}

9.0

Cependant, les fonctions de dessin, telles que ellipse (), ne renvoient pas de valeur. Utilisez void si la fonction ne renvoie pas une ** valeur de retour ** comme celle-ci.

Point : Les fonctions qui ne renvoient pas de valeur de retour sont généralement utilisées seules. (Autrement dit, le vide n'est pas écrit) background (), fill (), rect () .... etc. Ajoutez void à la fonction ** qui détermine le contenu de traitement à l'aide de ** {}. void setup () {}, void draw () {} ... etc.

3. Exemple de modularisation de fonction → réutilisation

◯ Programme pour dessiner des pétales de fleurs de cerisier

sakura.java

int x = 300;
int y = 300;
//Définissez une variable r qui détermine la vitesse de rotation.
float r = 30.0;
//Définissez la variable a qui détermine la transparence des fleurs de cerisier.
int a = 150;

void setup(){
size(600,600);
}

void draw(){
  background(255);
  //Les représentations jusqu'à popMatrix sont sorties ensemble.
  pushMatrix();
  //Point de référence des coordonnées(origine)À(x,y)Déménager à
  translate(x,y);
  //Utilisez la variable r pour déterminer le degré de rotation.
  rotate(frameCount/r);
  //Représentation des fleurs de cerisier
  for(int i = 0;i < 5;i++){
    rotate(TWO_PI * 1/5);
    noStroke();
    fill(255,50,80,a);
    stroke(225,50,80,100);
    bezier(0,0,35,-20,35,-52,8,-80);
    bezier(0,0,-35,-20,-35,-52,-8,-80);
    stroke(225,50,80,30);
    triangle(0,0,8,-80,0,-75);
    triangle(0,0,-8,-80,0,-75);
  }
  fill(200,50,100,200);
  ellipse(0,0,15,15);
  //La représentation des fleurs de cerisier est sortie ensemble.
  popMatrix();
}

◯ Programme pour dessiner des pétales de fleurs de cerisier (modulariser)

sakura_module.java

int x = 300;
int y = 300;
float r = 30.0;
int a = 150;

void setup(){
size(600,600);
}

//draw()L'intérieur de la fonction est devenu plus propre et plus facile à voir.
void draw(){
  background(255);
  //Utilisez votre propre fonction définie!
  sakura();
}

//Définissez une fonction pour les pétales de fleurs de cerisier.
void sakura(){
  pushMatrix();
  translate(x,y);
  rotate(frameCount/r);
  for(int i = 0;i < 5;i++){
    rotate(TWO_PI * 1/5);
    noStroke();
    fill(255,50,80,a);
    stroke(225,50,80,100);
    bezier(0,0,35,-20,35,-52,8,-80);
    bezier(0,0,-35,-20,-35,-52,-8,-80);
    stroke(225,50,80,30);
    triangle(0,0,8,-80,0,-75);
    triangle(0,0,-8,-80,0,-75);
  }
  fill(200,50,100,200);
  ellipse(0,0,15,15);
  popMatrix();
}

◯ Programme pour dessiner des pétales de fleurs de cerisier (le rendre réutilisable)

sakura_reuse.java

void setup(){
size(600,600);
}

void draw(){
  background(255);
  //Sortie 3 fonctions avec différents paramètres
  sakura(400,200,30,150);
  sakura(100,300,-40,100);
  sakura(380,400,60,50);
}
//Définir la fonction d'origine
//Les arguments sont définis sous la forme de types de données et de variables.
void sakura(float x,float y,float r,float a){
  
  pushMatrix();
  translate(x,y);
  rotate(frameCount/r);
  for(int i = 0;i < 5;i++){
    rotate(TWO_PI * 1/5);
    noStroke();
    fill(255,50,80,a);
    stroke(225,50,80,100);
    bezier(0,0,35,-20,35,-52,8,-80);
    bezier(0,0,-35,-20,-35,-52,-8,-80);
    stroke(225,50,80,30);
    triangle(0,0,8,-80,0,-75);
    triangle(0,0,-8,-80,0,-75);
  }
  fill(200,50,100,200);
  ellipse(0,0,15,15);
  popMatrix();
}

finalement

Merci pour la lecture. Nous apprécions vos opinions et suggestions afin de rendre l'article encore meilleur.

• Cet article est basé sur YouTube "Coding Train" de Daniel Chefman.