web-dev-qa-db-fra.com

Comment passer enum en tant qu'argument dans une méthode en Java?

public class Enumvalues{

    enum courseList {
        Java,
        C,
        PYTHON,
        Perl
    }

    enum generalInformation {
        NAME,
        AGE,
        PHONE
    }  

    enum sex {
        MALE,
        FEMALE
    }
}

public static void main(String args[]) {
     printEnumValue(generalInformation); // how to pass enum in this block
}


static void printEnumValue(enum generalInformation) { // how to receive enum  in this block    
    System.out.println(Java.util.Arrays.asList(generalInformation.values()));
}
javaenums
22
Reegan Miranda

Une enum est une classe. Ainsi, vous pouvez passer une instance de la classe (EnumValues.generalInformation.PHONE par exemple) ou vous pouvez transmettre la classe elle-même (EnumValues.generalInformation.class par exemple).

Si vous souhaitez répertorier toutes les instances d'une classe enum, vous devez transmettre la classe enum et utiliser EnumSet.allOf(EnumValues.generalInformation.class) par exemple.

Votre confusion provient principalement du fait que vous ne respectez pas les conventions de dénomination Java. Les ENums sont des classes et doivent commencer par une lettre majuscule (GeneralInformation par exemple). Le mauvais choix de noms est une autre source de confusion. Java n'est pas une liste de cours. C'est un cours. Donc, l'énumération devrait être nommée Course.

11
JB Nizet

Si vous voulez passer une seule valeur de l'énumération

    public class Test {

    enum GeneralInformation{
        NAME;
    }

    private static void print(GeneralInformation val){
        System.out.println(val);
    }

    public static void main(String[] args) {
        print(GeneralInformation.NAME);
    }
}

sinon, si vous voulez que toute la classe soit adoptée, alors que la question ne le dit pas clairement

private static void print(Class<?> generalInfo){

    }

    public static void main(String[] args) {
        print(GeneralInformation.class);
    }
9
Narendra Pathai

Notez que votre question a mélangé deux problèmes différents: Transmettre une énumération à une fonction OR Transmettre une constante Enum à une fonction. Je croyais comprendre que vous souhaitiez transmettre l'énumération elle-même, et non l'une de ses constantes à la fonction. Si ce n'est pas le cas: reportez-vous à la réponse de Narendra Pathai sur la manière de passer une constante d'enum à une fonction. Si vous ne savez pas quelle est la différence entre une constante enum et une constante enum, consultez la docs à propos des enums ...

Je comprends que ce que vous voulez, c'est avoir une fonction print (ou toute autre) où vous pouvez passer n'importe quel enum possible, pour imprimer chacune des valeurs possibles de l'énum (c'est-à-dire des constantes). J'ai trouvé les deux approches suivantes pour ce faire:

Disons que nous avons l'énumération suivante:

// The test enum, any other will work too
public static enum ETest
{
    PRINT,MY,VALUES
}

Variante 1: Passez le tableau de constantes de votre enum à votre fonction; Comme les constantes de l'énumération sont des valeurs statiques, vous pouvez facilement y accéder et les transmettre à votre fonction 'print' comme suit:

public static void main(String[] args)
{
    // retreive all constants of your enum by YourEnum.values()
    // then pass them to your function
    printEnum(ETest.values());
}

// print function: type safe for Enum values
public static <T extends Enum<T>> void printEnum(T[] aValues)
{
    System.out.println(Java.util.Arrays.asList(aValues));
}

Variante 2: Passer la classe de l'énum en tant que paramètre de fonction. Cela peut paraître plus beau, mais sachez que la réflexion est en jeu (performance):

public static void main(String[] args)
{
    printEnum2(ETest.class);
}

// print function: accepts enum class and prints all constants
public static <T extends Enum<T>> void printEnum2(Class<T> aEnum)
{
    // retreive all constants of your enum (reflection!!)
    System.out.println(Java.util.Arrays.asList(aEnum.getEnumConstants()));
}

