Java >> Java tutorial >  >> Java

Java Enum valueOf() metode (med eksempler)

Enum-klassen er inkluderet i java.lang-pakken. Det er den universelle grundklasse for alle opregningstyper i Java-sproget. valueOf-metoden for Java Enum-klassen bruges til at hente. Enum-konstanter deklareres i Enum-typer ved at give en streng eller konvertere streng til Enum-konstanter.

Enum-klassens valueOf()-funktion returnerer enum-konstanten for den angivne enum-type sammen med det angivne navn.

Java Enum valueOf()-syntaks

public static > T valueOf(Class enumType,String name)

Parametre

T: Udbyttekonstanten er af enum-typen.

enumType – Enum-typens Class-objekt returnerer en konstant.

navn – Det vil returnere navnet på konstanten.

Værdien af ​​returneringen

Enum-konstanten returneres sammen med det definerede navn ved hjælp af valueOf()-metoden.

Skast

Funktionen valueOf() kaster følgende undtagelse:

Hvis den definerede enum-type er inkonsistent med det angivne navn, eller hvis det definerede klasseobjekt ikke illustrerer en enum-type, kastes en IllegalArgumentException. Hvis værdien af ​​enumType eller navn er null, vises en NullPointerException.

enum Companies{  
  
IBM, Amazon, Google, Facebook, Twitter;  
  
}  
  
public class Enum_valueOfTechCompanies {  
  
public static void main(String[] args) {  
  
System.out.println("What is the name of the company:");  
  
for( Companies comp : Companies.values()){  
  
int i = part.ordinal()+1;  
  
System.out.println(i+" "+comp);  
  
        }  
  
      Companies comp = Companies.valueOf("IBM");  
  
System.out.println("\nAns: "+comp);  
  
       }  
}

Eksempel:enum på programmeringssprog

enum Languages{  
  
Python, Java, JavaScript, C, Kotlin;  
  
}  
  
public class Enum_valueOfProgrammingLanguage {  
  
public static void main(String[] args) {  
  
System.out.println("Choose your programming languages:");  
  
for( Languages planguage : Languages.values()) {  
  
System.out.println(Languages.valueOf(" "));  
  
        }  
  
    }  
  
}

}

Som det kan ses, er Enum en abstrakt klasse. Derfor kan vi ikke generere Enum-objekter.

Enum-klassemetoder

Enum-klassen har ti væsentlige metoder. Object-klassen tilsidesætter de fleste af dem. Enum-klassen erklærer disse metoder som endelige, hvilket forhindrer programmøren i at ændre nogen enum-konstanter.

final String name()

Denne funktion returnerer navnet på denne enum-konstant, som er det samme som enum-deklarationen.

Syntaksen er som følger:

public final String name()
public final String name()

// program  demonstrating the name() method
enum Cities
{
	London, New York, Manchester;
}

public class nameTest
{

	public static void main(String[] args)
	{
		Cities cityName = Cities.Manchester;
		System.out.print("enum's constant is: ");

		// method's name
		System.out.println(cityName .name());
	}
}

final int ordinal()

Denne metode returnerer indekset for denne opregningskonstant. final int ordinal():

Syntaksen er som følger:

public final int ordinal()
// program  demonstrating the ordinal() method
enum Cities
{
	London, New York, Manchester;
}

public class ordinalTest
{
	// Driver method
	public static void main(String[] args)
	{
		Cities cOrdinal = Cities.London;
		System.out.print("ordinal of enum constant "+cOrdinal .name()+" : ");

		// ordinal method
		System.out.println(cOrdinal .ordinal());
	}
}

String toString()

String toString() returnerer et String-objekt, der repræsenterer denne opregningskonstant. Denne metode er identisk med metoden name().

Syntaksen er som følger:

// program  demonstrating the toString() method
enum Cities
{
	London, New York, Manchester;
}

