Beispiele Kapitel 7-16 - Merker EDV-Beratung

aus Kapitel 7:
-----------------------------------------------------------------------------------------------------------------------
class Arithmetik01 {
public static void main(String[] args) {
    float a = 25.7f;
    float b = 5f;
    short x = 212;
    int   y = 148;

    System.out.println("x + y = " + (x + y));
    System.out.println("x - y = " + (x - y));
    System.out.println("x / y = " + (x / y));
    System.out.println("a / b = " + (a / b));
}
}

class Arithmetik02 {
public static void main(String[] args) {
    int y = 15;
    System.out.println(y % 4);
}
}

public class Arithmetik05 {
public static void main(String args[]) {
byte z1 = -10;
long z2 = -11;
long erg = z1 + -z2;
System.out.println(erg);
}
}

public class Arithmetik06 {
public static void main(String args[])   {
double d2 = 1/3 * 3;
System.out.println(d2);
}
}

public class Arithmetik07 {
public static void main(String args[])   {
double d3 = 1d / 3d * 3;
System.out.println(d3);
}
}

public class Arithmetik08 {
public static void main(String args[])   {
int z1 = 100000;
int z2 = 100000;
System.out.println(z1 * z2);
}
}

public class Arithmetik09 {
public static void main(String args[]) {
long z1 = Long.MAX_VALUE;
long z2 = Long.MAX_VALUE;
System.out.println(z1);
System.out.println(z2);
System.out.println(z1 * z2);
}
}

import java.math.*;
public class Arithmetik10 {
public static void main(String args[])   {
BigInteger z1 = new BigInteger("1234567890123456");
BigInteger z2 = new BigInteger("9876543210987654");
System.out.println(z1.multiply(z2));
}
}

public class Arithmetik11 {
public static void main(String args[])   {
double d1 = 0.17;
float f1 = 0.000001f;
System.out.println(d1 / f1);
System.out.println(d1 * f1);
}
}

public class Arithmetik12 {
public static void main(String[] args) {
double start = 100000.0;
int jahre = 20;
float zinssatz = 1.065f;   // 6.5%
double total;
total = zinssatz * jahre * start;
System.out.println("Neues Kapital: " + total);
}
}

class Assoziativitaet01 {
public static void main(String[] args) {
   int x,y,z;
   x = y = z = 5;
   System.out.println(x);
   y = y + ++z;
   System.out.println(y);
}
}

class Ausdruck01 {
public static void main(String[] args) {
double gehalt = 2000;
gehalt = gehalt * 1.15 - 8;
System.out.println("Das neue Gehalt ist: " + gehalt);
}
}

class Ausdruck02 {
public static void main(String[] args) {
// int z1 = (int)1.23 * 100; // Zuerst 1.23 in int konvertieren
int z1 = (int) (123 * 100); // Zuerst multiplizieren
System.out.println(z1);
}
}

class Ausdruck03 {
public static void main(String[] args) {
char ticket = 'C';
int datum = 13;
if (!(ticket == 'A') || !(ticket == 'B') &&
    (datum == 11 || datum == 12))
   System.out.println("Kein Flug");
else
   System.out.println("Flug");
}
}

class Ausdruck04 {
public static void main(String[] args) {
char ticket = 'B';
int datum = 12;
if ((ticket == 'A' || ticket == 'B') &&
    (datum == 11 || datum == 12))
   System.out.println("Flug");
else
   System.out.println("Kein Flug");
}
}

import java.math.*;
public class BigDecimal01 {
public static void main(String args[]) {
BigDecimal d1 = new BigDecimal("0.17");
BigDecimal d2 = new BigDecimal("0.000001");
System.out.println(d1.divide(d2));
System.out.println(d1.multiply(d2));

}
}

import java.math.BigDecimal;
class BigDecimal02 {
   static public void main(String[] args) {

         BigDecimal d1 = new BigDecimal(0.17);
         BigDecimal d2 = new BigDecimal(0.000001);
         BigDecimal d3 = new BigDecimal(0.0);

         d3 = d1.divide(d2, 2, BigDecimal.ROUND_HALF_UP);
         System.out.printf("%s\n", d3);
         System.out.println(d3); // Alternative Ausgabe

         // Multiplizieren
         d3 = d1.multiply(d2);
         // Anschließend runden
         BigDecimal d4 = d3.setScale(2, BigDecimal.ROUND_UP);
         // Ergebnis ausgeben
         System.out.printf("%s", d4);
}
}

import java.math.*;
public class BigDecimal03 {
public static void main(String[] args) {
MathContext def = MathContext.DECIMAL32;
BigDecimal start = new BigDecimal(100000);
BigDecimal jahre = new BigDecimal(20);
BigDecimal zinssatz = new BigDecimal("1.065"); // 6.5%
BigDecimal total;
total = zinssatz.multiply(jahre).multiply(start);
System.out.println("Neues Kapital: " + total.toString());
}
}

class BitShift01 {
public static void main(String[] args) {
char zeichen1 = 'A';
int zeichen2, zeichen3;
zeichen2 = zeichen1 << 1; // nach links
zeichen3 = zeichen1 >> 1; // nach rechts
System.out.println(zeichen2);
System.out.println(zeichen3);
}
}

class BitVerknuepf01 {
public static void main(String[] args) {
char zeichen1 = 'A';
char zeichen2 = 'B';
int erg;

erg = zeichen1 & zeichen2;     // UND
System.out.print(erg + " = ");
System.out.println((char)erg);

erg = zeichen1 | zeichen2;     // ODER
System.out.print(erg + " = ");
System.out.println((char)erg);

erg = zeichen1 ^ zeichen2;     // XOR
System.out.print(erg + " = ");
System.out.println((char)erg);
}
}

class Bitverknuepf02 {
public static void main(String[] args) {
byte b = 3;
System.out.println(~b);
}
}

public class Byte01 {
public static void main(String args[]) {
byte b1 = 10;
byte b2 = 11;
byte erg = b1 + b2;
System.out.println(erg);
}
}

public class Byte02 {
public static void main(String args[])   {
byte z1 = 10;
z1 = z1 + 5;
System.out.println(z1);
}
}

class Dekrement01 {
public static void main(String[] args) {
   int zahl = 0;
   zahl--;   // Kurzschreibweise für: zahl = zahl - 1;
   System.out.println(zahl);
}
}

class Dekrement02 {
public static void main(String[] args) {
   int a = 1;
   System.out.println(--a);
}
}

public class Dekrement03 {
public static void main(String args[]) {
int a = 0;
System.out.println(a + 1);
System.out.println(a++);
}
}

public class Euro01 {
public static void main(String args[])   {
double dm = 100.00;
double euro = dm / 1.95583;
System.out.println(euro);
}
}

import java.math.*;
public class Euro02 {
public static void main(String args[]) {
BigDecimal dm   = new BigDecimal("100.00");
BigDecimal kurs = new BigDecimal("1.95583");
BigDecimal euro = dm.divide(kurs,2, BigDecimal.ROUND_HALF_UP);
System.out.printf("%s", euro);
}
}

public class Gleitkomma01 {
public static void main(String[] args) {
double zahl1 = 15.21;
double zahl2 = 0.0;
double erg   = zahl1 / zahl2;
System.out.println("Ergebnis ist: " + erg);
}
}

public class Gleitkomma02 {
public static void main(String[] args) {
double zahl1 = 0.0 / 0.0;
float zahl2 = Float.NaN;
System.out.println(zahl1 + " " + zahl2);
}
}

class Inkrement01 {
public static void main(String[] args) {
   int zahl = 0;
   zahl++;   // Kurzschreibweise für: zahl = zahl + 1;
   System.out.println(zahl);
}
}

public class Inkrement02 {
public static void main(String args[]) {
int x = 1;
int y = 7 * ++x; // Präfix, Erst erhöhen, dann rechnen
System.out.println(y);

int z = 7 * x++; // Postfix Erst rechnen, dann erhöhen.
System.out.println(z);
}
}

class Logik01 {
public static void main(String[] args) {
int x = 7;
System.out.println(x > 0 && x < 10);
}
}

class Logik02 {
public static void main(String[] args) {
int x = 85;
boolean richtigeZahl = ((x>0 && x<10) || (x>80 && x<90));
System.out.println(richtigeZahl);
}
}

class Logik03 {
public static void main(String[] args) {
int x = 85;
boolean richtigeZahl = !((x>0 && x<10) || (x>80 && x<90));
System.out.println(richtigeZahl);
}
}

class Logik04 {
public static void main(String[] args) {
boolean andreas   = true; // Andreas kommt
boolean bernd    = false; // Bernd kommt nicht
boolean christian = true;   // Christian kommt
boolean party = ((!andreas   || andreas && bernd)) &&
    ((andreas && christian) || (!andreas && !christian)) &&
    ((bernd && !christian) || (!bernd && christian));
System.out.println(party);
}
}

class Prioritaet01 {
public static void main(String[] args) {
int x = 5;
int y = 9;
System.out.println(x + 15 / 5);
System.out.println(x != 6 && y < 8);
System.out.println(x == 5 ^ y > 0);
System.out.println(x < 3 || y == 5);
}
}

class Prioritaet02 {
public static void main(String[] args) {
System.out.println(2 + 15 / 3 < 7 && 5 < 3);
}
}

public class Sce01 {
public static void main(String args[]) {
boolean b1 = false;
long z2 = 11;
System.out.println(b1 && z2++ > 5);
System.out.println(z2);
}
}

public class Sce02 {
public static void main(String args[]) throws Exception {
int a = 0;
if (a==0 || (a = System.in.read()) > 0)
    System.out.println(a);
}
}

