[Verarbeitung × Java] Verwendung der Klasse

Dieser Artikel dient zum Verständnis der Struktur des Programms durch Verarbeitung. Dieses Mal werde ich über die Klasse schreiben.

Inhaltsverzeichnis 0. Was ist eine Klasse?

1. Vorbereitete Klasse
2. Klassen, die Sie definieren und erstellen

0. Was ist eine Klasse?

0-0. ** Was ist eine Klasse **

Eine Vorlage (Typ), die verwandte Felder (Variablen) und Methoden (Funktionen) enthält. Es wird oft mit Rezepten und Konstruktionszeichnungen verglichen.

0-1. ** Warum Klassen verwenden **

Der Hauptgrund ist ① ** Weil das Programm leichter zu lesen ist. ** ** ** ② ** Weil es wiederverwendet werden kann. ** ** ** (Details zur Wiederverwendung später)

0-2. ** Klassentyp **

Es gibt zwei Arten von Klassen: "** vorbereitete Klasse " und " selbst definierte Klasse **".

Die vorbereiteten Klassen sind insbesondere String, PImage, PFont, PShape, PVector ... usw.

1. ** Vorbereitete Kurse **

In der Verarbeitung ** werden viele Klassen im Voraus vorbereitet **. String, PImage, PFont, PShape, PVector ... etc.

1-0. ** Verwendung der vorbereiteten Klassen **

Da die Klasse nur eine Vorlage (Typ) ist, kann sie nicht so verwendet werden, wie sie ist. Damit

① Machen Sie die Klasse konkret ** Erstellen Sie ein Objekt ** ② ** Füge den Inhalt in das Objekt ein ** ③ Behandle das Objekt als ** Variable **

In der Prozedur verwenden wir die Klasse (Informationen darin).

Schauen wir uns ein einfaches Beispiel an.

string.java

//Objekterklärung
String s1;
//Objektdefinition
s1 = "breakfast"
//Verwendung von Objekten
println(s1.length());

9

Dieses Programm ist ein Programm, das die Zeichenlänge erfasst und anzeigt. Schauen wir uns jeden Schritt genauer an.

** ① Erstellen Sie ein Objekt, indem Sie eine Klasse verkörpern **

//Objekterklärung
String s1;

** ② Legen Sie den Inhalt in das Objekt. ** ** **

//Objektdefinition
s1 = "breakfast"

** ③ Behandle das Objekt als Variable **

//Verwendung von Objekten
println(s1.length());

Jedes Objekt hat ** Felder und Methoden **, die die Klasse hat.

Verwenden Sie Punkte (.), Um auf die Felder und Methoden des Objekts zuzugreifen. Das Objekt selbst wird wie eine Variable behandelt.

Um es wie eine Variable zu verwenden ** Definition (Deklaration-> Grundeinstellung) -> Verwendung ** Es bedeutet, es so zu benutzen.

2. ** Klassen, die Sie definieren und erstellen **

Mit der Programmierung können Sie eigene Klassen erstellen, um die Programmierung zu vereinfachen. Zunächst werden wir das Programm vereinfachen, das die folgenden springenden Bälle anzeigt.

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;
  }
}

Um das Programm zu vereinfachen ① ** Modularisieren ** ② ** Mach es wiederverwendbar ** Ich werde das machen.

① Modulieren

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();
}


//Funktion zur Anzeige des Balls
void display(){
  fill(234,159,217);
  noStroke();
  ellipse(x,y,30,30);
}

//Funktion zum Bewegen des Balls
void move(){
  x += xspeed;
  y += yspeed;
}

//Funktion zum Abprallen des Balls
void edges(){
  if(x > width-15 || x < 15){
    xspeed *= -1;
  }
  if(y > height-15 || y < 15){
    yspeed *= -1;
  }
}

Point : Durch die Kombination von ** zu einer Funktion ** wird das Innere der Funktion draw () sauber und das Programm leicht verständlich.

② Machen Sie es wiederverwendbar

Wiederverwendbar bedeutet, dass ** mehrere Ausgänge möglich sind **.

bouncingball_reuse.java

//Objekterklärung
Ball b1;
Ball b2;

void setup(){
  size(600,400);
  //Definieren Sie ein Objekt
  b1 = new Ball(50,50,7,5);
  b2 = new Ball(400,50,-7,-5);
}

void draw(){
  background(255);
  //Verwenden Sie das Objekt b1
  b1.display();
  b1.move();
  b1.edges();
  
  //Verwenden Sie das Objekt b2
  b2.display();
  b2.move();
  b2.edges();
}

//Definieren Sie eine Klasse
class Ball{
  //Zu verwendende Variablen(Feld)Erklären
  int x;
  int y;
  float xspeed;
  float yspeed;
  
  //Ballklassenkonstruktor
  Ball(int xpos,int ypos,float xvelocity,float yvelocity){
    x = xpos;
    y = ypos;
    xspeed = xvelocity;
    yspeed = yvelocity;
  }
  
  //Funktion zur Anzeige des Balls(Methode)
  void display(){
    fill(234,159,217);
    noStroke();
    ellipse(x,y,30,30);
  }
  