public class toStringTest
{
	// Driver method
	public static void main(String[] args)
	{
		Cities cString = Cities.GREEN;
		
		// fetch string representation of enum
		// using toString() method
		String strCities = Cities.toString();
		
		System.out.println(strCities);
	}
}

final boolean lig med(Object obj)

final boolean equals(Object obj):Hvis det leverede objekt er lig med denne enum-konstant, returnerer denne funktion sand; ellers returnerer den falsk.

Syntaksen er som følger:

public final boolean equals(Object obj)
// program  demonstrating the equals() method
enum Cities
{
	London, Austin, Manchester;
}

public class equalsTest
{

	public static void main(String[] args)
	{
		Cities cOne = Cities.London ;
		Cities cTwo = Cities.Austin ;
		Cities cThree = Cities.Manchester ;
		
		// equality checking between enums
		// using equals() method
		
		boolean bOne = cOne.equals(cTwo);
		boolean bTwo = cOne.equals(cThree);
		boolean bThree = cTwo.equals(null);
		
		System.out.println("is cOne equal to cTwo : " + bOne);
		System.out.println("is cOne equal to cThree : " + bTwo);
		System.out.println("is cTwo equal to null : " + bThree);
	}
}

final int hashCode()

Denne metode returnerer en hash-kode for denne enum-konstant. Denne metode returnerer en hash-kode for denne enum-konstant. Faktisk omfatter denne funktion kun én sætning:"return super.hashCode()", som kalder hashCode()-metoden for Object-klassen.

Syntaksen er som følger:

public final int hashCode()
public final int hashCode()

// program  demonstrating the hashCode() method
enum Cities
{
	London, Austin, Manchester;
}

public class hashCodeTest
{

	public static void main(String[] args)
	{
		Cities cOne = Cities.RED;
		System.out.print("hashcode of enum constant "+ cOne.name() +" : ");

		// hashcode method
		System.out.println(cOne.hashCode());
		
		Cities cTwo = Cities.GREEN;
		System.out.print("hashcode of enum constant "+ cTwo.name() +" : ");

		// hashcode method
		System.out.println(cTwo.hashCode());
	}
}

final int compareTo(E obj)

Denne metode "sammenligner" rækkefølgen af ​​denne enum med det angivne objekt. Kun andre enum-konstanter af samme enum-type kan sammenlignes med enum-konstanter.

Syntaksen for compareTo er som følger:

public int compareTo(E obj)
// program  demonstrating the compareTo() method
enum Cities
{
	London, Austin, Manchester;
}

public class Test
{
	// Driver method
	public static void main(String[] args)
	{
		Cities cOne = Cities.RED;
		Cities cTwo = Cities.GREEN;
		Cities cThree = Cities.RED;
		Cities cFour = Cities.BLUE;
		
		System.out.print("Comparing "+cOne.name()+" with "+ cTwo.name() +" : ");
		
		// compareTo method
		System.out.println(cOne.compareTo(cTwo));
		
		System.out.print("Comparing "+cOne.name()+" with "+ cThree.name() +" : ");
		
		// compareTo method
		System.out.println(cOne.compareTo(cThree));
		
		System.out.print("Comparing "+cFour.name()+" with "+ cTwo.name() +" : ");
		
		// compareTo method
		System.out.println(cFour.compareTo(cTwo));
		
		// The following statement throw NullPointerException
		// as argument of compareTo method is null
		// System.out.println(cFour.compareTo(null));
		
	}
}

statisk T valueOf(Class enumType,String name)

Denne funktion returnerer navnet på enum-konstanten for den leverede enum-type. En identifikator, der bruges til at erklære en enum-konstant i denne type, skal svare nøjagtigt til navnet.

Syntaksen er som følger:

public static T valueOf(Class enumType,String name)
// program  demonstrating the valueOf() method
enum Cities
{
	London, Austin, Manchester;
}
public class valueOfTest
{