public class Ueberlauf01 {
public static void main(String args[]) {
int z1 = 2000000000;
int z2 = 1800000000;
System.out.println(z1 + z2);
}
}

public class Vergleich01 {
public static void main(String[] args) {
int z1 = 10;
int z2 = 15;
System.out.println(z1 < z2);
}
}

public class Vergleich02   {
public static void main(String[] args) {
char z1 = 'a';
char z2 = 'b';
System.out.println(z1 != z2);
System.out.println(z1 == z2);
}
}

public class Vergleich03 {
public static void main(String[] args) {
char z1 = 'a';
char z2 = 'b';
     System.out.println(z1 = z2);
}
}

public class Vergleich04 {
public static void main(String[] args) {
float zahl1 = 0.1f;
zahl1 = zahl1 / 0.0001f;
System.out.println(zahl1 == 1000);
System.out.println(zahl1);
}
}

public class Vergleich05 {
public static void main(String[] args) {
String s1 = new String("Hallo");
String s2 = new String("Hallo");
System.out.println(s1 == s2);
}
}

public class Vergleich06 {
public static void main(String[] args) {
String s1 = new String("Hallo");
String s2 = new String("Hallo");
System.out.println(s1.equals(s2));
}
}

public class Zeichen01 {
public static void main(String args[]) {
char zeichen = 'A';
System.out.println(++zeichen);
}
}

aus Kapitel 8:
-----------------------------------------------------------------------------------------------------------------------
class Anweisung01 {
public static void main(String[] args) {
if (5 > 3)
   System.out.println("5 ist groesser als 3");
}
}

class Anweisung02 {
public static void main(String[] args) {
if (5 > 3) {
   System.out.println("Das Ergebnis der Prüefung ist: ");
   System.out.println("Fuenf ist groesser als 3");
}
}
}

import java.util.*;
public class Break01 {
public static void main(String[] args) {
int zahl;
int summe = 0;

Scanner eingabe = new Scanner(System.in);

for (int i=0; i < 10; i++) {
System.out.println("Bitte Zahl eingeben: ");
zahl = eingabe.nextInt();
if ((summe + zahl) > 1000) {
   System.out.println("Die Summe ist > 1000");
   break;
}
else {
   summe = summe + zahl;
   System.out.println("Summe = " + summe);
}
}
}
}

public class Continue01 {
public static void main(String[] args) {
for (int i= -10; i <11; i++) {
   if (i == 0)
     continue;   // Laufende Iteration beenden
   System.out.println("Kehrwert von " + i + " = " + 1.0 / i);
}
}
}

import java.util.*;
public class Continue02 {
public static void main(String[] args) {
int zahl;
int summe = 0;

for (int i=0; i < 3; i++) {
System.out.println("Aussenschleife " + i);
for (int j=0; j < 4; j++) {
   if (i== 1) continue;
   System.out.println("Innenschleife " + i);
}
}
}
}

public class Do01 {
public static void main(String[] args) {
   int zahl = 5;
   do
    System.out.println(zahl++);
   while (zahl < 5);
}
}

public class Do02 {
public static void main(String[] args) {
   int zahl = 5;
   do
    System.out.println(zahl--);
   while (zahl > 0);
}
}

import java.util.*;
public class Do03 {
public static void main(String[] args) {
Scanner eingabe = new Scanner(System.in);
int zahl;
   do {
     System.out.println("Bitte Zahl zwischen 0-9 eingeben:");
     zahl = eingabe.nextInt();
   }
   while (zahl != 4);
   System.out.println("Treffer! Richtig geraten");
}
}

public class For01 {
public static void main(String[] args) {
for (int zahl = 1; zahl < 11; zahl++)
   System.out.println(zahl);
}
}

public class For02 {
public static void main(String[] args) {
int sum = 0;
for (int zahl = 1; zahl <= 10; zahl++) {
   sum = sum + zahl;
}
System.out.println("Summe ist = " + sum);
}
}

public class For03 {
public static void main(String[] args) {
for (char c = '!'; c < '/'; c++)
   System.out.println(c);
}
}

public class For04 {
public static void main(String[] args) {
for (int i=0; i < 0;)
   System.out.println("Ich werde nie ausgegeben");
System.out.println("Programmende");
}
}

public class For05 {
public static void main(String[] args) {
int i= 0;
for (; i < 1;) {
System.out.println("Ich werde einmal ausgegeben");
i++;
}
}
}

public class For06 {
public static void main(String[] args) {
for (int i=1, j=12; i<5 || j < 13; i++, j=j+2)
   System.out.println("Ich werde viermal ausgegeben");
}
}

public class For07 {
public static void main(String[] args)throws Exception {
for (float i=0; i != 5.0; i=i+0.2f) {
    System.out.println(i);
    if (i > 5) break;
}
}
}

public class For08 {
public static void main(String[] args) {
for (int zahl1 = 1; zahl1 <= 3; zahl1++) {
   for (int zahl2 = 1; zahl2 <=5; zahl2++)
    System.out.println(zahl1 + " " + zahl2);
}
}
}

public class For09 {
public static void main(String[] args) {
for (int i=0; i < 3; i++) {
   System.out.println("Aussenschleife");
   for (int j = 0; j < 2; j++)
    System.out.println("Innenschleife");
}
}
}

class ForEach01 {
public static void main(String[] args) {
int[] sammlung = {1,5,7,3};
for (int zahl : sammlung)
   System.out.println(zahl);
}
}

public class Fragezeichen02 {
public static void main(String[] args)   {
String text = " " ;
if (6 > 5)
   text = "Groesser";
else
   text = "Kleiner/Gleich";
System.out.println(text);
}
}

public class If01 {
public static void main(String args[]) throws Exception {
if (5 < 3) {
      System.out.println("5 ist kleiner 3");
}
else {
      System.out.println("5 ist nicht kleiner als 3");
}
}
}

public class If02 {
public static void main(String args[])   {
char c = 'A';
if (Character.isUpperCase(c)) {
    System.out.println("Der Zeichen " + c +
       " ist ein Grossbuchstabe");
}
}
}

public class If03 {
public static void main(String args[])   {
char c = 'a';
if (Character.isUpperCase(c)) {
    System.out.println("Der Zeichen " + c +
       " ist ein Grossbuchstabe");
}
else {
    System.out.println("Das Zeichen " + c +
        " ist ein Kleinbuchstabe");
}
}
}

public class If04 {
public static void main(String args[]) {
boolean fehler = false;
int monat = 12;
if ((!fehler) && (monat > 0) && (monat < 13))
   System.out.println("Alles o.k.");
else
   System.out.println("Fehler aufgetreten oder Monat falsch");
}
}

public class If05 {
public static void main(String args[]) {
int a = 2500;
int b = 1500;
if (a < b) {
   System.out.println("a ist kleiner als b ");
     if (b > 1000)
         System.out.println("und b ist groesser als 1000");
      }
     else {
     System.out.println("a ist nicht kleiner als b ");
     if (b > 1000)
      System.out.println("und b ist groesser als 1000");
      }
   }
}

public class If06 {
public static void main(String args[]) {
char c1 = 'z';
char c2 = 'z';
if (c1 == ' ')
    System.out.println("c1 ist leer");
else if (c1 < c2)
      System.out.println("c1 ist kleiner c2");
    else if (c1 > c2)
        System.out.println("c1 ist groesser c2");        else if (c1 == c2)
          System.out.println("c1 ist gleich c2");
}
}

public class If07 {
public static void main(String args[]) {
int dollar = 0;
boolean kreditkarte=true;
if (!kreditkarte)   {
     if (dollar == 0)
          System.out.println("Weder Dollar noch Karte");
     }
     else
      System.out.println("Kreditkarte vorhanden");
   }
}

public class If08 {
public static void main(String args[]) {
int a = 2500;
int b = 1500;
if (a < b)
       if (b > 1000)
               System.out.println("a ist kleiner b " +
             "und b ist groesser als 1000");
else
      System.out.println("a ist nicht kleiner b ");
    System.out.println("Programmende");
}
}

public class IfOperator02 {
public static void main(String[] args)   {
System.out.println((6 > 5) ? "groesser" : "kleiner/gleich");
}
}

public class Label01 {
public static void main(String[] args) {
   aussen:              // Label vergeben
   for (int i=0; i <4; i++) {
   for (int j=0; j<4; j++) {
     System.out.println("innen: j = " + j);
     if (j == i) {
      System.out.println(" ");
      continue aussen;
     }
   }
   }
}
}

public class Label02 {
public static void main(String[] args)   {
   for (int i=0; i < 3; i++) {
   if (i==2)
    break aussen; // Umwandlungsfehler
}
aussen: for (int x=1; x < 0; x++) {
   System.out.println("So gehts nicht");
}
}
}