  //Funktion zum Bewegen des Balls(Methode)
  void move(){
    x += xspeed;
    y += yspeed;
  }
  
  //Funktion zum Abprallen des Balls(Methode)
  void edges(){
    if(x > width-15 || x < 15){
      xspeed *= -1;
    }
    if(y > height-15 || y < 15){
      yspeed *= -1;
    }
  }
}

Schritte, um es wiederverwendbar zu machen

① Erstellen Sie ein Klassenframework

class Ball{

}

② Fügen Sie eine modularisierte Funktion ein

(Der Inhalt wird entfernt, damit die Struktur leicht verständlich ist.)

class Ball{

  //Funktion zur Anzeige des Balls(Methode)
  void display(){
  }
  //Funktion zum Bewegen des Balls(Methode)
  void move(){
  }
  //Funktion zum Abprallen des Balls(Methode)
  void edges(){
  }
}

③ Bereiten Sie Variablen (Felder) für Funktionen (Methoden) vor.

//Zu verwendende Variablen(Feld)Erklären
int x;
int y;
float xspeed;
float yspeed;

//Definieren Sie eine Klasse
class Ball{

  //Funktion zur Anzeige des Balls(Methode)
  void display(){
  }
  //Funktion zum Bewegen des Balls(Methode)
  void move(){
  }
  //Funktion zum Abprallen des Balls(Methode)
  void edges(){
  }
}

④ Deklarieren Sie das Objekt.

//Deklarieren Sie das zu verwendende Objekt b1.
Ball b1;
//Deklarieren Sie das zu verwendende Objekt b2.
Ball b2;

void setup(){
}
void draw(){
}

class Ball{
}

⑤ Legen Sie den Inhalt in das Objekt

Objekterklärung
Ball b1;
Ball b2;

void setup(){
  //Weisen Sie dem Objekt b1 eine Instanz der Ball-Klasse zu.
  //Eine Instanz ist eine materialisierte Klasse.
  //Objekt b1 wird als Variable behandelt.
  b1 = new Ball();
  b2 = new Ball();
}
void draw(){
}

class Ball{
}

Point :b1⬅︎new Ball() Sie weisen einem ** Objekt ** b1 eine ** Instanz ** Ball () der Ball-Klasse zu.

⑥ Verwenden Sie ein Objekt.

• Alle Objekte haben Felder (Variablen) und Methoden (Funktionen), über die die Klasse verfügt. Verwenden Sie Punkte (.), Um auf Ihre eigenen Felder und Methoden zuzugreifen.

Ball b1;
Ball b2;

void setup(){
  b1 = new Ball();
  b2 = new Ball();
}
void draw(){

  //Punkt(.)Verwenden Sie diese Option, um auf die Methoden im Objekt zuzugreifen.
  b1.display();
  b1.move();
  b1.edges();

  //Punkt(.)Verwenden Sie diese Option, um auf die Methoden im Objekt zuzugreifen.
  b2.display();
  b2.move();
  b2.edges();
}

class Ball{
}

⑦ Erstellen Sie einen Klassenkonstruktor

Der Konstruktor ist das, was Sie benötigen, um mehrere Objekte aus einer Klasse zu erstellen. Das Objekt dient zum Zugriff auf die Funktionen in der Klasse.

//Objekterklärung
//Es ist noch nichts drin
Ball b1;
Ball b2;

void setup(){
  //Objekterstellung(Definition)
  //Weisen Sie dem erstellten Objekt eine Instanz zu, die die Klasse verkörpert
  b1 = new Ball(50,50,7,5);
  b2 = new Ball(400,50,-7,-5);
}
void draw(){

  //Punkt(.)Verwenden Sie diese Option, um auf die Methoden im Objekt zuzugreifen.
  b1.display();
  b1.move();
  b1.edges();

  //Punkt(.)Verwenden Sie diese Option, um auf die Methoden im Objekt zuzugreifen.
  b2.display();
  b2.move();
  b2.edges();
}

class Ball{
  //Zu verwendende Variablen(Feld)Erklären
  int x;
  int y;
  float xspeed;
  float yspeed;

  //Ballklassenkonstruktor
  //Datentypvariable
  Ball(int xpos,int ypos,float xvelocity,float yvelocity){
    x = xpos;
    y = ypos;
    xspeed = xvelocity;
    yspeed = yvelocity;
  }

  void display(){}
  void move(){}
  void edges(){}
}

** Punkt **: Konstruktor Der Konstruktor verbindet die Instanz und das Feld.

(In diesem Fall) 7 = float xvelocity = float xspeed Wenn das Programm ausgeführt wird, wird xspeed 7 zugewiesen.

** Punkt **: Instanz Die Materialisierung des Objekts. In diesem Fall ist ** Ball (50,50,7,5) ** eine der Klasseninstanzen. Ball (400,50, -7, -5) ist ebenfalls eine Instanz der Klasse. ** Sie können mehrere Instanzen aus derselben Klasse erstellen. ** ** **

Schließlich

Danke fürs Lesen. Wir freuen uns über Ihre Meinungen und Vorschläge, um den Artikel noch besser zu machen.

• Dieser Artikel basiert auf Daniel Chefmans Youtube "Coding Train".