	public static void main(String[] args)
	{
		// getting value of enum with specified String
		// using valueOf method
		Cities cOne = Cities.valueOf("London");
		Cities cTwo = Cities.valueOf("Austin");
		
		// name method
		System.out.println(cOne.name());
		System.out.println(cTwo.name());
		
		// The following statement throw IllegalArgumentException
		// as LoNDON is not an enum constant
		// Cities cThree = Cities.valueOf("LoNDON");
		
		// The following statement throw NullPointerException
		// as argument of valueOf method is null
	// Cities cFour = Cities.valueOf(null);
	}
}

final Class getDeclaringClass()

Denne funktion returnerer klasseobjektet for enum-typen for denne enum-konstant. Hvis denne funktion returnerer det samme klasseobjekt for begge enum-konstanter e1 og e2, er de af samme enum-type.

Syntaksen er som følger:

public final Class getDeclaringClass()
// program  demonstrating the getDeclaringClass() method
enum Cities
{
	London, Austin, Manchester;
}

enum Month
{
	JANUARY, FEBRUARY ;
}

public class getDeclaringClassTest
{
	// Driver method
	public static void main(String[] args)
	{
		// getting value of enum with specified String
		// using valueOf method
		Cities c1 = Cities.valueOf("London");
		Cities c2 = Cities.valueOf("Austin");
		Month mOne = Month.valueOf("JANUARY");
		Month mTwo = Month.valueOf("FEBRUARY");
		
		System.out.print("Class corresponding to "+ c1.name() +" : ");
	
		// getDeclaringClass method
		System.out.println(cOne.getDeclaringClass());
		
		System.out.print("Class corresponding to "+ cTwo.name() +" : ");
		
		// getDeclaringClass method
		System.out.println(cTwo.getDeclaringClass());
		
		System.out.print("Class corresponding to "+ mOne.name() +" : ");
		
		// getDeclaringClass method
		System.out.println(mOne.getDeclaringClass());
		
		System.out.print("Class corresponding to "+ mTwo.name() +" : ");
		
		// getDeclaringClass method
		System.out.println(mTwo.getDeclaringClass());
	}
}

final Object clone()

Denne funktion sikrer, at enums aldrig klones, hvilket er nødvendigt for at holde dem "singleton". Det bruges af compileren til at generere Enum-konstanter.

Syntaksen er som følger:

public final Object clone() throws CloneNotSupportedException
// program  demonstrating the clone() method
enum Cities
{
	London, Austin, Manchester;
}

public class cloneTest
{
	// Driver method
	public static void main(String[] args)
			throws CloneNotSupportedException
	{
		System.out.println("Enums are never cloned");
		cloneTest tClone = new cloneTest()
		{
			// final clone method
			protected final Object clone()
					throws CloneNotSupportedException
			{
				return new CloneNotSupportedException();
			}
		};
		
		System.out.println(tClone.clone());
	}
}

final void finalize()

Enum-klasser kan ikke have afsluttende metode ifølge denne metode.

Syntaksen er som følger:

protected final void finalize()
// program  demonstrating the finalize() method
enum Cities
{
	London, Austin, Manchester;
}

public class finalizeTest
{

	public static void main(String[] args) throws Throwable
	{
		System.out.println("enum classes cannot have finalize methods");
		finalizeTest tVal = new finalizeTest()
		{
			// final finalize method
			protected final void finalize() throws Throwable
			{
				// empty implementation
			};		
		};
	}
}

Konklusion

Vi har undersøgt, hvordan man bruger valueOf-metoden i Java i dette Java Enum valueOf-eksempel. Fordi hver enum i Java i sagens natur udvider java.lang, er valueOf-metoden tilgængelig for alle Java Enum. Enum er en type klasse. Enum valueOf-metoden modtager den nøjagtige streng, der bruges til at erklære Enum-konstanten og returnerer denne Enum-konstant. IllegalArgumentException udløses, hvis valueOf-metoden returnerer en ugyldig streng.


Java tag