public class Leeranweisung01 {
public static void main(String[] args) {
if (3>5);
   System.out.println("3 ist größer 5);
}
}

public class Lokal01 {
public static void main(String[] a) {
int zahl1 = 10;
{
   int zahl2 = 5;
   System.out.println(zahl2++);
}
System.out.println(zahl1 + zahl2);
}
}

import java.io.*;
public class Next01 {
public static void main (String[] args) throws Exception {
BufferedReader in = new BufferedReader(
       new InputStreamReader(System.in));
String str = " ";
while (str != null) {
   System.out.println("Bitte Text eingeben: ");
   str = in.readLine();
   System.out.println("Verarbeitet wird; " + str);
}
System.out.println("Programmende");
}
}

import java.io.*;
public class Next02 {
public static void main (String[] args) throws Exception {
BufferedReader in = new BufferedReader(
       new InputStreamReader(System.in));
String str = " ";
while (true) {
   System.out.println("Bitte Text eingeben: ");
   str = in.readLine();
   if (str == null) break;
   System.out.println("Verarbeitet wird: " + str);
}
System.out.println("Programmende");
}
}

import java.io.*;
public class Next03 {
public static void main (String[] args) throws Exception {
BufferedReader in = new BufferedReader(
       new InputStreamReader(System.in));
System.out.println("Bitte Text eingeben: ");
String str = in.readLine();
while (str != null) {
   System.out.println("Verarbeitet wird: " + str);
   System.out.println("Bitte Text eingeben: ");
   str = in.readLine();
}
System.out.println("Programmende");
}
}

import java.util.Scanner;
public class Next04 {
public static void main (String[] args) {
Scanner cons = new Scanner(System.in);
String ein = null;
System.out.println("Bitte Text eingeben: ");
while (cons.hasNext()) {
   ein = cons.next();
   if (ein.equals("ende")) break;
   System.out.println("Eingabe ist " + ein);
}
System.out.println("Programmende");
}
}

import java.util.*;
public class Next05 {
public static void main (String[] args) {
// Erstellen einer Objektsammlung im Speicher
ArrayList list = new ArrayList();
list.add(new String("Erstes Objekt"));
list.add(new String("Zweites Objekt"));
list.add(new String("Drittes Objekt"));
// Iterieren durch die Objektsammlung
Iterator i = list.iterator();
while(i.hasNext()) {
   System.out.println(i.next());
}
}
}

import java.util.*;
public class Next06 {
public static void main (String[] args) {

// Erstellen einer Objektsammlung im Speicher
ArrayList<String> list = new ArrayList<.String>();
list.add(new String("Erstes Objekt"));
list.add(new String("Zweites Objekt"));
list.add(new String("Drittes Objekt"));

// Iterieren durch die Objektsammlung
Iterator<String> i = list.iterator();
while(i.hasNext()) {
   System.out.println(i.next());
}
}
}

import java.util.*;
public class Next07 {
public static void main (String[] args) {
String s ="Dies ist nur ein Test";
StringTokenizer st = new StringTokenizer(s);
while (st.hasMoreTokens())
   System.out.println(st.nextToken());
}
}

import java.util.*;
public class Switch01 {
public static void main(String[] args)   {
   System.out.println("Bitte geben Sie den Monat 1.Halbjahr ein: ");
   Scanner eingabe = new Scanner(System.in);
int monat   = eingabe.nextInt();
   if (monat == 1) System.out.println("Januar");
   else if (monat == 2) System.out.println("Februar");
   else if (monat == 3) System.out.println("März");
     else if (monat == 4) System.out.println("April");
      else if (monat == 5) System.out.println("Mai");
      else if (monat == 6) System.out.println("Juni");
       else System.out.println("Falsche Eingabe");
}
}

import java.util.*;
public class Switch02 {
public static void main(String[] args)   {
System.out.println("Bitte Monat eingeben (1.Halbjahr)");
   Scanner eingabe = new Scanner(System.in);
int monat   = eingabe.nextInt();
switch (monat) {
     case 1: System.out.println("Januar"); break;
     case 2: System.out.println("Februar"); break;
     case 3: System.out.println("Maerz"); break;
     case 4: System.out.println("April"); break;
     case 5: System.out.println("Mai"); break;
     case 6: System.out.println("Juni"); break;
   default: System.out.println("Der Monat ist falsch");
    }
    System.out.println("Programm-Ende");
}
}

import java.util.*;
public class Switch03 {
public static void main(String[] args) throws Exception {
   System.out.println("Bitte einen Buchstaben eingeben:");
   Scanner eingabe = new Scanner(System.in);
byte c = eingabe.nextByte();
   switch (c) {
    case 'A': System.out.println("a");
    case 'B':   System.out.println("b");
    case 'C':   System.out.println("c");
    case 'E':   System.out.println("e");
    default : System.out.println ("Alle anderen Buchstaben");
   }
}
}

public class Switch04 {
   public static void main(String[] args) {
int monat = 2;
int jahr = 2000;
int tage = 0;

switch (monat) {
   case 1:
   case 3:
   case 5:
   case 7:
   case 8:
   case 10:
   case 12:
    tage = 31; break;
   case 4:
   case 6:
   case 9:
   case 11:
    tage = 30; break;
   case 2:
    if ( ((jahr % 4 == 0) && !(jahr % 100 == 0))
      || (jahr % 400 == 0) ) tage = 29;
    else
     tage = 28; break;
   }
System.out.println("Anzahl der Tage = " + tage);
    }
}

public class Switch05 {
enum Wochentage {montag, dienstag, mittwoch, donnerstag,
    freitag, samstag, sonntag}

public static void main (String[] args) {
    Wochentage w = Wochentage.samstag;
    switch(w) {
     case montag: System.out.println("Wochenbeginn");
     case samstag: System.out.println("Arbeitsfrei");
    }
}
}

public class While01 {
public static void main(String[] args) {
   int zahl = 1;
   while (zahl < 5)
    System.out.println(zahl++);
}
}

public class While02 {
public static void main(String[] args) {
   char buchstabe = 'a';
   while (buchstabe <= 'z')
    System.out.println(buchstabe++);
}
}

public class While03 {
public static void main(String[] args)   {
   char buchstabe = 'a';
   while (buchstabe <= 'z') {
    System.out.println((char)(buchstabe - 32));
    buchstabe++;
   }
}
}

import java.util.*;
public class While04 {
public static void main(String[] args) {
Scanner eingabe = new Scanner(System.in);
String zeile;
while (true) {
    System.out.println("Bitte Text eingeben:");
     zeile = eingabe.next();
     System.out.println("Eingegeben wurde: " + zeile);
   }
}
}

import java.util.*;
public class While05 {
public static void main(String[] args) {
Scanner eingabe = new Scanner(System.in);
int zahl;
int summe = 0;
   while (summe < 100) {
     System.out.println("Bitte Zahl eingeben:");
     zahl = eingabe.nextInt();
     summe = summe + zahl;
   }
   System.out.println("Die Summe betraegt: " + summe);
}
}

public class While06 {
public static void main(String[] args) {
   boolean ichBinMillionaer = false;
while (ichBinMillionaer == true); {
     System.out.println("Ich bin Millionaer");
   }
}
}

public class While07 {
public static void main(String[] args) {
int zahl = 1;
while (zahl < 11) {
   System.out.println(zahl);
   zahl++;
}
}
}

public class While20 {
public static void main(String[] args) {
int zahl1 = 1;
while (zahl1 <= 3) {
   int zahl2 = 1;
   while (zahl2 <=5) {
    System.out.println(zahl1 + " " + zahl2);
    zahl2++;
   }
   zahl1++;
}
}
}

public class While99 {
public static void main(String[] args) {
   int zahl = 5;
   while (zahl > 0)
    System.out.println(zahl--);
}
}
class Zuweisung01 {
public static void main(String[] args) {
   int zahl = 15;    // Initialisierung
   System.out.println("Vorher: " + zahl);
   zahl = 1;      // Wertezuweisung
   System.out.println("Nachher: " + zahl);
}
}

class Zuweisung02 {
public static void main(String[] args) {
   int zahl = 15;
   System.out.println("Vorher: " + zahl);
   zahl = (1 + 6) / 2;
   System.out.println("Nachher: " + zahl);
}
}

public class Zuweisung03 {
public static void main(String args[]) {
int zahl1   = 10;
short zahl2 = 5;
zahl2 = zahl1;
zahl1 = zahl2;
}
}

public class Zuweisung04 {
public static void main(String args[]) {
float s1 = 5.0;
}
}

public class Zuweisung05 {
public static void main(String args[]) throws Exception {
String str = "Bahnhofstr.";
int nr = 125;
System.out.println(str + nr);
}
}

public class Zuweisung06 {
public static void main(String args[]) {
int x = 1;
int y = 10;
x += 13;       // x = x + 13;
System.out.println(x);
y *= y + 5;      // y = y * (y + 5);
System.out.println(y);
}
}

public class Zuweisung07 {
public static void main(String args[])   {
int x = 1;
int y = 10;
x = y = 0;
System.out.println("x= " + x + " y= " + y);
}
}

public class Zuweisung08 {
public static void main(String args[])   {
int zahl;
int zahl1;
System.out.println(zahl = 2);
System.out.println(zahl +=5);    // Vermeiden!
System.out.println(zahl1 = zahl = 6); // Vermeiden!
}
}

aus Kapitel 9:
-----------------------------------------------------------------------------------------------------------------------
public class Fakultaet {
public static void main(String[] args) {
int z = 1;
int f = 1;

while (z <= 10) {
   f = f * z;
   z++;
}
System.out.println(f);
}
}

public class Kaefer01 {
public static void main(String[] args) throws Exception {
   for (int spinne=1; spinne<10; spinne++)
    for (int kaefer=1; kaefer<15; kaefer++)
     if ((spinne * 8) + (kaefer * 4) == 64)
      System.out.printf("Kaefer = %d, Spinne =%d \n",
              kaefer, spinne);
}
}

public class KleinsteZahl {
public static void main(String[] args) {
int z1, z2, z3;
z1 = 20;
z2 = 11;
z3 = 10;

if (z1 <= z2 && z1 <= z3)
   System.out.println("Block-A wird ausgeführt");
else
   if (z2 <= z3)
    System.out.println("Block-B wird ausgeführt");
   else
    System.out.println("Block-C wird ausgeführt");
}
}

import java.util.*;
import java.text.*;
class Locale01 {
public static void main(String[] args) {
// Default-Locale (wenn nicht deutsch, dann bitte angegeben)
NumberFormat nf1 = NumberFormat.getInstance();
System.out.println(nf1.format(1245.23));
// Englisches Format
NumberFormat nf2 = NumberFormat.getInstance(Locale.ENGLISH);
System.out.println(nf2.format(1245.23));
}
}

class TopDown01a {
public static void main(String[] args) {
int erg = potenzieren(5,3);
System.out.println(erg);
}
static int potenzieren(int z1, int z2) {
int erg = z1;
if (z2 == 0) return(1);
for (; z2>1; z2--) {
    erg = erg * z1;
}
return erg;
}
}

import java.io.*;
class TopDown01d {
public static void main(String[] args) {
System.out.println("Bitte eine Zahl als Basis eingeben: ");
int basis = eingabe();
System.out.println("Bitte eine Zahl als Exponent eingeben: ");
int exponent = eingabe();
int erg = potenzieren(basis, exponent);
ausgabe(erg);
}
static int eingabe() {
String str = null;
try {
   str = new DataInputStream(System.in).readLine();
}
catch (Exception e) {
   System.out.println(e);
}
return Integer.parseInt(str);
}
static int potenzieren(int z1, int z2) {
int erg = z1;
if (z2 == 0) return(1);
for (; z2>1; z2--) {
    erg = erg * z1;
}
return erg;
}
static void ausgabe(int erg) {
System.out.println("Das Ergebnis ist: " + erg);
}
}

aus Kapitel 10:
-----------------------------------------------------------------------------------------------------------------------
import java.math.*;
class BigDecimal01 {
static public void main(String[] _) {
   BigDecimal d1 = new BigDecimal(15);
   BigDecimal d2 = new BigDecimal(3);
   System.out.println(d1.multiply(d2).divide(d1).multiply(d2));
   }
}

public class Integer01 {
public static void main (String[] args) {
String str = "125";
int ergebnis = Integer.parseInt(str);
System.out.println(ergebnis);
}
}

public class Integer02 {
public static void main (String[] args) {
String str = "125";
int ergebnis = Integer.parseInt(str);
System.out.println(Integer.toHexString(ergebnis));
}
}

public class Leerzeilen01 {
public static void main (String[] args)   {
leerzeilen(5);
}
static void leerzeilen(int anzahl) {
System.out.println("Nun werden " + anzahl
        + "Leerzeilen ausgegeben");
for (int i = 1; i<anzahl; i++) {
   System.out.println("\n");
}
System.out.println("Ausgabe beendet");
}
}

public class Leerzeilen02 {
public static void main (String[] args)   {
leerzeilen(05);
leerzeilen();
}
static void leerzeilen(int anzahl) {
   for (int i = 1; i<anzahl; i++) {
    System.out.println("\n");
   }
}
static void leerzeilen() {
   int defaultanzahl= 2;
   for (int i = 1; i<defaultanzahl; i++) {
    System.out.println("\n");
   }
}
}

public class Leerzeilen03 {
public static void main (String[] args)   {
short zahl = 5;
   leerzeilen(zahl);
}
static void leerzeilen(int anzahl) {
   for (int i = 1; i<anzahl; i++) {
    System.out.println("\n");
   }
}
}

public class Leerzeilen04 {
public static void main (String[] args)   {
int zahl = 5;
   leerzeilen(zahl / 2 + 1);
}
static void leerzeilen(int anzahl) {
   for (int i = 1; i<anzahl; i++) {
    System.out.println("\n");
   }
}
}

import java.io.*;

public class LesenTest01 {
public static void main(String[] args) throws Exception {
   double d = Lesen.liesDouble();
   System.out.println(d);
}
}

class Lesen {
static String zeile;
static InputStreamReader isr =
         new InputStreamReader(System.in);
static BufferedReader bfr = new BufferedReader(isr);
public static double liesDouble() throws Exception {
   System.out.println("Bitte double-Wert eingeben: ");
   zeile = bfr.readLine();
   double zahl = Double.parseDouble(zeile);
   return zahl;
}
}
import java.io.*;

public class LesenTest01 {
public static void main(String[] args) throws Exception {
   double d = Lesen.liesDouble();
   System.out.println(d);
}
}

class Lesen {
static String zeile;
static InputStreamReader isr =
         new InputStreamReader(System.in);
static BufferedReader bfr = new BufferedReader(isr);
public static double liesDouble() throws Exception {
   System.out.println("Bitte double-Wert eingeben: ");
   zeile = bfr.readLine();
   double zahl = Double.parseDouble(zeile);
   return zahl;
}
}

import java.io.*;
class Lesen02 {
String zeile;
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader bfr = new BufferedReader(isr);

public double liesDouble() throws Exception {
   System.out.println("Bitte double-Wert eingeben: ");
   zeile = bfr.readLine();
   double zahl = Double.parseDouble(zeile);
   return zahl;
}
}

public class LesenTest02 {
public static void main(String[] args) throws Exception {
   Lesen02 obj1 = new Lesen02();
   double d = obj1.liesDouble();
   System.out.println(d);
}
}

public class Math01 {
public static void main (String[] args) {
int ergebnis = Math.max(5,3);
System.out.println(ergebnis);
}
}

public class Methode01 {
public static void main (String[] args) {   // Kopf
System.out.println(args[0]);         // Block
}
}
class Methode02 {
public static void main (String[] args) {
    String zeile = new String("Dies ist ein Satz");
    String wort = zeile.substring(9,12);
    System.out.println(wort);
}
}

public class Methode03 {
public static void main(String args[])   {
java.util.Random generator = new java.util.Random();
int zufallszahl = generator.nextInt(50);
System.out.println(zufallszahl);
}
}

public class Methode04 {
public static void main (String[] args)   {
System.out.println(args[0]);
}
}

public class Methode05 {
public static void main (String[] args) {
for (int i=0; i<5; i++)
   ausgeben();
}
static void ausgeben() {
System.out.println("Hallo Welt");
}
}

public class Methode06   {
   public static void main (String[] args) {
System.out.println(A.addieren(5,3));
}
}
class A {
   static int addieren(int a, int b) {
return a + b;
   }
}

public class Methode06a   {
    public static void main (String[] args) {
     A a = new A();
   System.out.println(a.addieren(5,3));
    }
}
class A {
     int addieren(int a, int b) {
   return a + b;
    }
}

public class Methode08   {
   public static void main (String[] args) {
     A a = new A();
   System.out.println(A.addieren(5,3));
}
}
class A {
int x = 5;
static int addieren(int a, int b) {
return a + b + x;
}
}

public class Methode09   {
   public static void main (String[] args) {
System.out.println(A.addieren(5,3));
}
}
class A {
int x = 5;
static int addieren(int a, int b) {
   return a + b + x;
   }
}

public class Methode10   {
    public static void main (String[] args) {
     A a = new A();
   System.out.println(a.addieren(5,3));
   System.out.println(a.addieren(15.3, 27.9));
    }
}
class A {
    int addieren(int a, int b) {
     System.out.println("Ganzzahlen addieren");
   return a + b;
    }
    double addieren(double a, double b) {
     System.out.println("Gleitkommazahlen addieren");
   return a + b;
    }
}

class Methode11 {
public static void main (String[] args) {
    double zahl = 123.45;
    aendern(zahl);
    System.out.println(zahl);
}
static public void aendern(double zahl) {
   zahl = zahl + 200;
   System.out.println(zahl);
}
}

public class MethodenTest11 {
public static void main (String[] args)   {
Methode11 m = new Methode11();
for (int i=0; i<5; i++)
   m.ausgeben();
}
}
class Methode11 {
void ausgeben() {
String text = "Hallo lokale Variable";
System.out.println(text);
}
void aendern() {
// text = "Neuer Inhalt für lokale Variable";
}
}

public class Potenz01 {
public static void main(String[] args)   {
int a = 5;
int b = 3;
System.out.println(potenzieren(a,b));
}
static int potenzieren(int z1, int z2) {
int erg = z1;
if (z2 == 0)
    return 1;
for (; z2>1; z2--) {
   erg = erg * z1;
}
return erg;
}
}

import java.util.*;
public class Properties01 {
public static void main (String[] args) {
Properties prop = new Properties();
prop.setProperty("name", "Roman Merker");
prop.setProperty("beruf", "Programmierer");
prop.setProperty("ort", "Steinfurt");
prop.list(System.out);
}
}

public class Properties02 {
public static void main (String[] args)   {
String s = "os.name";
System.out.println(System.getProperties().getProperty(s));
}
}

public class Punkt01 {
private int x;
private int y;

void speichern(int a, int b) {
x = a;
y = b;
}
void pruef() {
if (x < 0 || y < 0)
   System.out.println("Der Punkt liegt ausserhalb");
else
   System.out.println("Der Punkt liegt im Fenster");
}
}

public class Punkt02 {
private int x;
private int y;

void speichern(int a, int b) {
x = a;
y = b;
}
void pruef() {
if (x < 0 || y < 0)
   System.out.println("Der Punkt liegt ausserhalb");
else
   System.out.println("Der Punkt liegt im Fenster");
}
void addieren(Punkt02 p2) {
   x = x + p2.x;
   y = y + p2.y;
}
}

public class PunktTest01 {
public static void main(String[] args)   {
int a = 5;
int b = 3;
Punkt01 p = new Punkt01();
p.speichern(a, b);
p.pruef();
}
}

public class PunktTest02 {
public static void main(String[] args)   {
int a = 5;
int b = 3;
Punkt02 p = new Punkt02();
p.speichern(a, b);
Punkt02 p2 = new Punkt02();
p.addieren(p2);
}
}

public class Return01 {
public static void main (String[] args)   {
short zahl1 = 15;
short zahl2 = 48;
System.out.println(teiler(zahl1, zahl2));
}
static int teiler(int z1, int z2) {
int rest;
do {
   rest = z1 % z2;
   z1   = z2;
   z2 = rest;
} while (rest > 0);
return z1;
}
}

public class Return02 {
public static void main (String[] args)   {
System.out.println(ausgabe("Erwin"));
}
static String ausgabe(String name) {
return "Hallo " + name;
}
}
class StandardIn02 {
public static void main(String[] args) throws Exception   {
int zeichen1 = System.in.read();
System.out.println(zeichen1);
}
}
class System01 {
public static void main(String[] args) throws Exception {
String name;
name = System.getProperty("user.name");
System.out.println(name);
}
}

import static java.lang.System.*;
class System02 {
public static void main(String[] args) throws Exception {
String name;
name = getProperty("user.name");
out.println(name);
}
}

public class VarArgs01 {
   public static void main (String[] args)   {
      ausgabe("Roman", "Erwin");
}
static void ausgabe(String ... namen) {
for (String n : namen) {
   System.out.println("Hallo " + n);
}
}
}

import java.text.DecimalFormat;
import java.math.*;
class Zahlen01 {
public static void main(String[] args) {

// Primitive Datentypen runden / aufbereiten
double zahl1 = 0.15780003;
DecimalFormat df = new DecimalFormat("##,##0.00");
System.out.println(df.format(zahl1));

// Komfortabler mit BigDecimal und MethContext
BigDecimal zahl2 = new BigDecimal(0.15780003);
    int nachkomma = 3;
MathContext mc = new MathContext(nachkomma,
        RoundingMode.HALF_UP);
BigDecimal erg = zahl2.round(mc);
System.out.println(erg);
}
}

import java.text.DecimalFormat;
import java.math.*;
class Zahlen02 {
public static void main(String[] args) {
BigDecimal zahl1 = new BigDecimal(0.15780003);
System.out.println(zahl1.round(new MathContext(3, RoundingMode.HALF_UP)));
}
}

aus Kapitel 11:
-----------------------------------------------------------------------------------------------------------------------
class Apfel extends Obst {
private String anbaugebiet;

Apfel(String a, String n, float g) {
super(n, g);
anbaugebiet = a;
}
void print() {
super.print();
System.out.println("Anbaugebiet: " + anbaugebiet);
}
}

class Birne extends Obst {
private String farbe;
Birne(String f, String n, float g) {
super(n, g);
farbe = f;
}
void print() {
super.print();
System.out.println("Farbe      : " + farbe);
}
}

import java.util.*;
public class Datum {
int tag;
int monat;
int jahr;

Datum() {
Calendar cal = new GregorianCalendar();
tag   = cal.get(Calendar.DATE);
monat = (cal.get(Calendar.MONTH) + 1);
jahr = cal.get(Calendar.YEAR);
}
Datum(int t, int m, int j) {
tag = t;
monat = m;
jahr = j;
}
void ausgeben(char zeichen) {
char c = zeichen;
System.out.printf("%s %s %s %s %s",
       tag, c, monat, c, jahr);
}
}

import java.util.*;
public class Datum01 {
private int tag;
private int monat;
private int jahr;

void erstellen() {
Calendar cal = new GregorianCalendar();
tag   = cal.get(Calendar.DATE);
monat = (cal.get(Calendar.MONTH) + 1);
jahr = cal.get(Calendar.YEAR);
}

void ausgeben() {
char c = '.';
System.out.printf("%s%s%s%s%s",
        tag, c, monat, c, jahr);
}
}

public class DatumClient01 {
public static void main(String[] args) {
Datum01 heute = new Datum01();
heute.erstellen();
heute.ausgeben();
}
}

public class DatumTest01   {
public static void main(String[] args) {
Datum d1 = new Datum(24, 12, 2005);
d1.ausgeben('|');
}
}
enum Farbe {
rot, gruen, blau;
}

public class Enum01 {
public static void main(String[] args) {
    for (Farbe f : Farbe.values())
     System.out.println(f);
}
}

public class Enum02 {
enum Wochentage {
sonntag,montag,dienstag,mittwoch,
donnerstag,freitag,samstag;
}
public static void main(String[] args) {
    for (Wochentage w : Wochentage.values())
     System.out.println(w);
}
}

enum Tageszeit {
morgens, mittag, abends;
void anzeigen() {
System.out.println(this);
}
}

public class Enum03 {
public static void main(String[] args)   {
Tageszeit t1;        // Variable definieren
t1 = Tageszeit.mittag;    // Wertezuweisung
if (t1 == Tageszeit.mittag) // Variable abfragen
    System.out.println("Guten Tag");
switch(t1) {
    case morgens: System.out.println("Guten Morgen"); break;
    case mittag: System.out.println("Guten Tag");    break;
    case abends: System.out.println("Guten Abend"); break;
}
for (Tageszeit t2 : Tageszeit.values())
    System.out.println(t2);
t1.anzeigen();       // Aufruf einer Methode
}
}

public class EnumTest02 {
// Tageszeit
static final int MORGENS = 0;
static final int MITTAG = 1;
static final int ABENDS = 2;

// Farben
static final int ROT    = 0;
static final int BLAU   = 1;

public static void main(String[] args) {
int tageszeit = BLAU;    // FALSCH ! Keine Kontrolle
if (tageszeit == MITTAG)
   System.out.println("Guten Tag");
}
}

import java.awt.*;
class Farben01 {
public static void main (String[] args) {
    Color c1 = new Color(255,0,0);
    Color c2 = c1.darker();
    System.out.println("Farbe 1 " + c1);
    System.out.println("Farbe 2 " + c2);
    System.out.println(c1.getRed());
}
}

import java.util.*;
public class Gregorian01 {
public static void main(String[] args)    {
GregorianCalendar heute = new GregorianCalendar();
System.out.println(heute.get(Calendar.DAY_OF_MONTH));
System.out.println(heute.get(Calendar.MONTH));
System.out.println(heute.get(Calendar.YEAR));
}
}

public class Hallo01 {
private String text = new String("Hallo Welt");
void ausgeben() {
System.out.print("Die Variable text enthaelt: ");
System.out.println(text);
}
}

public class HalloClient01 {
public static void main(String[] args) {
Hallo01 k = new Hallo01();
k.ausgeben();
}
}

public class Init01 {
int zahl1;
char c;
float zahl2;
public static void main(String[] args) {
Init01 instanz1 = new Init01();
System.out.println(instanz1.zahl1);
System.out.println(instanz1.zahl2);
}
}

public class Init02 {
int zahl1;
char c;
float zahl2;

Init02(int z1, char c, int z2) {
zahl1 = z1;
this.c = c;
zahl2 = z2;
}

public static void main(String[] args) {
Init02 instanz1 = new Init02(15, 'a', 27);
System.out.println(instanz1.zahl1);
System.out.println(instanz1.c);
System.out.println(instanz1.zahl2);
}
}

interface Interface01 {
void setZahl1(int z);
int getZahl1();
}
class InterfaceTest01   {
public static void main(String[] args)   {
   Interface01 schnittstelle01;
}
}

public class InterfaceTest01a {
public static void main(String[] args) {
    A a = new B();
    System.out.println(a.potenzieren(5));
}
}
class B implements A {
int z = 5;
int potenzieren() {
return z * z;
}
}

public class InterfaceTest02 implements Interface01   {
int zahl1;
public void setZahl1(int z) {
   zahl1 = z;
}
public int getZahl1() {
   return zahl1;
}
public static void main(String[] args) {
   Interface01 schnittstelle01;
   schnittstelle01 = new InterfaceTest02();
   schnittstelle01.setZahl1(5);
   System.out.println(schnittstelle01.getZahl1());
}
}

public class Konstruktor01 {
public static void main(String[] args) {
ClassB b = new ClassB();
}
}
class ClassA {
ClassA () {
System.out.println("Hier ist Konstruktor A");
}
}
class ClassB extends ClassA {
ClassB() {
System.out.println("Hier ist Konstruktor B");
}
}
class Kunde extends Partner {
private double umsatz;
void ausgeben() {
super.ausgeben();
System.out.println("Umsatz: " + umsatz);
}
void setUmsatz(double umsatz) {
this.umsatz = umsatz;
}
}
class Lieferer extends Partner {
private float rabatt;
void ausgeben() {
super.ausgeben();
System.out.println("Rabatt: " + rabatt);
}
void setRabatt(float rabatt) {
this.rabatt = rabatt;
}
}
class Obst {
private String name;
private float gewicht;
Obst(String n, float g) {
name = n;
gewicht = g;
}
void print() {
System.out.println("Bezeichnung: " + name);
System.out.println("Gewicht:   " + gewicht);
}
}

public class ObstTest01 {
public static void main(String[] args) {
Apfel a1 = new Apfel("Boskop", "Altes Land",120);
Birne b1 = new Birne("Williams Christ", "Bodensee",140);
a1.print();
b1.print();
}
}
class Partner {
private int nr;
private String name;

Partner(int nr1, String name1) {
nr = nr1;
name = name1;
}
void ausgeben() {
System.out.println(nr + " " + name);
}
void setName(String name1) {
name = name1;
}
}
class Partner01 {
private int nr;
private String name;

void neu(int nr1, String name1) {
nr = nr1;
name = name1;
}
void ausgeben() {
System.out.println(nr + " " + name);
}
void setName(String name1) {
name = name1;
}
}
class Partner01 {
private int nr;
private String name;
Partner() {}            // neu
Partner(int nr1, String name1) {
nr = nr1;
name = name1;
}
void ausgeben() {
System.out.println(nr + " " + name);
}
void setName(String name1) {
name = name1;
}
}

public class Partner02 {
public static void main(String[] args) {
Partner02 g1 = new Partner02();
g1.neu(4700, "Meyer");
g1.ausgeben();
}
private int nr;
private String name;
void neu(int nr1, String name1) {
nr = nr1;
name = name1;
}
void ausgeben() {
System.out.println(nr + " " + name);
}
void setName(String name1) {
name = name1;
}
}
class PartnerTest01 {
public static void main(String[] args) {
Partner01 g1 = new Partner01();
g1.neu(4700, "Meyer");
g1.ausgeben();
}
}

public class PartnerTest02 {
public static void main (String[] args) {
Partner p = new Partner(15, "Merker");
p.ausgeben();

Kunde k = new Kunde(12, "Schulz");
k.setUmsatz(50000);
k.ausgeben();

Lieferer l = new Lieferer(21, "Meyer");
l.setRabatt(15.0f);
l.ausgeben();
}
}
class Pruefen01 {
private int zahl = 5;
boolean pruefInt() {
if ((zahl % 2) == 0)
   return true;
else
   return false;
}
}

public class PruefenClient01 {
public static void main(String[] args) {
Pruefen01 p = new Pruefen01();
if (p.pruefInt())
   System.out.println("Die Zahl ist gerade");
else
   System.out.println("Die Zahl ist ungerade");
}
}

import java.awt.*;
public class Punkt01 {
public static void main(String[] args) {
Point p = new Point(5,3);
System.out.println(p);
}
}

import java.awt.*;
public class Punkt02 {
public static void main(String[] args) {
Point p1 = new Point(5,3);
Point p2 = new Point(4,5);
System.out.println(p1.equals(p2));
}
}
i
mport java.awt.*;
import java.util.*;
class Rechteck {
private int x1, y1;
private int x2, y2;

Rechteck(int x1, int y1, int x2, int y2) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}
Rechteck(Point linksoben, Point rechtsunten) {
x1 = linksoben.x;
y1 = linksoben.y;
x2 = rechtsunten.x;
y2 = rechtsunten.y;
}
public String toString() {
return String.format("%d / %d / %d / %d",
             x1 , y1, x2, y2);
}
public static void main(String[] args) {
Rechteck r1 = new Rechteck(5, 10, 20, 10);
System.out.println(r1);
}
}

