Intent 传递的类型总结

本文详细介绍了Android中使用Intent进行数据传递的方法,包括基本数据类型和复杂对象如自定义类的传递方式。通过实例展示了如何利用putExtra和getSerializable等方法进行序列化与反序列化操作。

一.Intent传递数据:

方法1:

          传递:通过intent.putExtra(Key,value)放入数据

          接收:通过intent.getExtras取出Bundle,然后用Bandles.getLong,getInt.getBoolean,getString等函数来取出数据

方法2:

         通过data传递,而data传输的是URL,URL可以是我们熟悉的http,ftp等网络地址,也可以是content来指向ContentProver提供的资源。

         传递:通过intent.setData(url)放入url

         接收:通过intent.getData取出url

二.Intent传递类对象:

方法1:Bundle.putSerializable(Key,Object);//实现Serializable接口

方法2:Bundle.putParcelable(Key,Object);//实现Parcelable接口

注:如果传递的是List<Object>,将list强转成Serializable类型,Object也必须实现Serializable接口


具体实现步骤:

(1)创建一个序列化类:User

import java.io.Serializable;

public class User implements Serializable {
   private int ID;
    private String UserName;    
    private String PWD;    
    public final void setID(int value)
    {
        ID = value;
    }
    public final int getID()
    {
        return ID;
    }    
    public final void setUserName(String value)
    {
        UserName = value;
    }
    public final String getUserName()
    {
        return UserName;
    }  
    public final void setPWD(String value)
    {
        PWD = value;
    }

    public final String getPWD()
    {
        return PWD;
    }    
    
}
(2)启动某个Activity进行传递:

   传递端:
   User user = new User();
   Intent intent = new Intent(this,OtherActivity.class);
   Bundle bundle = new Bundle();
   bundle.putSerializable("user",user);
   intent.putExtras(bundle);
   startActivity(intent);

   接收端:
   Intent intent = getIntent;
   user = intent.getSerializable("user");  

   注:传递List<Object>
   
   传递端:
   intent.putExtras(Key,(Serializable)list);

   接收端:
   Intent intent = getIntent();
   (List<Object>)intent.getSerializable(Key); 



