Schnelle lernen Java für Anfänger

View more categories:

1- Die Vorstellung

Zum ersten möchten Sie wissen, was brauchen Sie, die Java zu lernen. Schauen Sie an bei ...

2- Neues Projekt erstellen

Zum ersten erstellen wir ein Projekt. Es wird in dieser Hinweise benutzen
Name von Projekt eingeben
  • BasicJavaTutorial
Das ist Image von dem erstellten Project 
Beachten Sie: Um die sonstige Sprache außer Englisch in Projekt zu typen, sollen Sie die Verschlüsselung zu UTF8 ändern.
Drücken Sie die Rechte Maustaste ein und wählen Sie Properties:

3- Primitive Datentypen (Primitive Data Types)

Es gibt 8 primitive daten in JAVA:
  • Für die ganze Zahl haben wir:   byte, short, int, long
  • Für die reelle Zahl haben wir: float, double
  • Für Zeichen: char
  • Für logic Type:  true oder false ( richtig oder falsch)
Type Description bit Min value Max value
byte 8 bit integer number 8  -128 (-2^7) 127 (2^7-1)
short 16 bit integer number 16 -32,768 (-2^15) 32,767 (2^15 -1)
int 32 bit integer number 32 - 2,147,483,648
(-2^31)
2,147,483,647
(2^31 -1)
long 64 bit integer number 64 -9,223,372,036,854,775,808
(-2^63)
9,223,372,036,854,775,807
(2^63 -1)
float 32 bit real number 32 -3.4028235 x 10^38 3.4028235 x 10^38
double 64 bit real number 64 -1.7976931348623157 x 10^308 1.7976931348623157 x 10^308
boolean Logic type   false true
char Character type 16 '\u0000' (0) '\uffff' (65,535).
See more details:

4- Variable

Drücken Sie die rechte Maustaste in src ein und dann wählen Sie "New/Package":
Stellen Sie den Name von package :
  • org.o7planning.tutorial.javabasic.variable
Den Name von Class eingeben:
  • VariableExample1
Class VariableExample1 wird erstellt
Ändern Sie die Code der class VariableExample1:
VariableExample1.java
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);

	}

}
Starten Sie class VariableExample1:
Drücken Sie die Maustaste ins class VariableExample1 ein und dann wählen Sie "Run As/Java Application":
Das Ergebnis des Class Laufen in Console Fenster 
Sie können viele Variable gleichzeitig melden. Das unten Beispiel stellt diese Dinge dar.
Erstellung der class VariableExample2
VariableExample2.java
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);
	}

}
Das Ergebniss für dem Starten der Class VariableExample2:

5- Der Fluss des Programms steuern (Control flow)

5.1- If-else Anweisung (statement)

Die Struktur der Anweisung if - else ist:
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    
}
Die Klasse  ElseIfExample1 erstellen
ElseIfExample1.java
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!");
		}

	}
}
Ergebnis von dem Starten der class ElseIfExample1:
Ändern Sie den Wert der Variable "score" in dem obengenannten Beispiel und Restarten Sie die Class ElseIfExample1:
int score = 20;

5.2- Der normale Operator

  • > größer
  • < kleiner
  • >= größer oder gleich
  • <= kleiner oder gleich
  • && und
  • || oder
  • == gleiche Vergleich
  • != unterschiedliche Vergleich
  • ! negativ
Erstellung der class ElseIfExample2
ElseIfExample2.java
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");
			}

		}

	}
}
Sie können den Wert der "age" ändern und starten Sie class ElseIfExample2 und dann sehen die Ergebnisse

5.3- Boolean

boolean ist ein Datenart. Es hat nur 2 Werte   true oder  false (richtig oder falsch).
Erstellen Sie class BooleanExample:
BooleanExample.java
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");
		}
	}
}

5.4- Switch-case-default Anweisung

Das ist ein Anweisung mit Zweig, es ist so gleich wie die obengemeinten Anweisung If-Else 
// 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    
}
SwitchExample1.java
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 Ergebnis von dem Starten der class  SwitchExample1:
Beachten Sie, dass Die Anweisung case einen bestimmten Wert fördert. Sie können nicht wie folgend machen
// Das wird nicht erlaubt!!
case (age < 18) :

// Der Fall akzeptiert nur eine konkrete Wert, zum Beispiel:
case 18:
  // etwas hier machen
  break;
