Schnelle lernen Java für Anfänger

package org.o7planning.tutorial.javabasic.variable;

public class VariableExample1 {

	public static void main(String[] args) {

		// Eine Variable mit dem Int Typ erklären  (32 bit Integer).
		int firstNumber;

		// Die Wert für firstNumber zuweisen 
		firstNumber = 10;

		System.out.println("First Number =" + firstNumber);

		// Eine Variable von dem float Typ verzollen (32 bit reelle Zahl)
		// Diese Zahl wird die Wert 10.2 zugewiesen
		// Das Zeichen 'f' am Ende hilft Jave bei dem Verstanden, das das float Typ ist
		float secondNumber = 10.2f;

		System.out.println("Second Number =" + secondNumber);

		// Eine Zahl von double Typ erklären (die 64 bit reelle Zahl)
		// Die Zahl wird die Wert 10.2 zugewiesen
		// Das Zeichen 'd' am Ende hilf Java bei dem Verstanden, das das double Typ ist.
		// Mit dem float 'f' Typ unterscheiden.
		double thirdNumber = 10.2d;

		System.out.println("Third Number =" + thirdNumber);

		// Eine Variable von dem Zeichen Typ erklären
		char ch = 'a';

		System.out.println("Char ch= " + ch);

	}

}

package org.o7planning.tutorial.javabasic.variable;

public class VariableExample2 {

	public static void main(String[] args) {

		// § Zahlen von dem long Typ erklären (die 64 bit Integer).
		long firstNumber, secondNumber, thirdNumber;

		// Die Wert für firstNumber zuweisen
		// Das Zeichen 'L' am Ende um Java zu informieren, das das long Typ ist, 
		// unterscheidet sich mit dem int Typ
		firstNumber = 100L;

		// Die Wert für secondNumber zuweisen
		secondNumber = 200L;

		// Die Wert für thirdNumber zuweisen.
		thirdNumber = firstNumber + secondNumber;

		System.out.println("First Number = " + firstNumber);
		System.out.println("Second Number = " + secondNumber);
		System.out.println("Third Number = " + thirdNumber);
	}

}

if(condition 1)  {
   //  Hier etwas machen    
}else if(condition 2) {
   //  Hier etwas machen    
}else if(condition 3) {
   //  Hier etwas machen    
}
// Umgekehrt
else  { 
   //  Hier etwas machen    
}

package org.o7planning.tutorial.javabasic.controlflow;

public class ElseIfExample1 {

	public static void main(String[] args) {

		// Eine Variable von dem int Typ erklären (die 32 bit Integer), 
		// die Ihre Prüfungsnote vertritt
		int score = 20;

		System.out.println("Your score =" + score);

		// Wenn die Prüfungsnote weniger als  50 ist
		if (score < 50) {
			System.out.println("You are not pass");
		}
		// umgekehrt wenn die Note größer als oder gleich wie 50 und kleiner als 80.
		else if (score >= 50 && score < 80) {
			System.out.println("You are pass");
		}
		// Die restlichen Fälle (d.h größer als oder gleich wie 80)
		else {
			System.out.println("You are pass, good student!");
		}

	}
}

int score = 20;

package org.o7planning.tutorial.javabasic.controlflow;

public class ElseIfExample2 {

	public static void main(String[] args) {

		// Eine Variable von dem Int Typ erklären, die Ihr Alter vertritt.
		int age = 20;

		// Das Alter prüfen, weniger als oder gleich wie 17
		if (age <= 17) {
			System.out.println("You are 17 or younger");
		}

		// Das Alter gleich wie 18 prüfen
		else if (age == 18) {
			System.out.println("You are 18 year old");
		}
		// Das Alter prüfen, größer als 18 und kleiner als 40
		else if (age > 18 && age < 40) {
			System.out.println("You are between 19 and 39");
		}
		// Die restlichen Fällen (größer als oder gleich wie 40)
		else {
			// Ein eingenister Befehl 'if' .
			// Das Alter anders als 50 prüfen
			if (age != 50) {
				System.out.println("You are not 50 year old");
			}

			// Der negative Befehl des Alter gleich wie 50, d.h anders als 50.
			if (!(age == 50)) {
				System.out.println("You are not 50 year old");
			}

			// Wenn das Alter 60 oder 70 ist
			if (age == 60 || age == 70) {
				System.out.println("You are 60 or 70 year old");
			}

		}

	}
}

package org.o7planning.tutorial.javabasic.controlflow;

public class BooleanExample {

	public static void main(String[] args) {

		// Eine Variable von dem boolean Typ
		boolean value = true;

		// Wenn value true ist
		if (value == true) {
			System.out.println("It's true");
		}
		// umgekehrt
		else {
			System.out.println("It's false");
		}

		// Mit dem boolean Typ können Sie schreiben
		// With boolean type, you can also write
		if (value) {
			System.out.println("It's true");
		}
		// Umgekehrt
		else {
			System.out.println("It's false");
		}
	}
}

