De schets maakt gebruik van de classes "Ellips" , "Rechthoek" , "Mens" en de superclass "Super"

In de classes worden x_ en y_ via super(x_, y_) (is de superconstructor) aan de constructor van de superclass gegeven waar ze dan global worden gemaakt.

Alle classes moeten een superconstructor hebben met hetzelfde aantal argumenten als in de constructor van de superclass

De schets

 

Rechthoek rechth;   
Ellips    ellips;   
Mens      vrouw;  
Ruitjes   ruitjespap; 
 
void setup() {   
  size(840, 360); 
  float x = width/2; 
  float y = height/2; 
  float n = height/10; 
  float h = n/9; //Het poppetje is 9*n hoog met h is het poppetje n hoog 
 
  ruitjespap = new Ruitjes(n, x, y); 
  rechth  = new Rechthoek(x-6*n, y, 3*n, 2*n, color(0, 20, 100, 80));   
  vrouw   = new Mens(     x,     y, 4*h,      color(106, 165, 45));   
  ellips  = new Ellips(   x+5*n, y, n,   5*n, color(106, 165, 45)); 
} 
 
void draw() {   
  background(255);  
  ruitjespap.display(); 
  rechth.display();   
  vrouw.displayVrouw();  
  vrouw.yUpDown();  
  ellips.display();  
  ellips.trillen();  
}

 

class Super {              
 float x;  
 float y;  
  
 float ysnelhUp = 1; 
 
//Het aantal variabelen in de constructor van de superclass moet hetzelfde zijn  
//als het aantal variabelen in de superconstructor van de classes  
Super(float x_, float y_) { //constructor van de superclass 
  x = x_;  
  y = y_;  
 } 
   
void yUpDown() {      
    y = y - ysnelhUp;      
    if ((y < 0) || (y > height)) {      
      ysnelhUp = ysnelhUp* -1;    
    }    
  }  
   
void trillen() {  
 x += random(-1, 1);  
 y += random(-1, 1);  
 } 
  
// Display in de superklasse om override te demonsteren  
 void display() {  
 ellipse(x, y, 30, 10);  
 }  
}

 De class "Rechthoek"

 


class Rechthoek extends Super {

  float b; 
  float h; 
  color c; 
   
Rechthoek(float x_, float y_, float b_, float h_, color c_) { 
// onderstaande  super constructor geeft de variabelen x_ en y_ aan de constructor in de superclass  
// x_ en y_ worden in de class super gebruikt tbv de bewegingsmethoden 
// x_ en y_ worden in "Super" global gemaakt en zijn dan ook global beschikbaar voor de classes. 
 super(x_, y_); //de superconstructor 
 b = b_; 
 h = h_; 
 c = c_; 
 } 
  
void display() {  
 rectMode(CENTER);  
 fill(c);  
 stroke(0);  
 rect(x, y, b, h);  
 super.display();   
 }  
} 

de subclass  "Ellips"

 


class Ellips extends Super { 
//b, h en c  worden hier global gemaakt 
  float b; 
  float h; 
  color c; 
   
Ellips(float x_, float y_, float b_, float h_, color c_) { 
// onderstaande  super constructor geeft de variabelen x_ en y_ aan de constructor in de superclass  
// x_ en y_ worden in de class super gebruikt tbv de bewegingsmethoden 
// x_ en y_ worden in "Super" global gemaakt en zijn dan ook global beschikbaar voor de classes. 
 super(x_, y_); //de superconstructor 
 b = b_; 
 h = h_; 
 c = c_; 
 } 
  
void display() {  
 fill(c);  
 stroke(0);  
 ellipse(x, y, b, h);  
 super.display();  
 }  
} 

de class "Mens" met de methodes displayMan en displayVrouw

 


class Mens extends Super{      
   float n; 
   color c; 
   
Mens(float x_, float y_, float n_, color c_) {   
// x_ en y_ worden ook gebruikt in de class super tbv de bewegingsmethoden 
// x_ en y_ worden daar global gemaakt en dus "gezien" in de displayVrouw en displayMan methodes 
// Deze super constructor geeft de variabelen aan de constructor in de superclass  
   super(x_, y_); 
   x = x_; 
   y = y_; 
   n = n_; 
   c = c_;    
  }   
     
 void displayVrouw() {    
   rectMode(CORNER); 
   strokeWeight(2);    
   fill(37,159,232,100);       
   ellipse(x,  y-4*n, 2*n, 2*n);   //hoofd        
   rect(x-n,   y-3*n, 2*n, 3*n);   //lichaam      
   rect(x-2*n, y-3*n, n,   3*n);   //arm li      
   rect(x+n,   y-3*n, n,   3*n);   //arm re     
   rect(x-n,   y+2*n, n/2, 2*n);   //li been      
   rect(x+n/2, y+2*n, n/2, 2*n);   //Re been     
   fill(c);  
   quad(x-2*n, y+2*n, x-n, y, x+n, y, x+2*n, y+2*n); //jurk     
 }    
      
 void displayMan() {   
   rectMode(CORNER); 
   strokeWeight(2);    
   fill(c);        
   ellipse(x,  y-4*n, 2*n, 2*n);   //hoofd        
   rect(x-n,   y-3*n, 2*n, 4*n);   //lichaam      
   rect(x-2*n, y-3*n, n,   3*n);   //arm li      
   rect(x+n,   y-3*n, n,   3*n);   //arm re     
   rect(x-n,   y+n,   n/2, 3*n);   //li been      
   rect(x+n/2, y+n,   n/2, 3*n);   //Re been       
 }    
}