java reflection tutorial with examples
In diesem Video-Tutorial wird erklärt, was Reflection ist und wie es mithilfe der Reflection-API implementiert wird:
Die Reflexion in Java besteht darin, das Verhalten eines Programms zur Laufzeit zu überprüfen und zu ändern.
Mithilfe dieser Reflection-API können Sie zur Laufzeit Klassen, Konstruktoren, Modifikatoren, Felder, Methoden und Schnittstellen überprüfen. Zum Beispiel, Sie können den Namen der Klasse oder Details zu den privaten Mitgliedern der Klasse abrufen.
Lesen Sie unser gesamtes durch JAVA Trainingsreihe Weitere Informationen zu Java-Konzepten.
Hier ist ein Video-Tutorial zu Java Reflection:
Was du lernen wirst:
- Reflexion in Java
- Reflexions-API In Java
- java.lang.Class-Klasse
- Erstellen Sie java.lang.Class-Objekte
- Holen Sie sich Super Class & Access Modifikatoren
- Schnittstellen abrufen
- Reflexion: Feldwert abrufen
- Reflexion: Methode
- Reflexion: Konstruktor
- Nachteile der Reflexion
- Häufig gestellte Fragen
- Weitere Informationen zu Java Reflection
- Fazit
Reflexion in Java
Wir sind uns bewusst, dass wir in einer bestimmten Klasse ihre Eigenschaften und Methoden zur Kompilierungszeit ändern können, und dies ist sehr einfach. Unabhängig davon, ob die Eigenschaften und Methoden anonym sind oder Namen haben, können sie während der Kompilierungszeit nach unserem Willen geändert werden.
Wir können diese Klassen, Methoden oder Felder jedoch nicht sofort zur Laufzeit ändern. Mit anderen Worten, es ist sehr schwierig, das Verhalten verschiedener Programmierkomponenten zur Laufzeit zu ändern, insbesondere für unbekannte Objekte.
Die Programmiersprache Java bietet eine Funktion namens 'Betrachtung' Dadurch können wir das Laufzeitverhalten einer Klasse, eines Felds oder einer Methode zur Laufzeit ändern.
Somit kann eine Reflexion definiert werden als „Technik zur Überprüfung und Änderung des Laufzeitverhaltens eines unbekannten Objekts zur Laufzeit. Ein Objekt kann eine Klasse, ein Feld oder eine Methode sein. “
Reflection ist eine von Java bereitgestellte „Application Programming Interface“ (API).
Der 'Reflexions' -Prozess ist unten dargestellt.
In der obigen Darstellung können wir sehen, dass wir ein unbekanntes Objekt haben. Dann verwenden wir die Reflection-API für dieses Objekt. Infolgedessen können wir das Verhalten dieses Objekts zur Laufzeit ändern.
Daher können wir die Reflection-API in unseren Programmen verwenden, um das Verhalten des Objekts zu ändern. Die Objekte können Methoden, Schnittstellen, Klassen usw. sein. Wir untersuchen diese Objekte und ändern dann ihr Verhalten zur Laufzeit mithilfe der Reflection-API.
In Java sind 'java.lang' und 'java.lang.reflect' die beiden Pakete, die Klassen zur Reflexion bereitstellen. Die spezielle Klasse 'java.lang.Class' bietet die Methoden und Eigenschaften zum Extrahieren von Metadaten, mit denen wir das Klassenverhalten überprüfen und ändern können.
Wir verwenden die von den oben genannten Paketen bereitgestellte Reflection-API, um die Klasse und ihre Mitglieder einschließlich Felder, Methoden, Konstruktoren usw. zur Laufzeit zu ändern. Ein Unterscheidungsmerkmal der Reflection-API besteht darin, dass wir auch die privaten Datenelemente oder Methoden der Klasse bearbeiten können.
Die Reflection-API wird hauptsächlich verwendet in:
- Reflection wird hauptsächlich in Debugging-Tools, JUnit und Frameworks verwendet, um das Verhalten zur Laufzeit zu überprüfen und zu ändern.
- IDE (Integrierte Entwicklungsumgebung) Z.B. Eclipse IDE, NetBeans usw.
- Testwerkzeuge usw.
- Es wird verwendet, wenn Ihre Anwendung über Bibliotheken von Drittanbietern verfügt und Sie Informationen zu den verfügbaren Klassen und Methoden erhalten möchten.
Reflexions-API In Java
Mit der Reflection-API können wir die Reflektion für die folgenden Entitäten implementieren:
- Feld : Die Field-Klasse enthält Informationen, mit denen wir eine Variable oder ein Feld wie einen Datentyp (int, double, String usw.), einen Zugriffsmodifikator (privat, öffentlich, geschützt usw.), einen Namen (bezeichner) und einen Wert deklarieren.
- Methode : Die Methodenklasse kann uns helfen, Informationen wie den Zugriffsmodifikator der Methode, den Methodenrückgabetyp, den Methodennamen, die Methodenparametertypen und die von der Methode ausgelösten Ausnahmetypen zu extrahieren.
- Baumeister : Die Konstruktorklasse enthält Informationen zum Klassenkonstruktor, die den Konstruktorzugriffsmodifikator, den Konstruktornamen und die Parametertypen enthalten.
- Bearbeiten : Die Modifier-Klasse gibt uns Informationen zu einem bestimmten Access-Modifier.
Alle oben genannten Klassen sind Teil des Pakets java.lang.reflect. Als nächstes werden wir jede dieser Klassen diskutieren und Programmierbeispiele verwenden, um die Reflexion über diese Klassen zu demonstrieren.
Beginnen wir zunächst mit der Klasse java.lang.Class.
java.lang.Class-Klasse
Die Klasse java.lang.The enthält zur Laufzeit alle Informationen und Daten zu Klassen und Objekten. Dies ist die Hauptklasse, die zur Reflexion verwendet wird.
Die Klasse java.lang.Class bietet:
- Methoden zum Abrufen von Klassenmetadaten zur Laufzeit.
- Methoden zum Überprüfen und Ändern des Verhaltens einer Klasse zur Laufzeit.
Erstellen Sie java.lang.Class-Objekte
Wir können Objekte von java.lang.Class mit einer der folgenden Optionen erstellen.
Interviewfragen für einen Business Analyst
# 1) .class Erweiterung
Die erste Option zum Erstellen eines Objekts der Klasse ist die Verwendung der Erweiterung .class.
Beispielsweise,Wenn Test eine Klasse ist, können wir ein Klassenobjekt wie folgt erstellen:
Class obj_test = Test.class;
Dann können wir den obj_test verwenden, um eine Reflexion durchzuführen, da dieses Objekt alle Informationen über die Klasse Test enthält.
# 2) forName () Methode
Die forName () -Methode verwendet den Namen der Klasse als Argument und gibt das Class-Objekt zurück.
Beispielsweise,Das Objekt der Testklasse kann wie folgt erstellt werden:
class obj_test = Class.forName (“Test”);
# 3) getClas () Methode
Die Methode getClass () verwendet das Objekt einer Klasse, um das Objekt java.lang.Class abzurufen.
Beispielsweise,Betrachten Sie den folgenden Code:
Test obj = new Test (); Class obj_test = obj.getClass ();
In der ersten Zeile haben wir ein Objekt der Testklasse erstellt. Mit diesem Objekt haben wir dann die Methode 'getClass ()' aufgerufen, um ein Objekt obj_test von java.lang.Class abzurufen.
Holen Sie sich Super Class & Access Modifikatoren
java.lang.class bietet eine Methode 'getSuperClass ()', mit der die Oberklasse einer Klasse abgerufen wird.
In ähnlicher Weise wird eine Methode getModifier () bereitgestellt, die den Zugriffsmodifikator der Klasse zurückgibt.
Das folgende Beispiel zeigt die Methode getSuperClass ().
import java.lang.Class; import java.lang.reflect.*; //define Person interface interface Person { public void display(); } //declare class Student that implements Person class Student implements Person { //define interface method display public void display() { System.out.println('I am a Student'); } } class Main { public static void main(String[] args) { try { // create an object of Student class Student s1 = new Student(); // get Class object using getClass() Class obj = s1.getClass(); // get the superclass of Student Class superClass = obj.getSuperclass(); System.out.println('Superclass of Student Class: ' + superClass.getName()); } catch(Exception e) { e.printStackTrace(); } } }
Ausgabe
Im obigen Programmierbeispiel wird eine Schnittstelle Person mit einer einsamen Methode 'display ()' definiert. Dann definieren wir eine Schülerklasse, die die Personenschnittstelle implementiert. In der Hauptmethode verwenden wir die Methode getClass (), um das Class-Objekt abzurufen und dann mit der Methode getSuperClass () auf das übergeordnete Element oder die Oberklasse des Student-Objekts zuzugreifen.
Schnittstellen abrufen
Wenn die Klasse einige Schnittstellen implementiert, können wir diese Schnittstellennamen mit der Methode getInterfaces () der Datei java.lang.Class abrufen. Dazu müssen wir eine Reflexion über die Java-Klasse durchführen.
Das folgende Programmierbeispiel zeigt die Verwendung der Methode getInterfaces () in Java Reflection.
import java.lang.Class; import java.lang.reflect.*; //define Interface Animals and PetAnimals interface Animals { public void display(); } interface PetAnimals { public void makeSound(); } //define a class Dog that implements above interfaces class Dog implements Animals, PetAnimals { //define interface method display public void display() { System.out.println('This is a PetAnimal::Dog'); } //define interface method makeSound public void makeSound() { System.out.println('Dog makes sound::Bark bark'); } } class Main { public static void main(String[] args) { try { // create an object of Dog class Dog dog = new Dog(); // get class object Class obj = dog.getClass(); // get the interfaces implemented by Dog Class[] objInterface = obj.getInterfaces(); System.out.println('Class Dog implements following interfaces:'); //print all the interfaces implemented by class Dog for(Class citem : objInterface) { System.out.println('Interface Name: ' + citem.getName()); } } catch(Exception e) { e.printStackTrace(); } } }
Ausgabe
Im obigen Programm haben wir zwei Schnittstellen definiert, d. H. Animals und PetAnimals. Dann definieren wir eine Klasse Dog, die beide Schnittstellen implementiert.
In der Hauptmethode rufen wir das Objekt der Klasse Dog in java.lang.Class ab, um eine Reflexion durchzuführen. Dann verwenden wir die Methode getInterfaces (), um die Schnittstellen abzurufen, die von der Klasse Dog implementiert werden.
Reflexion: Feldwert abrufen
Wie bereits erwähnt, enthält das Paket java.lang.reflect die Field-Klasse, mit deren Hilfe wir die Feld- oder Datenelemente der Klasse widerspiegeln können.
Nachfolgend sind die Methoden aufgeführt, die von der Feldklasse für die Reflexion eines Feldes bereitgestellt werden.
Methode | Beschreibung |
---|---|
getField ('fieldName') | Gibt das Feld (public) mit einem angegebenen Feldnamen zurück. |
getFields () | Gibt alle öffentlichen Felder zurück (sowohl für Klasse als auch für Oberklasse). |
getDeclaredFields () | Ruft alle Felder der Klasse ab. |
getModifier () | Gibt eine ganzzahlige Darstellung des Zugriffsmodifikators des Feldes zurück. |
set (classObject, value) | Weist dem Feld den angegebenen Wert zu. |
get (classObject) | Ruft den Feldwert ab. |
setAccessible (boolean) | Machen Sie ein privates Feld zugänglich, indem Sie true übergeben. |
getDeclaredField ('fieldName') | Gibt das Feld mit einem angegebenen Namen zurück. |
Im Folgenden sind zwei Reflexionsbeispiele aufgeführt, die die Reflexion im öffentlichen und privaten Bereich demonstrieren.
Das folgende Java-Programm demonstriert die Reflexion in einem öffentlichen Feld.
import java.lang.Class; import java.lang.reflect.*; class Student { public String StudentName; } class Main { public static void main(String[] args) { try{ Student student = new Student(); // get an object of the class Class Class obj = student.getClass(); // provide field name and get the field info Field student_field = obj.getField('StudentName'); System.out.println('Details of StudentName class field:'); // set the value of field student_field.set(student, 'Lacey'); // get the access modifier of StudentName int mod1 = student_field.getModifiers(); String modifier1 = Modifier.toString(mod1); System.out.println('StudentName Modifier::' + modifier1); // get the value of field by converting in String String typeValue = (String)student_field.get(student); System.out.println('StudentName Value::' + typeValue); } catch(Exception e) { e.printStackTrace(); } } }
Ausgabe
In diesem Programm haben wir eine Klasse 'Student' mit einem öffentlichen Feld 'StudentName' deklariert. Anschließend reflektieren wir über die API-Schnittstelle der Field-Klasse das Feld StudentName und rufen dessen Zugriffsmodifikator und -wert ab.
Das nächste Programm reflektiert ein privates Feld der Klasse. Die Operationen sind ähnlich, außer dass ein zusätzlicher Funktionsaufruf für das private Feld ausgeführt wird. Wir müssen setAccessible (true) für das private Feld aufrufen. Dann reflektieren wir dieses Feld auf ähnliche Weise wie das öffentliche Feld.
import java.lang.Class; import java.lang.reflect.*; class Student { private String rollNo; } class Main { public static void main(String[] args) { try { Student student = new Student(); // get the object for class Student in a Class. Class obj = student.getClass(); // access the private field Field field2 = obj.getDeclaredField('rollNo'); // make the private field accessible field2.setAccessible(true); // set the value of rollNo field2.set(student, '27'); System.out.println('Field Information of rollNo:'); // get the access modifier of rollNo int mod2 = field2.getModifiers(); String modifier2 = Modifier.toString(mod2); System.out.println('rollNo modifier::' + modifier2); // get the value of rollNo converting in String String rollNoValue = (String)field2.get(student); System.out.println('rollNo Value::' + rollNoValue); } catch(Exception e) { e.printStackTrace(); } } }
Ausgabe
Reflexion: Methode
Ähnlich wie in den Feldern der Klasse können wir auch Klassenmethoden reflektieren und ihr Verhalten zur Laufzeit ändern. Dazu verwenden wir die Method-Klasse des Pakets java.lang.reflect.
Nachfolgend sind die Funktionen aufgeführt, die von der Methodenklasse zur Reflexion der Klassenmethode bereitgestellt werden.
Methode | Beschreibung |
---|---|
getMethods () | Ruft alle öffentlichen Methoden ab, die in der Klasse und ihrer Oberklasse definiert sind. |
getDeclaredMethod () | Gibt in der Klasse deklarierte Methoden zurück. |
getName () | Gibt die Methodennamen zurück. |
getModifiers () | Gibt eine ganzzahlige Darstellung des Zugriffsmodifikators der Methode zurück. |
getReturnType() | Gibt den Methodenrückgabetyp zurück. |
Das folgende Beispiel zeigt die Reflexion von Klassenmethoden in Java unter Verwendung der obigen APIs.
import java.lang.Class; import java.lang.reflect.*; //declare a class Vehicle with four methods class Vehicle { public void display() { System.out.println('I am a Vehicle!!'); } protected void start() { System.out.println('Vehicle Started!!!'); } protected void stop() { System.out.println('Vehicle Stopped!!!'); } private void serviceVehicle() { System.out.println('Vehicle serviced!!'); } }class Main { public static void main(String[] args) { try { Vehicle car = new Vehicle(); // create an object of Class Class obj = car.getClass(); // get all the methods using the getDeclaredMethod() in an array Method[] methods = obj.getDeclaredMethods(); // for each method get method info for(Method m : methods) { System.out.println('Method Name: ' + m.getName()); // get the access modifier of methods int modifier = m.getModifiers(); System.out.print('Modifier: ' + Modifier.toString(modifier) + ' '); // get the return type of method System.out.print('Return Type: ' + m.getReturnType()); System.out.println('
'); } } catch(Exception e) { e.printStackTrace(); } } }
Ausgabe
Im obigen Programm sehen wir, dass die Methode getDeclaredMethods das von der Klasse deklarierte Array von Methoden zurückgibt. Dann durchlaufen wir dieses Array und zeigen die Informationen jeder Methode an.
Reflexion: Konstruktor
Wir können die Klasse 'Constructor' des Pakets java.lang.reflect verwenden, um die Konstruktoren einer Java-Klasse zu untersuchen und zu ändern.
Die Konstruktorklasse stellt zu diesem Zweck die folgenden Methoden bereit.
Methode | Beschreibung |
---|---|
getConstructors () | Gibt alle in class und seiner Oberklasse deklarierten Konstruktoren zurück. |
getDeclaredConstructor () | Gibt alle deklarierten Konstruktoren zurück. |
getName () | Ruft den Namen des Konstruktors ab. |
getModifiers () | Gibt die ganzzahlige Darstellung des Zugriffsmodifikators von Konstruktoren zurück. |
getParameterCount () | Gibt die Gesamtzahl der Parameter für einen Konstruktor zurück. |
Das folgende Reflexionsbeispiel zeigt die Reflexion von Konstruktoren einer Klasse in Java. Wie die Methodenreflexion gibt auch hier die Methode getDeclaredConstructors ein Array von Konstruktoren für eine Klasse zurück. Dann durchlaufen wir dieses Konstruktorarray, um Informationen zu jedem Konstruktor anzuzeigen.
import java.lang.Class; import java.lang.reflect.*; //declare a class Person with three constructors class Person { public Person() { } //constructor with no parameters public Person(String name) { } //constructor with 1 parameter private Person(String name, int age) {} //constructor with 2 parameters } class Main { public static void main(String[] args) { try { Person person = new Person(); Class obj = person.getClass(); // get array of constructors in a class using getDeclaredConstructor() Constructor[] constructors = obj.getDeclaredConstructors(); System.out.println('Constructors for Person Class:'); for(Constructor c : constructors) { // get names of constructors System.out.println('Constructor Name: ' + c.getName()); // get access modifier of constructors int modifier = c.getModifiers(); System.out.print ('Modifier: ' + Modifier.toString(modifier) + ' '); // get the number of parameters in constructors System.out.println('Parameters: ' + c.getParameterCount()); //if there are parameters, get parameter type of each parameter if(c.getParameterCount() > 0){ Class[] paramList=c.getParameterTypes(); System.out.print ('Constructor parameter types :'); for (Class class1 : paramList) { System.out.print(class1.getName() +' '); } } System.out.println('
'); } } catch(Exception e) { e.printStackTrace(); } } }
Ausgabe
Nachteile der Reflexion
Reflexion ist stark, sollte aber nicht wahllos verwendet werden. Wenn es möglich ist, ohne Reflexion zu arbeiten, ist es vorzuziehen, die Verwendung zu vermeiden.
Nachfolgend sind einige Nachteile von Reflection aufgeführt:
- Leistungsaufwand: Obwohl Reflexion eine leistungsstarke Funktion ist, weisen Reflexionsoperationen immer noch eine langsamere Leistung auf als nichtreflektierende Operationen. Daher sollten wir die Verwendung von Reflexionen in leistungskritischen Anwendungen vermeiden.
- Sicherheitsbeschränkungen: Da Reflection eine Laufzeitfunktion ist, sind möglicherweise Laufzeitberechtigungen erforderlich. Für Anwendungen, bei denen der Code in einer eingeschränkten Sicherheitseinstellung ausgeführt werden muss, ist die Reflexion möglicherweise nicht hilfreich.
- Belichtung von Interna: Mithilfe von Reflection können wir auf private Felder und Methoden in einer Klasse zugreifen. Reflexion unterbricht somit die Abstraktion, die Code möglicherweise nicht portierbar und funktionsunfähig macht.
Häufig gestellte Fragen
F # 1) Warum wird Reflection in Java verwendet?
Antworten: Mithilfe von Reflection können wir Klassen, Schnittstellen, Konstruktoren, Felder und Methoden zur Laufzeit überprüfen, auch wenn sie zur Kompilierungszeit anonym sind. Diese Überprüfung ermöglicht es uns, das Verhalten dieser Entitäten zur Laufzeit zu ändern.
Q # 2) Wo wird Reflexion eingesetzt?
Antworten: Reflexion wird beim Schreiben von Frameworks verwendet, die mit benutzerdefinierten Klassen zusammenarbeiten, wobei der Programmierer nicht einmal weiß, wie die Klassen oder andere Entitäten aussehen werden.
Q # 3) Ist Java Reflection langsam?
Antworten: Ja, es ist langsamer als der Nichtreflexionscode.
Q # 4) Ist Java Reflection schlecht?
Antworten: In gewisser Weise ja. Erstens verlieren wir die Sicherheit während der Kompilierung. Ohne Sicherheit zur Kompilierungszeit können Laufzeitfehler auftreten, die sich auf Endbenutzer auswirken können. Es wird auch schwierig sein, den Fehler zu debuggen.
Q # 5) Wie stoppt man eine Reflexion in Java?
Antworten: Wir vermeiden einfach die Verwendung von Reflexion, indem wir Nichtreflexionsoperationen schreiben. Oder vielleicht können wir einige generische Mechanismen wie eine benutzerdefinierte Validierung mit Reflexion verwenden.
Weitere Informationen zu Java Reflection
Das Paket java.lang.reflect enthält die Klassen und Schnittstellen für die Reflexion. Und die java.lang.class kann als Einstiegspunkt für die Reflexion verwendet werden.
So erhalten Sie die Klassenobjekte:
1. Wenn Sie eine Instanz eines Objekts haben,
Klasse c = obj.getclass ();
2. Wenn Sie den Typ der Klasse kennen,
Klasse c = type.getClass ();
3. Wenn Sie den Klassennamen kennen,
Klasse c = Class.forName ('com.demo.Mydemoclass');
So erhalten Sie die Klassenmitglieder:
Klassenmitglieder sind Felder (Klassenvariablen) und Methoden.
- getFields () - Wird verwendet, um alle Felder außer den privaten Feldern abzurufen.
- getDeclaredField () - Wird verwendet, um die privaten Felder abzurufen.
- getDeclaredFields () - Wird verwendet, um die privaten und öffentlichen Felder abzurufen.
- getMethods () - Wird verwendet, um alle Methoden außer den privaten Methoden abzurufen.
- getDeclaredMethods () –Verwendet, um die öffentlichen und privaten Methoden zu erhalten.
Demo-Programme:
ReflectionHelper.java:
Dies ist die Klasse, in der wir mithilfe der Reflection-API prüfen werden.
kostenloser Registry Cleaner für Windows 10
class ReflectionHelper { private int age; private String name; public String deptName; public int empID; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDeptName() { return deptName; } public void setDeptName(String deptName) { this.deptName = deptName; } }
ReflectionDemo.java
public class ReflectionDemo { public static void main(String[] args) throws NoSuchFieldException, SecurityException { //get the class Class ReflectionHelperclass=ReflectionHelper.class; //get the name of the class String className = ReflectionHelperclass.getName(); System.out.println('className=='+className); System.out.println('getModifiers'+ReflectionHelperclass.getModifier s()); System.out.println('getSuperclass'+ReflectionHelperclass.getSupercla ss()); System.out.println('getPackage'+ReflectionHelperclass.getPackage()); Field[] fields =ReflectionHelperclass.getFields(); //getting only the public fields for(Field oneField : fields) { Field field = ReflectionHelperclass.getField(oneField.getName()); String fieldname = field.getName(); System.out.println('only the public fieldnames:::::'+fieldname); } //getting all the fields of the class Field[] privatefields =ReflectionHelperclass.getDeclaredFields(); for(Field onefield : privatefields) { Field field = ReflectionHelperclass.getDeclaredField(onefield.getName()); String fieldname = field.getName(); System.out.println('all the fieldnames in the class:::'+fieldname); } Method[] methods =ReflectionHelperclass.getDeclaredMethods(); for(Method m: methods) { System.out.println('methods::::'+m.getName()); } }}
Fazit
In diesem Tutorial wurde die Reflection-API in Java ausführlich erläutert. Wir haben gesehen, wie Klassen, Schnittstellen, Felder, Methoden und Konstruktoren reflektiert werden können, zusammen mit einigen Nachteilen der Reflexion.
Reflexion ist eine relativ fortgeschrittene Funktion in Java, sollte jedoch von Programmierern verwendet werden, die eine starke Sprache beherrschen. Dies liegt daran, dass es zu unerwarteten Fehlern und Ergebnissen kommen kann, wenn es nicht mit Vorsicht verwendet wird.
Obwohl Reflexion stark ist, sollte sie vorsichtig verwendet werden. Mithilfe von Reflection können wir jedoch Anwendungen entwickeln, die bis zur Laufzeit keine Kenntnis von Klassen und anderen Entitäten haben.
=> Schauen Sie sich hier den Java Beginners Guide an.
Literatur-Empfehlungen
- Java Scanner Class Tutorial mit Beispielen
- Java Integer und Java BigInteger Klasse mit Beispielen
- JAVA-Tutorial für Anfänger: Über 100 praktische Java-Video-Tutorials
- Einführung in die Java-Programmiersprache - Video-Tutorial
- Was ist Java Vector? Java Vector Class Tutorial mit Beispielen
- Java Interface und Abstract Class Tutorial mit Beispielen
- Java substring () -Methode - Tutorial mit Beispielen
- JCF-Tutorial (Java Collections Framework)