精华内容
下载资源
问答
  • Android Activity之间通过Intent传递对象在Activity之间传递对象,这个对象须是可以序列化的,传递对象可以通过下面几种方式实现 * 类实现 Serializable,Java 提供的序列化的接口 * 类实现 Parcelable,Android...

    Android Activity之间通过Intent传递对象

    在Activity之间传递对象,这个对象须是可以序列化的,传递对象可以通过下面几种方式实现
    * 类实现 Serializable,Java 提供的序列化的接口
    * 类实现 Parcelable,Android提供的在移动端的序列化接口,效率更高

    工程源码

    Serializable

    将类实现Serializable接口即可

      public class CustomTest1 implements Serializable{
        public String name;
        public int age;
      }

    A Activity 发送数据

      Intent intent = new Intent();
      intent.setClass(this,IntentActivity2.class);
      CustomTest1 test1 = new CustomTest1();
      test1.name = "Kevin";
      test1.age = 12;
      Bundle b = new Bundle();
      b.putSerializable("serial",test1);
      intent.putExtras(b);

    B Activity 接收数据

      CustomTest1 test1 =  (CustomTest1) getIntent().getExtras().getSerializable("serial");
      if(test1 != null){
          Log.e("tag","test1 name: "+test1.name+" age: "+test1.age);
      }

    Parcelable

    将类实现Parcelable接口,必须重载相关的方法,必须创建一个CREATOR的变量,实现Parcelable接口,实现有点复杂
    但是效率高

      public class CustomTest2 implements Parcelable{
          public String name;
          public int age;
    
          public CustomTest2(){}
    
          public CustomTest2(Parcel p) {
              readFromParcel(p);
          }
    
          @Override
          public void writeToParcel(Parcel dest, int flags) {
              dest.writeString(name);
              dest.writeInt(age);
          }
    
          @Override
          public int describeContents() {
              return 0;
          }
    
          private void readFromParcel(Parcel in ) {
              name = in.readString();
              age = in.readInt();
          }
    
          public static final Parcelable.Creator CREATOR = new Parcelable.Creator(){
              @Override
              public CustomTest2 createFromParcel(Parcel source) {
                  return new CustomTest2(source);
              }
    
              @Override
              public CustomTest2[] newArray(int size) {
                  return new CustomTest2[size];
              }
          };
      }

    A Activity 发送数据

      Intent intent = new Intent();
      intent.setClass(this,IntentActivity2.class);
      CustomTest2 test2 = new CustomTest2();
      test2.age = 14;
      test2.name = "Jhon";
      Bundle b = new Bundle();
      b.putParcelable("parcle",test2);
      intent.putExtras(b);

    B Activity 接收数据

      CustomTest2 test2 = getIntent().getExtras().getParcelable("parcle");
      if(null != test2){
          Log.e("tag","test2 name: "+test2.name+" age: "+test2.age);
      }

    传递Bitmap对象

    Activity之间可以传递bitmap对象,Bitmap的源码可以看到Bitmap已经实现了Parcelable的接口

    public final class Bitmap implements Parcelable{}

    A Activity 发送数据

      Intent intent = new Intent();
      intent.setClass(this,IntentActivity2.class);
      intent.putExtra("bitmap", bitmap);

    B Activity 接收数据

      Bitmap bitmap = getIntent().getParcelableExtra("bitmap");

    数据不能传递太大的数据,如果数据太大户籍引起异常,可以先对bitmap做一下压缩,然后在传递

    A Activity 发送数据(压缩bitmap)

      ByteArrayOutputStream stream = new ByteArrayOutputStream();
      bitmap.compress(Bitmap.CompressFormat.JPG, 100, stream);
      byte[] bytes = stream.toByteArray();
      intent.putExtra("bitmapbytes",bytes);

    B Activity 接收数据

      byte[] bytes = getIntent().getByteArrayExtra("bitmapbytes");
      Bitmap bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

    工程源码

    展开全文
  • 传递model private GetSoftByTypeResultEntity product ; startActivity( new Intent( this, SetNumOfPurchaseActivity. class ).putExtra( "product" , product )) ; //接收model private ...
    public class GetSoftByTypeResultEntity implements Serializable {
    
        /**
         * userId : null
         * token : null
         * serverTime : 1476509608650
         * content : null
         * state : null
         * id : c238dcdca64a4e66bf5dad42660e1cfa
         * name : 杆塔台阶基础设计
         * version : V1.0
         */
    
        public String userId;
        public String token;
        public String serverTime;
        public String content;
        public String state;
        public String id;
        public String name;
        public String version;
        public String softNum;//数量
        public String description;//描述
        public String verId;
        public String softId;
    
        @Override
        public String toString() {
            return name;
        }
    

    }

    传递model

    private GetSoftByTypeResultEntity product;
    startActivity(new Intent(this, SetNumOfPurchaseActivity.class).putExtra("product", product));
    //接收model
    private GetSoftByTypeResultEntity product;
    product = (GetSoftByTypeResultEntity) getIntent().getSerializableExtra("product");




    展开全文
  • Activity之间传递对象

    2016-10-25 10:51:51
    Activity之间传递对象 声明:如果对象要被传递,那么该对象必须通过实现Serialable接口或者Parcelable接口实现对象的序列化。 Serialable为java提供对象序列化的接口,效率低 Parcelable为android提供对象序列...
    
    

    Activity之间传递对象


    声明:如果对象要被传递,那么该对象必须通过实现Serialable接口或者Parcelable接口实现对象的序列化。

    Serialable为java提供对象序列化的接口,效率低

    Parcelable为android提供对象序列化的接口,移动平台专用,效率高

    1、传递List《String》

    传递List

    ArrayList<String> list = new ArrayList<>();
    intent.putStringArrayListExtra("key",list);
    

    接收List

    intent.getStringArrayListExtra("key");
    

    2、传递List《Integer》

    传递List

    ArrayList<Integer> list = new ArrayList<>();
    intent.putIntegerArrayListExtra("key",list);
    

    接收List

    intent.getIntegerArrayListExtra("key");
    

    3、传递Object

    3.1实现Serialable接口

    前提:Object要是先Serialbale接口
    用Serializable方式传递Object的语法:bundle.putSerializable(key,object);
    用Serializable方式接收Object的语法:getIntent().getSerializableExtra(key);
    

    3.2实现Parcelable接口

    前提:Object需要实现Parcelable接口
    用Parcelable方式传递Object的语法:bundle.putParcelable(key,object);
    用Parcelable方式接收Object的语法:getIntent().getParcelableExtra(key);
    

    实现Parcelable接口的类比较复杂,Parcelable是个什么东西呢?

    Android提供了一种新的类型:Parcel,被用作封装数据的容器,封装后的数据可以通过Intent或IPC传递。 除了基本类型以外,只有实现了Parcelable接口的类才能被放入Parcel中。
    
    实现Parcelable接口需要实现三个方法:
      1)writeToParcel方法。该方法将类的数据写入外部提供的Parcel中。
      2)describeContents方法。直接返回0就可以。
      3)静态的Parcelable.Creator<T>接口,本接口有两个方法:createFromParcel(Parcel in) 实现从in中创建出类的实例的功能。
       newArray(int size) 创建一个类型为T,长度为size的数组, returnnew T[size];即可。本方法是供外部类反序列化本类数组使用。
    

    实现Parcelable接口[demo]示例

    package com.wirelessqa.testintent;
    
    import android.os.Parcel;
    import android.os.Parcelable;
    
    /**
     * Object需要实现Parcelable接口
     * @author XF 2016.10.25
     */
    public class ParInfo implements Parcelable{
        private String name;
        private String website;
        private String weibo;
        public ParInfo(){
    
        }
        public ParInfo(String name, String website, String weibo){
            this.name = name;
            this.website = website;
            this.weibo = weibo;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getWebsite() {
            return website;
        }
    
        public void setWebsite(String website) {
            this.website = website;
        }
    
        public String getWeibo() {
            return weibo;
        }
    
        public void setWeibo(String weibo) {
            this.weibo = weibo;
        }
        @Override
        public int describeContents() {
            // TODO Auto-generated method stub
            return 0;
        }
        //该方法将类的数据写入外部提供的Parcel中。
        @Override
        public void writeToParcel(Parcel dest, int flags) {
            dest.writeString(name);
            dest.writeString(website);
            dest.writeString(weibo);
        }
    
        public static final Parcelable.Creator<ParInfo> CREATOR  = new Creator<ParInfo>() {
            //实现从source中创建出类的实例的功能
            @Override
            public ParInfo createFromParcel(Parcel source) {
                ParInfo parInfo  = new ParInfo();
                parInfo.name = source.readString();
                parInfo.website= source.readString();
                parInfo.weibo = source.readString();
                return parInfo;
            }
            //创建一个类型为T,长度为size的数组
            @Override
            public ParInfo[] newArray(int size) {
                return new ParInfo[size];
            }
        };   
    
    }
    

    4、传递List《Object》

    传递

        ArrayList<SerInfo> listObj = new ArrayList<SerInfo>();
    
        SerInfo serInfo1 = new SerInfo(name, website, weibo);
    
        SerInfo serInfo2 = new SerInfo(name, website, weibo);
    
        listObj.add(serInfo1);
    
        listObj.add(serInfo2);
    
        Intent intent = new Intent();
    
        intent.setClass(MainActivity.this, ResultActivity.class);
    
        intent.putExtra("listobj", (Serializable) listObj);
    
        startActivity(intent);
    

    接收

    ArrayList<SerInfo> listObj =  (ArrayList<SerInfo>) getIntent().getSerializableExtra("listobj"); 
    展开全文
  • 这次,先和大家分享如何通过协议实现对象之间的信息传递。 首先简单描述一下协议是什么。 协议是多个类共享的一个方法列表。协议中列出的方法没有相应的实现,需要由继承此协议的类来实现(所以定义协议的...


    在Objective C中,目前对象之间的通信方式主要是通过协议(Protocol)和块(blcok)。

    这次,先和大家分享如何通过协议实现对象之间的信息传递。

    首先简单描述一下协议是什么。

    协议是多个类共享的一个方法列表。协议中列出的方法没有相应的实现,需要由继承此协议的类来实现(所以定义协议的只有一个.h文件)。

    了解C#和Java的同学一看可能马上就想到了接口,其实在Objective C中,协议的概念和接口的概念是类似的,基本上可以类比过来。

    协议在.h文件中的定义看起来像下面这个样子,

    @protocol protocolName

    @optional

    method1

    ......

    @required

    method2

    ......

    @end

    首先简单解释一下@optional和@required关键字。当你使用了@optional关键字,那么下面声明的方法(例如,method1)都是继承此协议的类可选的实现的方法。也就是说,继承此协议的类既可以实现此方法也可以不实现此方法。那么如果使用@required关键字,则下面声明的方法(例如,method2)必须有继承此协议的类实现。当然了,这两个关键字你都可以不写,那么此时默认的方法就是可选择实现的方法,即继承此协议的方法既可以实现也可以不实现。

    上面是对协议的简单描述,那么具体如何在Objective C中使用协议进行消息传递呢?下面给出了一个简陋的例子,意在说明简单的实现流程。

    在这个例子中,涉及到两个类(Person类和Dog类)和一个协议(MyProtocol协议)。下面给出简单的实现。

    • MyProtocol协议

    1
    2
    3
    4
    #import <Foundation/Foundation.h>
    @protocol MyProtocol<NSObject>
    -(void)Bark;
    @end
    • Dog类接口

    1
    2
    3
    4
    5
    6
    7
    8
    9
    #import <Foundation/Foundation.h>
    #import "MyProtocol.h"
              
    @interfaceDog:NSObject
    id<MyProtocol> deleget;     //声明代理协议
    }
    -(void)SomthingHappen;
    -(void)SetHost:(id)host;    //设置狗的主人
    @end
    • Dog类实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #import "Dog.h"
            
    @implementation Dog
    -(void)SomthingHappen{
       [deleget Bark];      //代理协议调用Bark方法
    }
    -(void)SetHost:(id)host{
       deleget = host;
    }
    @end

    • Person类接口

    1
    2
    3
    4
    5
    #import <Foundation/Foundation.h>
    #import "MyProtocol.h"                 //此处引入MyProtocol协议
          
    @interface Person:NSObject<MyProtocol> //继承MyProtocol协议
    @end

    • Person类实现

    1
    2
    3
    4
    5
    6
    7
    #import "Person.h"
         
    @implementation Person
    -(void)Bark{               //此处实现MyProtocol协议中Bark方法
     NSLog(@"my dog is barking..");//当Dog对象调用SomthingHappen方法
    }                              //时会回调此处的Bark方法
    @end
    • Main方法调用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #import <Foundation/Foundation.h>
    #import "Person.h"
    #import "Dog.h"
    #import "MyProtocol.h"
      
    int main(int argc,const char *argv[])
    {
       @autoreleasepool{
          Person *p = [[Person alloc]init];
          Dog *dog = [[Dog alloc]init];
          [dog SetHost:p];     //设置代理对象为Person
          [dog SomthingHappen];//此方法可以回调Person中实现的Bark方法
      }
      return 0;
    }

    上述代码很简单,也只是简单的示意一下,协议(Protocol)的更多细节可以看这里。另外需要说明一下,上述代码实例是在ARC模式下实现的,所以没有考虑资源的释放,下次分享block概念的时候会在非ARC模式下演示,因为block的概念虽然像是方法,但是也需要进行资源释放,这一点很特别,虽然是小问题,但是却很重要。

    展开全文
  • 在Objective C中,目前对象之间...这次,先和大家分享如何通过协议实现对象之间的信息传递。 首先简单描述一下协议是什么。 协议是多个类共享的一个方法列表。协议中列出的方法没有相应的实现,需要由继
  • 在Activity之间通过Intent和Bundle能够很好地传递java支持的基础类型,但是有时候我们需要在Activity之间传递对象甚至传递对象列表。   传递对象 如果需要传递对象对象需要继承Serializable接口,在Bundle中有...
  • 本篇主要内容:使用Intent在activity之间传递对象的两种实现方式.Serializable和Parcalable.  1.Serializable  Serializable就是序列化的意思,表示将一个对象转换成科存储化或可传输的状态,序列化后的对象可以保存...
  • 在Activity之间传递对象

    千次阅读 2015-10-10 13:08:13
    今天来讲向一个Activity中传递对象在这里声明,如果一个对象要被传递,那么该对象必须通过Serializable接口或者Parcelable接口来实现对象的序列化。Serializable为JAVA提供的对象序列化接口:效率低 Parcelable为...
  • Activity等相关各组件之间通过Intent传递值,支持基本数据类型和String对象及它们的数组对象byte、byte[]、char、char[]、boolean、boolean[]、short、short[]、int、int[]、long、long[]、float、float[]、double、...
  • activity之间传递对象

    2015-10-20 14:58:48
    1.通过bundle来传递Serializable 序列化//创建对象, Car car = new Car(); car.setName(“宝马”); car.setPrice(“100万”);Intent intent = new Intent(MainActivity.this,SecondActivity.class); Bundle ...
  • 序列化:将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化,它将流转换为对象。这两个过程结合起来,可以轻松地存储和传输数据。 大家读不读得懂先暂且不说,因为概念什么的东西我也最烦了,...
  • Activity之间传递对象

    千次阅读 2013-01-24 16:33:45
    Activity之间通过Intent传递值,支持基本数据类型和String对象及它们的数组对象: byte、byte[];char、char[];boolean、boolean[];short、short[];int、int[];long、long[];float、float[];double、double[]...
  • 一个简单的对象存储,用于推送/弹出可通过唯一键访问的对象,对于在活动/服务和其他组件之间传递自定义对象非常有用。 灵感来自。 为什么选择 AndroidObjectStore 除了作为通用对象存储之外,该库还非常适合在...
  • // 被传递对象 window.open("xxx.html","_blank");  在被打开的页面里面,通过 window.opener 获的打开页面对象的引用: var parent = window.opener;// 获取打开页面的引用 var obj = parent.passObj;//...
  • Activity之间传递对象数组

    千次阅读 2013-09-16 20:15:10
    对于Android来说传递复杂类型,主要是将自己的类转换为基础的字节数组,Activity之间传递数据是通过Intent实现的。 Android序列化对象主要有两种方法,实现Serializable接口、或者实现Parcelable接口。实现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,663
精华内容 1,465
关键字:

对象之间通过传递