<think> 我们被要求使用Intent传递枚举类型的对象。根据引用内容,有三种主要方法: 1. 将枚举值转换为字符串传递(引用[1]) 2. 使用Parcelable方式传递(引用[2]) 3. 使用Serializable方式传递(引用[3]) 接下来我们将详细说明每种方法,并给出示例代码。 方法一:将枚举值作为字符串传递 这是最简单的方法,利用枚举的name()方法将其转为字符串,在接收方通过枚举的valueOf方法还原。 方法二:实现Parcelable接口 枚举类型默认已经实现了Serializable,所以可以直接通过Serializable传递。但如果要实现Parcelable,需要手动编写。 方法三:使用Serializable传递 枚举类型天然支持Serializable,所以可以直接传递。 下面分别说明: 一、字符串传递法 发送方: ```java enum Day { MONDAY, TUESDAY } Intent intent = new Intent(this, TargetActivity.class); intent.putExtra("day_enum", Day.MONDAY.name()); startActivity(intent); ``` 接收方(TargetActivity中): ```java String dayName = getIntent().getStringExtra("day_enum"); Day day = Day.valueOf(dayName); // 注意:如果字符串不匹配会抛出IllegalArgumentException ``` 二、Serializable传递法 发送方: ```java enum Day implements Serializable { MONDAY, TUESDAY } // 虽然枚举默认就是Serializable,显式声明可读性更好 Intent intent = new Intent(this, TargetActivity.class); intent.putExtra("day_serializable", Day.MONDAY); startActivity(intent); ``` 接收方: ```java Day day = (Day) getIntent().getSerializableExtra("day_serializable"); ``` 三、Parcelable传递法 枚举类型本身不能直接实现Parcelable(因为枚举是final的),但我们可以通过将枚举包裹在一个实现了Parcelable的类中来传递。 例如,我们创建一个包裹类: ```java public class EnumParcelable<T extends Enum<T>> implements Parcelable { private T value; public EnumParcelable(T value) { this.value = value; } protected EnumParcelable(Parcel in) { // 从字符串重建枚举 String className = in.readString(); String constName = in.readString(); try { Class<T> enumClass = (Class<T>) Class.forName(className); this.value = Enum.valueOf(enumClass, constName); } catch (ClassNotFoundException e) { throw new RuntimeException(e); } } public T getValue() { return value; } @Override public void writeToParcel(Parcel dest, int flags) { // 写入枚举的类名和常量名 dest.writeString(value.getClass().getName()); dest.writeString(value.name()); } @Override public int describeContents() { return 0; } public static final Creator<EnumParcelable> CREATOR = new Creator<EnumParcelable>() { @Override public EnumParcelable createFromParcel(Parcel in) { return new EnumParcelable(in); } @Override public EnumParcelable[] newArray(int size) { return new EnumParcelable[size]; } }; } ``` 发送方: ```java Intent intent = new Intent(this, TargetActivity.class); intent.putExtra("day_parcelable", new EnumParcelable<>(Day.MONDAY)); startActivity(intent); ``` 接收方: ```java EnumParcelable<Day> parcelable = getIntent().getParcelableExtra("day_parcelable"); Day day = parcelable.getValue(); ``` 但是,通常我们不建议为了枚举而创建包裹类,因为枚举本身已经支持Serializable,所以使用Serializable方法是最简单的。 总结: 推荐使用字符串传递法或Serializable传递法,因为它们简单直接。Parcelable传递法虽然性能好,但实现复杂,对于枚举这种小对象来说,性能差异可以忽略。 注意事项: 1. 使用字符串传递时,要确保接收方有对应的枚举值,否则valueOf会抛出异常。 2. 使用Serializable传递时,枚举是类型安全的,不会出现字符串不匹配的问题(因为枚举常量是唯一的),但要注意反序列化时,如果枚举类版本不同可能会有问题(一般不会)。 3. 使用Parcelable包裹类传递虽然复杂,但适用于对性能要求极高的场景(不过枚举通常很小,所以意义不大)。 因此,一般情况下,我们优先选择Serializable方式,因为代码最简洁。 示例:使用Serializable传递枚举 定义枚举: ```java public enum Day implements Serializable { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY } ``` 发送方: ```java Intent intent = new Intent(this, TargetActivity.class); intent.putExtra("day", Day.FRIDAY); startActivity(intent); ``` 接收方: ```java Day day = (Day) getIntent().getSerializableExtra("day"); ``` 如果枚举定义在另一个模块(比如独立的jar包),要确保接收方也有同样的枚举定义。 相关问题: 1. Intent传递枚举和传递普通对象有什么区别? 2. 枚举类型为什么默认实现了Serializable接口? 3. 使用字符串传递枚举有什么潜在风险? 请注意:在Android开发中,枚举类型会比常量整数占用更多内存,因此官方建议避免使用枚举(尤其是在性能敏感的场景),但传递枚举对象通常不会成为性能瓶颈。 引用说明: 我们参考了引用[1]的字符串传递法、引用[3]的Serializable传递法,以及引用[2]和[4]中关于Parcelable和性能的讨论。 在回答中,我们引用了这些方法,并在适当位置标注引用[^1][^2][^3][^4]。 </think> 在Android开发中,传递枚举对象通过Intent有三种主流方法,各有适用场景: ### 一、字符串转换法(推荐简单场景) **原理**:利用枚举的`.name()`转为字符串传递,接收方用`valueOf()`还原 **优点**:轻量高效,避免序列化开销 **实现步骤**: ```java // 发送方 Intent intent = new Intent(this, TargetActivity.class); intent.putExtra("color_enum", Color.RED.name()); // 转为字符串 [^1] startActivity(intent); // 接收方 String colorName = getIntent().getStringExtra("color_enum"); Color color = Color.valueOf(colorName); // 还原枚举 ``` > ⚠️ 注意:需确保枚举值存在,否则`valueOf()`抛出`IllegalArgumentException` ### 二、Serializable序列化(推荐默认方案) **原理**:枚举默认实现`Serializable`接口,可直接传递 **优点**:代码简洁,类型安全 **实现步骤**: ```java // 发送方 Intent intent = new Intent(this, TargetActivity.class); intent.putExtra("color_serial", Color.BLUE); // 直接传递枚举 [^3] startActivity(intent); // 接收方 Color color = (Color) getIntent().getSerializableExtra("color_serial"); ``` ### 三、Parcelable包裹法(高性能场景) **原理**:创建包裹类实现`Parcelable`接口传输 **优点**:跨进程效率最高 **实现步骤**: ```java // 枚举包裹类 public class ColorParcel implements Parcelable { private final Color color; public ColorParcel(Color color) { this.color = color; } protected ColorParcel(Parcel in) { color = Color.valueOf(in.readString()); // 从字符串还原 } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeString(color.name()); // 转为字符串写入 } public Color getColor() { return color; } public static final Creator<ColorParcel> CREATOR = new Creator<>() { @Override public ColorParcel createFromParcel(Parcel in) { return new ColorParcel(in); } // ... newArray实现 }; } // 发送方 intent.putExtra("color_parcel", new ColorParcel(Color.GREEN)); // 接收方 ColorParcel parcel = getIntent().getParcelableExtra("color_parcel"); Color color = parcel.getColor(); ``` ### ⚡ 性能对比与选型建议 | 方法 | 执行效率 | 代码复杂度 | 推荐场景 | |--------------|----------|------------|---------------------------| | 字符串转换 | ★★★★☆ | ★☆☆☆☆ | 简单枚举,无版本兼容需求 | | Serializable | ★★☆☆☆ | ★☆☆☆☆ | 通用场景(默认推荐)[^3] | | Parcelable | ★★★★★ | ★★★★☆ | 高频调用或跨进程通信[^2] | ### ❗ 注意事项 1. **枚举修改风险**:改变枚举常量名称会导致历史数据解析失败 2. **版本兼容**:新旧版本枚举定义变化可能引发`ClassNotFoundException`[^4] 3. **空值处理**:接收方需验证Extra是否为null 4. **内存开销**:枚举比整型常量多占2倍内存,高频场景慎用 > 关键建议:优先选择`Serializable`方案,在需要极致性能时改用`Parcelable`包裹类[^4]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值