À mon avis, il est préférable d’utiliser la variante 1 en raison de la surutilisation de la réflexion dans la variante 2. Le seul avantage de la variante 2 est que vous avez l’objet Class de Enum lui-même (l’énumération statique, pas seulement ses constantes). à l'intérieur de votre fonction, donc je l'ai mentionné pour être complet.

7
A. Markóczy

TestEnumMain.Java: 

package enumSample;

import org.Apache.commons.lang3.EnumUtils; 

    public static void main(String[] args) {
        boolean result= isValidEnum(DummyEnum.class, "Apple"); 
        System.out.println("result= " + result); 
        boolean result2= isValidEnum2(DummyEnum.class, "COF"); 
        System.out.println("result2= " + result2); 
        //boolean result3= isValidEnum2(A_Different_Enum.class, "COF");  //works
        //System.out.println("result3= " + result3); 

    }

    public static<E extends Enum<E>> boolean isValidEnum2(Class<E> enumClass, String enumName) {

        System.out.println("enumClass.getEnumConstants().length= " + enumClass.getEnumConstants().length); 
        System.out.println("enumClass.getEnumConstants()[0]= " + enumClass.getEnumConstants()[0]); 
        System.out.println("enumClass.getEnumConstants()[1]= " + enumClass.getEnumConstants()[1].name()); 
        System.out.println("enumName.valueOf(enumClass)= "+ enumName.valueOf(enumClass));

        if(enumName== null) {
            return false; 
        } else {
            try {
                if(enumClass.isAssignableFrom(DummyEnum.class)) { /*Checks if enumClass is an instance of DummyEnum.class*/
                    for (int i=0; i!= enumClass.getEnumConstants().length; i++) {
                        System.out.println("(DummyEnum) enumClass.getEnumConstants()["+i+"]).code()= "+ ((DummyEnum) enumClass.getEnumConstants()[i]).code());          
                        if(enumName.equals(((DummyEnum) enumClass.getEnumConstants()[i]).code())) {
                            return true; 
                        }
                    }                   
                    return false; 
                } else {
                    Enum.valueOf(enumClass, enumName); 
                    return true; 
                }
            } catch (IllegalArgumentException var3){
                return false; 
            }
        }

    }

    //Original Method from Apache.commons.long3.EnumUtils: 
    public static<E extends Enum<E>> boolean isValidEnum(Class<E> enumClass, String enumName) {
        if(enumName== null) {
            return false; 
        } else {
            try {
                Enum.valueOf(enumClass, enumName); 
                return true; 
            } catch (IllegalArgumentException var3){
                return false; 
            }
        }
    }
}

DummyEnum.Java:

package enumSample;

public enum DummyEnum {
    Apple("APP"), 
    GOOGLE("GOOG"), 
    CAPITAL_ONE("COF");

    private String code; 
    DummyEnum(String code) {this.code= code;}
    public String code() {return code;}
}
2
Gene

printEnumValue(EnumValues.generalInformation.NAME,EnumValues.generalInformation.AGE,EnumValues.generalInformation.PHONE);
Réception:

public static void printEnumValue(EnumValues.generalInformation en){
System.out.println(en.toString());
}
1
Govind Balaji

La clase enum sería

public enum LdapExceptionEnumeration {

    LDAP_ATTR_NAME_CREATE_INVALIDO("3018","El nombre del atributo enviado es inválido")
String codigo;
    String error;

    private LdapExceptionEnumeration(String codigo, String error) {
        this.codigo = codigo;
        this.error = error;
    }

    public String getCodigo() {
        return codigo;
    }

    public String getError() {
        return error;
    }

}

Este seria el junitest para la prueba

public class EnumTest {
 @Test
 public void consultaenum(){

     imprimeEnum(LdapExceptionEnumeration.LDAP_ATTR_NAME_CREATE_INVALIDO);

 }
public void imprimeEnum(LdapExceptionEnumeration enumClass){
     System.out.println("codigo: "+ enumClass.getCodigo());
     System.out.println("mensaje: "+ enumClass.getError());
 }
}
0
Giovanni Perea