精华内容
下载资源
问答
  • 面试官:兄弟,说说基本类型和包装类型的区别吧

    万次阅读 多人点赞 2019-09-29 08:36:07
    Java 的每个基本类型都对应了一个包装类型,比如说 int 的包装类型为 Integer,double 的包装类型为 Double。基本类型和包装类型的区别主要有以下 4 点。

    六年前,我从苏州回到洛阳,抱着一幅“海归”的心态,投了不少简历,也“约谈”了不少面试官,但仅有两三个令我感到满意。其中有一位叫老马,至今还活在我的手机通讯录里。他当时扔了一个面试题把我砸懵了:说说基本类型和包装类型的区别吧。

    我当时二十三岁,正值青春年华,从事 Java 编程已有 N 年经验(N < 4),自认为所有的面试题都能对答如流,结果没想到啊,被“刁难”了——原来洛阳这块互联网的荒漠也有技术专家啊。现在回想起来,脸上不自觉地泛起了羞愧的红晕:主要是自己当时太菜了。不管怎么说,是时候写篇文章剖析一下基本类型和包装类型的区别了。

    Java 的每个基本类型都对应了一个包装类型,比如说 int 的包装类型为 Integer,double 的包装类型为 Double。基本类型和包装类型的区别主要有以下 4 点。

    01、包装类型可以为 null,而基本类型不可以

    别小看这一点区别,它使得包装类型可以应用于 POJO 中,而基本类型则不行。

    POJO 是什么呢?这里稍微说明一下。

    POJO 的英文全称是 Plain Ordinary Java Object,翻译一下就是,简单无规则的 Java 对象,只有属性字段以及 setter 和 getter 方法,示例如下。

    class Writer {
    	private Integer age;
    	private String name;
    
    	public Integer getAge() {
    		return age;
    	}
    
    	public void setAge(Integer age) {
    		this.age = age;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    }
    

    和 POJO 类似的,还有数据传输对象 DTO(Data Transfer Object,泛指用于展示层与服务层之间的数据传输对象)、视图对象 VO(View Object,把某个页面的数据封装起来)、持久化对象 PO(Persistant Object,可以看成是与数据库中的表映射的 Java 对象)。

    那为什么 POJO 的属性必须要用包装类型呢?

    《阿里巴巴 Java 开发手册》上有详细的说明,我们来大声朗读一下(预备,起)。

    数据库的查询结果可能是 null,如果使用基本类型的话,因为要自动拆箱(将包装类型转为基本类型,比如说把 Integer 对象转换成 int 值),就会抛出 NullPointerException 的异常。

    02、包装类型可用于泛型,而基本类型不可以

    泛型不能使用基本类型,因为使用基本类型时会编译出错。

    List<int> list = new ArrayList<>(); // 提示 Syntax error, insert "Dimensions" to complete ReferenceType
    List<Integer> list = new ArrayList<>();
    

    为什么呢?因为泛型在编译时会进行类型擦除,最后只保留原始类型,而原始类型只能是 Object 类及其子类——基本类型是个特例。

    03、基本类型比包装类型更高效

    基本类型在栈中直接存储的具体数值,而包装类型则存储的是堆中的引用。

    很显然,相比较于基本类型而言,包装类型需要占用更多的内存空间。假如没有基本类型的话,对于数值这类经常使用到的数据来说,每次都要通过 new 一个包装类型就显得非常笨重。

    03、两个包装类型的值可以相同,但却不相等

    两个包装类型的值可以相同,但却不相等——这句话怎么理解呢?来看一段代码就明明白白了。

    Integer chenmo = new Integer(10);
    Integer wanger = new Integer(10);
    
    System.out.println(chenmo == wanger); // false
    System.out.println(chenmo.equals(wanger )); // true
    

    两个包装类型在使用“”进行判断的时候,判断的是其指向的地址是否相等。chenmo 和 wanger 两个变量使用了 new 关键字,导致它们在“”的时候输出了 false。

    chenmo.equals(wanger) 的输出结果为 true,是因为 equals 方法内部比较的是两个 int 值是否相等。源码如下。

    private final int value;
    
    public int intValue() {
        return value;
    }
    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }
    

    瞧,虽然 chenmo 和 wanger 的值都是 10,但他们并不相等。换句话说就是:将“==”操作符应用于包装类型比较的时候,其结果很可能会和预期的不符

    04、自动装箱和自动拆箱

    既然有了基本类型和包装类型,肯定有些时候要在它们之间进行转换。把基本类型转换成包装类型的过程叫做装箱(boxing)。反之,把包装类型转换成基本类型的过程叫做拆箱(unboxing)。

    在 Java SE5 之前,开发人员要手动进行装拆箱,比如说:

    Integer chenmo = new Integer(10);  // 手动装箱
    int wanger = chenmo.intValue();  // 手动拆箱
    

    Java SE5 为了减少开发人员的工作,提供了自动装箱与自动拆箱的功能。

    Integer chenmo  = 10;  // 自动装箱
    int wanger = chenmo;     // 自动拆箱
    

    上面这段代码使用 JAD 反编译后的结果如下所示:

    Integer chenmo = Integer.valueOf(10);
    int wanger = chenmo.intValue();
    

    也就是说,自动装箱是通过 Integer.valueOf() 完成的;自动拆箱是通过 Integer.intValue() 完成的。理解了原理之后,我们再来看一道老马当年给我出的面试题。

    // 1)基本类型和包装类型
    int a = 100;
    Integer b = 100;
    System.out.println(a == b);
    
    // 2)两个包装类型
    Integer c = 100;
    Integer d = 100;
    System.out.println(c == d);
    
    // 3)
    c = 200;
    d = 200;
    System.out.println(c == d);
    

    答案是什么呢?有举手要回答的吗?答对的奖励一朵小红花哦。

    第一段代码,基本类型和包装类型进行 == 比较,这时候 b 会自动拆箱,直接和 a 比较值,所以结果为 true。

    第二段代码,两个包装类型都被赋值为了 100,这时候会进行自动装箱,那 == 的结果会是什么呢?

    我们之前的结论是:将“==”操作符应用于包装类型比较的时候,其结果很可能会和预期的不符。那结果是 false?但这次的结果却是 true,是不是感觉很意外?

    第三段代码,两个包装类型重新被赋值为了 200,这时候仍然会进行自动装箱,那 == 的结果会是什么呢?

    吃了第二段代码的亏后,是不是有点怀疑人生了,这次结果是 true 还是 false 呢?扔个硬币吧,哈哈。我先告诉你结果吧,false。

    为什么?为什么?为什么呢?

    事情到了这一步,必须使出杀手锏了——分析源码吧。

    之前我们已经知道了,自动装箱是通过 Integer.valueOf() 完成的,那我们就来看看这个方法的源码吧。

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
    

    难不成是 IntegerCache 在作怪?你猜对了!

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
    
        static {
            // high value may be configured by property
            int h = 127;
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);
            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            high = h;
    
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
    
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
    }
    

    大致瞟一下这段代码你就全明白了。-128 到 127 之间的数会从 IntegerCache 中取,然后比较,所以第二段代码(100 在这个范围之内)的结果是 true,而第三段代码(200 不在这个范围之内,所以 new 出来了两个 Integer 对象)的结果是 false。

    看完上面的分析之后,我希望大家记住一点:当需要进行自动装箱时,如果数字在 -128 至 127 之间时,会直接使用缓存中的对象,而不是重新创建一个对象

    自动装拆箱是一个很好的功能,大大节省了我们开发人员的精力,但也会引发一些麻烦,比如下面这段代码,性能就很差。

    long t1 = System.currentTimeMillis();
    Long sum = 0L;
    for (int i = 0; i < Integer.MAX_VALUE;i++) {
        sum += i;
    }
    long t2 = System.currentTimeMillis();        
    System.out.println(t2-t1);
    

    sum 由于被声明成了包装类型 Long 而不是基本类型 long,所以 sum += i 进行了大量的拆装箱操作(sum 先拆箱和 i 相加,然后再装箱赋值给 sum),导致这段代码运行完花费的时间足足有 2986 毫秒;如果把 sum 换成基本类型 long,时间就仅有 554 毫秒,完全不一个等量级啊。

    05、最后

    谢谢大家的阅读,原创不易,喜欢就点个赞,这将是我最强的写作动力。如果你觉得文章对你有所帮助,也蛮有趣的,就关注一下我的公众号,谢谢。

    展开全文
  • 场景:在微服务中,一般返回数据都会有个返回码、返回信息和返回消息体,但是每次返回时候调用或者是封装,太过麻烦,有没有什么办法不用每次都封装呢? 答案是有的。 返回值对象 package ...

    场景:在微服务中,一般返回数据都会有个返回码返回信息返回消息体,但是每次返回时候调用或者是封装,太过麻烦,有没有什么办法不用每次都封装呢?

    答案是有的。

    返回值对象 ResponseData

    package com.study.auth.comm;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.annotation.JSONField;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    
    import java.io.Serializable;
    
    /**
     * @Package: com.study.auth.comm
     * @Description: <返回数据>
     * @Author: MILLA
     * @CreateDate: 2018/4/8 9:10
     * @UpdateUser: MILLA
     * @UpdateDate: 2018/4/8 9:10
     * @Version: 1.0
     */
    public final class ResponseData<T> implements Serializable {
        private static final long serialVersionUID = 7824278330465676943L;
    
        private static final String SUCCESS_CODE = "1000";
    
        private static final String SUCCESS_MSG = "success";
        /**
         * 响应编码
         */
        @JSONField(serialzeFeatures = {SerializerFeature.WriteMapNullValue}, ordinal = 1)
        private String code;
    
        /**
         * 响应提示
         */
        @JSONField(serialzeFeatures = {SerializerFeature.WriteMapNullValue}, ordinal = 2)
        private String msg;
    
        /**
         * 返回的数据
         */
        @JSONField(serialzeFeatures = {SerializerFeature.WriteMapNullValue}, ordinal = 10)
        private T data;
    
        public static ResponseData success() {
            return initData(SUCCESS_CODE, SUCCESS_MSG, null);
        }
    
        public static ResponseData error(String code) {
            String msg = PropertiesReaderUtil.getProperty(code, null);
            return initData(code, msg, null);
        }
    
        public static ResponseData error(String code, String msg) {
            return initData(code, msg, null);
        }
    
        public static <T> ResponseData success(T t) {
            return initData(SUCCESS_CODE, SUCCESS_MSG, t);
        }
    
        public static <T> ResponseData errorData(String code, T data) {
            String msg = PropertiesReaderUtil.getProperty(code, null);
            return initData(code, msg, data);
        }
    
        public static <T> ResponseData errorData(String code, String msg, T data) {
            return initData(code, msg, data);
        }
    
        private static <T> ResponseData initData(String code, String msg, T t) {
            ResponseData data = new ResponseData(SUCCESS_CODE);
            if (!isBlank(msg)) {
                data.setMsg(msg);
            }
            if (!isBlank(code)) {
                data.setCode(code);
            }
            if (t != null) {
                data.setData(t);
            }
            return data;
        }
    
        private static boolean isBlank(CharSequence cs) {
            int strLen;
            if (cs != null && (strLen = cs.length()) != 0) {
                for (int i = 0; i < strLen; ++i) {
                    if (!Character.isWhitespace(cs.charAt(i))) {
                        return false;
                    }
                }
                return true;
            } else {
                return true;
            }
        }
    
        public ResponseData() {
        }
    
        public ResponseData(String code) {
            this.code = code;
        }
    
        public String getCode() {
            return code;
        }
    
        public void setCode(String code) {
            this.code = code;
        }
    
        public String getMsg() {
            return msg;
        }
    
        public void setMsg(String msg) {
            this.msg = msg;
        }
    
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    
        @Override
        public String toString() {
            return JSON.toJSONString(this);
        }
    }

     

    如上图的包装,还是太繁琐了。 

     装饰者模式使用-增强类InitializingAdviceDecorator 

    通过实现InitializingBean和装饰者模式对Controller层的返回值进行包装,大致思路:

    1. 通过RequestMappingHandlerAdapter获取所有的返回值处理对象HandlerMethodReturnValueHandler
    2. 创建一个新的集合存储上一步获取的集合(因为上一步的结果是unmodifiableList类型的
    3. 遍历该集合找到HandlerMethodReturnValueHandler对象,将这个位置的handler替换程自定义的handler
    4. 将新获到的集合重新设置到RequestMappingHandlerAdapter的setReturnValueHandlers方法中

     

    package com.study.auth.config;
    
    import com.study.auth.comm.ResponseData;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.MethodParameter;
    import org.springframework.web.context.request.NativeWebRequest;
    import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
    import org.springframework.web.method.support.ModelAndViewContainer;
    import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
    import org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @Package: com.study.auth.config.core
     * @Description: <增强controller层返回值>
     * @Author: milla
     * @CreateDate: 2020/09/04 14:42
     * @UpdateUser: milla
     * @UpdateDate: 2020/09/04 14:42
     * @UpdateRemark: <>
     * @Version: 1.0
     */
    @Configuration
    public class InitializingAdviceDecorator implements InitializingBean {
        @Autowired
        private RequestMappingHandlerAdapter adapter;
    
        @Override
        public void afterPropertiesSet() {
            //获取所有的handler对象
            List<HandlerMethodReturnValueHandler> returnValueHandlers = adapter.getReturnValueHandlers();
            //因为上面返回的是unmodifiableList,所以需要新建list处理
            List<HandlerMethodReturnValueHandler> handlers = new ArrayList(returnValueHandlers);
            this.decorateHandlers(handlers);
            //将增强的返回值回写回去
            adapter.setReturnValueHandlers(handlers);
        }
    
    
        /**
         * 使用自定义的返回值控制类
         *
         * @param handlers
         */
        private void decorateHandlers(List<HandlerMethodReturnValueHandler> handlers) {
            for (HandlerMethodReturnValueHandler handler : handlers) {
                if (handler instanceof RequestResponseBodyMethodProcessor) {
                    //找到返回值的handler并将起包装成自定义的handler
                    ControllerReturnValueHandler decorator = new ControllerReturnValueHandler((RequestResponseBodyMethodProcessor) handler);
                    int index = handlers.indexOf(handler);
                    handlers.set(index, decorator);
                    break;
                }
            }
        }
    
        /**
         * 自定义返回值的Handler
         * 采用装饰者模式
         */
        private class ControllerReturnValueHandler implements HandlerMethodReturnValueHandler {
            //持有一个被装饰者对象
            private HandlerMethodReturnValueHandler handler;
    
            ControllerReturnValueHandler(RequestResponseBodyMethodProcessor handler) {
                this.handler = handler;
            }
    
            @Override
            public boolean supportsReturnType(MethodParameter returnType) {
                return true;
            }
    
            /**
             * 增强被装饰者的功能
             *
             * @param returnValue  返回值
             * @param returnType   返回类型
             * @param mavContainer view
             * @param webRequest   请求对象
             * @throws Exception 抛出异常
             */
            @Override
            public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
                //如果已经封装了结构体就直接放行
                if (returnValue instanceof ResponseData) {
                    handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
                    return;
                }
                //正常返回success
                ResponseData success = ResponseData.success(returnValue);
                handler.handleReturnValue(success, returnType, mavContainer, webRequest);
            }
        }
    }
    

     配置文件读取类PropertiesReaderUtil

     

    package com.study.auth.comm;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.util.Properties;
    
    /**
     * @Package: com.milla.navicat.comm
     * @Description: <读取配置properties工具类>
     * @Author: MILLA
     * @CreateDate: 2018/8/10 10:30
     * @UpdateUser: MILLA
     * @UpdateDate: 2018/8/10 10:30
     * @UpdateRemark: <>
     * @Version: 1.0
     */
    public final class PropertiesReaderUtil {
        private static final String ENCODING = "UTF-8";
        private static final Logger logger = LoggerFactory.getLogger(PropertiesReaderUtil.class);
        private static Properties propsZH;
        private static Properties propsCN;
        private static String name = null;
    
        static {
            //加载英文
            //loadProps(false);
            //加载中文
            loadProps(true);
        }
    
        /**
         * 第一种,通过类加载器进行获取properties文件流
         * 第二种,通过类进行获取properties文件流
         * in = PropertyUtil.class.getResourceAsStream("/properties/message_ZH.properties");
         * in = PropertiesReaderUtil.class.getClassLoader().getResourceAsStream("properties/message_ZH.properties");
         */
        synchronized static private void loadProps(boolean isZh) {
            logger.debug("start loading properties");
            InputStream in = null;
            if (isZh) {
                propsZH = new Properties();
                name = "properties/message_ZH.properties";
                in = PropertiesReaderUtil.class.getClassLoader().getResourceAsStream(name);
            } else {
                propsCN = new Properties();
                name = "properties/message_EN.properties";
                in = PropertiesReaderUtil.class.getClassLoader().getResourceAsStream(name);
            }
            try {
                if (isZh) {
                    propsZH.load(new InputStreamReader(in, ENCODING));
                } else {
                    propsCN.load(new InputStreamReader(in, ENCODING));
                }
            } catch (Exception e) {
                logger.debug("loading properties error :{}", e);
            } finally {
                try {
                    if (null != in) {
                        in.close();
                    }
                } catch (IOException e) {
                    logger.debug("closing properties io error :{}", e);
                }
            }
        }
    
        public static String getProperty(String key) {
            return getPropertyZH(key);
        }
    
        public static String getProperty(String key, String defaultValue) {
            return getPropertyZH(key, defaultValue);
        }
    
        public static String getPropertyZH(String key) {
            if (null == propsZH) {
                loadProps(true);
            }
            return propsZH.getProperty(key);
        }
    
        public static String getPropertyZH(String key, String defaultValue) {
            if (null == propsZH) {
                loadProps(true);
            }
            return propsZH.getProperty(key, defaultValue);
        }
    
        public static String getPropertyCN(String key) {
            if (null == propsCN) {
                loadProps(false);
            }
            return propsCN.getProperty(key);
        }
    
        public static String getPropertyCN(String key, String defaultValue) {
            if (null == propsCN) {
                loadProps(false);
            }
            return propsCN.getProperty(key, defaultValue);
        }
    }
    

     配置文件message_ZH.properties

     路径为:properties/message_ZH.properties

    也可添加国家化英文或者是其他语言配置

    1001=用户未登录
    #====非业务返回码=========
    1100=服务器内部错误
    1101=空指针异常
    1102=数据类型转换异常
    1103=IO异常
    1104=该方法找不到异常
    1105=数组越界异常
    1106=请求体缺失异常
    1107=类型匹配异常
    1108=请求参数缺失异常
    1109=请求方法不支持异常
    1110=请求头类型不支持异常
    1111=参数解析异常
    1112=必要参数不能为空
    #=======================

    统一异常捕捉类RestfulExceptionHandler  

    此时,基本能保证增强Controller层的返回值了,如果有需要的话,可能通过@RestControllerAdvice注解,针对抛出的异常使用返回值对象进行包装

    package com.study.auth.exception;
    
    import com.alibaba.fastjson.JSONException;
    import com.study.auth.comm.PropertiesReaderUtil;
    import com.study.auth.comm.ResponseData;
    import com.study.auth.constant.CommonConstant;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.TypeMismatchException;
    import org.springframework.boot.json.JsonParseException;
    import org.springframework.http.converter.HttpMessageNotReadableException;
    import org.springframework.web.HttpMediaTypeNotSupportedException;
    import org.springframework.web.HttpRequestMethodNotSupportedException;
    import org.springframework.web.bind.MethodArgumentNotValidException;
    import org.springframework.web.bind.MissingServletRequestParameterException;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseStatus;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    
    import javax.security.auth.login.AccountException;
    import java.io.IOException;
    import java.sql.SQLException;
    
    /**
     * @Package: com.study.auth.exception
     * @Description: <所有异常拦截类>
     * @Author: milla
     * @CreateDate: 2020/09/04 15:35
     * @UpdateUser: milla
     * @UpdateDate: 2020/09/04 15:35
     * @UpdateRemark: <>
     * @Version: 1.0
     */
    @Slf4j
    @RestControllerAdvice
    public class RestfulExceptionHandler {
        private ResponseData responseData(String code, Exception e) {
            log.error("异常代码:{},异常描述:{},异常堆栈:", code, PropertiesReaderUtil.getProperty(code), e);
            return ResponseData.error(code);
        }
    
        private ResponseData<String> responseData(String code, String message, Exception e) {
            log.error("异常代码:{},异常描述:{},异常堆栈:", code, message, e);
            return ResponseData.error(code, message);
        }
    
        /**
         * 运行时异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(Exception.class)
        public ResponseData runtimeExceptionHandler(Exception e) {
            return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e);
        }
    
        /**
         * 处理SQLSyntaxErrorException
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(SQLException.class)
        public ResponseData<String> sqlException(SQLException e) {
            return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e.getMessage(), e);
        }
    
    
        /**
         * 处理CustomerMessageException
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(CustomMessageException.class)
        public ResponseData<String> customerMessageException(CustomMessageException e) {
            return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e.getMessage(), e);
        }
    
        /**
         * 处理AccountException
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(AccountException.class)
        public ResponseData<String> accountException(AccountException e) {
            return responseData(e.getMessage(), e);
        }
    
    
        //---------------------------------------jdk/spring自带的异常----------------------------------
    
        /**
         * 处理IllegalArgumentException
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(IllegalArgumentException.class)
        public ResponseData<String> illegalArgumentException(IllegalArgumentException e) {
            return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e.getMessage(), e);
        }
    
        /**
         * 空指针异常
         *
         * @param e 异常
         * @return
         */
        @ResponseStatus
        @ExceptionHandler(NullPointerException.class)
        public ResponseData nullPointerExceptionHandler(NullPointerException e) {
            return responseData(CommonConstant.EX_NULL_POINTER_EXCEPTION, e);
        }
    
        /**
         * 类型转换异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(ClassCastException.class)
        public ResponseData classCastExceptionHandler(ClassCastException e) {
            return responseData(CommonConstant.EX_CLASS_CAST_EXCEPTION, e);
        }
    
        /**
         * IO异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(IOException.class)
        public ResponseData iOExceptionHandler(IOException e) {
            return responseData(CommonConstant.EX_IO_EXCEPTION, e);
        }
    
        /**
         * 未知方法异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(NoSuchMethodException.class)
        public ResponseData noSuchMethodExceptionHandler(NoSuchMethodException e) {
            return responseData(CommonConstant.EX_NO_SUCH_METHOD_EXCEPTION, e);
        }
    
        /**
         * 数组越界异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(IndexOutOfBoundsException.class)
        public ResponseData indexOutOfBoundsExceptionHandler(IndexOutOfBoundsException e) {
            return responseData(CommonConstant.EX_INDEX_OUT_OF_BOUNDS_EXCEPTION, e);
        }
    
        /**
         * 请求body缺失异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler({HttpMessageNotReadableException.class})
        public ResponseData requestNotReadable(HttpMessageNotReadableException e) {
            return responseData(CommonConstant.EX_HTTP_MESSAGE_NOT_READABLE_EXCEPTION, e);
        }
    
        /**
         * 类型匹配异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler({TypeMismatchException.class})
        public ResponseData requestTypeMismatch(TypeMismatchException e) {
            return responseData(CommonConstant.EX_HTTP_MESSAGE_NOT_READABLE_EXCEPTION, e);
        }
    
        /**
         * 方法不支持异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler({HttpRequestMethodNotSupportedException.class})
        public ResponseData methodNotSupported(HttpRequestMethodNotSupportedException e) {
            return responseData(CommonConstant.EX_HTTP_REQUEST_METHOD_NOT_SUPPORTED_EXCEPTION, e);
        }
    
        /**
         * 请求头不支持异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler({HttpMediaTypeNotSupportedException.class})
        public ResponseData mediaTypeNotAcceptable(HttpMediaTypeNotSupportedException e) {
            return responseData(CommonConstant.EX_HTTP_MEDIA_TYPE_NOT_ACCEPTABLE_EXCEPTION, e);
        }
    
        /**
         * 参数解析异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(JSONException.class)
        public ResponseData runtimeExceptionHandler(JSONException e) {
            return responseData(CommonConstant.PARAMS_PARSE_EXCEPTION, e);
        }
    
        /**
         * 参数解析异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(JsonParseException.class)
        public ResponseData runtimeExceptionHandler(JsonParseException e) {
            return responseData(CommonConstant.PARAMS_PARSE_EXCEPTION, e);
        }
    
        /**
         * 请求参数缺失异常
         *
         * @param e 异常
         * @return
         */
    
        @ExceptionHandler({MissingServletRequestParameterException.class})
        public ResponseData requestMissingServletRequest(MissingServletRequestParameterException e) {
            return responseData(CommonConstant.EX_MISSING_SERVLET_REQUEST_PARAMETER_EXCEPTION, e);
        }
    
        /**
         * 参数不能为空
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(MethodArgumentNotValidException.class)
        public ResponseData exceptionHandler(MethodArgumentNotValidException e) {
            return responseData(CommonConstant.PARAMS_IS_NULL, e);
        }
    }
    

    常量类 CommonConstant 

    package com.study.auth.constant;
    
    /**
     * @Package: com.study.auth.constant
     * @Description: <公共常量类>
     * @Author: milla
     * @CreateDate: 2020/09/04 15:37
     * @UpdateUser: milla
     * @UpdateDate: 2020/09/04 15:37
     * @UpdateRemark: <>
     * @Version: 1.0
     */
    public final class CommonConstant {
        /**
         * 当前用户名称
         */
        public static final String C_CURRENT_ACCOUNT = "current_account";
    
        /**
         * 用户未登录
         */
        public static final String EX_NO_TOKEN_EXCEPTION = "1001";
    
        //--------------------------------非业务返回码---------------------------------------
        /**
         * 运行时异常
         */
        public static final String EX_RUN_TIME_EXCEPTION = "1100";
        /**
         * 空指针异常
         */
        public static final String EX_NULL_POINTER_EXCEPTION = "1101";
        /**
         * 数据转换异常
         */
        public static final String EX_CLASS_CAST_EXCEPTION = "1102";
        /**
         * IO异常
         */
        public static final String EX_IO_EXCEPTION = "1103";
        /**
         * 找不到该方法异常
         */
        public static final String EX_NO_SUCH_METHOD_EXCEPTION = "1104";
        /**
         * 数组越界异常
         */
        public static final String EX_INDEX_OUT_OF_BOUNDS_EXCEPTION = "1105";
        /**
         * 请求体缺失异常
         */
        public static final String EX_HTTP_MESSAGE_NOT_READABLE_EXCEPTION = "1106";
        /**
         * TYPE匹配异常
         */
        public static final String EX_TYPE_MISMATCH_EXCEPTION = "1107";
        /**
         * 请求参数丢失
         */
        public static final String EX_MISSING_SERVLET_REQUEST_PARAMETER_EXCEPTION = "1108";
        /**
         * 请求方法类型不支持异常
         */
        public static final String EX_HTTP_REQUEST_METHOD_NOT_SUPPORTED_EXCEPTION = "1109";
        /**
         * MEDIA 类型不支持异常
         */
        public static final String EX_HTTP_MEDIA_TYPE_NOT_ACCEPTABLE_EXCEPTION = "1110";
        /**
         * 参数解析异常
         */
        public static final String PARAMS_PARSE_EXCEPTION = "1111";
        /**
         * 参数不能为空
         */
        public static final String PARAMS_IS_NULL = "1112";
        //-----------------------------------------------------------------------------------
    }

    自定义异常类 CustomMessageException

    package com.study.auth.exception;
    
    /**
     * @Package: com.study.auth.exception
     * @Description: <自定义异常类>
     * @Author: MILLA
     * @CreateDate: 2019/8/15 18:39
     * @UpdateUser: MILLA
     * @UpdateDate: 2019/8/15 18:39
     * @UpdateRemark: <>
     * @Version: 1.0
     */
    public class CustomMessageException extends RuntimeException {
    
        public CustomMessageException() {
            super();
        }
    
        public CustomMessageException(String message) {
            super(message);
        }
    
        public CustomMessageException(String message, Throwable cause) {
            super(message, cause);
        }
    
        public CustomMessageException(Throwable cause) {
            super(cause);
        }
    
        protected CustomMessageException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
            super(message, cause, enableSuppression, writableStackTrace);
        }
    }
    

     

    所需依赖

    因为使用了阿里的fastJson工具类还需要进入该类的依赖

     <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>fastjson</artifactId>
          <version>1.2.58</version>
      </dependency>

     至此,可以愉快的使用该返回值的增强类了,在为服务中,还以将该代码重构到comm中,供多个服务共同使用,避免重复早轮子

    展开全文
  • 包装

    千次阅读 多人点赞 2019-02-24 21:42:49
    包装类(Wrapper Class): Java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的。基本类型的数据不具备&amp;amp;amp;quot;对象&amp;amp;amp;quot;的特性(没有成员变量和成员方法可以...

    一.包装类:
    1. 包装类(Wrapper Class):

    Java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的。基本类型的数据不具备"对象"的特性(没有成员变量和成员方法可以调用),因此,java为每种数据类型分别设计了对应的类,即包装类。

    基本数据类型 对应的包装类
    byte Byte
    short Short
    int Integer
    long Long
    char Character
    floar Float
    double Double
    boolean Boolean

    2.包装类的特点:

    在这里插入图片描述

    (1)所有包装类都是final类型,因此不能创建他们的子类。
    (2)包装类是不可变类,一个包装类的对象自创建后,他所包含的基本类型数据就不能被改变。

    二.Integer类

    1.装箱和拆箱

    装箱:将基本数据类型变为包装类对象。
    拆箱:将包装类中包装的基本数据类型取出。

    int到Integer Integer到int
    使用Integer类的构造方法 调用Integer类的intValue()方法
    使用Integer类内部的valueOf( )方法 自动拆箱
    自动装箱

    2.int到nteger类:

    三种方法:
    (1)使用Integer类的构造方法
    (2)使用Integer类内部的valueOf( )方法
    (3)自动装箱

    (1)方法1:使用Integer类的构造方法

    • public Integer(int value):将int类型转换为Integer类。
    • public Integer(String s):将String类型转换为Integer类。
      注意:使用此构造方法时,字符串内的字符必须由数字组成,不可以是字母或者其他形式,否则抛出NumberFormatException。
    public static void main(String[] args)
      {
        //方式1:public Integer(int value)
      	int i= 100;
      	//将int类型的i转换为Integer类型的ii
      	Integer ii = new Integer(i);
      	System.out.println("ii:"+ii);
      	
      	//方式2:public Integer(String s)
      	String s = "100";
      	//String s = "abc";出错,因为这个字符串必须由数字字符组成。	
      	Integer iii = new Integer(s);
      	System.out.println("iii:"+iii);//100	
      }
    

    (2)方法2:使用Integer类内部的valueOf方法

    • public static Integer valueOf(int i):将int类型转换为Integer类。
    Integer i3 = Integer.valueOf(30);
    

    (3)方法3:自动装箱的方法:
    事实上,编译器自动执行了valueOf方法。

     Integer ii = 100;//编译器自动执行了Integer ii = Integer.valueOf(100)	
    
    包装类 装箱 拆箱
    Byte valueOf() byteValue()
    Short valueOf() shortValue()
    Integer valueOf() intValue()
    Long valueOf() longValue()
    Float valueOf() floatValue()
    Double valueOf() doubleValue()
    Character valueOf() charValue()
    Boolean valueOf() booleanValue()

    valueOf源码分析:

    public static Integer valueOf(int i) {
         assert IntegerCache.high>= 127;
         if (i >= IntegerCache.low&& i <= IntegerCache.high)
         return IntegerCache.cache[i+ (-IntegerCache.low)];
         return new Integer(i); 
    }
    

    通过查看原码可知,java针对-128-127之间的数据做了一个数据缓冲池。
    如果数据是该范围内的,每次并不创建新的空间。
    如果数据是该范围内的,就new一个空间

    相关面试题:

    public static void main(String[] args)
    	{
    		Integer i1 = new Integer(127);
    		Integer i2 = new Integer(127);
    		System.out.println(i1 == i2);//false
    		System.out.println(i1.equals(i2));//true重写了equals方法,比较的内容
    		
    		
    		Integer i3 = new Integer(128);
    		Integer i4 = new Integer(128);
    		System.out.println(i3 == i4);//false
    		System.out.println(i3.equals(i4));//true
    	
    		Integer i5 = 128;
    		Integer i6 = 128;
    		System.out.println(i5 == i6);//false
    		System.out.println(i5.equals(i6));//true
    		
    		Integer i7 = 127;
    		Integer i8 = 127;
    		System.out.println(i7 == i8);//true
    		System.out.println(i7.equals(i8));//true
    		
    

    3.Integer类到 int:

    (1)调用包装类的intValue()方法
    (2)通过自动拆箱:

    • 方法1:调用包装类的intValue()方法
      public int intValue():以 int 类型返回该 Integer 的值。
    public void test2() {
            Integer i1 = new Integer(14);
            Float f1 = new Float(12.3F);
            //1.调用包装类的XxxValue()方法
            int i2 = i1.intValue();//i2 = 14
            float f2 = f1.floatValue();//f2 = 12.3
            }
    
    • 方法2:通过自动拆箱:
      编译器自动执行了valueOf方法
            //5是基本数据类型,通过自动装箱变成对象类型。
            //编译器执行了Integer iii = Integer.valueOf(5)
            Integer iii=5;
            //自动拆箱,实际上执行了 int iii2 = iii.intValue()
            int iii2=iii;
            System.out.println(iii2);
    

    4.int类型数据和String形式之间的相互转换:

    intl到String String到int
    字符串的拼接 String–>Integer–>int
    String类的valueOf()方法 int parseInt(String s)
    int --> Integer -->String (所用方法:valueOf()+toString())
    toString(int i)
    public static void main(String[] args)
    	{
    		//int--String把int类型的数据转化为字符串的形式
    		int number = 100;
    		
    		//方式1:字符串的拼接
    		String s1 = "" + number;
    		System.out.println("s1:"+s1);
    		
    		//方式2:String类的valueOf可以把任意类型的数据转换成String类型
    		String s2 = String.valueOf(number);
    		System.out.println("s2:"+s2);
    		
    		//方式3
    		//int -- Integer -- String
    		Integer i = new Integer(number);
    		String s3 = i.toString();
    		System.out.println("s3:"+s3);
    		
    		//方式4
    		//public static String toString(int i)返回一个表示该 Integer 值的 String 对象。
    		String s4 = Integer.toString(number);
    		System.out.println("s4:"+s4);
    		
    		
    		//String--int
    		String s ="100";
    		//方式1
    		//String--Integer--int
    		//String--Integer
    		Integer ii = new Integer(s);
    		//Integer--int
    		//public int intValue()以 int类型返回该 Integer的值
    		 int x = ii.intValue();
    		System.out.println("x:"+x);
    		
    		//方式2
    		//public static int parseInt(String s)
    		int y = ii.parseInt(s);
    		System.out.println("y:"+y);
    	}
    

    5.进制的转换:

    进制间转换 方法 说明
    十进制到二进制 toBinaryString(int i) 将一个十进制整数转换成字符串形式的二进制数
    十进制到八进制 toOctalString(int i) 将一个十进制整数转换成字符串形式的八进制数
    十进制到十六进制 toHexString(int i) 将一个十进制整数转换成字符串形式的十六进制数
    十进制到其他进制 toString(int i,int radix) 将一个十进制数转换字符串形式的radix进制数,radix为进制值
    其他进制到十进制 int parseInt(String s, int radix) 将一个radix进制的数转换为十进制
    public static void main(String[] args)
    	{
    		//十进制到二进制,八进制,十六进制
    		System.out.println(Integer.toBinaryString(100));
    		System.out.println(Integer.toOctalString(100));
    		System.out.println(Integer.toHexString(100));
    		System.out.println("--------");
    		
    		//十进制到其他进制
    		System.out.println(Integer.toString(100,10));
    		System.out.println(Integer.toString(100,2));
    		System.out.println(Integer.toString(100,8));
    		System.out.println(Integer.toString(100,15));
    		System.out.println(Integer.toString(100,5));
    		System.out.println(Integer.toString(100,7));
    		System.out.println(Integer.toString(100,-7));
    		System.out.println(Integer.toString(100,70));
    		System.out.println(Integer.toString(100,34));
    		System.out.println(Integer.toString(100,37));
    		System.out.println(Integer.toString(100,36));
    		
    		//其他进制转换为十进制
    		System.out.println(Integer.parseInt("100",10));
    		System.out.println(Integer.parseInt("100",2));
    		System.out.println(Integer.parseInt("100",4));
    		System.out.println(Integer.parseInt("100",16));
    		System.out.println(Integer.parseInt("100",23));
    		//System.out.println(Integer.parseInt("123",2));出错,因为2进制没有3
    	}
    

    三.Character类
    1.Character类概述:

    Character类在对象中包装了一个char的值,用于对单个字符进行操作。
    该类提供了几种方法来操纵字符,以确定字符的类别(小写字母,数字,等等),并将字符从大写转换成小写等。

    2.Character类的构造方法:

    • public Character(char value):将char类型转换为Character类。
    Character ch1 = new Character('a');
    System.out.println("ch1:"+ch1);  //ch1:97
    

    注意:char和Character类之间的转换方法与int和Integer类之间的转换方法相同,不再赘述。
    3.Character类的方法:

    序号 方法 说明
    1 isDigit() 是否是一个数字字符
    2 isWhiteSpace() 是否是一个空格
    3 isUpperCase() 是否是大写字母
    4 isLowerCase() 是否是小写字母
    5 toUpperCase() 指定字母的大写形式
    6 toLowerCase() 指定字母的小写形式
    7 toString() 返回字符的字符串形式
    public static void main(String[] args)
    	{
    		//public static boolean isUpperCase(int codePoint)判断给定的字符是否为大写字符
    		System.out.println(Character.isUpperCase('A'));
    		System.out.println(Character.isUpperCase('a'));
    		System.out.println(Character.isUpperCase('0'));
    		
    		//public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
    		System.out.println(Character.isUpperCase('A'));
    		System.out.println(Character.isUpperCase('a'));
    		System.out.println(Character.isUpperCase('0'));
    		
    		// public static boolean isDigit(int codePoint):判断给定的字符是否是数字
    		System.out.println(Character.isUpperCase('A'));
    		System.out.println(Character.isUpperCase('a'));
    		System.out.println(Character.isUpperCase('0'));
    		
    		//public static char toUpperCase(char ch):把给定的字符转换为大写字符
    		System.out.println(Character.toUpperCase('a'));
    		
    		//public static char toLowerCase(char ch):把给定的字符转换为小写字符
    		System.out.println(Character.toLowerCase('A'));
    	}
    
    
    展开全文
  • 销售包装和运输包装的区别?

    千次阅读 2020-08-07 16:55:52
    销售包装又称内包装,主要作用是保护商品、方便使用、促进销售,并应符合销售地国家的法律和法规。 运输包装又称外包装、大包装,其主要作用是保护商品、方便储运和节省费用。简单来说就是为了保护商品数量、品质和...

    销售包装又称内包装,主要作用是保护商品、方便使用、促进销售,并应符合销售地国家的法律和法规。
    富港检测专业包装运输模拟测试机构

    运输包装又称外包装、大包装,其主要作用是保护商品、方便储运和节省费用。简单来说就是为了保护商品数量、品质和便于运输、储存而进行的外层包装。
    运输包装是以满足商品的运输、装卸和储存需要为目的的包装。通常运输包装不随商品卖给顾客。它一般不与商品直接接触,而是由许多小包装(销售包装)集装而成。例如烟、酒、化妆品等。商品先装进小包装,然后集装于包装容器内。运输包装在运输、装卸和储存中,首先是起保护商品安全的作用:其次是方便运输、装卸搬运和储存,以提高物流的效率;再次起传达作用,以便于物流管理。
    运输包装:主要有单件(运输)包装和集合(运输)包装两类。
    1、单件(运输)包装按包装的外形有包、箱、桶、袋、萎、管、卷、捆、罐等;按包装的结构方式有软性、半硬性、硬性包装;按包装材料有纸制、金属制、木制、塑料、棉麻、陶瓷、玻璃制品,草柳藤编织制品等包装。
    2、集合(运输)包装是将若干单件运输包装组合成一件大包装,如集装箱、集装包、集装袋、托盘等。有利于提高装卸速度、减轻装卸搬运劳动强度、便利运输、保证货物数(质)量,并促进包装标准化,节省运杂费用。
    苏州富港工业检测机构有限公司 是专业的第三方包装运输模拟实验机构。CNAS ISTA 认可实验实。设备人才应有齐全,权威报告,全球有效,欢迎来电咨询免费了解包装相关知识,我们有专业的检测技术工程师 很高兴为您解答!17562785753。

    展开全文
  • EWM - 包装主数据 - 包装明细 -2 https://mp.weixin.qq.com/s/hyis9kAU5GTkdVHSLvA-Ug 4. Element Group:用于简化创建包装明细得操作,在创建包装明细时只需要分配元素组而不需要手工创建分配元素。在手工...
  • Java 中有 8 个基本类型,分别对应的包装类如下 byte -- Byte boolean -- Boolean short -- Short char -- Character int -- Integer long -- Long float -- Float double -- Double 为什么要有包装类 ...
  • 包装类、包装(类)对象、包装类的类型转换功能 本文案的主要目的就是区分:包装类、包装类对象、使用包装类进行类型转换,这三者 在叙述前首先区分三者间的关系(因为在复习过程中,发现自己傻傻分不清): 1.包装类...
  • 【面向对象】包装

    万次阅读 多人点赞 2017-10-24 11:32:07
    包装类概念,包装类的用途,
  • js图片轮播:VCD包装盒个性幻灯片实例源码

    万次下载 热门讨论 2014-06-15 19:04:08
    代码为博客实例代码:http://blog.csdn.net/lmj623565791/article/details/31015121 有问题博客中留言
  • Java数据类型—包装

    万次阅读 2020-12-16 16:16:27
    1. 为什么需要包装类:JAVA是面向对象的语言,很多类和方法中的参数都需使用对象(例如集合),但基本数据类型却不是面向对象的,这就造成了很多不便 2. 拆装箱的概念:将基本数据类型转为包装类的过程叫装箱,将包装...
  • JS包装对象

    千次阅读 2019-05-22 21:18:26
    1、包装对象 JS中有三个基本数据类型是比较特殊的存在,分别是String、number、Boolear,这个三个基本是由自己对应的包装对象。并且随时等候召唤, 包装对象: 其实就是对象,有相应的属性和方法,至于这个过程...
  • Java包装

    2019-02-25 17:14:46
    Java包装类 java中的包装类提供了将原始数据类型转换为对象,以及将对象转换为原始数据类型的机制。是为了把原始数据当做对象进行操作; 八个包装类 基本类型 包装类 boolean Boolean char Character ...
  • java中基本类型包装

    万次阅读 多人点赞 2020-12-14 08:38:00
    1. 基本类型包装类概述为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。将基本数据类型封装成对象...
  • 包装器简介

    千次阅读 2019-09-14 23:49:24
    包装器归纳是基于有监督学习的,他从标注好的训练样例集合中学习数据抽取规则,用于从其他相同标记或相同网页模板抽取目标数据。 1、网页清洗:有些网页结构不规范,例如前后标签不对称,没有结束标签符。不规范的...
  • Java中的包装

    千次阅读 多人点赞 2019-04-16 15:34:10
    一、包装类概述 二、包装类的自动装箱、自动拆箱机制 三、包装类中的缓存机制 四、包装类的四则运算、位运算、比较运算、逻辑运算 五、包装类作为方法的形参、返回值 六、包装类作为集合的元素 七、包装类使用...
  • 第二部,根据用户的选择需要对用户输入的sql进行包装包装后的sql应该为: select dept, avg("工资(人民币)") from (select ename, dept, sal as "工资(人民币)" from emp) group by dept ; 问题来了,...
  • JavaScript基本包装类型

    2021-01-29 13:30:27
    基本包装类 js中为了便于基本类型操作,提供了3个特殊的引用类型:Boolean、Number、String它们具有基本类型特殊行为。 实际上,每当读取一个基本类型的时候,js内部会自动创建一个基本包装类型对象,可以让我们调用...
  • js闭包和包装

    千次阅读 2021-03-13 11:27:15
    JavaScript闭包和包装类的过程
  • JS 基本包装类型

    2019-01-11 10:14:23
    基本包装类型:本身是基本类型,但是在执行代码的过程中,如果这种类型的变量调用了属性或者方法,那么这种类型就不在是基本类型了,而是基本包装类型,这个变量也不是普通的变量,而是基本包装类型对象。...
  • C++函数包装器与引用包装器的使用
  • 包装类和基本类型

    千次阅读 2019-03-06 09:18:53
    什么是包装类 所谓包装类,就是能够直接将简单类型的变量表示为一个类,在执行变量类型的相互转换时,我们会大量使用这些包装类。 包装包装类有以下用途 1.集合不允许存放基本数据类型,故常用包装类 2.包含了每...
  • 把基本数据类型转换成包装类类型就是装箱,把包装类类型装换成基本数据类型就是拆箱。 1.代码举例自动拆箱和包装过程 package eclipse; public class Test_Integer { public static void main(String[] args...
  • 给袋式全自动包装机通常由给袋机和称量机两部分组成,称量机可以是称重式也可以是螺杆式,颗粒、粉剂物料都能包装。该机的工作原理是利用机械手对用户的预制袋进行取袋、开袋、套袋和封口,同时在微电脑的协调控制下...
  • 包装类Wrapper Class

    千次阅读 2018-08-07 12:07:57
    为什么需要包装类? Java并不是纯面向对象的语言,Java语言是一个面向对象的语言,但是Java中的基本数据类型确实不面向对象的,但是我们在实际使用中经常需要将基本数据转化成对象,便于操作,比如:集合的操作中...
  • Java 包装类是什么

    万次阅读 多人点赞 2018-04-26 14:29:49
    包装类就是将基本的数据类型以及一些辅助方法封装到类中,例如 class IntDemo { private int num; public IntDemo(int num) { this.num = num; } public int intValue() { return this.num; } } Java...
  • java中的包装

    2019-06-15 17:10:31
    包装类主要提供了两大类方法: 1. 将本类型和其他基本类型进行转换的方法 2. 将字符串和本类型及包装类互相转换的方法 以 Integer 包装器为例: Integer 包装器的常用方法: 装箱:把基本类型转换成包装...
  • Java中包装类作用及注意点

    万次阅读 多人点赞 2018-03-16 19:30:50
    Java中对每种基本类型都有一个对应的包装类,这里主要讲解包装类的作用和包装类使用时的一些注意点。 包装类的作用 作用主要有以下两方面: - 编码过程中只接收对象的情况,比如List中只能存入对象,不能存入...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 107,087
精华内容 42,834
关键字:

包装