import java.awt.*;
public class Rechteck02 {
public static void main(String[] args) {
Point p1 = new Point(10,100);
Dimension d1 = new Dimension(20,30);
Rectangle r1 = new Rectangle(p1, d1);
System.out.println(r1);
}
}

public class Static01 {
static int zaehler = 0;
Static01() {
zaehler++;
}
public static void main(String[] args) {
Static01 z1 = new Static01();
Static01 z2 = new Static01();
System.out.println(zaehler);
}
}

public class Static02 {
int zaehler = 0;
Static02() {
zaehler++;
}
public static void main(String[] args) {
Static02 z1 = new Static02();
Static02 z2 = new Static02();
System.out.println(z1.zaehler);
System.out.println(z2.zaehler);
}
}
class Static03 {
public static void main(String[] args) {
    System.out.println(A.x);
     System.out.println(B.x);
}
}
class A {
static int x = 1;
}
class B {
static int x = 2;
}

public class Zeit {
private int stunde;
private int minute;
private int sekunde;
Zeit(int stunde, int minute) {
this.stunde = stunde;
this.minute = minute;
this.sekunde = 0;
}
Zeit(int stunde, int minute, int sekunde) {
this.stunde = stunde;
this.minute = minute;
this.sekunde = sekunde;
}
void addStunde(int st) {
stunde = stunde + st;
if (stunde > 24)
   stunde = stunde - 24;
}
public String toString() {
String s1 = "Stunde: " + stunde + "\n";
String s2 = "Minute: " + minute + "\n";
String s3 = "Sekunde: " + sekunde + "\n";
return s1 + s2 + s3;
}
}

