在芬兰湾的科特林:

enum class MyEnum {
  NAME, SURNAME, GENDER
}

把这个枚举放在一个Bundle中:

Bundle().apply {
  putInt(MY_ENUM_KEY, MyEnum.ordinal)
}

从Bundle中获取enum:

val ordinal = getInt(MY_ENUM_KEY, 0)
MyEnum.values()[ordinal]

完整的例子:

class MyFragment : Fragment() {

    enum class MyEnum {
        NAME, SURNAME, GENDER
    }

    companion object {
        private const val MY_ENUM_KEY = "my_enum_key"

        fun newInstance(myEnum: MyEnum) = MyFragment().apply {
            arguments = Bundle().apply {
                putInt(MY_ENUM_KEY, myEnum.ordinal)
            }
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        with(requireArguments()) {
            val ordinal = getInt(MY_ENUM_KEY, 0)
            val myEnum = MyEnum.values()[ordinal]
        }
    }
}

在Java中:

public final class MyFragment extends Fragment {
    private static final String MY_ENUM_KEY = "my_enum";

    public enum MyEnum {
        NAME,
        SURNAME,
        GENDER
    }

    public final MyFragment newInstance(MyEnum myEnum) {
        Bundle bundle = new Bundle();
        bundle.putInt(MY_ENUM_KEY, myEnum.ordinal());
        MyFragment fragment = new MyFragment();
        fragment.setArguments(bundle);
        return fragment;
    }

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Bundle arguments = this.requireArguments();
        int ordinal = arguments.getInt(MY_ENUM_KEY, 0);
        MyEnum myEnum = MyEnum.values()[ordinal];
    }
}

另一个选择:

public enum DataType implements Parcleable {
    SIMPLE, COMPLEX;

    public static final Parcelable.Creator<DataType> CREATOR = new Creator<DataType>() {

        @Override
        public DataType[] newArray(int size) {
            return new DataType[size];
        }

        @Override
        public DataType createFromParcel(Parcel source) {
            return DataType.values()[source.readInt()];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(this.ordinal());
    }
}

我用高棉。

companion object {

        enum class Mode {
            MODE_REFERENCE,
            MODE_DOWNLOAD
        }
}

然后放入Intent:

intent.putExtra(KEY_MODE, Mode.MODE_DOWNLOAD.name)

当你上网获得价值时:

mode = Mode.valueOf(intent.getStringExtra(KEY_MODE))

为了完整起见，这是一个完整的示例，说明如何从bundle中放入和返回enum。

给定以下enum:

enum EnumType{
    ENUM_VALUE_1,
    ENUM_VALUE_2
}

你可以把枚举放到一个bundle中:

bundle.putSerializable("enum_key", EnumType.ENUM_VALUE_1);

并返回enum:

EnumType enumType = (EnumType)bundle.getSerializable("enum_key");

enum YourEnum { 类型1, 类型2 ｝

传递bundle as bundleOf("TYPE" to youenum . type1)

收到, 参数?。let {it.getSerializable(B"TYPE") as YourEnum}

我创建了一个Koltin扩展:

fun Bundle.putEnum(key: String, enum: Enum<*>) {
    this.putString( key , enum.name )
}

inline fun <reified T: Enum<T>> Intent.getEnumExtra(key:String) : T {
    return enumValueOf( getStringExtra(key) )
}

创建一个bundle并添加:

Bundle().also {
   it.putEnum( "KEY" , ENUM_CLAS.ITEM )
}

并获得:

intent?.getEnumExtra< ENUM_CLAS >( "KEY" )?.let{}