// variable_to_test: Eine Variable zu prüfen
switch ( variable_to_test ) {
  case value1:
   //  Hier etwas machen    
   break;
  case value2:
   //  Hier etwas machen    
   break;
  default:
   //  Hier etwas machen    
}

package org.o7planning.tutorial.javabasic.controlflow;

public class SwitchExample1 {

	public static void main(String[] args) {

		// Eine Alter Variable 
		int age = 20;

		// Die Wert des Alter prüfen
		switch (age) {
		// Falls das Alter 18 ist
		case 18:
			System.out.println("You are 18 year old");
			break;
		// Falls das Alter 20 ist
		case 20:
			System.out.println("You are 20 year old");
			break;
		// Die restlichen Fällen
		default:
			System.out.println("You are not 18 or 20 year old");
		}

	}

}

// Das wird nicht erlaubt!!
case (age < 18) :

// Der Fall akzeptiert nur eine konkrete Wert, zum Beispiel:
case 18:
  // etwas hier machen
  break;

package org.o7planning.tutorial.javabasic.controlflow;

public class SwitchExample2 {

	public static void main(String[] args) {

		// Eine Alter Variable erklären
		int age = 30;

		// Die Wert des Alter prüfen.
		switch (age) {
		// Falls das Alter 18 ist
		case 18:
			System.out.println("You are 18 year old");
			break;
		// Die Fälle das Alter 20, 30, 40 ist.
		case 20:
		case 30:
		case 40:
			System.out.println("You are " + age);
			break;
		// Die restlichen Fällen
		default:
			System.out.println("Other age");
		}

	}

}

// start_value: Die Beginnwert
// end_value: Die Endwert
// increment_number: die added Wert nach der Iteration
for ( start_value; end_value; increment_number ) {
   // Hier etwas machen ...
}

package org.o7planning.tutorial.javabasic.loop;

public class ForLoopExample1 {

	public static void main(String[] args) {

		// Eine 'step' Variable erklären, die Schritte der Schleife bezeichnen
		int step = 1;

		// Eine 'value' Variable mit der Beginnwert als 0
		// Nach jeder Iteration wird 'value' 3 erhöhen
		// Und die Schleife endet wenn 'value' größer als oder gleich wie 10
		for (int value = 0; value < 10; value = value + 3) {

			System.out.println("Step =" + step + "  value = " + value);

			// Die Wert 'step' 1 nach jeder Iteration erhöhen
			step = step + 1;

		}

	}

}

package org.o7planning.tutorial.javabasic.loop;

public class ForLoopExample2 {

	// Das ist ein Beispiel zur Kalkulation der Summe von 1 bis 100 
	// und dem Ausdruck des Ergebnis in Bildschirm
	public static void main(String[] args) {

		// Eine Variable erklären
		int total = 0;

		// Eine Variable 'value' erklären
		// Die erste Wert 1 anweisen
		// Nach jeder Iteration wird ihre Wert 1 erhöhen
		// Achtung: value++ ist ähnlich wie den Befehl : value = value + 1;
		// value-- ist ähnlich wie den Befehl: value = value - 1;
		for (int value = 1; value <= 100; value++) {

			// Die Wert 'total' durch die Zuzahlung der alten Wert und 'value'.
			total = total + value;
		}

		System.out.println("Total = " + total);

	}

}

// Während condition (die Bedingung) richtig ist, etwas machen.
while ( condition ) {
   // Hier etwas machen...
}

package org.o7planning.tutorial.javabasic.loop;

public class WhileExampe1 {

	public static void main(String[] args) {

		int value = 3;

		// Während  'value' kleiner als 10 ist, funktioniert die Schleife noch.
		while (value < 10) {

			System.out.println("Value = " + value);

			// Die Wert von value in 2 erhöhen
			value = value + 2;
		}
	}
	
}

// Die Schleife do-while macht mindesten eine Iteration und es macht weiter so lang wie die Bedingung richtig ist
do {
   // hier etwas machen
}
while (condition);

package org.o7planning.tutorial.javabasic.loop;

public class DoWhileExample1 {

	public static void main(String[] args) {

		int value = 3;

		// Die Schleife do-while wird immer mindesten einsmal implementiert.
		do {

			System.out.println("Value = " + value);

			// Die Wert von 'value' in 3 erhöhen
			value = value + 3;

		} while (value < 10);

	}
}

// Ein Array verzollen, die Anzahl der Elemente nicht bestimmen.
int[] array1;

// Ein Array mit 100 Elemente initializieren
// Die Elemente werden die bestimmte Wert nicht angewiesen
array1 = new int[100];