import java.util.*;
public class ZeitTest {
public static void main(String[] args) {
// selbst erstelle Klasse benutzen
Zeit z = new Zeit(7, 25);
z.addStunde(2);
System.out.println(z.toString());
// mitgelieferte Klasse benutzen
GregorianCalendar heute = new GregorianCalendar();
int st = heute.get(Calendar.HOUR);
int m = heute.get(Calendar.MINUTE);
int se = heute.get(Calendar.SECOND);
Zeit z2 = new Zeit(st, m, se);
System.out.println(z2.toString());
}
}

aus Kapitel 12:
-----------------------------------------------------------------------------------------------------------------------
import java.util.*;
public class ArrayList01 {
public static void main(String[] args) {
ArrayList sammlung = new ArrayList();
sammlung.add("Erstes Objekt");
sammlung.add("Zweites Objekt");
sammlung.add("Drittes Objekt");
sammlung.add("Viertes Objekt");
// Ausgeben mit Iterator
Iterator it = sammlung.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}
}
}

import java.util.*;
public class ArrayList02 {
public static void main(String[] args) {
ArrayList sammlung = new ArrayList();
sammlung.add("Erstes Objekt");
sammlung.add("Zweites Objekt");
sammlung.add("Drittes Objekt");
sammlung.add("Viertes Objekt");
// Ausgeben mit erweiterter For-Schleife
for (Object s : sammlung) {
    System.out.println(s);
}
}
}

