Executing action depending on enum value

Executing action depending on enum value - java

I'm trying to retrieving a value depending on the enum value.
Basically, let's say I have the following enum:
private enum Auth{
KEY, PASSWORD, MAIL;
public String get(){
return "";
}
}
By doing Auth.KEY.get() it would return "mykey", while Auth.MAIL.get() would return "mymail"
I googled a bit but I couldn't find an answer, I didn't try anything before because I totally hadn't an idea on how I could start.

Just add a field and constructor, as explained in the java-docs
Example code:
enum Auth {
KEY("myKey"), PASSWORD("myPass"), MAIL("myMail");
private final String identifier;
Auth(String identifier) {
this.identifier = identifier;
}
public String get(){
return identifier;
}
}
Also note, that there is name() and toString() which may be useful: see also java-enum-why-use-tostring-instead-of-name

Although I strongly advise not to use the following mechanism for getting something simple like a hardcoded String from an enum value and rather use it for associating particular behavior like in java.util.concurrent.TimeUnit, this is how it can be achieved:
private enum Auth {
KEY {
public String get() {
return "mykey";
}
},
PASSWORD {
public String get() {
return "mypassword";
}
},
MAIL {
public String get() {
return "mymail";
}
};
public abstract String get();
}

enum Auth{
private enum Auth{
String value;
KEY("mykey"), PASSWORD("mypassword"), MAIL(mymail");
Auth(String value){
thia.value=value;
}
public String get(){
return value;
}
}

You need to have a string which holds the name of of enum and a constructor which sets it. Then get method returns the name as below.
private enum Auth{
KEY, PASSWORD, MAIL;
string name;
public Auth(string nm) {
name = nm;
}
public String get(){
return name;
}
}

Related

Java How can I have a method return either a child or parent class object

I have two classes where one class inherits the other one as given below:
public class UserData {
protected final String emailAddress;
protected final String name;
public UserData(final String emailAddress, final String name) {
this.emailAddress = emailAddress;
this.name = name;
}
public Optional<String> getEmailAddress() {
return Optional.ofNullable(this.emailAddress);
}
public Optional<String> getName() {
return Optional.ofNullable(this.name);
}
}
public class EmployeeData extends UserData {
protected final String designation;
public EmployeeData(
final String emailAddress,
final String name,
final String designation
) {
super(emailAddress, name);
this.designation = designation;
}
public Optional<String> getDesignation() {
return Optional.ofNullable(this.designation);
}
}
I need to create method in another class that can return either one of these objects and have all getters accessible. I already tried making the return type UserData for both kinds of objects (example given below) but that way, I cannot access the getDesignation getter for EmployeeData. Is there a better way inheritance can be setup to avoid this problem where I cannot access child-specific properties?
public UserData getData() {
if (...some condition) {
return new EmployeeData("address#provider.com", "myName", "Dev")
}
else {
return new UserData("address#provider.com", "myName");
}
}
I did look into these stackoverflow questions but couldn't quite figure it out for my use case
C# how to make a function that can return either child or parent class
What's the equivalent of C# IEnumerable in Java? The covariant-capable one, not the Iterable

Because the object we are returning is of type UserData, we will be unable to call methods that are added within the child class, EmployeeData. You could create the getDesignation() method inside the UserData class and have it return an empty optional object.
public Optional<String> getDesignation() {
return Optional.empty();
}
In this case, you can now override the method within the EmployeeData class to return designation as an Optional like this,
#Override
public Optional<String> getDesignation() {
return Optional.ofNullable(this.designation);
}
Now you will have access to the getDestination() method from returned object of getData(), but you will have to be careful and understand that if the returned type is of UserData, then when calling getDesignation() you will be receiving an Optional.empty() object.

Duplicate code across enums .. is there an approach to centralize common code in these enums?

I have the following 3 enum's in my project, which are all very similar.
Since each enum has at least 2 common fields i.e key and code, is there any way that I can make the common:
constructors
getters
field declarations
shared to all of my enums? Without having to declare inside each one.
I know no extends clause allowed for enum.
But is there an elegant way to achieve reuse of the common parts of these enums?
public enum CarType {
SEAT("2000", "001"),
FIAT("3000", "002");
String key;
String code;
CarType(String key, String code) {
this.key = key;
this.code = code;
}
public String getKey() {
return key;
}
public String getCode() {
return code;
}
}
public enum TruckType {
MERCEDES("4000", "001"),
FORD("5000", "002");
String key;
String code;
TruckType(String key, String code) {
this.key = key;
this.code = code;
}
public String getKey() {
return key;
}
public String getCode() {
return code;
}
}
public enum VanType {
JEEP("6000", "001", "40"),
KIA("7000", "002", "50");
String key;
String code;
String tankSize;
VanType(String key, String code, String tankSize) {
this.key = key;
this.code = code;
this.tankSize = tankSize;
}
public String getKey() {
return key;
}
public String getCode() {
return code;
}
public String getTankSize() {
return tankSize;
}
}

Enum - is a special kind of class that is very restricted. And you may think of enum constants as if they are public static final fields (note: explicit modifiers are not allowed with enum constants).
That actually resembles the Singleton pattern.
All enum constants are eagerly initialized when an enum is being loaded into memory. And that is the simplest implementation of the singleton when an instance (in this case instances) is being initialed before any of its static methods of fields can be accessed.
My idea is to introduce an abstract class VehicleType that will contain two string fields key and code, constructor and getters.
And every enum will turn into a concrete class that extends the VehicleType class. Apart from constructors and static final fields in these classes, we'll need to declare only a single field inside the VanType and provide a getter for it.
The code for that will look like that.
public abstract class VehicleType {
protected String key;
protected String code;
public VehicleType(String key, String code) {
this.key = key;
this.code = code;
}
// getters + common behaviour
}
public class CarType extends VehicleType {
public static final CarType SEAT = new CarType("2000", "001");
public static final CarType FIAT = new CarType("3000", "002");
private CarType(String key, String code) {
super(key, code);
}
}
public class TruckType extends VehicleType {
public static final TruckType SEAT = new TruckType("4000", "001");
public static final TruckType FIAT = new TruckType("5000", "002");
private TruckType(String key, String code) {
super(key, code);
}
}
public class VanType extends VehicleType {
public static final VanType JEEP = new VanType("6000", "001", "40");
public static final VanType KIA = new VanType("7000", "002", "50");
private String tankSize;
private VanType(String key, String code, String tankSize) {
super(key, code);
this.tankSize = tankSize;
}
public String getTankSize() {
return tankSize;
}
}

Is there any default method for ENUM? [duplicate]

What is the best way to use the values stored in an Enum as String literals?
For example:
public enum Modes {
some-really-long-string,
mode1,
mode2,
mode3
}
Then later I could use Mode.mode1 to return its string representation as mode1. Without having to keep calling Mode.mode1.toString().

You can't. I think you have FOUR options here. All four offer a solution but with a slightly different approach...
Option One: use the built-in name() on an enum. This is perfectly fine if you don't need any special naming format.
String name = Modes.mode1.name(); // Returns the name of this enum constant, exactly as declared in its enum declaration.
Option Two: add overriding properties to your enums if you want more control
public enum Modes {
mode1 ("Fancy Mode 1"),
mode2 ("Fancy Mode 2"),
mode3 ("Fancy Mode 3");
private final String name;
private Modes(String s) {
name = s;
}
public boolean equalsName(String otherName) {
// (otherName == null) check is not needed because name.equals(null) returns false
return name.equals(otherName);
}
public String toString() {
return this.name;
}
}
Option Three: use static finals instead of enums:
public final class Modes {
public static final String MODE_1 = "Fancy Mode 1";
public static final String MODE_2 = "Fancy Mode 2";
public static final String MODE_3 = "Fancy Mode 3";
private Modes() { }
}
Option Four: interfaces have every field public, static and final:
public interface Modes {
String MODE_1 = "Fancy Mode 1";
String MODE_2 = "Fancy Mode 2";
String MODE_3 = "Fancy Mode 3";
}

Every enum has both a name() and a valueOf(String) method. The former returns the string name of the enum, and the latter gives the enum value whose name is the string. Is this like what you're looking for?
String name = Modes.mode1.name();
Modes mode = Modes.valueOf(name);
There's also a static valueOf(Class, String) on Enum itself, so you could also use:
Modes mode = Enum.valueOf(Modes.class, name);

You could override the toString() method for each enum value.
Example:
public enum Country {
DE {
#Override
public String toString() {
return "Germany";
}
},
IT {
#Override
public String toString() {
return "Italy";
}
},
US {
#Override
public String toString() {
return "United States";
}
}
}
Usage:
public static void main(String[] args) {
System.out.println(Country.DE); // Germany
System.out.println(Country.IT); // Italy
System.out.println(Country.US); // United States
}

As Benny Neugebauer mentions, you could overwrite the toString(). However instead overwriting the toString for each enum field I like more something like this:
public enum Country{
SPAIN("España"),
ITALY("Italia"),
PORTUGAL("Portugal");
private String value;
Country(final String value) {
this.value = value;
}
public String getValue() {
return value;
}
#Override
public String toString() {
return this.getValue();
}
}
You could also add a static method to retrieve all the fields, to print them all, etc.
Simply call getValue to obtain the string associated to each Enum item

mode1.name() or String.valueOf(mode1). It doesn't get better than that, I'm afraid

public enum Modes {
MODE1("Mode1"),
MODE2("Mode2"),
MODE3("Mode3");
private String value;
public String getValue() {
return value;
}
private Modes(String value) {
this.value = value;
}
}
you can make a call like below wherever you want to get the value as a string from the enum.
Modes.MODE1.getvalue();
This will return "Mode1" as a String.

For my enums I don't really like to think of them being allocated with 1 String each. This is how I implement a toString() method on enums.
enum Animal
{
DOG, CAT, BIRD;
public String toString(){
switch (this) {
case DOG: return "Dog";
case CAT: return "Cat";
case BIRD: return "Bird";
}
return null;
}
}

You can use Mode.mode1.name() however you often don't need to do this.
Mode mode =
System.out.println("The mode is "+mode);

As far as I know, the only way to get the name would be
Mode.mode1.name();
If you really need it this way, however, you could do:
public enum Modes {
mode1 ("Mode1"),
mode2 ("Mode2"),
mode3 ("Mode3");
private String name;
private Modes(String s) {
name = s;
}
}

my solution for your problem!
import java.util.HashMap;
import java.util.Map;
public enum MapEnumSample {
Mustang("One of the fastest cars in the world!"),
Mercedes("One of the most beautiful cars in the world!"),
Ferrari("Ferrari or Mercedes, which one is the best?");
private final String description;
private static Map<String, String> enumMap;
private MapEnumSample(String description) {
this.description = description;
}
public String getEnumValue() {
return description;
}
public static String getEnumKey(String name) {
if (enumMap == null) {
initializeMap();
}
return enumMap.get(name);
}
private static Map<String, String> initializeMap() {
enumMap = new HashMap<String, String>();
for (MapEnumSample access : MapEnumSample.values()) {
enumMap.put(access.getEnumValue(), access.toString());
}
return enumMap;
}
public static void main(String[] args) {
// getting value from Description
System.out.println(MapEnumSample.getEnumKey("One of the fastest cars in the world!"));
// getting value from Constant
System.out.println(MapEnumSample.Mustang.getEnumValue());
System.out.println(MapEnumSample.getEnumKey("One of the most beautiful cars in the world!"));
System.out.println(MapEnumSample.Mercedes.getEnumValue());
// doesnt exist in Enum
System.out.println("Mustang or Mercedes, which one is the best?");
System.out.println(MapEnumSample.getEnumKey("Mustang or Mercedes, which one is the best?") == null ? "I don't know!" : "I believe that "
+ MapEnumSample.getEnumKey("Ferrari or Mustang, which one is the best?") + " is the best!.");
// exists in Enum
System.out.println("Ferrari or Mercedes, wich one is the best?");
System.out.println(MapEnumSample.getEnumKey("Ferrari or Mercedes, which one is the best?") == null ? "I don't know!" : "I believe that "
+ MapEnumSample.getEnumKey("Ferrari or Mercedes, which one is the best?") + " is the best!");
}
}

You can simply use:
""+ Modes.mode1

public enum Environment
{
PROD("https://prod.domain.com:1088/"),
SIT("https://sit.domain.com:2019/"),
CIT("https://cit.domain.com:8080/"),
DEV("https://dev.domain.com:21323/");
private String url;
Environment(String envUrl) {
this.url = envUrl;
}
public String getUrl() {
return url;
}
}
String prodUrl = Environment.PROD.getUrl();
It will print:
https://prod.domain.com:1088/
This design for enum string constants works in most of the cases.

Enum is just a little bit special class. Enums can store additional fields, implement methods etc. For example
public enum Modes {
mode1('a'),
mode2('b'),
mode3('c'),
;
char c;
private Modes(char c) {
this.c = c;
}
public char character() {
return c;
}
}
Now you can say:
System.out.println(Modes.mode1.character())
and see output:
a

package com.common.test;
public enum Days {
monday(1,"Monday"),tuesday(2,"Tuesday"),wednesday(3,"Wednesday"),
thrusday(4,"Thrusday"),friday(5,"Friday"),saturday(6,"Saturday"),sunday(7,"Sunday");
private int id;
private String desc;
Days(int id,String desc){
this.id=id;
this.desc=desc;
}
public static String getDay(int id){
for (Days day : Days.values()) {
if (day.getId() == id) {
return day.getDesc();
}
}
return null;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
};

This method should work with any enum:
public enum MyEnum {
VALUE1,
VALUE2,
VALUE3;
public int getValue() {
return this.ordinal();
}
public static DataType forValue(int value) {
return values()[value];
}
public String toString() {
return forValue(getValue()).name();
}
}

i found this one is more easy for preventing type error:
public enum Modes {
some-really-long-string,
mode1,
mode2,
mode3;
String str;
Modes(){
this.str = super.name();
}
#Override
#NonNull
public String toString() {
return str;
}
however - this may work when you need to use a String on a log/println or whenever java compiles the toString() method automatically, but on a code line like this ->
// sample method that require (string,value)
intent.putExtra(Modes.mode1 ,shareElement.getMode()); // java error
// first argument enum does not return value
instead as mentioned above you will still have to extend the enum and use .name() in those cases like this:
intent.putExtra(Modes.mode1.name() ,shareElement.getMode());

after many tries I have come with this solution
public static enum Operation {
Addition, Subtraction, Multiplication, Division,;
public String getUserFriendlyString() {
if (this==Addition) {
return " + ";
} else if (this==Subtraction) {
return " - ";
} else if (this==Multiplication) {
return " * ";
} else if (this==Division) {
return " / ";
}
return "undefined";
}
}

You can try this:
public enum Modes {
some-really-long-string,
mode1,
mode2,
mode3;
public String toString(){
switch(this) {
case some-really-long-string:
return "some-really-long-string";
case mode2:
return "mode2";
default: return "undefined";
}
}
}

use mode1.name() or String.valueOf(Modes.mode1)

Java enum, different value depending on bool value

I want to create an enum class, lets say:
public enum runtimeStatus {
STATUS1("passed"),
STATUS2("failed"),
STATUS3("notrun");
private String status;
private runtimeStatus(String statusCode) {
status = statusCode;
}
public String getStatus() {
return status;
}
}
Okay, I'm accesing those properties with runtimeStatus.STATUS1.getStatus();
But how can I accomplish to pass a boolean to that call, so I get a different output. Lets say for STATUS1 if passed boolean is TRUE to return "passed" if its FALSE to return "passed-type2"

Check the below way. We can define as many number of fields in enum and have logics in enum methods.
public enum runtimeStatus
{
STATUS1("passed", "passedType2"),
STATUS2("failed", "failedType2"),
STATUS3("notrun", "notRunType2");
private String statusTrue;
private String statusFalse;
private runtimeStatus(String statusTrueCode, String statusFalseCode)
{
this.statusTrue = statusTrueCode;
this.statusFalse = statusFalseCode;
}
public String getStatus(boolean value)
{
return (value == true) ? statusTrue : statusFalse;
}
}

Overload your getStatus method.
public String getStatus(boolean statusType) {
if (statusType) {
return getStatus();
}
return "passed-type2";
}
public String getStatus() {
return status;
}

Add following method to Your existing enum :
public String getStatus(boolean passed) {
if(passed) {
return STATUS1.getStatus();
}else {
return STATUS2.getStatus();
}
}

Best way to create enum of strings?

What is the best way to have a enum type represent a set of strings?
I tried this:
enum Strings{
STRING_ONE("ONE"), STRING_TWO("TWO")
}
How can I then use them as Strings?

I don't know what you want to do, but this is how I actually translated your example code....
package test;
/**
* #author The Elite Gentleman
*
*/
public enum Strings {
STRING_ONE("ONE"),
STRING_TWO("TWO")
;
private final String text;
/**
* #param text
*/
Strings(final String text) {
this.text = text;
}
/* (non-Javadoc)
* #see java.lang.Enum#toString()
*/
#Override
public String toString() {
return text;
}
}
Alternatively, you can create a getter method for text.
You can now do Strings.STRING_ONE.toString();

Custom String Values for Enum
from http://javahowto.blogspot.com/2006/10/custom-string-values-for-enum.html
The default string value for java enum is its face value, or the element name. However, you can customize the string value by overriding toString() method. For example,
public enum MyType {
ONE {
public String toString() {
return "this is one";
}
},
TWO {
public String toString() {
return "this is two";
}
}
}
Running the following test code will produce this:
public class EnumTest {
public static void main(String[] args) {
System.out.println(MyType.ONE);
System.out.println(MyType.TWO);
}
}
this is one
this is two

Use its name() method:
public class Main {
public static void main(String[] args) throws Exception {
System.out.println(Strings.ONE.name());
}
}
enum Strings {
ONE, TWO, THREE
}
yields ONE.

Either set the enum name to be the same as the string you want or, more generally,you can associate arbitrary attributes with your enum values:
enum Strings {
STRING_ONE("ONE"), STRING_TWO("TWO");
private final String stringValue;
Strings(final String s) { stringValue = s; }
public String toString() { return stringValue; }
// further methods, attributes, etc.
}
It's important to have the constants at the top, and the methods/attributes at the bottom.

Depending on what you mean by "use them as Strings", you might not want to use an enum here. In most cases, the solution proposed by The Elite Gentleman will allow you to use them through their toString-methods, e.g. in System.out.println(STRING_ONE) or String s = "Hello "+STRING_TWO, but when you really need Strings (e.g. STRING_ONE.toLowerCase()), you might prefer defining them as constants:
public interface Strings{
public static final String STRING_ONE = "ONE";
public static final String STRING_TWO = "TWO";
}

You can use that for string Enum
public enum EnumTest {
NAME_ONE("Name 1"),
NAME_TWO("Name 2");
private final String name;
/**
* #param name
*/
private EnumTest(final String name) {
this.name = name;
}
public String getName() {
return name;
}
}
And call from main method
public class Test {
public static void main (String args[]){
System.out.println(EnumTest.NAME_ONE.getName());
System.out.println(EnumTest.NAME_TWO.getName());
}
}

If you do not want to use constructors, and you want to have a special name for the method, try it this:
public enum MyType {
ONE {
public String getDescription() {
return "this is one";
}
},
TWO {
public String getDescription() {
return "this is two";
}
};
public abstract String getDescription();
}
I suspect that this is the quickest solution. There is no need to use variables final.

Get and set with default values.
public enum Status {
STATUS_A("Status A"), STATUS_B("Status B"),
private String status;
Status(String status) {
this.status = status;
}
public String getStatus() {
return status;
}
}

We Keep Coding

Java is a programming language and computing platform first released by Sun Microsystems in 1995.

Executing action depending on enum value - java

enum Auth{ private enum Auth{ String value; KEY("mykey"), PASSWORD("mypassword"), MAIL(mymail"); Auth(String value){ thia.value=value; } public String get(){ return value; } }

You need to have a string which holds the name of of enum and a constructor which sets it. Then get method returns the name as below. private enum Auth{ KEY, PASSWORD, MAIL; string name; public Auth(string nm) { name = nm; } public String get(){ return name; } }

Related

Java How can I have a method return either a child or parent class object

Duplicate code across enums .. is there an approach to centralize common code in these enums?

Is there any default method for ENUM? [duplicate]

Java enum, different value depending on bool value

Best way to create enum of strings?

Categories

Resources