int[] c = {0,1,2,3,4};             // Statisches Feld mit Init.
int anz=0;
for (i=0; i<c.length; ++i) {
   if (3>=c[i]) anz++;
};
System.out.println("Anzahl der Elemente <=3 in Feld c:" + anz);

b = ea.InI("Länge des Feldes d ");
int   d[] = new int[b];            // Dynamisches Feld ohne Init.
for (i=0; i<d.length; ++i) {
   d[i] = i;
};

int   e[][] = new int[2][3];       // Zweistufiges Feld
int f[][] = {{0},                  // Nicht-rechteckiges Feld
             {1,2},
             {4,5,6}
            }; 
e[1][2] = f[2][2];

-------------------------------------------------------------------------------

int[] v = new int[n+1];
int[] w = new int[n+1];
int[][]  A = new int[n+1][n+1];
int sum;
for (i=1; i<=n; ++i) {
    v[i]=i;
    for (j=1; j<=n; ++j) {
       if (j==n+1-i) A[i][j]=1;
       else A[i][j]=0;
    };
};
for (i=1; i<=n; ++i) {
    sum=0;
    for (j=1; j<=n; ++j) {
       sum = sum + A[i][j]*v[j];
    };
    w[i]=sum;
};
for (i=1; i<=n; ++i) {
   System.out.print(w[i]);
};
System.out.println("");


--------------------------------------------------------------------------------

class bruch {                        // Verbund, direktes Produkt
   int vz, zähler, nenner;           // Selektoren

   bruch(int VZ, int Z, int N){      // Konstruktor mit Init.
      vz=VZ; zähler=Z; nenner=N;
   }
   bruch(){}                         // Konstruktor ohne Init.
}



      bruch b0 
         = new bruch(plus,2,4);   // 2. Schritt: Erzeugen
      bruch b1 = new bruch();     //      "

      b1.zähler=b0.zähler/2;
      b1.nenner=b0.nenner/2;
      b1.vz=b0.vz;


-------------------------------------------------------------------------------

class bruchMitOderOhne {                   // Direkte Summe, 
                                              Varianten
   static final int plus=0, minus=1;   
   static final int mit=1, ohne=0;   

   int diskr, zähler, nenner;              // Diskriminante,                     
                                              Selektoren

   bruchMitOderOhne(int D, int Z, int N) { // Teil-Konstruktor  
                                              mit Initialisierung
      diskr=D; zähler=Z; nenner=N;
   }

   bruchMitOderOhne(int D){diskr=D;}       // Teil-Konstruktor 
                                              mit Init.
   bruchMitOderOhne(){}                    // Teil-Konstruktor
                                              ohne Init.
}





class bruchMit extends bruchMitOderOhne {  // 1. Variante
   int vz;

   bruchMit(int V, int Z, int N) {         // Konstruktor mit 
                                              Init.
      super(mit,Z,N);
      vz=V;
   }

   bruchMit(){super(mit);}    // Konstruktor, nur Diskriminante
   
}

class bruchOhne extends bruchMitOderOhne { // 2. Variante

   bruchOhne(int Z, int N){   // Konstruktor mit Init.
      super(ohne,Z,N);
   }

   bruchOhne(){super(ohne);}  // Konstruktor, nur Diskriminante
}

      bruchMit b2 
         = new bruchMit(plus,2,4);      // 2. Schritt: Erzeugen
      bruchOhne b3 
         = new bruchOhne(2,4);          //      " 

      b2.zähler=b2.zähler/2;
      b2.nenner=b2.nenner/2;
      b2.vz=b2.vz;


--------------------------------------------------------------------------------

class Hoersaal {     // Mit Umlauten kann es außerhalb der
   char Name;        // Programme Probleme geben
   int AnzPlätze;
}

Hoersaal[] Haus = new Hoersaal[4];   // Vektor mit Referenzen

Haus[1] = new Hoersaal();            // Verbund für einen Hörsaal
Haus[1].Name = '1';
Haus[1].AnzPlätze = 140;

Haus[2] = new Hoersaal();
Haus[2].Name = '2';
Haus[2].AnzPlätze = 145;

Haus[3] = new Hoersaal();
Haus[3].Name = 'D';
Haus[3].AnzPlätze = 336;

class Buch {
   String Titel;
   float Preis;
}

class Person {
   String Name;
   Buch[] Bibl;
}
    
Person[] Alle = new Person[3];      // Vektor Alle mit Referenzen

Alle[1] = new Person();             // Verbund fuer eine Person
Alle[1].Name = "Hans";
Alle[1].Bibl = new Buch[3];         // Vektor Bibl mit Referenzen

Alle[1].Bibl[1] = new Buch();       // Verbund fuer ein Buch
Alle[1].Bibl[1].Titel = "Java 1.1";
Alle[1].Bibl[1].Preis = 59.90f;

Alle[1].Bibl[2] = new Buch();       // Verbund fuer ein Buch
Alle[1].Bibl[2].Titel = "Alte Knochen";
Alle[1].Bibl[2].Preis = 12.90f;

Alle[2] = new Person();             // Verbund fuer eine Person
Alle[2].Name = "Grete";
Alle[2].Bibl = new Buch[4];         // Vektor Bibl mit Referenzen
Alle[2].Bibl[1] = new Buch();       // Verbund fuer ein Buch
Alle[2].Bibl[1].Titel = "Informatik I";
Alle[2].Bibl[1].Preis = 44.90f;
Alle[2].Bibl[2] = new Buch();       // Verbund fuer ein Buch
Alle[2].Bibl[2].Titel = "Junge Hunde";
Alle[2].Bibl[2].Preis = 24.90f;
Alle[2].Bibl[3] = new Buch();       // Verbund fuer ein Buch  
Alle[2].Bibl[3].Titel = "Selbs Betrug";
Alle[2].Bibl[3].Preis = 16.80f;      

 
-------------------------------------------------------------------------------


  class BKnoten {                              // Klasse für Baumknoten
      String info;                            
      BKnoten links, rechts;
      BKnoten(String s, BKnoten li, BKnoten re) {   // Konstruktor
         info = s;
         links = li;
         rechts = re;
      }
   }

   class Baum {
      BKnoten b = null;

      BKnoten Ein (String s, BKnoten k) {    // Resultat: der modifizierte Teilbaum
         BKnoten lok=k;                      // mit neuem Eintrag, falls nicht schon
         if (k==null)                        // vorhanden
            return new BKnoten(s,null,null);   
         else {
            if (s.compareTo(k.info) < 0)
               k.links = Ein(s,k.links);      // Im linken Teilbaum einfügen
            else {
               if (s.compareTo(k.info) > 0)
               k.rechts = Ein(s,k.rechts);    // Im rechten Teilbaum einfügen
            };
            return k;                         // evtl. schon enthalten
         }
      }

      void FügeEin(String s) {                // Eintrag s in Baum b einfügen
         b=Ein(s,b);
      }

      void Dr(BKnoten k) {                    // Druckt die Inform.-Komponenten
         if (k.links!=null) Dr(k.links);      // eines Teilbaumes in Inordnung
         System.out.print(k.info+" ");
         if (k.rechts !=null) Dr(k.rechts);
      }

      void DrBaumIn(String t) {               // Druckt die Inform.-Komponenten
         System.out.println("  ");            // des Baumes b in Inordnung
         System.out.print(t+":");
         if (b==null) System.out.println(" Leer");
         else Dr(b);
         System.out.println("  ");
      }
   }