// Ein Array mit der bestimmten Anzahl der Elemente erklären
// Die Elemente werden die bestimmte Wert nicht angewiesen
double[] array2 = new double[10];

// Ein Array mit der Elemente, die die Wert angewiesen werden.
// Der Array hat 4 Elemente
long[] array3= {10L, 23L, 30L, 11L};

package org.o7planning.tutorial.javabasic.array;

public class ArrayExample1 {

	public static void main(String[] args) {

		// Ein Array mit 5 Elemente erklären
		int[] myArray = new int[5];

		// Achtung: das erste Element des Array hat die Index 0:
		// Die Wert für das erste Element anweisen (die Index 0)
		myArray[0] = 10;

		// Die Wert für das 2. Element anweisen (die Index 1)
		myArray[1] = 14;

		myArray[2] = 36;
		myArray[3] = 27;

		// Die Wert für das 5. Element anweisen (das letzte Elemente im Array)
		myArray[4] = 18;

		// Die Anzahl der Arrayelemente auf dem Bildschirm Console ausdrucken.
		System.out.println("Array Length=" + myArray.length);

		// Das Element in der Index 3 ausdrucken (das 4. Element des Array)
		System.out.println("myArray[3]=" + myArray[3]);

		// Die Schleife for benutzen um die Element im Array auszudrucken
		for (int index = 0; index < myArray.length; index++) {
			System.out.println("Element " + index + " = " + myArray[index]);
		}
	}

}

package org.o7planning.tutorial.javabasic.array;

public class ArrayExample2 {

	public static void main(String[] args) {

		// Ein Array mit 5 Element erklären
		int[] myArray = new int[5];

		// Auf dem Bildschirm Console die Anzahl der Elemente des Array ausdrucken.
		System.out.println("Array Length=" + myArray.length);

		// Die Schleife for benutzen um die Wert für die Elemente des Array anzuweisen.
		for (int index = 0; index < myArray.length; index++) {
			myArray[index] = 100 * index * index + 3;
		}

		// Auf dem Bildschirm das Element des Index 3 ausdrucken
		System.out.println("myArray[3] = " + myArray[3]);
	}

}

package org.o7planning.tutorial.javabasic.javastructure;

public class Person {

	// Das ist ein Feld (Field).
	// Der Name der Person.
	public String name;

	// Das ist ein Constructor
	// Ihn benutzen um ein Objekt zu erstellen.
	// Dieser Constructor hat einen Parameter.
	// Constructor hat immer den gleichen Name wie den Name der Klasse.
	public Person(String persionName) {
		// Die Wert für den Parameter für den Feld name anweisen
		this.name = persionName;
	}

	// Die Methode gibt das String Typ zurück
	public String getName() {
		return this.name;
	}

}

package org.o7planning.tutorial.javabasic.javastructure;

public class PersonTest {

	public static void main(String[] args) {

		// Ein Objekt aus der Klasse Person erstellen
		// Dieses Objekt aus dem Constructor der Klasse Person initializieren
		Person edison = new Person("Edison");

		// Die Klasse Person hat die Methode getName()
		// Das Objekt benutzen um die Methode getName() aufrzurufen:
		String name = edison.getName();
		System.out.println("Person 1: " + name);

		// Ein Objekt aus der Klasse Person erstellen.
		// Dieses Objekt aus dem Constructor der Klasse Person initializieren
		Person billGate = new Person("Bill Gates");

		// Die Klasse Person hat den Felder name, der public ist
		// Dieses Objekt benutzen, um die Referenz nach ihm zu machen
		String name2 = billGate.name;
		System.out.println("Person 2: " + name2);

	}

}

package org.o7planning.tutorial.javabasic.javastructure;

public class FieldSample {

	// Das ist ein static Feld (static field).
	public static int MY_STATIC_FIELD = 100;

	// Das ist ein normaler Feld.
	public String myValue;

	// Constructor zur Initialization des Objekt FieldSample.
	public FieldSample(String myValue) {
		this.myValue = myValue;
	}

}

package org.o7planning.tutorial.javabasic.javastructure;

public class FieldSampleTest {