Ein anderes Beispiel
SwitchExample2.java
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");
		}

	}

}
Ergebnis des Beispiel

5.5- for Loop

Das ist Struktur der Schleife:
// 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 ...
}
Ein Beispiel sehen
ForLoopExample1.java
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;

		}

	}

}
Das Ergebnis für das Starten der class ForLoopExample1:
Ein weiteres Beispiel: Die Summe von 1 bis 100 kalkulieren
ForLoopExample2.java
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);

	}

}
Das Ergebnis

5.6- while Loop

Hier ist die Struktur der Schleife while:
// Während condition (die Bedingung) richtig ist, etwas machen.
while ( condition ) {
   // Hier etwas machen...
}
Sehen Sie das Beispiel
WhileExample1.java
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;
		}
	}
	
}

5.7- do-while Loop

Das ist die Struktur der Schleife  do-while:
// 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);
Sehen Sie das Beispiel
DoWhileExample1.java
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);

	}
}
das Ergebnis

6- Arrays in Java

6.1- Was ist Array?

Array ist ein benachbar zueinander Liste der Elementen in Speicher 
Sehen Sie ein Array mit 5 Elemente, die aus int-Zahlen bestehen

6.2- Arbeiten mit Arrays

Wie melden Sie ein Array in Java ein
// 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};
Sehen Sie ein Beispiel:
ArrayExample1.java
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]);
		}
	}

}
Das Ergebnis
Ein weiteres Beispiel stellt ein Schleife for für die Ernennung des Wert der Elemente dar
ArrayExample2.java
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]);
	}

}
das Ergebnis

7- Klasse, Instanz, Constructor

Sie brauchen die Untercheidung zwischen 3 Definition zu wissen
  • Class
  • Constructor)
  • Instance)
Wenn wir über den Baum zu sprechen, ist es etwas abstrakt, es ist eine Klasse. Aber wenn wir zu einem bestimmten Baum zeigte, war es klar, und das ist die Instanz (Instance)
Oder wenn wir über die Person sprechen, ist das abstrakt, es ist eine Klasse. Aber wenn Sie auf Sie oder mich hinweisen, es sind zwei verschiedene Instanzen, die gleiche Klasse von Menschen.
Person.java
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;
	}

}
Person klasse hat keine main methode. TestPerson klasse erstellen Person Objekt über Konstruktor
PersonTest.java
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);

	}

}
Ergebnis des Beispiel

8- Der Feld

Zum nächsten diskutieren wir einige Definition
Das Feld (Field)
  • normale Field
  • static Field)
  • final Field)
  • static final Field)
Sehen Sie ein Beispiel über die normale Field und static Field
FieldSample.java
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;
	}

}
FieldSampleTest.java
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);
	}
	
}
Das Ergebnis
Die Fields final ist die Fields, damit Sie nicht die Wert für sie zuweisen können. Sie ist so gleich wie ein Konstante
FinalFieldExample.java
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;

}

9- Methode (Method)

Die Methode (Method):
  • Normale Method.
  • static Method 
  • final Method  (in die Erbchaft der class gemeint).
MethodSample.java
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;
	}
}
MethodSampleTest.java
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);
	}

}

10- Die Vererbung in Java

Java ermöglicht die Class aus einer Class ausgeweitert. Die ausgeweiterten Class ist die Tochterclass genannt. die Tochterclass können die Field und Methode vom Vaterclass erben
Animal.java
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>");
	}

}
Cat.java
package org.o7planning.tutorial.javabasic.inheritance;

public class Cat extends Animal {

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

}
Dog.java
package org.o7planning.tutorial.javabasic.inheritance;

public class Dog extends Animal {

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

}
Ant.java
package org.o7planning.tutorial.javabasic.inheritance;

// Die Ameise
public class Ant extends Animal {

}
AnimalTest.java
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();
   }
}
Ergebnis des Beispiel

11- Die Anleitung der Gebrauchweise von Javadoc

Javadoc ist ein Unterlagen für die Nachschlagen der Benutzungsweise der Class in java. Zum Beispiel: Class A schlienßt welche Method, Field, construtor,...
Sie können die Hinweise der Herunterladung und Benutzen der Jdk9 Javadoc mit der CHM Format in :

View more categories: