精华内容
下载资源
问答
  • JAVA类属性和对象属性的初始化顺序

    千次阅读 2016-07-14 16:11:50
    1)属性(静态变量)定义时的初始化,如:static String ="string-a"; 2)static块中的初始化代码,如 ...3)对象属性(非静态变量)定义时的初始化,如:static c="string -c"; 4)构造方法(函数)中的初始化代码,

    1)类属性(静态变量)定义时的初始化,如:static String ="string-a";

    2)static块中的初始化代码,如

    static{

    string b="string -b";

    }

    3)对象属性(非静态变量)定义时的初始化,如:static c="string -c";

    4)构造方法(函数)中的初始化代码,


    展开全文
  • java 对象属性 属性

    千次阅读 2019-08-09 09:50:18
    对象属性:又叫实例属性,非静态属性。 如果一个属性声明成属性,那么所以的对象,都共享这么一个值。 给所以英雄设置一个属性叫做“版权(copyright)”,那么无论有多少具体的英雄,所以的英雄的版权都属于Riot...

    1,定义

    类属性:又叫做静态属性,即被static修饰。

    对象属性:又叫实例属性,非静态属性。

    如果一个属性声明成类属性,那么所以的对象,都共享这么一个值。

    给所以英雄设置一个类属性叫做“版权(copyright)”,那么无论有多少具体的英雄,所以的英雄的版权都属于Riot Games公司。

    2,访问类属性

    1),对象.类属性

    temoo.copyright;
    

    2),类.类属性

    Hero.copyright;
        这两种方式都可以访问类属性,访问即修改和获取,但建议使用第二种  类.类属性  的方式进行,这样更符合语义上的理解。

    3,什么时候用对象属性,什么时候用类属性

    如果一个属性,每一个英雄都不一样,比如name,这样的属性就应该设计为对象属性,因为它是 跟着对象走的 ,每个对象的name都是不一样的。

    如果一个属性,所有的英雄都共享,都是一样的,那么就应该设计为类属性,比如说英雄的血量上限都是9999,不会因为英雄不同而取不同的值。这样的属性,就适合设计为类属性。

    版权声明:本文为CSDN博主「宇智波爱编程」的原创文章,遵循CC 4.0 by-sa版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/weixin_39590058/article/details/79861723

    展开全文
  • java对象复制和属性值复制工具

    千次阅读 2017-11-30 16:19:10
    两个不同类型的对象中有字段名称不区分大小写的情况下一样,字段含义一样,需要组装到另一个对象中去,然后就写了一个这种工具 我的类型比较特殊,老系统和新系统的对象命名大小写命名不一致,并且字段相同类型也...

    两个不同类型的对象中有字段名称不区分大小写的情况下一样,字段含义一样,需要组装到另一个对象中去,然后就写了一个这种工具类
    我的类型比较特殊,老系统和新系统的对象命名大小写命名不一致,并且字段相同类型也有不一致的情况,所以自己写了一个,
    不是很完美基本能用。

    温馨提示:
    如果同一种类型的对象 属性字段名equals相等 并且类型一致。则完全可以用commons-beanutils包或者spring包中
    的BeanUtils工具类中的copey属性方法。

    /**
     * 实体类字段值相同的复制
     *
     * @author 隔壁老王 2017年8月18日
     */
    public class CopyBeanUtil {
        static Logger log = LoggerFactory.getLogger(CopyBeanUtil.class);
    
        /**
         * 复制sour里属性不为空的值到obje为空的属性
         *
         * @param obje    目标实体类
         * @param sour    源实体类
         * @param isCover 是否保留obje类里不为null的属性值(true为保留源值,属性为null则赋值)
         * @return obje
         */
        public static Object Copy(Object obje, Object sour, boolean isCover) {
            Field[] fields = sour.getClass().getDeclaredFields();
            for (int i = 0, j = fields.length; i < j; i++) {
                String propertyName = fields[i].getName();
                Object propertyValue = getProperty(sour, propertyName);
                if (isCover) {
                    if (getProperty(obje, propertyName) == null && propertyValue != null) {
                        Object setProperty = setProperty(obje, propertyName, propertyValue);
                    }
                } else {
                    Object setProperty = setProperty(obje, propertyName, propertyValue);
                }
    
            }
            return obje;
        }
    
        /**
         * 复制sour里属性不为空的值到obj里并相加
         *
         * @param obj     目标实体类
         * @param sour    源实体类
         * @param isCover
         * @return obj
         */
        public static Object CopyAndAdd(Object obj, Object sour, boolean isCover) {
            Field[] fields = sour.getClass().getDeclaredFields();
            for (int i = 0, j = fields.length; i < j; i++) {
                String propertyName = fields[i].getName();
                Object sourPropertyValue = getProperty(sour, propertyName);
                Object objPropertyValue = getProperty(obj, propertyName);
                if (isCover) {
                    if (objPropertyValue == null && sourPropertyValue != null) {
                        Object setProperty = setProperty(obj, propertyName, sourPropertyValue);
                    } else if (objPropertyValue != null && sourPropertyValue == null) {
                        Object setProperty = setProperty(obj, propertyName, objPropertyValue);
                    } else if (objPropertyValue != null && sourPropertyValue != null) {
                        Object setProperty = setProperty(obj, propertyName, ((int) sourPropertyValue) + (int) objPropertyValue);
                    }
                }
    
            }
            return obj;
        }
    
    
        /**
         * 得到值
         *
         * @param bean
         * @param propertyName
         * @return
         */
        private static Object getProperty(Object bean, String propertyName) {
            Class clazz = bean.getClass();
            try {
                Field field = clazz.getDeclaredField(propertyName);
                Method method = clazz.getDeclaredMethod(getGetterName(field.getName(),field.getType()), new Class[]{});
                return method.invoke(bean, new Object[]{});
            } catch (Exception e) {
            }
            return null;
        }
    
        /**
         * 给bean赋值
         *
         * @param bean
         * @param propertyName
         * @param value
         * @return
         */
        private static Object setProperty(Object bean, String propertyName, Object value) {
            Class clazz = bean.getClass();
            try {
                Field field = clazz.getDeclaredField(propertyName);
                Method method = clazz.getDeclaredMethod(getSetterName(field.getName()), new Class[]{field.getType()});
                return method.invoke(bean, new Object[]{value});
            } catch (Exception e) {
            }
            return null;
        }
    
        /**
         * 根据变量名得到get方法
         *
         * @param propertyName
         * @return
         */
        private static String getGetterName(String propertyName) {
            String method ;
            if( propertyName.length()>1&& Character.isUpperCase(propertyName.charAt(1))){
                 method = "get" +propertyName;
            }else{
                method = "get" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            }
            return method;
        }
    
        /**
         * 根据变量名和类型获取getter方法
         * @param propertyName
         * @param type
         * @return
         */
        private static String getGetterName(String propertyName, Class<?> type) {
            String method ;
            if(type==Boolean.class|| type==boolean.class){
                if("is".equalsIgnoreCase(propertyName.substring(0, 2))){
                    return propertyName;
                }else{
                    return "is" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
                }
    
            }
            if( propertyName.length()>1&& Character.isUpperCase(propertyName.charAt(1))){
                method = "get" +propertyName;
            }else{
                method = "get" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            }
            return method;
        }
    
        /**
         * 得到setter方法
         *
         * @param propertyName 变量名
         * @return
         */
        private static String getSetterName(String propertyName) {
    //        String method = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            String method ;
            if( propertyName.length()>1&& Character.isUpperCase(propertyName.charAt(1))){
                method = "set" +propertyName;
            }else{
                method = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            }
            return method;
        }
    
    
        /**
         * 父类集合转成子类集合集合通用方法(子类集合接收父类集合)
         *
         * @param list 父类集合
         * @param <T>  子类
         * @param <E>  父类
         * @return
         */
        public static <T, E> List<T> chang2ChildClassList(List<E> list) {
            List<T> alist = new ArrayList<>();
            for (E o : list) {
                alist.add((T) o);
            }
            return alist;
    
        }
    
        /**
         * 属性copy  复制sour里属性和obje里属性值忽略大小写相同的 ,不为空的值赋值到obje里
         * 如果存在属性复杂类型并为有效值慎用或改进
         *
         * @param obje
         * @param sour
         * @param isCover 是否保留obje里面属性值不为空的字段值
         * @return
         */
        public static Object copyByIgnoreCase(Object obje, Object sour, boolean isCover) {
    
            try {
                Field[] objFields = obje.getClass().getDeclaredFields();
    
                Field[] sourFields = sour.getClass().getDeclaredFields();
                for (int i = 0; i < sourFields.length; i++) {
                    String sourPropertyName = sourFields[i].getName();
                    //获取来源对象的属性值
                    Object propertyValue = getSourPropertyValue(sour, sourPropertyName);
                    for (int j = 0; j < objFields.length; j++) {
    
                        try {
                            String objPropertyName = objFields[j].getName();
                            if (objPropertyName.equalsIgnoreCase(sourPropertyName)) {
                                if (isCover) {
                                    if (getProperty(obje, objPropertyName) == null && propertyValue != null) {
                                        setObjProperty(obje, objPropertyName, propertyValue);
                                    }
                                } else {
                                    setObjProperty(obje, objPropertyName, propertyValue);
                                }
                                break;
                            }
                        } catch (Exception e) {
                            log.error("给目标bean赋值出错,objPropertyName:{},value:{}",sourPropertyName,propertyValue,e);
                            e.printStackTrace();
                        }
                    }
    
                }
            } catch (SecurityException e) {
                e.printStackTrace();
                log.error("给目标bean赋值出错,obje:{},sour:{}", JSON.toJSONString(obje), JSON.toJSONString(sour),e);
            }
            return obje;
        }
    
        /**
         * 根据属性名获取的值
         *
         * @param sourceBean
         * @param sourcePropertyName
         * @return
         */
        private static Object getSourPropertyValue(Object sourceBean, String sourcePropertyName) {
            Class clazz = sourceBean.getClass();
            try {
                Field field = clazz.getDeclaredField(sourcePropertyName);
                Method method = clazz.getDeclaredMethod(getGetterName(field.getName(),field.getType()), new Class[]{});
                return method.invoke(sourceBean, new Object[]{});
            } catch (Exception e) {
                log.error("获取属性名(不区分大小写)相似的值赋值出差", e);
            }
            return null;
        }
    
    
    
        /**
         * 给目标bean赋值
         *
         * @param objBean
         * @param sourcePropertyName
         * @param value
         * @return
         */
        private static Object setObjPropertyBySourceProperty(Object objBean, String sourcePropertyName, Object value) {
            Class clazz = objBean.getClass();
            Field[] fields = clazz.getDeclaredFields();
            try {
                for (int i = 0, j = fields.length; i < j; i++) {
                    String propertyName = fields[i].getName();
                    if (sourcePropertyName.equalsIgnoreCase(propertyName)) {
                        Field field = clazz.getDeclaredField(propertyName);
                        if (field.getType() == BigDecimal.class) {
                            if (value instanceof String) {
                                value = new BigDecimal(String.valueOf(value));
                            } else if (value instanceof Integer || value instanceof Double) {
    //							传double直接new BigDecimal,数会变大
                                value = BigDecimal.valueOf(Double.parseDouble(String.valueOf(value)));
                            }
                        }
                        if (field.getType() == Double.class || field.getType() == double.class) {
                            if (value instanceof BigDecimal) {
                                DecimalFormat df = new DecimalFormat("#.000000");
                                Double v = Double.parseDouble(String.valueOf(value));
                                value = df.format(v);
                            }
                        }
    
                        Method method = clazz.getDeclaredMethod(getSetterName(field.getName()), new Class[]{field.getType()});
                        return method.invoke(objBean, new Object[]{value});
                    }
                }
    
            } catch (Exception e) {
            }
            return null;
        }
    
    
        /**
         * 给目标bean赋值
         *
         * @param objBean
         * @param propertyName
         * @param value
         * @return
         */
        private static Object setObjProperty(Object objBean, String propertyName, Object value) {
            Class clazz = objBean.getClass();
            try {
                Field field = clazz.getDeclaredField(propertyName);
                if (field.getType() == BigDecimal.class) {
                    if (value instanceof String) {
                        value = new BigDecimal(String.valueOf(value));
                    } else if (value instanceof Integer || value instanceof Double) {
    //							传double直接new BigDecimal,数会变大
                        value = BigDecimal.valueOf(Double.parseDouble(String.valueOf(value)));
                    }
                }
                if (field.getType() == Double.class || field.getType() == double.class) {
                    if (value instanceof BigDecimal) {
                        DecimalFormat df = new DecimalFormat("#.000000");
                        Double v = Double.parseDouble(String.valueOf(value));
                        value =new BigDecimal(df.format(v));
                    }
                }
                if (field.getType() == Integer.class || field.getType() == int.class) {
                    if (value instanceof Float) {
                         value = Math.round(Float.parseFloat(String.valueOf(value)));
                    }
                }
                Method method = clazz.getDeclaredMethod(getSetterName(field.getName()), new Class[]{field.getType()});
                log.info("给目标bean赋值,propertyName:{},value:{}",propertyName,value);
                Object obj = method.invoke(objBean, new Object[]{value});
                return obj;
    
            } catch (Exception e) {
                log.error("给目标bean赋值出错,propertyName:{},value:{}",propertyName,value,e);
            }
            return null;
        }
        public static void main(String[] args) {
    //        ReAlarmResult re= new ReAlarmResult();
    //        re.setAlarmContent("sdfsdfsd");
    //        re.setBlat(2.234343);
    //        re.setBlon(34.34324);
    //        ReAlarmResult s = new ReAlarmResult();
    //        s.setAlarmContent("222");
    //        copyByIgnoreCase(s,re,true);
    //        System.out.printf(JSON.toJSONString(s));
    //        BeanUtils.copyProperties();
            //BeanUtils.copyProperties();
        }
    
    }
    
    展开全文
  • java属性与对象属性

    千次阅读 2018-04-09 09:54:59
     对象属性:又叫实例属性,非静态属性。 如果一个属性声明成属性,那么所以的对象,都共享这么一个值。 给所以英雄设置一个属性叫做“版权(copyright)”,那么无论有多少具体的英雄,所以的英雄的版权都属于...

    1,定义

        类属性:又叫做静态属性,即被static修饰。

        对象属性:又叫实例属性,非静态属性。

        如果一个属性声明成类属性,那么所以的对象,都共享这么一个值。

        给所以英雄设置一个类属性叫做“版权(copyright)”,那么无论有多少具体的英雄,所以的英雄的版权都属于Riot Games公司。

    2,访问类属性

        1),对象.类属性

    	temoo.copyright;
    

        2),类.类属性

    Hero.copyright;

        这两种方式都可以访问类属性,访问即修改和获取,但建议使用第二种  类.类属性  的方式进行,这样更符合语义上的理解。

    3,什么时候用对象属性,什么时候用类属性

        如果一个属性,每一个英雄都不一样,比如name,这样的属性就应该设计为对象属性,因为它是 跟着对象走的 ,每个对象的name都是不一样的。

        如果一个属性,所有的英雄都共享,都是一样的,那么就应该设计为类属性,比如说英雄的血量上限都是9999,不会因为英雄不同而取不同的值。这样的属性,就适合设计为类属性。

    展开全文
  • 1、工具 import com.myfutech.employee.service.api.vo.request.candidate.CandidateImportVO; import com.myfutech.employee.service.api.vo.request.employee.EmployeeModifyVO; import ...
  • Java类和对象 详解(一)

    万次阅读 多人点赞 2016-10-06 20:48:02
    几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,在70年代的Smaltalk语言之中进行了应用,后来根据面向对象的设计思路,才形成C++,而由C++产生了Java这门面向对象的编程语言。...
  • 当我们使用java封装了一个实体时,该实体中,有一些变量函数。此时在该中的函数,我们可以称之为该实体的方法了,该实体中的变量,我们可以称之为该实体属性。我们这里以一个Person实体为例。 ...
  • Java 类属性

    千次阅读 2018-12-15 17:40:26
    对象属性对比:  不同对象的 对象属性 的值都可能不一样。  比如盖伦的hp 提莫的hp 是不一样的。  但是所有对象的属性的值,都是一样的 步骤 1 : 属性 属性: 又叫做静态属性  对象属性: 又叫...
  • java拷贝对象属性的几种方式对比

    千次阅读 2018-12-10 11:47:16
    常用的对象属性的拷贝方式有很多,就随便说几个: spring 的 BeanUtils.copyproperties() 原理:反射 apache的 BeanUtils.copyproperties() String的 BeanUtils.copyproperties() PropertyUtils....
  • 获取java类中的属性注释

    千次阅读 2020-07-08 14:21:22
    一般我们的某个数据库表对象model,java bean对象如下: package com.xxx.message.model; import com.middol.common.model.BaseModel; import lombok.Data; import lombok.EqualsAndHashCode; import javax....
  • java对象数组 创建对象数组,初始化对象数组

    万次阅读 多人点赞 2019-07-30 16:34:15
    当需要一个的多个对象时,应该用该对象数组来表示,通过改变下标值就可以访问到不同的对象对象数组的定义使用: 对象数组的定义与一般数组的定义类似,但是需要为每一个元素实例化。 对象数组的声明形式...
  • private static Logger logger= LoggerFactory.getLogger(ObjectFieldUtil.class); /** ... * @return 修改的对象属性值名称集合 */ public static List<String> getChangeList(Object o.
  • 不仅仅是int类型,其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该情况。但是如果你复制的是一个对象,情况就有些复杂了。假设说我是一个beginner,我会这样写:class Student {
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JREJDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序小程序的...
  • 当我们需要对对象的所有值进行遍历的时候,依次进行get、set方法非常的麻烦,这个时候我们就会用到对象属性和值的遍历,应用代码如下: // voucher是目标对象 try{ //通过getDeclaredFields()方法获取对象中的...
  • Java 判断对象对象属性是否为空

    万次阅读 2019-09-18 09:08:37
    import java.lang.reflect.Field; /** * Created by hj. */ public class VoUtilsTool { /**** * @param object 对象 * @return 如果对象不为空,且没有空值。返回false,对象为空或者有空值,返回true * */ ...
  • 对象属性,方法的解析。 创建对象,引用控制对象解析。 面向对象的基本思想
  • java 对象属性比较工具

    千次阅读 2017-09-14 14:50:10
    package com.zxy.product.human.web.log; import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map; import com.google.common.collect.Maps;... * BeanUtil 对象属性比较工具
  • //判断该对象是否: 返回ture表示所有属性为null  返回false表示不是所有属性都是null public static boolean isAllFieldNull(Object obj) throws IllegalAccessException { Class<?> aClass ...
  • 在运行状态中,对任意一个都有获取这个的所有属方法,对于任意一个对象,都能调用它的任意一个方法和属性(包括私有的方法和属性),这种动态获取的信息以及动态调用对象的方法的功能就称为java语言的反射机制。...
  •  由于项目需要,需要从object对象中获得对应的实体属性属性值,研究了半天,终于实现。介绍如下:  注:object为检索数据库后获得的object对象  Object object = super.selectByEntit
  • Java 属性

    千次阅读 2019-09-26 08:56:53
    章节Java 基础 Java 简介 Java 环境搭建 Java 基本语法 Java 注释 Java 变量 Java 数据类型 Java 字符串 Java 类型转换 Java 运算符 Java 字符串 Java Math Java 布尔运算 Java If … Else Java ...
  • 假设现在有需求如下:比较2个相同类型的不同对象,找到这2个对象的不同的地方,并展示记录一下。当然说的是相互对应的属性啦。 带着这个需求,看下面的例子。(我写代码的都不嫌弃长,你看代码的就也别嫌弃咯。) ...
  • java通过反射方式根据对象属性名称获取属性值 1.实现方法 public static Double getFieldValueByFieldName(String fieldName,Object object) { try { Field field = object.getClass().getDeclaredField(field...
  • java属性与方法

    千次阅读 多人点赞 2019-09-09 20:47:43
    文章目录java属性与方法1,什么是:2,什么是对象:属性:变量的分类:成员变量细分变量的作用域方法:3.变量的生命周期 1,什么是的定义 是现实世界当中是不存在的,是一个模版,是一个概念,是抽象...
  • 问题描述 在上面代码中,在create方法中直接使用了Student属性,并且通过编译。查阅《java核心技术》105页发现private关键字修饰的属性自身的方法还是可以访问的。 ...
  • java的成员之:属性,方法

    千次阅读 2018-03-03 23:11:56
    一、属性(或成员变量)Field:* 成员变量 vs 局部变量* 1.相同点:①变量的声明: 数据类型 变量名 = 初始化值;* ②都有其作用域,仅在作用域内有效* 2.不同点:* ①在中声明的位置不同* ...
  • 方式一(实体):1234567//java中遍历实体,获取属性和属性值 public static void testReflect(Object model) throws Exception{ for (Field field : model.getClass().getDeclaredFields()) { field.....
  • 使用common-utils包提供的CollectionUtilsBeanPropertyValueEqualsPredicate 比如找id属性值为9587的用户 Object obj = CollectionUtils.find(UserList.get(), new BeanPropertyValueEqualsPredicate("id&...
  • Java对象属性值合并

    万次阅读 2021-09-13 14:20:36
    } /** * description 合并对象(该方法是用于相同对象不同属性值的合并) * * @author yanzy * @version 1.0 * @date 2021/9/13 11:09 */ public static User mergeObject(User user1, User user2) throws ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,299,055
精华内容 519,622
关键字:

java类的属性和对象属性

java 订阅