[Traitement × Java] Comment utiliser la classe
Cet article est destiné à comprendre la structure du programme à travers le traitement. Cette fois, j'écrirai sur la classe.
table des matières 0. Qu'est-ce qu'une classe?
- Classe préparée à l'avance
- Classes que vous définissez et créez
0. Qu'est-ce qu'une classe?
0-0. ** Qu'est-ce qu'une classe **
Un modèle (type) qui contient des champs (variables) et des méthodes (fonctions) associés. Il est souvent comparé aux recettes et aux dessins de conception.
0-1. ** Pourquoi utiliser des classes **
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 classe **
Il existe deux types de classes: "** classe préparée " et " classe auto-définie **".
Les classes pré-préparées sont, en particulier, String, PImage, PFont, PShape, PVector ... etc.
1. ** Classes pré-préparées **
Dans Processing, ** de nombreux cours sont préparés à l'avance **. String, PImage, PFont, PShape, PVector ... etc.
1-0. ** Comment utiliser les classes préparées **
Comme la classe n'est qu'un modèle (type), elle ne peut pas être utilisée telle quelle. Alors
① Rendre la classe concrète ** Créer un objet ** ② ** Mettez le contenu dans l'objet ** ③ Traitez l'objet comme une ** variable **
Dans la procédure, nous utiliserons la classe (informations qu'elle contient).
Regardons un exemple simple.
string.java
//Déclaration d'objet
String s1;
//Définition d'objet
s1 = "breakfast"
//Utilisation d'objets
println(s1.length());
9
Ce programme est un programme qui acquiert et affiche la longueur des caractères. Examinons de plus près chaque étape.
** ① Créer un objet en incarnant une classe **
//Déclaration d'objet
String s1;
** ② Mettez le contenu dans l'objet. ** **
//Définition d'objet
s1 = "breakfast"
** ③ Traitez l'objet comme une variable **
//Utilisation d'objets
println(s1.length());
Chaque objet a ** champs et méthodes ** que la classe a.
Pour accéder aux champs et méthodes de l'objet, utilisez des points (.). L'objet lui-même est traité comme une variable.
Pour l'utiliser comme une variable ** Définition (déclaration-> réglage initial) -> utilisation ** Cela signifie l'utiliser comme ça.
2. ** Classes que vous définissez et créez **
La programmation vous permet de créer vos propres classes pour simplifier votre programmation. Dans un premier temps, nous simplifierons le programme qui affiche les balles rebondissantes suivantes.
bouncingball.java
float x = 30;
float y = 30;
float xspeed = 5;
float yspeed = 3;
void setup(){
size(398,198);
}
void draw(){
background(255);
noStroke();
fill(234,159,217);
ellipse(x,y,50,50);
x += xspeed;
y += yspeed;
if(x > width-20 || x < 20){
xspeed *= -1;
}
if(y > height-20 || y < 20){
yspeed *= -1;
}
}
Pour simplifier le programme ① ** Modulariser ** ② ** Rendez-le réutilisable ** Je le ferai.
① Moduler
bouncingball_module.java
float x = 30;
float y = 30;
float xspeed = 5;
float yspeed = 3;
void setup(){
size(398,198);
}
void draw(){
background(255);
display();
move();
edges();
}
//Fonction pour afficher la balle
void display(){
fill(234,159,217);
noStroke();
ellipse(x,y,30,30);
}
//Fonction pour déplacer la balle
void move(){
x += xspeed;
y += yspeed;
}
//Fonction pour faire rebondir la balle
void edges(){
if(x > width-15 || x < 15){
xspeed *= -1;
}
if(y > height-15 || y < 15){
yspeed *= -1;
}
}
Point : En combinant ** en une seule fonction **, l'intérieur de la fonction draw () sera soigné et le programme sera facile à comprendre.
② Rendez-le réutilisable
Réutilisable signifie que ** plusieurs sorties sont possibles **.
bouncingball_reuse.java
//Déclaration d'objet
Ball b1;
Ball b2;
void setup(){
size(600,400);
//Définir un objet
b1 = new Ball(50,50,7,5);
b2 = new Ball(400,50,-7,-5);
}
void draw(){
background(255);
//Utiliser l'objet b1
b1.display();
b1.move();
b1.edges();
//Utiliser l'objet b2
b2.display();
b2.move();
b2.edges();
}
//Définir une classe
class Ball{
//Variables à utiliser(champ)Déclarer
int x;
int y;
float xspeed;
float yspeed;
//Constructeur de classe Ball
Ball(int xpos,int ypos,float xvelocity,float yvelocity){
x = xpos;
y = ypos;
xspeed = xvelocity;
yspeed = yvelocity;
}
//Fonction pour afficher la balle(Méthode)
void display(){
fill(234,159,217);
noStroke();
ellipse(x,y,30,30);
}
//Fonction pour déplacer la balle(Méthode)
void move(){
x += xspeed;
y += yspeed;
}
//Fonction pour faire rebondir la balle(Méthode)
void edges(){
if(x > width-15 || x < 15){
xspeed *= -1;
}
if(y > height-15 || y < 15){
yspeed *= -1;
}
}
}
Étapes pour le rendre réutilisable
① Créer un cadre de classe
class Ball{
}
② Insérer une fonction modulaire
(Le contenu est supprimé pour que la structure soit facile à comprendre.)
class Ball{
//Fonction pour afficher la balle(Méthode)
void display(){
}
//Fonction pour déplacer la balle(Méthode)
void move(){
}
//Fonction pour faire rebondir la balle(Méthode)
void edges(){
}
}
③ Préparez les variables (champs) à utiliser pour les fonctions (méthodes).
//Variables à utiliser(champ)Déclarer
int x;
int y;
float xspeed;
float yspeed;
//Définir une classe
class Ball{
//Fonction pour afficher la balle(Méthode)
void display(){
}
//Fonction pour déplacer la balle(Méthode)
void move(){
}
//Fonction pour faire rebondir la balle(Méthode)
void edges(){
}
}
④ Déclarez l'objet.
//Déclarez l'objet b1 à utiliser.
Ball b1;
//Déclarez l'objet b2 à utiliser.
Ball b2;
void setup(){
}
void draw(){
}
class Ball{
}
⑤ Mettez le contenu dans l'objet
Déclaration d'objet
Ball b1;
Ball b2;
void setup(){
//Attribuez une instance de la classe Ball à l'objet b1.
//Une instance est une classe matérialisée.
//L'objet b1 est traité comme une variable.
b1 = new Ball();
b2 = new Ball();
}
void draw(){
}
class Ball{
}
Point :b1⬅︎new Ball()
Assigner ** instance ** Ball () de la classe Ball à ** objet ** b1.
⑥ Utilisez un objet.
- Tous les objets ont des champs (variables) et des méthodes (fonctions) que la classe a. Utilisez des points (.) Pour accéder à vos propres champs et méthodes.
Ball b1;
Ball b2;
void setup(){
b1 = new Ball();
b2 = new Ball();
}
void draw(){
//Point(.)Utilisez pour accéder aux méthodes à l'intérieur de l'objet.
b1.display();
b1.move();
b1.edges();
//Point(.)Utilisez pour accéder aux méthodes à l'intérieur de l'objet.
b2.display();
b2.move();
b2.edges();
}
class Ball{
}
⑦ Créer un constructeur de classe
Le constructeur est ce dont vous avez besoin pour créer plusieurs objets à partir d'une classe. L'objet est d'accéder aux fonctions de la classe.
//Déclaration d'objet
//Il n'y a encore rien à l'intérieur
Ball b1;
Ball b2;
void setup(){
//Création d'objets(Définition)
//Attribuer une instance qui incarne la classe à l'objet créé
b1 = new Ball(50,50,7,5);
b2 = new Ball(400,50,-7,-5);
}
void draw(){
//Point(.)Utilisez pour accéder aux méthodes à l'intérieur de l'objet.
b1.display();
b1.move();
b1.edges();
//Point(.)Utilisez pour accéder aux méthodes à l'intérieur de l'objet.
b2.display();
b2.move();
b2.edges();
}
class Ball{
//Variables à utiliser(champ)Déclarer
int x;
int y;
float xspeed;
float yspeed;
//Constructeur de classe Ball
//Variable de type de données
Ball(int xpos,int ypos,float xvelocity,float yvelocity){
x = xpos;
y = ypos;
xspeed = xvelocity;
yspeed = yvelocity;
}
void display(){}
void move(){}
void edges(){}
}
** Point **: Constructeur Le constructeur connecte l'instance et le champ.
(Dans ce cas) 7 = float xvelocity = float xspeed Lorsque le programme est exécuté, xspeed est affecté à 7.
** Point **: Instance La matérialisation de l'objet. Dans ce cas, ** Ball (50,50,7,5) ** est l'une des instances de classe. Ball (400,50, -7, -5) est également une instance de la classe. ** Vous pouvez créer plusieurs instances à partir de la même classe. ** **
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.
Recommended Posts