Arrays in Processing: Unterschied zwischen den Versionen

//Deklarieren der Arrayvariable
long [ ] fibonacci;
 
void setup(){
//Erzeugung des Arrays
long [ ] fibonacci = new long [20];
 
//Initialisierung des Arrays
  fibonacci[0]=0;
  fibonacci[1]=1;
  for (int i=2;i<20;i++){fibonacci[i]=fibonacci[i-1]+fibonacci[i-2];};
 
//Ausgabe des Arrays auf der Konsole
for (int j=0;j<20;j++){println(fibonacci[j]);};
}

//Deklarieren der Arrayvariable
long [ ] pot;
 
void setup(){
 
//Deklaration des Arrays
  long [ ] pot = new long [10];
 
//Deklaration und Initialisierung der Variablen (Beispiel: basis=2)
  int basis=23;
 
//Initialisierung des Arrays
  pot[0]=1;
  for(int i=1; i<10; i++) {pot[ i ]=pot[ i-1 ]*basis;}
 
//Ausgabe auf Konsole
  for(int j=0; j<10; j++){println(pot[ j ]);}
}

//Deklaration der Arrayvariable
Kreis [] k;
 
void setup(){
  size(400, 400);
 
  //Erzeugen des Arrays
  k = new Kreis[20];
 
  //Initialisierung des Arrays mittels einer Schleife
  for(int i=0; i<k.length; i++){
    k[i] = new Kreis(random(width), random(height));
  }
}
 
void draw(){
  background(0);
  noStroke();
 
  //Darstellung der wachsenden Kreise auf der Zeichenfläche
  for(int i=0; i<k.length; i++){
    k[i].display();
    k[i].grow();
}
}
 
 
 
class Kreis{
 
 //Position
 float x;
 float y;
 
 //Farbe und Transparenz
 color c = color(random(256), random(256), random(256)); 
 int opacity = 255;
 
 //Startwert für Radius
 int r = 1;
 
 
//Konstruktor Kreis(float x, float y){
   this.x = x;
   this.y = y;  
 }
 
 void display(){
   //Fülleigenschaften (Farbe und Transparenz); Zugriff auf die Farbbestandteile durch Farbfunktionen
   //Berechnung z.B. 255-red(c) garantiert vollere Farben
   fill(color(255-red(c), 255-green(c), 255-blue(c)), opacity);
   ellipse(x, y, r, r);
 }
 
 void grow(){
   //Wachsen und zunehmende Transparenz
   r++;
   opacity--;
   //Ab einem gewissen Radius werden Radius und Transparenz zurückgesetzt und der Kreis erhält eine neue Position
   if(r>220){r=1; opacity = 255; x= random(width); y = random (height);};
 }
}

Ball [] bouncer = new Ball[10];
 
void setup() {
  size(400,400);
 
  for(int i=0; i<bouncer.length; i++){
    bouncer[i] = new Ball(random(width-10), random(height-10), random(6), random(6));
  }
}
 
void draw() {
 
  background(255);
 
  for(int i=0; i<bouncer.length; i++){
   bouncer[i].display(); 
   bouncer[i].move();
   bouncer[i].bounce();
 
 
    for(int j=0; j<bouncer.length; j++){
      if ((dist(bouncer[i].x, bouncer[i].y, bouncer[j].x, bouncer[j].y) < 15)) {
    bouncer[i].vX = -bouncer[i].vX;
    bouncer[i].vY = -bouncer[i].vY;
    bouncer[j].vX = -bouncer[j].vX;
    bouncer[j].vY = -bouncer[j].vY;
      }
  }  
}
}
 
 
 
class Ball{
 
//Startposition des Balles
float x;
float y;
 
//Geschwindigkeit des Balles in x- bzw. y-Richtung
float vX;
float vY;
 
//Farbe (Grauwert) des Balles
color c;
 
Ball(float x, float y, float vX, float vY){
  this.x = x;
  this.y = y;
  this.vX = vX;
  this.vY = vY;
  c = color(random(256));
}
 
void display(){
  noStroke();
  fill(c);
  ellipse(x,y,20,20);
}
 
void move(){
   x = x + vX;
   y = y + vY;
}
 
void bounce(){
  if ((x > width-10) || (x < 10)) {vX = -vX;};
  if ((y > height-10) || (y < 10)) {vY = -vY;};
}
}

