Wat is reflectie en waarom is het nuttig?
Ik ben vooral geïnteresseerd in Java, maar ik neem aan dat de principes in elke taal hetzelfde zijn.
Antwoord 1, autoriteit 100%
De naamreflectie wordt gebruikt om code te beschrijven die andere code in hetzelfde systeem (of zichzelf) kan inspecteren.
Stel bijvoorbeeld dat je een object van een onbekend type in Java hebt, en dat je er een ‘doSomething’-methode op wilt aanroepen als die bestaat. Het statische typesysteem van Java is niet echt ontworpen om dit te ondersteunen, tenzij het object voldoet aan een bekende interface, maar door reflectie te gebruiken, kan je code naar het object kijken en ontdekken of het een methode heeft met de naam ‘doSomething’ en het dan aanroepen als je wil.
Dus, om je een codevoorbeeld hiervan in Java te geven (stel je voor dat het object in kwestie foo is):
Method method = foo.getClass().getMethod("doSomething", null);
method.invoke(foo, null);
Een veelvoorkomend gebruik in Java is het gebruik met annotaties. JUnit 4, bijvoorbeeld, zal reflectie gebruiken om door je klassen te kijken naar methoden die zijn getagd met de @Test-annotatie, en zal ze dan aanroepen tijdens het uitvoeren van de unit-test.
Er zijn enkele goede reflectievoorbeelden om u op weg te helpen op http://docs .oracle.com/javase/tutorial/reflect/index.html
En tot slot, ja, de concepten lijken veel op elkaar in andere statisch getypeerde talen die reflectie ondersteunen (zoals C#). In dynamisch getypeerde talen is de hierboven beschreven use case minder nodig (aangezien de compiler elke methode toestaat om op elk object te worden aangeroepen, tijdens runtime mislukt als deze niet bestaat), maar het tweede geval van het zoeken naar methoden die zijn gemarkeerd of op een bepaalde manier werken is nog steeds gebruikelijk.
Update vanuit een opmerking:
De mogelijkheid om de code in het systeem te inspecteren en objecttypen te zien is
geen reflectie, maar eerder Type Introspection. Reflectie is dan de
mogelijkheid om tijdens runtime wijzigingen aan te brengen door gebruik te maken van
zelfreflectie. Het onderscheid is hier noodzakelijk omdat sommige talen
ondersteunen introspectie, maar ondersteunen reflectie niet. Een voorbeeld hiervan:
is C++
Antwoord 2, autoriteit 15%
Reflectieis het vermogen van een taal om klassen, methoden, attributen, enz. tijdens runtime te inspecteren en dynamisch aan te roepen.
Alle objecten in Java hebben bijvoorbeeld de methode getClass(), waarmee u de klasse van het object kunt bepalen, zelfs als u deze niet weet tijdens het compileren (bijvoorbeeld als u het hebt gedeclareerd als een Object) – dit lijkt misschien triviaal, maar een dergelijke reflectie is niet mogelijk in minder dynamische talen zoals C++. Bij meer geavanceerd gebruik kunt u methoden, constructors, enz. weergeven en aanroepen.
Reflectie is belangrijk omdat je hiermee programma’s kunt schrijven die niet alles hoeven te “weten” tijdens het compileren, waardoor ze dynamischer worden, omdat ze tijdens runtime aan elkaar kunnen worden gekoppeld. De code kan tegen bekende interfaces worden geschreven, maar de daadwerkelijk te gebruiken klassen kunnen worden geïnstantieerd met behulp van reflectie uit configuratiebestanden.
Veel moderne frameworks maken om deze reden uitgebreid gebruik van reflectie. De meeste andere moderne talen gebruiken ook reflectie, en in scripttalen (zoals Python) zijn ze nog nauwer geïntegreerd, omdat het natuurlijker aanvoelt binnen het algemene programmeermodel van die talen.
Antwoord 3, autoriteit 7%
Een van mijn favoriete toepassingen van reflectie is de onderstaande Java-dumpmethode. Het neemt elk object als parameter en gebruikt de Java Reflection API om elke veldnaam en waarde af te drukken.
import java.lang.reflect.Array;
import java.lang.reflect.Field;
public static String dump(Object o, int callCount) {
callCount++;
StringBuffer tabs = new StringBuffer();
for (int k = 0; k < callCount; k++) {
tabs.append("\t");
}
StringBuffer buffer = new StringBuffer();
Class oClass = o.getClass();
if (oClass.isArray()) {
buffer.append("\n");
buffer.append(tabs.toString());
buffer.append("[");
for (int i = 0; i < Array.getLength(o); i++) {
if (i < 0)
buffer.append(",");
Object value = Array.get(o, i);
if (value.getClass().isPrimitive() ||
value.getClass() == java.lang.Long.class ||
value.getClass() == java.lang.String.class ||
value.getClass() == java.lang.Integer.class ||
value.getClass() == java.lang.Boolean.class
) {
buffer.append(value);
} else {
buffer.append(dump(value, callCount));
}
}
buffer.append(tabs.toString());
buffer.append("]\n");
} else {
buffer.append("\n");
buffer.append(tabs.toString());
buffer.append("{\n");
while (oClass != null) {
Field[] fields = oClass.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
buffer.append(tabs.toString());
fields[i].setAccessible(true);
buffer.append(fields[i].getName());
buffer.append("=");
try {
Object value = fields[i].get(o);
if (value != null) {
if (value.getClass().isPrimitive() ||
value.getClass() == java.lang.Long.class ||
value.getClass() == java.lang.String.class ||
value.getClass() == java.lang.Integer.class ||
value.getClass() == java.lang.Boolean.class
) {
buffer.append(value);
} else {
buffer.append(dump(value, callCount));
}
}
} catch (IllegalAccessException e) {
buffer.append(e.getMessage());
}
buffer.append("\n");
}
oClass = oClass.getSuperclass();
}
buffer.append(tabs.toString());
buffer.append("}\n");
}
return buffer.toString();
}
Antwoord 4, autoriteit 5%
Gebruik van reflectie
Reflection wordt vaak gebruikt door programma’s die de mogelijkheid nodig hebben om het runtime-gedrag van toepassingen die op de virtuele Java-machine worden uitgevoerd, te onderzoeken of te wijzigen. Dit is een relatief geavanceerde functie en mag alleen worden gebruikt door ontwikkelaars die de grondbeginselen van de taal goed beheersen. Met dat voorbehoud in gedachten, is reflectie een krachtige techniek en kan het applicaties in staat stellen bewerkingen uit te voeren die anders onmogelijk zouden zijn.
Uitbreidbaarheidsfuncties
Een toepassing kan gebruikmaken van externe, door de gebruiker gedefinieerde klassen door instanties van uitbreidbaarheidsobjecten te maken met hun volledig gekwalificeerde namen.
Klasbrowsers en visuele ontwikkelomgevingen
Een klassenbrowser moet de leden van klassen kunnen opsommen. Visuele ontwikkelomgevingen kunnen profiteren van het gebruik van type-informatie die beschikbaar is in reflectie om de ontwikkelaar te helpen bij het schrijven van de juiste code.
Debuggers en testtools
Debuggers moeten privéleden in klassen kunnen onderzoeken. Testharnassen kunnen gebruikmaken van reflectie om systematisch een detecteerbare set API’s aan te roepen die voor een klasse zijn gedefinieerd, om een hoog niveau van codedekking in een testsuite te garanderen.
Nadelen van reflectie
Reflectie is krachtig, maar mag niet klakkeloos worden gebruikt. Als het mogelijk is om een bewerking uit te voeren zonder reflectie, dan is het beter om deze niet te gebruiken. Houd rekening met de volgende punten bij het openen van code via reflectie.
- Overheadprestaties
Omdat reflectie typen omvat die dynamisch worden opgelost, kunnen bepaalde optimalisaties van Java-virtuele machines niet worden uitgevoerd. Bijgevolg presteren reflectieve bewerkingen langzamer dan hun niet-reflecterende tegenhangers en moeten ze worden vermeden in codesecties die vaak worden aangeroepen in prestatiegevoelige toepassingen.
- Beveiligingsbeperkingen
Reflection vereist een runtime-machtiging die mogelijk niet aanwezig is wanneer deze wordt uitgevoerd onder een beveiligingsmanager. Dit is een belangrijke overweging voor code die moet worden uitgevoerd in een beperkte beveiligingscontext, zoals in een applet.
- Blootstelling van interne onderdelen
Aangezien reflectie code in staat stelt bewerkingen uit te voeren die illegaal zouden zijn in niet-reflecterende code, zoals toegang tot privévelden en methoden, kan het gebruik van reflectie leiden tot onverwachte neveneffecten, waardoor code disfunctioneel kan worden en de draagbaarheid kan worden vernietigd. Reflecterende code breekt abstracties en kan daarom het gedrag veranderen met upgrades van het platform.
bron: De Reflection API
Antwoord 5, autoriteit 3%
Reflectie is een belangrijk mechanisme om een applicatie of framework te laten werken met code die misschien nog niet eens is geschreven!
Neem bijvoorbeeld uw typische web.xml-bestand. Dit zal een lijst met servlet-elementen bevatten, die geneste servlet-klasse-elementen bevatten. De servletcontainer verwerkt het web.xml-bestand en maakt door middel van reflectie een nieuwe instantie van elke servletklasse.
Nog een voorbeeld zou de Java API zijn voor XML-parsing (jaxp) . Wanneer een XML PARSER-provider is ‘aangesloten’ via bekende systeemeigenschappen, die worden gebruikt om nieuwe instanties te construeren via reflectie.
En tot slot, het meest uitgebreide voorbeeld is lente die reflectie gebruikt om zijn bonen te creëren, en voor zijn zware Gebruik van proxies
6, Autoriteit 2%
Niet elke taal ondersteunt reflectie, maar de principes zijn meestal hetzelfde in talen die het ondersteunen.
Reflectie is de mogelijkheid om “reflecteren” op de structuur van uw programma. Of meer beton. Om te kijken naar de objecten en klassen die u hebt en programmatisch terugkrijgt informatie over de methoden, velden en interfaces die ze implementeren. Je kunt ook kijken naar dingen zoals annotaties.
Het is in veel situaties nuttig. Overal waar u in staat wilt zijn om klassen in uw code in te stemmen. Veel objectrelationele mappers gebruiken reflectie om objecten uit databases te kunnen instantiëren zonder van tevoren te weten welke objecten ze gaan gebruiken. Plug-in architecturen is een andere plaats waar reflectie nuttig is. Kunnen in staat zijn om code te laden en te bepalen of er typen daar zijn die de juiste interface implementeren om te gebruiken als een plug-in is belangrijk in die situaties.
7, Autoriteit 2%
Reflectie maakt instantiatie mogelijk van nieuwe objecten, aanroeping van methoden en krijgt / ingestelde operaties op klassenvariabelen dynamisch op looptijd zonder voorafgaande kennis van de implementatie ervan te hebben.
Class myObjectClass = MyObject.class;
Method[] method = myObjectClass.getMethods();
//Here the method takes a string parameter if there is no param, put null.
Method method = aClass.getMethod("method_name", String.class);
Object returnValue = method.invoke(null, "parameter-value1");
In bovenstaande voorbeeld is de NULL-parameter het object dat u de methode wilt oproepen. Als de methode statisch is, levert u null toe. Als de methode niet statisch is, moet u tijdens het aanroepen van u een geldige myObject-instantie in plaats van null.
Reflectie biedt ook toegang tot privé-lid / methoden van een klasse:
public class A{
private String str= null;
public A(String str) {
this.str= str;
}
}
.
A obj= new A("Some value");
Field privateStringField = A.class.getDeclaredField("privateString");
//Turn off access check for this field
privateStringField.setAccessible(true);
String fieldValue = (String) privateStringField.get(obj);
System.out.println("fieldValue = " + fieldValue);
- Voor inspectie van klassen (ook bekend als introspectie) hoeft u het reflectiepakket (
java.lang.reflect) niet te importeren. Klasse metadata is toegankelijk viajava.lang.Class.
Reflectie is een zeer krachtige API, maar het kan de aanvraag vertragen als het in eigen risico wordt gebruikt, omdat het alle typen op runtime oplost.
8
Java-reflectie is vrij krachtig en kan erg handig zijn.
Java-reflectie maakt het mogelijk om klassen, interfaces, velden en methoden bij runtime, te inspecteren zonder de namen van de klassen, methoden etc. te kennen op compileertijd.
Het is ook mogelijk om Instantiate nieuwe objecten te instantiëren, methoden te roepen en veldwaarden te krijgen / instellen / instellen met behulp van reflectie.
Een snel voorbeeld van Java Reflection om u te laten zien hoe het gebruik van reflectie eruit ziet:
Method[] methods = MyObject.class.getMethods();
for(Method method : methods){
System.out.println("method = " + method.getName());
}
In dit voorbeeld wordt het object Class opgehaald uit de klasse met de naam MyObject. Met behulp van het klasseobject krijgt het voorbeeld een lijst van de methoden in die klasse, herhaalt de methoden en drukt hun namen af.
Hoe dit allemaal werkt, wordt hier uitgelegd
Bewerken: na bijna 1 jaar ben ik dit antwoord aan het bewerken, omdat ik tijdens het lezen over reflectie weinig meer gebruik van reflectie heb gekregen.
- Spring gebruikt bonenconfiguratie zoals:
<bean id="someID" class="com.example.Foo">
<property name="someField" value="someValue" />
</bean>
Als de Spring-context dit verwerkt < boon > element, zal het Class.forName(String) gebruiken met het argument “com.example.Foo” om die klasse te instantiëren.
Het zal dan opnieuw reflectie gebruiken om de juiste setter voor de < eigendom > element en stel de waarde in op de opgegeven waarde.
- Junit gebruikt Reflection speciaal voor het testen van privé/beschermde methoden.
Voor privémethoden,
Method method = targetClass.getDeclaredMethod(methodName, argClasses);
method.setAccessible(true);
return method.invoke(targetObject, argObjects);
Voor privévelden,
Field field = targetClass.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);
Antwoord 9
Voorbeeld:
Neem bijvoorbeeld een externe toepassing die uw toepassing een object geeft dat u verkrijgt met behulp van hun API-methoden . Nu, op basis van het object, moet u misschien een soort berekening uitvoeren.
De provider garandeert dat het object van 3 typen kan zijn en dat we berekeningen moeten uitvoeren op basis van welk type object.
We kunnen dus implementeren in 3 klassen die elk een andere logica bevatten. Het is duidelijk dat de objectinformatie beschikbaar is tijdens runtime, dus u kunt niet statisch coderen om berekeningen uit te voeren, daarom wordt reflectie gebruikt om het object van de klasse te instantiëren die u nodig hebt om de berekening uit te voeren op basis van het object ontvangen van de provider .
Antwoord 10
Eenvoudig voorbeeld voor reflectie.
In een schaakspel weet je niet wat er tijdens runtime door de gebruiker wordt verplaatst. reflectie kan worden gebruikt om methoden aan te roepen die al tijdens runtime zijn geïmplementeerd:
public class Test {
public void firstMoveChoice(){
System.out.println("First Move");
}
public void secondMOveChoice(){
System.out.println("Second Move");
}
public void thirdMoveChoice(){
System.out.println("Third Move");
}
public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Test test = new Test();
Method[] method = test.getClass().getMethods();
//firstMoveChoice
method[0].invoke(test, null);
//secondMoveChoice
method[1].invoke(test, null);
//thirdMoveChoice
method[2].invoke(test, null);
}
}
Antwoord 11
Reflectionis een API die wordt gebruikt om het gedrag van methoden, klassen, interfacestijdens runtime te onderzoeken of te wijzigen.
- De vereiste klassen voor reflectie worden geleverd onder
java.lang.reflect package. - Reflectie geeft ons informatie over de klasse waartoe een object behoort en ook de methoden van die klasse die kunnen worden uitgevoerd door het object te gebruiken.
- Door reflectie kunnen we methoden aanroepen tijdens runtime, ongeacht de toegangsspecificatie die ermee wordt gebruikt.
De pakketten java.langen java.lang.reflectbieden lessen voor Java-reflectie.
Reflectiekan worden gebruikt om informatie te krijgen over –
-
KlasseDe methode
getClass()wordt gebruikt om de naam te krijgen van de klasse waartoe een object behoort. -
ConstructorsDe methode
getConstructors()wordt gebruikt om de openbare constructors op te halen van de klasse waartoe een object behoort. -
MethodenDe methode
getMethods()wordt gebruikt om de openbare methoden op te halen van de klasse waartoe een object behoort.
De Reflection APIwordt voornamelijk gebruikt in:
IDE (Integrated Development Environment) b.v. Eclipse, MyEclipse, NetBeans enz.
Debugger en testtools enz.
Voordelen van het gebruik van reflectie:
Uitbreidbaarheidsfuncties:een toepassing kan gebruikmaken van externe, door de gebruiker gedefinieerde klassen door instanties van uitbreidbaarheidsobjecten te maken met hun volledig gekwalificeerde namen.
Tools voor foutopsporing en testen:debuggers gebruiken de eigenschap van reflectie om privéleden in klassen te onderzoeken.
Nadelen:
Overhead prestaties:reflecterende bewerkingen presteren langzamer dan hun niet-reflecterende tegenhangers en moeten worden vermeden in codegedeelten die vaak worden aangeroepen in prestatiegevoelige toepassingen.
Blootstelling van internals:reflecterende code breekt abstracties en kan daarom het gedrag veranderen met upgrades van het platform.
Ref: Java-reflectiejavarevisited.blogspot.in
Antwoord 12
Voor zover ik weet:
Reflectie stelt de programmeur in staat om dynamisch toegang te krijgen tot entiteiten in het programma. d.w.z. tijdens het coderen van een toepassing als de programmeur niet op de hoogte is van een klasse of zijn methoden, kan hij deze klasse dynamisch (tijdens runtime) gebruiken door reflectie te gebruiken.
Het wordt vaak gebruikt in scenario’s waarin een klassenaam vaak verandert. Als een dergelijke situatie zich voordoet, is het voor de programmeur ingewikkeld om de toepassing te herschrijven en de naam van de klasse steeds weer te veranderen.
In plaats daarvan, door reflectie te gebruiken, moet je je zorgen maken over een mogelijk veranderende klasnaam.
Antwoord 13
Reflectie is een reeks functies waarmee u toegang krijgt tot de runtime-informatie van uw programma en het gedrag ervan kunt wijzigen (met enkele beperkingen).
Het is handig omdat je het runtime-gedrag kunt veranderen afhankelijk van de meta-informatie van je programma, dat wil zeggen, je kunt het retourtype van een functie controleren en de manier veranderen waarop je met de situatie omgaat.
In C# kun je bijvoorbeeld een assembly (een .dll) in runtime laden en deze onderzoeken, door de klassen navigeren en acties ondernemen op basis van wat je hebt gevonden. Het laat je ook een instantie van een klasse maken tijdens runtime, zijn methode aanroepen, enz.
Waar kan het nuttig zijn? Is niet elke keer handig maar voor concrete situaties. U kunt het bijvoorbeeld gebruiken om de naam van de klasse te krijgen voor logboekdoeleinden, om dynamisch handlers voor gebeurtenissen te maken volgens wat is gespecificeerd in een configuratiebestand enzovoort…
Antwoord 14
Ik wil gewoon een punt toevoegen aan alles wat op de lijst stond.
Met Reflection APIkun je de universele toString()methode voor elk object schrijven.
Het is handig bij het debuggen.
Hier is een voorbeeld:
class ObjectAnalyzer {
private ArrayList<Object> visited = new ArrayList<Object>();
/**
* Converts an object to a string representation that lists all fields.
* @param obj an object
* @return a string with the object's class name and all field names and
* values
*/
public String toString(Object obj) {
if (obj == null) return "null";
if (visited.contains(obj)) return "...";
visited.add(obj);
Class cl = obj.getClass();
if (cl == String.class) return (String) obj;
if (cl.isArray()) {
String r = cl.getComponentType() + "[]{";
for (int i = 0; i < Array.getLength(obj); i++) {
if (i > 0) r += ",";
Object val = Array.get(obj, i);
if (cl.getComponentType().isPrimitive()) r += val;
else r += toString(val);
}
return r + "}";
}
String r = cl.getName();
// inspect the fields of this class and all superclasses
do {
r += "[";
Field[] fields = cl.getDeclaredFields();
AccessibleObject.setAccessible(fields, true);
// get the names and values of all fields
for (Field f : fields) {
if (!Modifier.isStatic(f.getModifiers())) {
if (!r.endsWith("[")) r += ",";
r += f.getName() + "=";
try {
Class t = f.getType();
Object val = f.get(obj);
if (t.isPrimitive()) r += val;
else r += toString(val);
} catch (Exception e) {
e.printStackTrace();
}
}
}
r += "]";
cl = cl.getSuperclass();
} while (cl != null);
return r;
}
}
Antwoord 15
Reflectie is om objecten hun uiterlijk te laten zien. Dit argument lijkt niets met reflectie te maken te hebben. In feite is dit het vermogen om zichzelf te identificeren.
Reflectie zelf is een woord voor talen die het vermogen tot zelfkennis en zelfwaarneming missen, zoals Java en C#. Omdat ze niet het vermogen tot zelfkennis hebben, moeten we, als we willen observeren hoe het eruit ziet, iets anders hebben om na te denken over hoe het eruit ziet. Uitstekende dynamische talen zoals Ruby en Python kunnen hun eigen reflectie waarnemen zonder de hulp van andere individuen. We kunnen zeggen dat het object van Java niet kan waarnemen hoe het eruit ziet zonder een spiegel, wat een object van de reflectieklasse is, maar een object in Python kan het zonder spiegel waarnemen. Daarom hebben we reflectie in Java nodig.
16
Zoals de naam zelf suggereert dat het weerspiegelt wat het bevat voor bijvoorbeeld klassenmethode, enz. Afgezien van het aanbieden van functie om methode die instantie dynamisch op runtime maakt.
Het wordt gebruikt door vele kaders en toepassing onder het hout om diensten aan te roepen zonder de code te kennen.
17
Reflection geeft je de mogelijkheid om meer algemene code te schrijven. Hiermee kunt u tijdens runtime een object maken en de methode ervan tijdens runtime aanroepen. Daarom kan het programma sterk geparametriseerd worden gemaakt. Het maakt ook introspectie van het object en de klasse mogelijk om zijn variabelen en methode te detecteren die aan de buitenwereld worden blootgesteld.
Antwoord 18
reflectionheeft veel toepassingen. Degene waar ik meer bekend mee ben, is om code on-the-fly te kunnen maken.
IE: dynamische klassen, functies, constructors – gebaseerd op alle gegevens
(xml/array/sql resultaten/hardcoded/etc..)
Antwoord 19
Ik wil deze vraag als voorbeeld beantwoorden. Allereerst gebruikt het Hibernate-project Reflection APIom CRUD-statements te genereren om de kloof tussen de actieve toepassing en de persistentieopslag te overbruggen. Als er dingen veranderen in het domein, moet de Hibernatehiervan op de hoogte zijn om ze in de gegevensopslag te bewaren en vice versa.
Als alternatief werkt Lombok Project. Het injecteert gewoon code tijdens het compileren, waardoor code wordt ingevoegd in uw domeinklassen. (Ik denk dat het goed is voor getters en setters)
Hibernatekoos voor reflectionomdat dit minimale impact heeft op het bouwproces van een applicatie.
En vanaf Java 7 hebben we MethodHandles, die werkt als Reflection API. In projecten, om met loggers te werken, kopiëren en plakken we gewoon de volgende code:
Logger LOGGER = Logger.getLogger(MethodHandles.lookup().lookupClass().getName());
Omdat het in dit geval moeilijk is om een typefout te maken.
Antwoord 20
Zoals ik het het beste vind om met een voorbeeld uit te leggen en geen van de antwoorden lijkt dat te doen…
Een praktisch voorbeeld van het gebruik van reflecties zou een Java-taalserver zijn die is geschreven in Java of een PHP-taalserver die in PHP is geschreven, enz. Taalserver geeft uw IDE-vaardigheden zoals autocomplete, spring naar definitie, contexthulp, tintypen en meer. Om alle tagnamen te hebben (woorden die kunnen worden geautocometeerd) om alle mogelijke overeenkomsten te tonen als u typt, moet de taalserver alles inspecteren over de klasse inclusief DOC-blokken en particuliere leden. Daarvoor heeft het een weerspiegeling van de klasse nodig.
Een ander voorbeeld zou een eenheidstest van een particuliere methode zijn. Een manier om dit te doen is om een reflectie te creëren en de reikwijdte van de methode naar het openbaar in de set-upfase van de test te wijzigen. Natuurlijk kan men argumenteren dat privémethoden niet rechtstreeks moeten worden getest, maar dat is niet het punt.
21
belangrijk
Uitgaande van Java 9 U kunt geen reflectie gebruiken, tenzij de Pakket-info.java de module op de reflectie-toegang opent.
Door de toegang tot alle pakketten in de module kan worden geweigerd.