header

 1) Structuur van een sketch in object georienteerd programmeren (OOP)

 
 

 
//1) declareren van objecten en variabelen 
Classnaam1 object1; // namen van classes beginnen met een hoofdletter 
Classnaam1 object2; // namen van objecten beginnen met een kleine letter 
Classnaam2 object3; // Classnaam2 als je nog een tweede classe hebt aangemaakt. 

 
//Van een classe kan je een oneindig aantal objecten aanmaken.  
//Je kan de objecten een positie geven met een array en geneste for lussen. 

 
//2) setup waarin objecten, en variabelen een beginwaarde (initialiseren) krijgen. 
void setup() { 
size(x,y); 

 
object1 = new Classnaam1(x,y, b,h, color(r,g,b));  
object2 = new Classnaam1(x,y, b,h, color(r,g,b)); 
object3 = new Classnaam2(x,y, b,h, color(r,g,b)); 
} 
 // (x,y, b,h, color(r,g,b); zijn de argumenten van de constructor 

//3) de objecten tekenen 
void draw() { 
background(r,g,b); //staat voor speciale effecten in setup  
object1.ellips(); //namen van methoden beginnen met een kleine letter 
object2.ellips(); 
object3.methode2();
}

Structuur van een sub of child classe
Als een methode niet in de subclasse staat wordt de methode van de superclass gebruikt
Je hoef in draw() van de sketch niet naar de superclass te verwijzen.

 

 //1) de classnaam met extends naar de superclass    
class ClassSub extends Super { 
  
//2) declareren van globale variabelen 
     // de argumenten van de constructor (x, y, b, h en c) niet declareren 
     // want dat gebeurt in de superclass 
 
//3) aanmaken van de constructor met de argumenten (argumenten zijn locale variabelen) 
  ClassSub(float x_, float y_, float b_, float h_, color c_) {  
    super(x_, y_, b_, h_, c_);             //zodat de superclass deze variabelen kan gebruiken//  
    
//locale argumenten van de constructor in de subclass hier niet global maken   
//want dat gebeurt in de superclass.             
  }    
 
//4) methodes aanmaken 
   void ellips() {             
    fill(c);             
    ellipse(x, y, b, h); 
   super.display();           //hiermee roep je als extra de methode display van de superclass op 
  }                                     
 
  void rechthoek() { 
    rectMode(CENTER); 
    fill(c); 
    rect(x, y, b, h); 
  } 
}
 
 structuur van de parent of superclass
Ik gebruik de superclass voor de bewegingsmethodes
 

//Beschikbare bewegingsmethodes: stijgen, dalen, heen, terug, heenEnTerug,
//terugEnHeen, opEnNeer,  snelhxy, trillen, draaien en sinus.

//1) classnaam 
class Super {
 
//2) declareren van de globals die in de constructor staan 
 float x; float y; float b; float h; color c; 
//opm: b, h en color worden niet gebruikt in deze superclass
 
//3) declareren en initialiseren van de globals die niet in de constructor staan 
 int r; float a; int yspeed = 2; int snelhHeen = 2; int snelhTerug = 4;  
 int snelhOpEnNeer = 2; int snelhHeenEnTerug = 8; int xsnelh = 1; int ysnelh = 8;
 
//4) de constructor 
 Super(float x_, float y_, float b_, float h_, color c_) {  
 x = x_; y = y_; b = b_; h = h_; c = c_ ;  
 }
 
//5) de bewegingsmethodes
void stijgen() {  
 y = y - yspeed;  
 if (y < 0) {  
 y = height; 
 } 
 }
 
void dalen() {  
 y = y + yspeed;  
 if (y > height) {  
 y = 0; 
 } 
 }
 
void heen() {  
 x = x + snelhHeen;  
 if (x > width) {  
 x = 0; 
 } 
 }
 
void terug() {  
 x = x - snelhTerug;  
 if (x < 0) {  
 x = width; 
 } 
 }
 
void heenEnTerug() {  
 x = x + snelhHeenEnTerug;  
 if ((x > width) || (x < 0)) {  
 snelhHeenEnTerug = snelhHeenEnTerug * -1; 
 } 
 }
 
void terugEnHeen() {  
 x = x - snelhHeenEnTerug;  
 if ((x > width) || (x < 0)) {  
 snelhHeenEnTerug = snelhHeenEnTerug * -1; 
 } 
 }
 
void opEnNeer() {  
 y = y - snelhOpEnNeer;  
 if ((y < 0) || (y > height)) {  
 snelhOpEnNeer = snelhOpEnNeer* -1; 
 } 
 }
 
void snelhxy() {  
 x = x + xsnelh;  
 if ((x > width) || (x < 0)) {  
 xsnelh = xsnelh * -1; 
 }  
 y = y + ysnelh;  
 if ((y > height) || (y < 0)) {  
 ysnelh = ysnelh * -1; 
 } 
 }
 
void trillen() {  
 x += random(-1, 1);  
 y += random(-1, 1); 
 }
 
void draaien() {  
 translate(width/2, height/2);  
//translate verplaatst het middelpunt van het canvas naar het (0,0) punt van het assenstelsel 
 r = r + 1; //ook mag r++ 
 rotate(radians(r));  
 if (r == 360) r = 0; 
 }
 //de methode draaien
//Je hebt ook rotateX, rotateY en rotateZ . Niet vergeten met P3D het assenstelsel 3d te maken. 
// De draaien methode moet in de sketch tussen pushMatrix(); en popMatrix(); staan 
// Als je de vorm in het centrum wil laten draaien moet je x en y in de constructor op 0 zetten dus: 
// object1 = new ClassSub(0, 0, b, h, color(r,g,b));  
// In draw: 
// pushMatrix(); 
// object1.draaien(); //na pushMatrix(); eerst de draaien methode aanroepen  
// object1.ellips(); 
// popMatrix();
 
void sinus() { 
 y = map(sin(a), -1, 1, 0, height); 
 x = x + 4;  
 if (x > width) x = 0; 
 a = a +0.03; 
 }
 
//Display in de super class om override te demonsteren  
 void display() {  
 ellipse(x, y, 30, 10); 
 } 
}

Opm: Ik kreeg na het opbouwen een NullPointerExeption omdat ik een object twee maal had geinitialiseerd. Er kwam geen foutmelding. Dit soort meldingen zie je ook als je uit een array loop
Soms loopt bij een NullPointerExeption de computer vast.