Punkt [] p;
Punkt [] q;
Punkt [] r;
 
 
void setup () {
  size (550, 500); 
 
 //Erzeugen und Initialisieren der drei Arrays 
  p = new Punkt[30];
 
  for(int i = 0; i<p.length; i++){
    p[i] = new Punkt(200, i*(360/p.length), 0.03, 10);
  }
 
   q = new Punkt[20];
 
  for(int i = 0; i<q.length; i++){
    q[i] = new Punkt(160, i*(360/q.length), -0.03, 20);
  }
 
  r = new Punkt[40];
 
  for(int i = 0; i<r.length; i++){
    r[i] = new Punkt(110, i*(360/r.length), 0.02, 8);
  }
}
 
void draw(){
  background(0);
 
  //Darstellung der drei rotierenden Kreise aus Punkten
  for(int i = 0; i<p.length; i++){
  p[i].display();
  p[i].move();
  }
 
  for(int i = 0; i<q.length; i++){
  q[i].display();
  q[i].move();
  }
 
  for(int i = 0; i<r.length; i++){
  r[i].display();
  r[i].move();
  }
}
 
 
 
class Punkt{
 
float x;                // x-Position des Punktes
float y;                // y-Position des Punktes
float r;                // Radius der Kreisbahn
float alpha;            // aktueller Rotationswinkel
float da;               // Änderungswert des Rotationswinkels
color c = color(random(256), random(256), random(256));  //Farbe des Punktes
int sw;                 // Dicke des Punktes
 
 
//Konstruktor
Punkt(float r, float alpha, float da, int sw){
  this.r = r;
  this.alpha = radians(alpha);
  this.da = da;
  this.sw = sw;
}
 
void display(){
  // Zeichnen des Kreises
  stroke(c);
  strokeWeight(sw);
  point (x, y);
}
 
void move () {
 
  // Veränderung des Rotationswinkels
  alpha += da; 
 
  // Berechnung der aktuellen Position
  x = width/2 + cos (alpha) * r;
  y = height/2 + sin (alpha) * r;
 
 
  //Zusätzlicher Code für die Variante
 
  //Vergrößerung des Radius
  r+=0.5;
  //Rückstellung des Radius und Änderung der Bewegungsrichtung bei width/3
  if(r>width/3){r=10; da=-da;};
} 
}

//Hintergrundbild Sektglas
PImage photo;
 
//Arrays von Bläschen
Bubble [] b1;
Bubble [] b2;
Bubble [] b3;
Bubble [] b4;
Bubble [] b5;
Bubble [] b6;
 
void setup(){
  size(450, 725);
  photo = loadImage("glas.jpg");
 
  b1 = new Bubble[20];
  b2 = new Bubble[20];
  b3 = new Bubble[20];
  b4 = new Bubble[20];
  b5 = new Bubble[20];
  b6 = new Bubble[20];
 
  //Initialisierung der Arrays
  for(int i=0; i< b1.length; i++){
   b1[i] = new Bubble(220, 220-i*8); 
  }  
  for(int i=0; i< b2.length; i++){
   b2[i] = new Bubble(200, 220-i*7); 
  }
  for(int i=0; i< b3.length; i++){
   b3[i] = new Bubble(170, 220-i*8); 
  }
  for(int i=0; i< b4.length; i++){
   b4[i] = new Bubble(230, 220-i*9); 
  }
  for(int i=0; i< b5.length; i++){
   b5[i] = new Bubble(260, 210-i*8); 
  }
  for(int i=0; i< b6.length; i++){
   b6[i] = new Bubble(240, 210-i*8); 
  }  
 
}
 
void draw(){
  image(photo, 0, 0);
 
  moveArray(b1, 240, 140);
  moveArray(b2, 210, 140);
  moveArray(b3, 230, 140);
  moveArray(b4, 240, 140);
  moveArray(b5, 230, 140);
  moveArray(b6, 230, 140);
}
 
 
//Methode erhält ein Array als Übergabewert
void moveArray(Bubble[] b, float start, float limit){
    for(int i=0; i< b.length; i++){
   b[i].display(); 
   b[i].move(start, limit);
  }
  }
 
 
 
class Bubble{
 
  float x;
  float y;  
 
  Bubble(float x, float y){
    this.x = x;
    this.y = y;
  }
 
  void display(){
    noStroke();
    fill(195, 110, 0);
    ellipse(x, y, 2, 2);
  }
 
//Übergabewerte für Start- und Endwert der Bläßchenreihe
  void move(float start, float limit){
    y-=2;
    if(y<limit){y = start;};
  }
}