public class ClassA {
String str = "Von wem wird dies ausgegeben?";
public static void main(String[] args) {
ClassA a = new ClassA();
ClassB b = new ClassB(a); // Hier ist meine Adresse
}
}
class ClassB {
ClassB(ClassA a) {
System.out.println(a.str);
}
}

public class ClassTest {
public static void main(String[] args) {
ClassA a = new ClassA("Von wem wird dies ausgegeben?");
ClassB b = new ClassB(a);
b.ausgeben();
}
}
class ClassA {
String str;
ClassA(String s) {
str = s;
}
}
class ClassB {
private ClassA a;
ClassB(ClassA a) {
this.a = a;
}
void ausgeben() {
System.out.println(a.str);
}
}

public class Vererbung01 {
public static void main(String[] args)   {
A a = new A();
B b = new B();
System.out.println(b.str);
a = b;
System.out.println(a.str);
}
}

class A {
String str = "KlasseA";
}
class B extends A {
}

aus Kapitel 13:
-----------------------------------------------------------------------------------------------------------------------
public class Array01 {
public static void main(String[] args)   {
    int[] umsatz;
    umsatz = new umsatz[3];
    umsatz[0] = 100;
    umsatz[1] = 200;
    umsatz[2] = 300;
}
}

public class Array02 {
public static void main(String[] args) {
float[] zahlen;
zahlen = new float[4];
}
}

public class Array03 {
public static void main(String[] args)   {
int[] umsatz = {100,200,300,0,0};
umsatz[4] = 1100;
System.out.println(umsatz[1]);
}
}

public class Array04 {
public static void main(String[] args)   {
char[] buchstaben = {'a','b','c','d','e'};
System.out.println(buchstaben[3]);
}
}

public class Array05 {
public static void main (String args[]) {
Object[] obj = new Object[3];
System.out.println(obj[0]);
   }
}

public class Array06 {
public static void main (String args[]) {
float[] zahlen;
zahlen[0] = 15.4f;
}
}

public class Array07 {
public static void main(String[] args) {
float[] zahlen;
zahlen = new float[4];
for (int i=0; i<4; i++)
   zahlen[i] = i + 125.0f;
}
}

public class Array08 {
public static void main(String[] args) {
float[] zahlen;
zahlen = new float[4];
java.util.Arrays.fill(zahlen, 12.45f);
for (float zahl : zahlen)
   System.out.println(zahl);
}
}

public class Array09 {
public static void main(String[] args)   {
char[] buchstaben = {'a','b','c','d','e'};
for(int i=0; i<6; i++) {
   System.out.println(buchstaben[i]);
}
}
}

public class Array10 {
public static void main(String[] args)   {
char[] buchstaben = {'a','b','c'};
for(int i=0; i<buchstaben.length; i++) {
   System.out.println(buchstaben[i]);
}
}
}

public class Array11 {
public static void main(String[] args)   {
char[] buchstaben = {'a','b','c'};
for (char buchstabe: buchstaben) {
   if (buchstabe == 'b') {
     System.out.println(buchstabe);
     break;
   }
   }
}
}

public class Array12 {
public static void main(String[] args)    {
int[] zahlen = new int[10];
for (int i=0; i<10; i++) {
   zahlen[i] = i+1;
}
int summe = 0;
for (int wert: zahlen) {
   summe = summe + wert;
}
System.out.println("Die Summe ist: " + summe);
}
}

import java.util.*;
public class Array14 {
public static void main(String[] args)   {
Calendar[] tage = new Calendar[3];
for (int i=0; i<3; i++)
   tage[i] = Calendar.getInstance();
System.out.println(tage[1]);
}
}

public class Array15 {
public static void main(String[] args) {
int umsatz[] = {100,200,300,50,100,5,0,98,700,50,0,90};
java.util.Arrays.sort(umsatz);
for (int wert: umsatz) {
   System.out.println(wert);
}
}
}

import java.util.*;
public class Array16 {
public static void main(String[] args)   {
int[] zahlen = {11, 23, 4, 15};
for (int zahl: zahlen)
   System.out.format("%d ", zahl);
Arrays.sort(zahlen);
System.out.println('\n');
for (int zahl: zahlen) {
   System.out.format("%d ", zahl);
}
}
}

public class Array20 {
public static void main(String[] args) {
int[][] matrix;
matrix = new int [2][3];
matrix[0][0] = 1;
matrix[0][1] = 2;
matrix[0][2] = 3;
matrix[1][0] = 4;
matrix[1][1] = 5;
matrix[1][2] = 6;
}
}

public class Array21 {
public static void main(String[] args)   {
String[][] woertermatrix = {
       {"Wort1", "Wort2", "Wort3"},
            {"Wort4", "Wort5", "Wort6"},
            {"Wort7", "Wort8", "Wort9"},
            {"Wort10","Wort11","Wort12"}
             };
for(int i=0; i<4; i++) {
   for (int j=0; j<3; j++)
     System.out.println(woertermatrix[i][j]);
}
}
}

public class Array22   {
public static void main(String[] args)   {
char[][] zeichen;
zeichen = new char[3][4];
char unicode = 97;
// Fuellen mit Zeichen
for(int i=0; i<3; i++) {
   for (int j=0; j<4; j++)
     zeichen[i][j] = unicode++;
}
// Ausgeben der Zeichen
for(int i=0; i<3; i++) {
   for (int j=0; j<4; j++) {
     System.out.print(zeichen[i][j]);
   }
   System.out.println();
}
}
}

public class Array23 {
public static void main(String[] args)   {
char[] buchstaben = {'a','b'};
tauschen(buchstaben);
for (char buchstabe: buchstaben)
     System.out.println(buchstabe);
}
static void tauschen(char[] b) {
char hilf = b[0];
b[0] = b[1];
b[1] = hilf;
}
}

public class Array24 {
public static void main(String[] args)   {
int zahl = 125;
int[] erg = dividieren(zahl);
System.out.println("125 / 3 = " + erg[0]);
System.out.println("Ganzzahliger Rest: " + erg[1]);
}
static int[] dividieren(int z) {
int[] erg = {0,1};
erg[0] = z / 3;
erg[1] = z % 3;
return erg;
}
}

public class Array30 {
public static void main(String[] args)   {
int[] z1 = {11, 23, 4, 15};
int[] z2;
z2 = z1;      // Referenz-Semantik !
for (int z : z2)
   System.out.println(z);
}
}

public class Array31 {
public static void main(String[] args)   {
int[] z1 = {11, 23, 4, 15};
int[] z2 = new int[z1.length];
for (int i=0; i<z1.length; i++)
   z2[i] = z1[i];
for (int z : z2)
   System.out.println(z);
}
}

public class Array32 {
public static void main(String[] args)   {
int[] z1 = {11, 23, 4, 15};
int[] z2 = new int[z1.length];
System.arraycopy(z1, 0, z2, 0, z1.length);
for (int z : z2)
   System.out.println(z);
}
}

public class Array33 {
public static void main(String[] args)   {
int[] z1 = {11, 23, 4, 15};
int[] z2 = z1.clone();
for (int z : z2)
   System.out.println(z);
}
}

aus Kapitel 14:
-----------------------------------------------------------------------------------------------------------------------
import java.util.regex.*;
public class RegEx01 {
public static void main(String[] args) {
boolean b = Pattern.matches(".*pfel.*", "Birne Apfel Banane");
   if (b)
       System.out.println("Gefunden");
   else
       System.out.println("Nicht gefunden");
}
}

import java.util.regex.*;
public class RegEx03 {
public static void main(String[] args) {
Pattern p = Pattern.compile(";");
String[] erg = p.split("Andres;Maier;Hauptweg.12;55131 Mainz");
for (int i=0; i<erg.length; i++)
      System.out.println(erg[i]);
}
}

import java.util.regex.*;
public class RegEx04 {
    public static void main(String[] args) {
   Pattern p = Pattern.compile(";|,|\\s");
   String[] erg = p.split("eins zwei;drei,vier");
   for (int i=0; i<erg.length; i++)
    System.out.println(erg[i] + '\n');
    }
}

import java.util.regex.*;
public class RegEx05 {
public static void main(String[] args) {
    // Pattern anlegen
    Pattern p = Pattern.compile("rot");
    // Factory zum Anlegen des Matcher
    Matcher m = p.matcher("Suche: rotes Auto, rotes Rad");
    boolean b = m.find();
    int anz = 0;
    while(b) {
      anz++;
      b = m.find();
    }
    System.out.println("Die Anzahl ist: " + anz);
}
}

import java.util.regex.*;
public class RegEx06 {
public static void main(String[] args) {
   Pattern p = Pattern.compile(".*pfel.*");
Matcher m = p.matcher("Birne Apfel Banane");
Boolean b = m.matches();
if (b)
      System.out.println("Gefunden");
else
      System.out.println("Nicht gefunden");
}
}

import java.util.Scanner;
public class Scanner01 {
public static void main(String[] args)   {
Scanner eingabe = new Scanner(System.in);
eingabe.useDelimiter(",");
String s =eingabe.next();
System.out.println("Erster Teil: " + s);
s =eingabe.next();
System.out.println("Zweiter Teil: " + s);
}
}

import java.util.Scanner;
class Scanner02 {
public static void main(String[] args) {
Scanner eingabe = new Scanner(System.in);
String zeilenende = System.getProperty("line.separator");
eingabe.useDelimiter(zeilenende); // Delimiter aendern
while (eingabe.hasNext())
   System.out.println(eingabe.next());
}
}

import java.util.Scanner;
class Scanner03 {
public static void main(String[] args)   {
Scanner eingabe = new Scanner(System.in);
eingabe.useDelimiter(",");     // Delimiter aendern
String str = eingabe.next();   // Komplettes Wort lesen
int zahl1   = eingabe.nextInt(); // Ganzzahl lesen
double zahl2 = eingabe.nextDouble(); // E-Format z.B. 5e3 lesen
System.out.printf("%s | %d | %f", str, zahl1,zahl2);
}
}

public class String01 {
public static void main(String[] args)   {
String vorname;
System.out.println(vorname);
}
}

public class String02 {
public static void main(String[] args)   {
String vorname = null;
System.out.println(vorname);
}
}

public class String03 {
public static void main(String[] args)   {
String vorname = " ";
System.out.println(vorname);
}
}

public class String04 {
public static void main(String[] args)    {
String str = 'Text \n mit Zeilenwechsel';
System.out.println(str);
}
}

public class String05 {
public static void main(String[] args)   {
String vorname = "Roman";
String nachname = "Merker";
String name1, name2;
name1 = vorname + " " + nachname;    // 1.Möglichkeit
name2 = vorname.concat(" " + nachname); // 2.Möglichkeit
System.out.println(name1);
System.out.println(name2);
}
}

public class String06   {
public static void main(String[] args)   {
System.out.println("Bahnhofstr. " + 48);
}
}

public class String07    {
public static void main(String[] args)   {
float f1 = 3.57f;
int z1 = 123;
String s1, s2;
     // s = z1;        // liefert Umwandlungsfehler
s1 = String.valueOf(f1);
s2 = String.valueOf(z1);
System.out.println(s1 + s2);
// System.out.println(f1 + z1);
}
}

public class String08 {
public static void main(String[] args)   {
String vorname = "Roman";
byte[] zeichen = vorname.getBytes();
}
}

public class String09   {
public static void main(String[] args)   {
String s1 = "Merker";
String s2 = new String("Merker");
String s3 = "Merker";
if (s1 == s2)
   System.out.println("==: Beide Strings sind gleich");
if (s1.equals(s2))
   System.out.println("equals: Beide Strings sind gleich");
}
}

public class String10 {
public static void main(String[] args)    {
String s1 = "Erwin Merker";
for (int i=0; i<s1.length(); i++)
   if (s1.charAt(i) == 'r')
     System.out.println("Buchstabe r " +
       "steht auf Stelle " + i);
}
}

public class String11   {
public static void main(String[] args) {
String s1 = "Vogelnest";
String s2 = s1.substring(5,9);
System.out.println(s2);
}
}

public class String12   {
public static void main(String[] args)   {
String name = "Merker";
System.out.println("Steinfurt".length());
System.out.println(name.toUpperCase());
}
}

public class String13   {
public static void main(String[] args)   {
String s1 = "Merker";
s1 = s1.replace('r', 'l');
System.out.println(s1);
}
}

public class String14 {
public static void main(String[] args)   {
String s1 = new String("Heidi");
String s2 = s1;
System.out.println(s1 == s2);
    s2 = "Heidi";
    System.out.print(s1 == s2);
}
}

public class String15   {
public static void main(String[] args) {
StringBuilder sb1 = new StringBuilder("Vogel");
sb1.append("nest");     // Anhaengen
System.out.println(sb1);
sb1.replace(0,5,"Oster");   // Ersetzen
System.out.println(sb1);
sb1.delete(6,9);       // Loeschen
System.out.println(sb1);
sb1.insert(6, " ist Urlaub"); // Einfuegen
System.out.println(sb1);
}
}

public class String16   {
public static void main(String[] args) {
StringBuilder str = new StringBuilder().
   append("Dieser ").append("Satz ").append("wird ").
   append("als ein ").append("Objekt angelegt");
System.out.println(str);
}
}

public class String20   {
public static void main(String[] args)   {
for (int i=0; i < args.length; i++)
   System.out.println(args[i]);
}
}

public class String21   {
public static void main(String[] args)   {
   if (args.length == 0)
    System.out.println("Eingabedaten fehlen");
}
}

public class String22   {
public static void main(String[] args)   {
   if (args.length == 0 || args.length > 3)
    System.out.println("Bitte 1 - 3 Parameter eingeben");
   for (int i=0; i < args.length; i++) {
      if (args[i].length() > 5) {
        System.out.print("Mehr als 5 Zeichen nicht erlaubt ");
        System.out.println(args[i]);
      }
   }
}
}

public class String23   {
public static void main (String[] args)   {
int anzahl = 0;
if (args.length == 1) {
   if (args[0].equals("Help")) {
    System.out.println("Aufruf: java String23 Anzahl");
    System.exit(1);
   }
    }
try {
   anzahl = Integer.parseInt(args[0]);
   }
catch (Exception e) {
   System.out.println("Es muss die Anzahl angegeben sein");
   System.exit(0);
   }
System.out.println("Die Anzahl ist: " + anzahl);
}
}

public class Utf08 {
public static void main(String[] args) throws Exception {
String str1 = "A\u0001\u0093";

// Konvertieren String in UTF
byte[] b1 = str1.getBytes("UTF8");
for (int i=0; i<b1.length; i++)
   System.out.println(b1[i]);

// Rekonstruieren von String aus Byte-Array
String str2 = new String(b1, "UTF8");
System.out.println(str2);
}
}

public class Zerlegen01 {
public static void main(String[] args)   {
String s1 = "Dies ist ein Satz, der zerlegt weden soll";
String[] ergebnis = s1.split(" ");
for (int i=0; i<ergebnis.length; i++)
     System.out.println(ergebnis[i]);
}
}
public class Zerlegen02 {
public static void main(String[] args)   {
String s1 = "Dies   ist ein   Satz, der zerlegt werden soll";
String[] ergebnis = s1.split(" +");
for (int i=0; i<ergebnis.length; i++)
     System.out.println(ergebnis[i]);
}
}

aus Kapitel 15:
-----------------------------------------------------------------------------------------------------------------------
class Boxing01 {
public static void main(String[] args)   {
int zahl1 = 15;
Integer zahl2 = new Integer(25);
System.out.println(zahl1 + zahl2); // Autoboxing
zahl1 = zahl2;           // Auto-Unboxing
System.out.println(zahl1);
}
}

public class Konversion01 {
public static void main(String[] args) {
short a = 123;
long b = a;
}
}

public class Konversion02 {
public static void main(String[] args)    {
byte b = 66;
System.out.println(b);
}
}

public class Konversion03   {
public static void main(String[] args)   {
byte b = 66;
System.out.println((char)b);
}
}

public class Konversion05 {
public static void main(String[] args)   {
char z1 = 75 + 2;
long z2 = 0x4b + 1;
System.out.printf("%c %d ", z1,z2);
}
}

public class Konversion06 {
public static void main(String[] args)   {
short a   = 110;
float b   = 456789.1f;
float erg = a * b;
System.out.println(erg);
}
}

public class Konversion07 {
public static void main (String[] args) {
ausgeben(25);
}
static void ausgeben(double zahl) {
System.out.println(zahl);
}
}

public class Konversion08 {
public static void main(String[] args)   {
long a = 1234567;
short b = a;
}
}

public class Konversion09   {
public static void main(String[] args)   {
long a = 123;
short b = (short)a;
System.out.println(b);
}
}

public class Konversion10 {
public static void main (String[] args) {
ausgeben(25.3);
}
static void ausgeben(int zahl) {
System.out.println(zahl);
}
}

public class Konversion11   {
public static void main(String[] args)    {
double a = 12345678E300;
float b = a;    // Fehler !
System.out.println(a);
}
}

public class Konversion12   {
public static void main(String[] args)   {
double a;
long   b = 12345678912348999L;
a = b;         // korrekt
b = (long)a;      // Datenverlust
System.out.println(b);
}
}

public class Konversion13 {
public static void main(String[] args)   {
double erg;
int x = 5;
int y = 3;
erg = x / y;       // Abschneiden
System.out.println(erg);
erg = (double)x / y;    // Korrekt
System.out.println(erg);
}
}

public class Konversion20 {
public static void main(String[] args)   {
A referenzA = new A();
B referenzB = new B();
referenzA = referenzB;
}
}
class A {}
class B extends A {}

public class Konversion21 {
public static void main(String[] args)   {
A referenzA = new A();
B referenzB = new B();
referenzB = referenzA; // Fehler, inkompatibel
}
}
class A {}
class B extends A {}

public class Konversion22 {
public static void main(String[] args)   {
A referenzA = new A();
B referenzB = new B();
referenzB = (B)referenzA;
}
}
class A {}
class B extends A {}

public class Konversion23 {
public static void main(String[] args)   {
A referenzA = new A();
B referenzB = new B();
if (referenzA instanceof B)
   referenzB = (B)referenzA;
else
   System.out.println("Kein Casting möglich");
}
}
class A {}
class B extends A {}

import java.awt.Point;
public class Konversion24 {
public static void main(String[] args)   {
Point p1, p2;
Object object;

p1 = new Point(100,200);
p2 = new Point(300,400);
object = new Object();
object = p1;     // generalisierende Konvertierung
p2 = (Point)object; // spezialisierende Konvertierung
System.out.println(p2);
}
}

class KonvertMethod01 {
public static void main(String[] args)   {
float zahl1 = 15E3f;
   System.out.println(zahl1);
}
}

class KonvertMethod02 {
public static void main(String[] args)   {
String str = "153";
Integer zahl = Integer.valueOf(str);
System.out.println(zahl);
}
}

class KonvertMethod03 {
public static void main(String[] args)   {
    String str = "153";
int zahl = Integer.parseInt(str);
   System.out.println(zahl);
}
}

class KonvertMethod04 {
public static void main(String[] args)   {
    String str = "153E5";
float zahl = Float.parseFloat(str);
   System.out.println(zahl);
}
}

class Wrapper01 {
public static void main(String[] args)   {
int zahl1 = 15;
// Integer zahl1 = new Integer(15);
System.out.println(zahl1);
}
}

aus Kapitel 16:
-----------------------------------------------------------------------------------------------------------------------
public class Init01 {
public static void main(String[] args) {
   KlasseA a = new KlasseA();
   System.out.println(a.str);
}
}
class KlasseA {
String str;
}

public class Init02 {
public static void main(String[] args) {
String str;
System.out.println(str);
}
}
class Instanz01 {
int zahl;
String text;
Instanz01() {};
Instanz01(int z, String t) {
zahl = z;
text = t;
}
}
class InstanzTest01 {
public static void main(String[] a) {
Instanz01 instanz1 = new Instanz01(17,"ABC");
Instanz01 instanz2 = new Instanz01(25,"XYZ");
System.out.println(instanz1.zahl + instanz1.text);
}
}

public class Lokal01 {
public static void main(String[] a) {
for (int i = 0; i< 3; i++) {
   System.out.println(i);
}
System.out.println(i);
}
}

public class Lokal02 {
public static void main(String[] a) {
int i;
for (i = 0; i< 3; i++) {
   System.out.println(i);
}
System.out.println(i);
}
}

public class MethodParm01 {
public static void main(String[] a) {
MethodParm01 m = new MethodParm01();
m.methodA(17);
// System.out.println(zahl); // existiert nicht mehr!
}
void methodA(int zahl) {
System.out.println(zahl++);
}
}

public class PackageList01 {
public static void main(String[] a) {
java.lang.Package[] all = java.lang.Package.getPackages();
System.out.println("Es gibt " + all.length + " Pakete");
}
}

public class PackageList02 {
public static void main(String[] a) {
java.lang.Package[] all = java.lang.Package.getPackages();
for (int i=0; i<all.length; i++)
   System.out.println(all[i]);
}
}
class Private01 {
private int zahl;
}
class PrivateTest01 {
public static void main(String[] a) {
   Private01 p1 = new Private01();
   System.out.println(p1.zahl);   // illegal
}
}
class Protected01 {
protected int zahl;
}
class ProtectedTest01 {
public static void main(String[] a) {
   Protected01 p1 = new Protected01();
   System.out.println(p1.zahl);   // legal
}
}

public class PublicTest01 {
public static void main(String[] a) {
Public01 p = new Public01();
}
}

public class Public01 {
private int zahl1;

void setZahl1(int z3) {
zahl1 = z3;
}
void ausgeben() {
System.out.println(zahl1);
}
}
class Scope01 {
int zahl1;           // Membervariable
void setZahl1() {
zahl1 = 5;
int zahl2 = 15;        // lokale Variable
}
void ausgeben() {
System.out.println(zahl1);
// System.out.println(zahl2); // Fehler, lokale V.
}
}

public class ScopeTest01 {
public static void main(String[] a) {
Scope01 scope = new Scope01();
scope.setZahl1();
scope.ausgeben();
}
}
class Shadow01 {
static int z1 = 100;
public static void main(String[] a) {
   int z1 = 2;
   System.out.println(z1);
}
}
class Static01 {
static int zahl;
static String text;
}
class StaticTest01 {
public static void main(String[] a) {
   System.out.println(Instanz02.zahl + Instanz02.text);
}
}

package merker;
class Zugriff02 {
int zahl1;
void setZahl1(int z3) {
zahl1 = z3;
}
void ausgeben() {
System.out.println(zahl1);
}
}

package merker;
public class Zugriff03   {
int zahl1;
public void setZahl1(int z3) {
zahl1 = z3;
}
public void ausgeben() {
System.out.println(zahl1);
}
}
class Zugriff01 {
int zahl1;         // Nicht private !
void setZahl1(int z3) {
zahl1 = z3;
}
void ausgeben() {
System.out.println(zahl1);
}
}

public class ZugriffTest01 {
public static void main(String[] a) {
Zugriff01 z01 = new Zugriff01();
z01.setZahl1(15);
z01.ausgeben();
   System.out.println(z01.zahl1);   // Direktaufruf
}
}

import merker.*;
public class ZugriffTest02 {
public static void main(String[] a) {
Zugriff02 z1 = new Zugriff02();
z1.setZahl1(15);
z1.ausgeben();
}
}