Come verificare se il nome della classe è valido?

Question

Esiste un metodo in Java per verificare se una stringa può essere utilizzata come nome di classe?

Answer 1

Yap -

Class.forName(String className); 

Esso restituisce l'oggetto classe associato alla classe o interfaccia con il dato nome della stringa. e getta Exceptions

LinkageError - if the linkage fails 
ExceptionInInitializerError - if the initialization provoked by this method fails 
ClassNotFoundException - if the class cannot be located 

Answer 2

Molto semplicemente, con il metodo Class.forName(String name), che può essere utilizzato per testare in questo modo:

public static boolean classExists(String className) 
{ 
    try 
    { 
     Class.forName(className); 
     return true; 
    } 
    catch(ClassNotFoundException ex) 
    { 
     return false; 
    } 
} 

Edit: Se, come ha detto dashrb, si sta chiedendo per un modo per determinare se una stringa può essere usata come un nome di classe (piuttosto che se c'è già una classe con quel nome), allora ciò che ti serve è una combinazione del metodo che ho postato sopra (con i booleani capovolti, come puoi t riutilizzare i nomi delle classi) e in combinazione con un controllo per verificare se String è una parola chiave riservata a Java. Ho avuto un problema simile di recente e ho creato una classe di utilità per questo che puoi trovare here. Non lo scriverò per te, ma in pratica devi solo aggiungere un assegno per !JavaKeywords.isKeyword(className).

Edit 2: E, naturalmente, se si vuole rispettare anche standard di codifica generalmente accettati, si può solo fare in modo che il nome della classe inizia con una lettera maiuscola con:

return Character.isUpperCase(className.charAt(0)); 

Edit 3: Come sottolinea Ted Hopp, anche il contenere una parola chiave java invalida il nome di una classe e poiché JavaKeywords viene utilizzato in una delle mie applicazioni di produzione, ho creato uno updated version che include il metodo containsKeyword(String toCheck) che verificherà anche questa eventualità. Il metodo è il seguente (si prega di notare è necessario l'elenco delle parole chiave nella classe troppo):

public static boolean containsKeyword(String toCheck) 
{ 
    toCheck = toCheck.toLowerCase(); 
    for(String keyword : keywords) 
    { 
     if(toCheck.equals(keyword) || toCheck.endsWith("." + keyword) || 
      toCheck.startsWith(keyword + ".") || toCheck.contains("." + keyword + ".")) 
     { 
      return true; 
     }//End if 
    }//End for 
    return false; 
}//End containsKeyword() 

Answer 3

ho usato la lista di parole chiave java gentilmente offerto da MrLore.

private static final Set<String> javaKeywords = new HashSet<String>(Arrays.asList(
    "abstract",  "assert",  "boolean",  "break",   "byte", 
    "case",   "catch",   "char",   "class",   "const", 
    "continue",  "default",  "do",   "double",   "else", 
    "enum",   "extends",  "false",  "final",   "finally", 
    "float",  "for",   "goto",   "if",    "implements", 
    "import",  "instanceof", "int",   "interface",  "long", 
    "native",  "new",   "null",   "package",   "private", 
    "protected", "public",  "return",  "short",   "static", 
    "strictfp",  "super",   "switch",  "synchronized", "this", 
    "throw",  "throws",  "transient", "true",   "try", 
    "void",   "volatile",  "while" 
)); 

private static final Pattern JAVA_CLASS_NAME_PART_PATTERN = 
    Pattern.compile("[A-Za-z_$]+[a-zA-Z0-9_$]*"); 

public static boolean isJavaClassName(String text) { 
    for (String part : text.split("\\.")) { 
     if (javaKeywords.contains(part) || 
       !JAVA_CLASS_NAME_PART_PATTERN.matcher(part).matches()) { 
      return false; 
     }   
    } 
    return text.length() > 0; 
} 

Answer 4

SourceVersion.isName può essere utilizzato per controllare i nomi completi.

Se non . s dovrebbe essere consentito, il controllo può essere fatto in questo modo:

boolean isValidName (String className) { 
    return SourceVersion.isIdentifier(className) && !SourceVersion.isKeyword(className); 
}