Assign Enum Values in Java

You can do this indirectly if you let both enum implement the same interface:

interface CommonEnumInterface{}

public enum E1 implements  CommonEnumInterface{
A, B
} 

public enum E2 implements  CommonEnumInterface{
C, D
}

CommonEnumInterface myE  = E1.A;
myE  = E2.D;

Yeah the answer as commented above, is you can't do it.

Enums in Java are type-safe and have their own namespace. It means your enum will have a type for example "Currency" and you can not assign any value other than specified in Enum Constants. E1 is E1 and E2 is E2 namespace.

Well - looking at your second snippet, what you could do is to define E2 as

enum E2 {
    A, B
}

and E1as

enum E1 {

    A(E2.A), B(E2.B);

    private E2 e2;

    E1(E2 e2) {
        this.e2 = e2;
    }

    public E2 getE2() {
        return e2;
    }

}

like this you can simply write your if statement as

E2 var = x.getE2();

The idea behind this solution is, that enums like any other class in Java can have properties (private E2 e2), constructors (E1(E2 es) {...}) and methods (public E2 getE2()). Like that you can "add" any other values to your enum instances and use a getter to query them later on.

The short answer is NO, java is not allowing that

I need more info about what exactly you need to do, but you can achieve something similar doing something like this

public static void main(String[] args) {

    E2 myE2 = E2.valueOf(E1.A.name());
    System.out.println(myE2);
    }

    enum E1 {
    A, B
    }

    enum E2 {
    A, B
    }

and note that will work ONLY because the field A is defined in both enums, otherwise is not going to work failing with an java.lang.IllegalArgumentException: No enum constant ...

but this workaround is exactly what you post when you say

(Assuming that I know in advance that B exists in both enums)

Since you can define enums as 'lightweight classes' conforming to interfaces with their own properties and methods, you can write up your combining rules something like this:

Upholstery.java

import java.util.List;

public interface Upholstery {

    public List<Material> combinesWith();

}

Material.java

import java.util.List;

public interface Material {

    public List<Upholstery> combinesWith();
}

Upholsteries.java

import java.util.Arrays;
import java.util.List;

public enum Upholsteries implements Upholstery {
    SATIN {
        @Override
        public List<Material> combinesWith() {
            return Arrays.asList(Materials.PLASTIC);
        }
    },
    LEATHER {
        @Override
        public List<Material> combinesWith() {
            return Arrays.asList(Materials.MAHOGANY);
        }
    }
}

Materials.java

import java.util.Arrays;
import java.util.List;

public enum Materials implements Material {
    MAHOGANY {
        @Override
        public List<Upholstery> combinesWith() {
            return Arrays.asList(Upholsteries.SATIN,
                                 Upholsteries.LEATHER);
        }
    },
    PLASTIC {
        @Override
        public List<Upholstery> combinesWith() {
             return Arrays.asList(Upholsteries.SATIN);
        }
    }
}

Obviously, you could add additional methods to the interfaces, or modify the signature of combinesWith() to implement more complex logic - e.g. combinesWith(FurnitureType f, double budget).