精华内容
下载资源
问答
  • 最近实践一个DDD项目,在领域层与持久层之间,Domain Model与Entity Model之间有时候需要进行属性值得拷贝,而这些属性,尽管它所在的类名称不一样,但它们的属性名和属性类型差不多都是一样的。系统中有不少这样的...

    最近实践一个DDD项目,在领域层与持久层之间,Domain Model与Entity Model之间有时候需要进行属性值得拷贝,而这些属性,尽管它所在的类名称不一样,但它们的属性名和属性类型差不多都是一样的。系统中有不少这样的Model需要相互转换,有朋友推荐使用AutoMapper,试了下果然不错,解决了问题,但作为一个老鸟,决定研究下实现原理,于是动手也来山寨一个。
    为了让这个“轮子”尽量有实用价值,效率肯定是需要考虑的,所以决定采用“反射+缓存+委托”的路子。

    第一次使用,肯定要反射出来对象的属性,这个简单,就下面的代码:

    Type targetType;
    //....
    PropertyInfo[] targetProperties = targetType.GetProperties(BindingFlags.Public | BindingFlags.Instance);

    这里只获取公开的实例对象的属性。

    要实现同名同类型的属性拷贝,那么需要把这些属性找出来,下面是完整的代码:

    复制代码
     public ModuleCast(Type sourceType, Type targetType)
            {
                PropertyInfo[] targetProperties = targetType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
                foreach (PropertyInfo sp in sourceType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
                {
                    foreach (PropertyInfo tp in targetProperties)
                    {
                        if (sp.Name == tp.Name && sp.PropertyType == tp.PropertyType)
                        {
                            CastProperty cp = new CastProperty();
                            cp.SourceProperty = new PropertyAccessorHandler(sp);
                            cp.TargetProperty = new PropertyAccessorHandler(tp);
                            mProperties.Add(cp);
                            break;
                        }
                    }
                }
            }
    复制代码

    这里使用了一个 CastProperty 类来保存要处理的源对象和目标对象,并且把这组对象放到一个CastProperty 列表的mProperties 静态对象里面缓存起来。
    下面是 CastProperty 类的定义:

    复制代码
    /// <summary>
            /// 转换属性对象
            /// </summary>
            public class CastProperty
            {
                public PropertyAccessorHandler SourceProperty
                {
                    get;
                    set;
                }
    
                public PropertyAccessorHandler TargetProperty
                {
                    get;
                    set;
                }
            }
    复制代码

    类本身很简单,关键就是这个属性访问器PropertyAccessorHandler 对象,下面是它的定义:

    复制代码
     /// <summary>
            /// 属性访问器
            /// </summary>
            public class PropertyAccessorHandler
            {
                public PropertyAccessorHandler(PropertyInfo propInfo)
                {
                    this.PropertyName = propInfo.Name;
                    //var obj = Activator.CreateInstance(classType);
                    //var getterType = typeof(FastPropertyAccessor.GetPropertyValue<>).MakeGenericType(propInfo.PropertyType);
                    //var setterType = typeof(FastPropertyAccessor.SetPropertyValue<>).MakeGenericType(propInfo.PropertyType);
    
                    //this.Getter = Delegate.CreateDelegate(getterType, null, propInfo.GetGetMethod());
                    //this.Setter = Delegate.CreateDelegate(setterType, null, propInfo.GetSetMethod());
    
                    if (propInfo.CanRead)
                        this.Getter = propInfo.GetValue;
    
                    if (propInfo.CanWrite)
                        this.Setter = propInfo.SetValue;
                }
                public string PropertyName { get; set; }
                public Func<object, object[], object> Getter { get; private set; }
                public Action<object, object, object[]> Setter { get; private set; }
            }
    复制代码

    在写这个类的时候,曾经走了好几次弯路,前期准备通过 Delegate.CreateDelegate 方式创建一个当前属性Get和Set方法的委托,但是经过数次测试发现,
    Delegate.CreateDelegate(getterType, obj, propInfo.GetGetMethod());

    这里的obj 要么是一个对象实例,要么是null,如果是null,那么这个委托定义只能绑定到类型的静态属性方法上;如果不是null,那么这个委托只能绑定到当前 obj 实例对象上,换句话说,如果将来用obj类型的另外一个实例对象,那么这个委托访问的还是之前那个obj 对象,跟新对象实例无关。
    PS:为了走这条“弯路”,前几天还特意写了一个FastPropertyAccessor,申明了2个泛型委托,来绑定属性的Get和Set方法,即上面注释掉的2行代码:

     var getterType = typeof(FastPropertyAccessor.GetPropertyValue<>).MakeGenericType(propInfo.PropertyType);
     var setterType = typeof(FastPropertyAccessor.SetPropertyValue<>).MakeGenericType(propInfo.PropertyType);

    好不容易将这个泛型委托创建出来了,编译也通过了,却发现最终没法使用,别提有多郁闷了:-《

    回归话题,有了PropertyAccessorHandler,那么我们只需要遍历当前要转换的目标类型的属性集合,就可以开始对属性进行拷贝了:

    复制代码
     public void Cast(object source, object target)
            {
                if (source == null)
                    throw new ArgumentNullException("source");
                if (target == null)
                    throw new ArgumentNullException("target");
    
                for (int i = 0; i < mProperties.Count; i++)
                {
                    CastProperty cp = mProperties[i];
                    if (cp.SourceProperty.Getter != null)
                    {
                        object Value = cp.SourceProperty.Getter(source, null); //PropertyInfo.GetValue(source,null);
                        if (cp.TargetProperty.Setter != null)
                            cp.TargetProperty.Setter(target, Value, null);// PropertyInfo.SetValue(target,Value ,null);
                    }
                }
            }
    复制代码

    上面的代码会判断属性的Set访问器是否可用,可用的话才复制值,所以可以解决“只读属性”的问题。

    注意:这里只是直接复制了属性的值,对应的引用类型而言自然也只是复制了属性的引用,所以这是一个“浅表拷贝”。

    现在,主要的代码都有了,因为我们缓存了执行类型对象的属性访问方法的委托,所以我们的这个“属性值拷贝程序”具有很高的效率,有关委托的效率测试,在前一篇
    《使用泛型委托,构筑最快的通用属性访问器》 http://www.cnblogs.com/bluedoctor/archive/2012/12/18/2823325.html
    已经做了测试,大家可以去看看测试结果,缓存后的委托方法,效率非常高的。

    为了让该小程序更好用,又写了个扩展方法,让Object类型的对象都可以方便的进行属性值拷贝

    复制代码
        /// <summary>
        /// 对象转换扩展
        /// </summary>
        public static class ModuleCastExtension
        {
            /// <summary>
            /// 将当前对象的属性值复制到目标对象,使用浅表复制
            /// </summary>
            /// <typeparam name="T">目标对象类型</typeparam>
            /// <param name="source">源对象</param>
            /// <param name="target">目标对象,如果为空,将生成一个</param>
            /// <returns>复制过后的目标对象</returns>
            public static T CopyTo<T>(this object source, T target = null) where T : class,new()
            {
                if (source == null)
                    throw new ArgumentNullException("source");
                if (target == null)
                    target = new T();
                ModuleCast.GetCast(source.GetType(), typeof(T)).Cast(source, target);
                return target;
            }
        }
    复制代码

    这样,该小程序可以象下面以几种不同的形式来使用了:

    复制代码
             //      下面几种用法一样:
             ModuleCast.GetCast(typeof(CarInfo), typeof(ImplCarInfo)).Cast(info, ic);
             ModuleCast.CastObject<CarInfo, ImplCarInfo>(info, ic);
             ModuleCast.CastObject(info, ic);
        
            ImplCarInfo icResult= info.CopyTo<ImplCarInfo>(null);
      
             ImplCarInfo icResult2 = new ImplCarInfo();
             info.CopyTo<ImplCarInfo>(icResult2);
    复制代码

    完整的代码下载,请看这里

    补充:

    经网友使用发现,需要增加一些不能拷贝的属性功能,下面我简单的改写了下原来的代码(这些代码没有包括在上面的下载中):

    复制代码
    /// <summary>
            /// 将源类型的属性值转换给目标类型同名的属性
            /// </summary>
            /// <param name="source"></param>
            /// <param name="target"></param>
            public void Cast(object source, object target)
            {
                Cast(source, target, null);
            }
    
            /// <summary>
            /// 将源类型的属性值转换给目标类型同名的属性,排除要过滤的属性名称
            /// </summary>
            /// <param name="source"></param>
            /// <param name="target"></param>
            /// <param name="filter">要过滤的属性名称</param>
            public void Cast(object source, object target,string[] filter)
            {
                if (source == null)
                    throw new ArgumentNullException("source");
                if (target == null)
                    throw new ArgumentNullException("target");
    
                for (int i = 0; i < mProperties.Count; i++)
                {
                    CastProperty cp = mProperties[i];
                    
                    if (cp.SourceProperty.Getter != null)
                    {
                        object Value = cp.SourceProperty.Getter(source, null); //PropertyInfo.GetValue(source,null);
                        if (cp.TargetProperty.Setter != null)
                        {
                            if (filter == null)
                                cp.TargetProperty.Setter(target, Value, null);
                            else if (!filter.Contains(cp.TargetProperty.PropertyName))
                                cp.TargetProperty.Setter(target, Value, null);
                        
                        }
                    }
                }
            }
    复制代码

    然后这修改一下那个扩展方法:

    复制代码
     public static T CopyTo<T>(this object source, T target = null,string[] filter=null) where T : class,new()
            {
                if (source == null)
                    throw new ArgumentNullException("source");
                if (target == null)
                    target = new T();
                ModuleCast.GetCast(source.GetType(), typeof(T)).Cast(source, target, filter);
                return target;
            }
    复制代码

     

    最后,这样调用即可:

    复制代码
        class Program
        {
            static void Main(string[] args)
            {
                A a = new A() {  Name="aaa", NoCopyName="no.no.no."};
                var b = a.CopyTo<B>(filter: new string[] { "NoCopyName" });
            }
        }
    
        class A
        {
           public string Name { get; set; }
           public string NoCopyName { get; set; }
           public DateTime GetTime { get { return DateTime.Now; } }
        }
    
        class B
        {
            public string Name { get; set; }
            public string NoCopyName { get; set; }
            public DateTime GetTime { get { return DateTime.Now; } }
        }
    复制代码

     

    filter 是一个可选参数,可以不提供。

    ----------------------------分界线-----------------------------------------------

    本文能够写成,特别感谢网友 “泥水佬”和“海华”的支持,他们在关键思路上提供了帮助。

    欢迎加入PDF.NET开源技术团队,做最快最轻的数据框架!

    展开全文
  • 在处理业务逻辑时,偶尔会有这样的需求:对象A已经实例化,但是有一些格式上的不符合标准,对象B没有具体的属性值但是格式却符合标准。 一般这样的情况会出现在DTO对象与VO对象之间。DTO需要实现序列化才可以传输。...

    在处理业务逻辑时,偶尔会有这样的需求:对象A已经实例化,但是有一些格式上的不符合标准,对象B没有具体的属性值但是格式却符合标准。

    一般这样的情况会出现在DTO对象与VO对象之间。DTO需要实现序列化才可以传输。

    这时候就需要对象属性的拷贝:

    public static void copyProperties(Object source, Object target) throws BeansException {  
    		    Assert.notNull(source, "Source must not be null");  
    		    Assert.notNull(target, "Target must not be null");  
    		    Class<?> actualEditable = target.getClass();  
    		    PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);  //得到属性数组
    		    for (PropertyDescriptor targetPd : targetPds) {//通过循环对属性一一赋值
    				if (targetPd.getWriteMethod() != null) {//针对某属性,目标对象是否具有写方法(setter)
    					PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
    		        if (sourcePd != null && sourcePd.getReadMethod() != null) {//源对象是否具有读方法(getter)
    					try {
    		            Method readMethod = sourcePd.getReadMethod();  
    		            if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {  
    		              readMethod.setAccessible(true);  //强制修改getter的修饰符为public
    		            }  
    		            Object value = readMethod.invoke(source);//获取属性值
    						// 这里判断以下value是否为空 当然这里也能进行一些特殊要求的处理 例如绑定时格式转换等等
    		            if (value != null) {  
    		              Method writeMethod = targetPd.getWriteMethod();  
    		              if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {  
    		                writeMethod.setAccessible(true);  //强制修改setter方法的修饰符为public
    		              }  
    		              writeMethod.invoke(target, value);//赋值
    					}
    		          } catch (Throwable ex) {  
    		            throw new FatalBeanException("Could not copy properties from source to target", ex);  
    		          }  
    		        }  
    		      }  
    		    }  
    		  } 
    顺便体会一下java反射机制的强大。
    展开全文
  • /** * ComUtil class * * @author xxxxx * @date 2020.03.10 22:38 */ public class ComUtil { /** * 用于将一个类中具有相同属性名和类型的值拷贝到另一个类中 * * @param source 被复制属性的类 * @param target ...

    该工具类中包括了怎么从泛型类型中通过反射获取泛型类型。

    import java.lang.reflect.Field;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * ComUtil class
     *
     * @author xxxxx
     * @date 2020.03.10 22:38
     */
    public class ComUtil {
    
        /**
         * 用于将一个类中具有相同属性名和类型的值拷贝到另一个类中
         *
         * @param source 被复制属性的类
         * @param target 需要获取属性的类
         * @throws Exception
         */
        public static void copyProperties(Object source, Object target) throws Exception {
            if (source == null || target == null) {
                throw new Exception("传入的 source 或 target 中有为 null 的对象");
            }
            // 获取 source 和 target 的属性列表
            Field[] sourFields = source.getClass().getDeclaredFields();
            Field[] tarFields = target.getClass().getDeclaredFields();
    
            // 将 source 的属性对象为 value,属性名为 key 封装为 map
            Map<String, Field> sourFieldMap = new HashMap<>(16);
            for (Field sourField : sourFields) {
                // 获取属性名
                String fieldName = sourField.getName();
                sourFieldMap.put(fieldName, sourField);
            }
    
            for (Field tarField : tarFields) {
                // 获取属性名
                String fieldName = tarField.getName();
                // 从 sourFieldMap 中通过 fieldName 取值,若能取出表示存在相同的属性名
                Field sourField = sourFieldMap.get(fieldName);
                if (sourField != null) {
                    // 获取 List 泛型类型
                    Class tarGenericClass = getGenericClass(tarField);
                    Class sourGenericClass = getGenericClass(sourField);
    
                    // 获取属性声明的类型 Class 对象
                    Class<?> sourType = sourField.getType();
                    Class<?> tarType = tarField.getType();
    
                    // 获取权限
                    sourField.setAccessible(true);
                    tarField.setAccessible(true);
    
                    // 若不是 List 或其父接口类型,为 null
                    if (tarGenericClass == null && sourGenericClass == null) {
                        // target 属性类型是 source 属性类型的子类或子接口
                        if (sourType.isAssignableFrom(tarType)) {
                            tarField.set(target, sourField.get(source));
                        }
                    } else if (tarGenericClass != null && sourGenericClass != null) {
                        // Iterable 是 List 最顶层接口,在 sourGenericClass 中判断是声明类型是 List 或其父接口
                        Iterable sourList = (Iterable) sourField.get(source);
                        if (sourList == null) {
                            continue;
                        }
                        // 该集合用于添加 target 拷贝的对象
                        List tarList = new ArrayList();
                        // 遍历 sourList,取出每个泛型对象
                        for (Object sourObj : sourList) {
                            // 创建 target List 集合泛型实例
                            Object tarObj = tarGenericClass.newInstance();
                            // 递归调用本方法,将相同属性名赋值
                            copyProperties(sourObj, tarObj);
                            // 将实例对象添加到集合中
                            tarList.add(tarObj);
                        }
                        // 将集合赋值给 target 同名的属性
                        tarField.set(target, tarList);
                    }
                }
            }
    
        }
    
        /**
         * 获取属性类型中的泛型类型,获取泛型的过程适用于其他类型,但是本方法仅适用于 List 集合,
         * 并且只有一个泛型的情况,若有需求后续增加功能。
         *
         * @param field
         * @return
         * @throws Exception
         */
        private static Class getGenericClass(Field field) throws Exception {
            // 获取属性声明的类型 Class 对象
            Class<?> type = field.getType();
            // 判断该 type 是否是 List 或其父接口
            if (type.isAssignableFrom(List.class)) {
    
                // 获取该属性声明的类型(Type 接口),getType():是获取属性声明的类型 Class 对象
                Type genericType = field.getGenericType();
                if (genericType == null) {
                    return null;
                }
                // 判断 geneicType 是否是参数化类型,即明确指定泛型的类型,如:java.util.List<java.lang.String>
                if (genericType instanceof ParameterizedType) {
    
                    //因为 genericType 是 ParameterizedType 的实例,故可以强转
                    ParameterizedType pt = (ParameterizedType) genericType;
    
                    // 获取泛型的类型数组
                    Type[] genericArgs = pt.getActualTypeArguments();
    
                    // 当泛型类型大于 1 个时,抛出异常
                    if (genericArgs.length > 1) {
                        throw new Exception(genericType + "  " + field.getName() + ": 泛型不只一个无法赋值");
                    }
    
                    // 当只有一个泛型类型时,获取泛型类型
                    return (Class) genericArgs[0];
                }
            }
            return null;
        }
    }
    
    展开全文
  • 在python继承中,子类的init()方法...1.如果在子类的构造函数中需要初始化父类的属性,一般需要使用super,是否可以使用同名属性来进行初始化。 看几个例子: 使用self.value复制的方式: class P(object): ...

    在python继承中,子类的init()方法中需要初始化父类的属性,常常会用到super(child, self).init(arg1, arg2)这样的方法。

    下面思考一下如下几个问题:

    1.如果在子类的构造函数中需要初始化父类的属性,一般需要使用super,是否可以使用同名的属性来进行初始化。
    看几个例子:
    使用self.value复制的方式:

    class P(object):
    
        def __init__(self):
            self.value = 0
            print "++++++"
            print id(self.value)
    
        def get(self):
            print "p get"
            print self.value
            return id(self.value)
    
    
    class C(P):
    
        def __init__(self):
            print "start"
            self.value = 44 #两句交换一下位置看看
            #super(C, self).__init__() #标准的写法是这样的, 先调用父类构造函数
            print id(self.value)
            print "======="
            print id(self.value)
    
        def get(self):
            print "c get"
            print self.value
            return id(self.value)
    
        def getsuper(self):
            return super(C, self).get()
    
    c = C()
    print c.get()
    print "----------"
    print c.getsuper()

    输出结果:

    ➜  ~ python object.py
    start
    19263528
    =======
    19263528
    c get
    44
    19263528
    ----------
    p get
    44
    19263528

    分析结果:
    从结果可以看到,父类和子类的同名成员是同一个id。


    使用super方式,修改一下代码:

    class P(object):
    
        def __init__(self):
            self.value = 0
            print "++++++"
            print id(self.value)
    
        def get(self):
            print "p get"
            print self.value
            return id(self.value)
    
    
    class C(P):
    
        def __init__(self):
            print "start"
            #self.value = 44 #两句交换一下位置看看
            super(C, self).__init__() #标准的写法是这样的, 先调用父类构造函数
            print id(self.value)
            print "======="
            print id(self.value)
    
        def get(self):
            print "c get"
            print self.value
            return id(self.value)
    
        def getsuper(self):
            return super(C, self).get()
    c = C()
    print c.get()
    print "----------"
    print c.getsuper()

    输出结果:

    ➜  ~ python object.py
    start
    ++++++
    22908032
    22908032
    =======
    22908032
    c get
    0
    22908032
    ----------
    p get
    0
    22908032

    分析结果:
    如果使用super来初始化父类属性,可以看到,结果是一样的。


    如果有两个初始化的操作

    class P(object):
    
        def __init__(self):
            self.value = 0
            print "++++++"
            print id(self.value)
    
        def get(self):
            print "p get"
            print self.value
            return id(self.value)
    
    
    class C(P):
    
        def __init__(self):
            super(C, self).__init__() #标准的写法是这样的, 先调用父类构造函数
            print "start"
            self.value = 44 #两句交换一下位置看看
            print id(self.value)
            print "======="
            print id(self.value)
    
        def get(self):
            print "c get"
            print self.value
            return id(self.value)
    
        def getsuper(self):
            return super(C, self).get()
    c = C()
    print c.get()
    print "----------"
    print c.getsuper()

    输出结果:

    ➜  ~ python object.py
    ++++++
    10316928
    start
    10317864
    =======
    10317864
    c get
    44
    10317864
    ----------
    p get
    44
    10317864

    分析结果:
    可以看出来结果有些不同,这是因为后一个初始化方法会覆盖前一个初始化方法。即self.value会覆盖super(C, self)._init_(),所以会有两个id,但是get方法得到的都是id,都是后面一个value的id。


    2.为什么一般都是用super这种方式来初始化父类的属性,而不用self.value = xxx这种方式。

    该例子中是因为父类的属性并不是特别多,所以并没有什么影响,如果子类需要继承的父类属性较多,可能就会比较麻烦,所以我们一般使用super来初始化父类属性。

    展开全文
  • delete运算符,可以删除对象属性。它的操作数应当是一个属性访问表达式。delete只是断开属性和宿主对象的联系,而不会去操作属性中的属性: delete book.author;//book不再有属性author delete book["main...
  • 类和对象、方法和属性

    千次阅读 2018-07-30 17:06:08
    2、类:具有相似属性和方法的对象的集合  是具有相同数据成员和函数成员的一组对象的集合,它为属于该类的全部对象提供了抽象的描述。 3、面向对象程序设计的特点:封装 继承 多态  封装:面向对象技术中的封装...
  • 对象是JS的基本数据类型。对象是一种复合值,ta
  • 单继承在python中 来类中 子类继承了父类 子类就拥有了父类的属性和方法格式: class 子类名(父类名):class Prentice(Master): pass单继承 就是只有一个父类多继承多继承格式: class 子类名(父类1, 父类2, ...):...
  • import org.springframework.beans.BeanUtils; BeanUtils.copyProperties(源对象, 目标对象);
  • 属性对象具有的各种特征 每个对象的每个属性都有特定值;例如小红和小明的年龄,姓名不一样 方法:对象执行的操作 类:--------抽象 类是对象概括,是对象的分类 具有相同属性和方法的一组对象的集合 是概念...
  • Scala的类、属性对象字段

    千次阅读 2018-06-12 16:43:11
    转载自:类、属性对象字段1 类(class)1.1 定义类 Scala是一种纯粹的面向对象编程语言,而又无缝地结合了命令式和函数式的编程风格。在面向对象的语言有两个重要的概念:类(class)和对象(object也被称为实例—...
  • js中Object对象常用方法和属性

    千次阅读 2018-11-14 11:53:54
    1、属性 Object.prototype.writable:默认为false Object.prototype.enumerable:默认为false Object.prototype.configurable:默认为false Object.prototype.constructor:用于创建一个对象的原型。 2、常用方法 ...
  • 两个对象的相同属性赋值

    千次阅读 2019-07-08 15:58:29
    利用BeanUtils在对象间复制属性 commons-beanutils是jakarta commons子项目中的一个软件包,其主要目的是利用反射机制对JavaBean的属性进行处理。我们知道,一个JavaBean通常包含了大量的属性,很多情况下,对Java....
  • 这样的吧,这有一种专业说法,叫“父类引用指向子类对象”。 首先 new Son();是肯定动态创建了一个子类对象的 。 Father father 则是一个创建了一个父类引用对象。 Father father = new Son(); 就是将父类引用指向...
  • Java 对象之间相同属性的赋值

    千次阅读 2018-09-06 15:03:31
    1.BeanUtils.copyProperties import org.springframework.beans.BeanUtils; User src = new User(); User dest = new User();...项目应用场景:将具有相同属性的ProductVO 转为Product。(Produc...
  • java 复制一个类中的属性给另一个具有相同属性的类。java 复制一个类中的属性给另一个具有相同属性的类。基于反射实现。
  • 阅读这篇文章是因为在工作中,需要通过document.getElementsByID,获取foreach中每一条数据,然后改变其样式,但是发现只有第一条数据生效,其他数据属性都是null,通过分析之后给foreach中加入动态id,之后找到下面...
  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 方法:类中定义的函数。 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中...
  • 在开发的时候可能会出现将一个类的属性值,复制给另外一个类的属性值,这在...1、首先有两个类,两个类之间有相同的属性名和类型,也有不同属性名很类型:public class ClassTestCopy2 { private int id; private
  • Scala教程(六)类、属性对象字段

    千次阅读 2015-09-22 10:40:28
    在Scala可以通过类与同名的“伴生”对象来达到同样的目的。类和它的伴生对象可以互相访问私有特性。它们必须在于同一个源文件中。 scala继承(extends):子类继承父类的特征和行为,使得子类具有
  • 本文转自:... 在开发过程中我们经常会遇到表单提交数据时,具有相同属性名的两个对象。 先创建两个对象,用户和产品 public class User { private Integer id; private String name; public In...
  • 两个具有相同属性的类互相转换

    千次阅读 2013-01-15 15:45:00
    在工作中遇到两个类具有相同的属性,但是是不同的两个类,属性很多,互相转换起来很麻烦,于是就想到了下面的办法,实现他们的互相转换,请指教: public static List<T2> ConvertT1ToT2<T1, T2>(List&...
  • 面向对象编程 常用术语/名词解释 抽象/实现 封装/接口 合成 派生/继承/继承结构 泛化/特化 多态 自省/反射 访问限制 私有属性和公有属性 私有方法的设置 类 创建类 声明与定义 类属性 类的数据属性 ...
  • 需求: 以相同的date(日期)进行分类 源数据: ... //新建属性名 if (Object.keys(newData).indexOf('' + e.date) === -1) { newData[e.date] = [] } //对应插入属性值 newData[e.date].push(e)...
  • JavaScript对象具有“自有属性”,也有一些属性是从原型对象上继承过来的。 假设要查询对象O的属性X,如果在O中不存在x,那么将会继续从原型对象中查找属性X,如果原型对象中也没有x,但这个原型对象也有原型,那么...
  • 面向对象的程序设计

    千次阅读 2016-10-14 23:37:10
    ECMA-262把对象定义为:”无序属性的集合,其属性可以包含基本值、对象或者函数。”一、理解对象1. 属性类型ECMAScript中有两种属性:数据属性和访问器属性。 数据属性包含一个值;访问器属性不包含值而定义了一个...
  • 继承概念、特点、作用   继承的基本概念:继承指一个对象直接使用另一对象属性和方法   继承的作用:继承是面向对象语言的...继承机制规定,子类可以拥有父类的所有属性和方法,也可以扩展定义自己特有的属性
  • 深入理解Java类型信息(Class对象)与反射机制

    万次阅读 多人点赞 2017-05-01 23:19:19
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ...深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,167
精华内容 29,266
关键字:

不同对象可以具有同名的属性