Schnelle lernen Java für Anfänger
View more Tutorials:
Zum ersten möchten Sie wissen, was brauchen Sie, die Java zu lernen. Schauen Sie an bei ...
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:


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:
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:

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;

- > 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
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"); } } }
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

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

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; } } }
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

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

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

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

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; }
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); } }

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


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 :
Sie können die Hinweise der Herunterladung und Benutzen der Jdk9 Javadoc mit der CHM Format in :