	public static void main(String[] args) {

		// Das erste Objekt erstellen.
		FieldSample obj1 = new FieldSample("Value1");

		System.out.println("obj1.myValue= " + obj1.myValue);

		// Die Wert des static Feld  MY_STATIC_FIELD ausdrucken.
		// Die Referenz durch ein Objekt (nicht empfohlen).
		System.out.println("obj1.MY_STATIC_FIELD= " + obj1.MY_STATIC_FIELD);

		// Die Wert des static Feld - MY_STATIC_FIELD ausdrucken
		// Durch die Klasse nach dem static Feld zugreiffen.
		// (empfohlen).
		System.out.println("FieldSample.MY_STATIC_FIELD= " + FieldSample.MY_STATIC_FIELD);

		// Das 2. Objekt erstellen:
		FieldSample obj2 = new FieldSample("Value2");

		System.out.println("obj2.myValue= " + obj2.myValue);

		System.out.println("obj2.MY_STATIC_FIELD= " + obj2.MY_STATIC_FIELD);

		System.out.println(" ------------- ");

		// Der static Feld für alle Objekte einer gleichen Klasse.
		// Die Wert für den static Feld MY_STATIC_FIELD anweisen
		// (oder benutzen: FieldSample.MY_STATIC_FIELD = 200)
		obj1.MY_STATIC_FIELD = 200;

		// Hier die Wert von 200 ausdrucken
		System.out.println("obj2.MY_STATIC_FIELD= " + obj2.MY_STATIC_FIELD);
	}
	
}

package org.o7planning.tutorial.javabasic.javastructure;

public class FinalFieldExample {

	// Ein final Feld ( auch einen Feld Konstante sogenannt).
	// Der final Feld darf die neue Wert nicht anweisen.
	public final int myValue = 100;

	// Ein static und final Feld.
	// Der final Feld darf die neue Wert nicht anweisen.
	public static final long MY_LONG_VALUE = 1234L;

}

package org.o7planning.tutorial.javabasic.javastructure;

public class MethodSample {

	public String text = "Some text";

	// Der Default-Constructor .
	public MethodSample() {

	}

	// Das ist die Methode zur String Typ Zurückgabe.
	// Diese Methode hat keinen Parameter
	public String getText() {
		return this.text;
	}

	// Das ist eine Methode mit dem String Parameter.
	// Diese Methode gibt das void String zurück (Oder nichts zurückgeben sogenannt)
	public void setText(String text) {
		// this.text macht die Referenz nach dem Feld text, 
		// das mit dem Parameter text unterscheidet.
		this.text = text;
	}

	// Das ist eine static Methode, die die int Typ Zurückgabe und 3 Parameter hat
	public static int sum(int a, int b, int c) {
		int d = a + b + c;
		return d;
	}
}

package org.o7planning.tutorial.javabasic.javastructure;

public class MethodSampleTest {

	public static void main(String[] args) {

		// Das Objekt MethodSample erstellen
		MethodSample obj = new MethodSample();

		// Die Aufruf nach der Methode getText()
		String text = obj.getText();

		System.out.println("Text = " + text);

		// Die Aufruf nach der Methode  setText(String)
		obj.setText("New Text");

		System.out.println("Text = " + obj.getText());

		// Die static Methode kann durch die Klasse aufgeruft werden.
		// (empfohlen  (**)
		int sum = MethodSample.sum(10, 20, 30);

		System.out.println("Sum  10,20,30= " + sum);

		// Oder durch das Objekt aufrufen .
		// (nicht empfohlen) (**)
		int sum2 = obj.sum(20, 30, 40);

		System.out.println("Sum  20,30,40= " + sum2);
	}

}

package org.o7planning.tutorial.javabasic.inheritance;

public class Animal {

	public Animal() {

	}

	public void move() {
		System.out.println("Move ...!");
	}

	// Der Ruf von diesem Tier
	public void say() {
		System.out.println("<nothing>");
	}

}

package org.o7planning.tutorial.javabasic.inheritance;

public class Cat extends Animal {

	// Die Methode der Klasse Animal überschreiben
	public void say() {
		System.out.println("Meo");
	}

}

package org.o7planning.tutorial.javabasic.inheritance;

public class Dog extends Animal {

	// Die Methode der Klasse Animal überschreiben
	public void say() {
		System.out.println("Go");
	}

}

package org.o7planning.tutorial.javabasic.inheritance;

// Die Ameise
public class Ant extends Animal {

}

package org.o7planning.tutorial.javabasic.inheritance;

public class AnimalTest {

   public static void main(String[] args) {

      // Ein Objekt Cat erstellen.
      Cat cat = new Cat();

      // Prüfen, ob 'cat' das Objekt der Animal ist oder nicht.
      // Das Ergebnis ist true.
      boolean isAnimal = cat instanceof Animal;
      System.out.println("cat instanceof Animal?" + isAnimal);

      // ==> Meo
      // Die Aufruf nach der Methode say() von Cat.
      cat.say();

      // Ein Objekt Animal erklären.
      // Das Objekt durch den Constructor von Cat initializieren.
      Animal cat2 = new Cat();

      // ==> Meo
      // Die Methode say() von Cat wird aufgeruft (nicht von Animal).
      cat2.say();

      // Das Objekt Animal erstellen.
      // Durch den Constructor der Subklasse Ant.
      Animal ant = new Ant();

      // Ant hat keine Methode say()
      // ==> Es ruft nach die Methode say() auf, erbt aus der Vaterklasse (Animal).
      ant.say();
   }
}