Java - 封装类

来源：互联网发布：淘宝天猫开店费用编辑：程序博客网时间：2024/06/05 23:50

基本数据类型和封装类对照表

[plain] view plain copy
基本数据类型  封装类    
byte        Byte    
short       Short    
int         Integer    
long        Long    
float       Float    
double      Double    
char        Character    
boolean     Boolean  

基本概念

[plain] view plain copy
封装类功能  
    将基本数据类型封装当对象操作  
    为基本数据类型提供各种转换功能  
封装类一旦被创建,内容永不改变,如需封装新的内容,创建新对象  
    通过修改封装类引用的指向来实现如同修改对象值  
封装类都是final的类,不能被继承  

Integer

[plain] view plain copy
final  
extends Number  
implements Comparable<Integer>  

Integer常用方法

[java] view plain copy
package com.itlwc;  
  
public class Test {  
    public static void main(String[] args) {  
        // int转型为Integer  
        new Integer(10);  
        Integer.valueOf(10);  
  
        // int转型为String  
        Integer.toString(10);  
        // int转型为String带进制  
        Integer.toString(10, 2);  
        Integer.toString(10, 8);  
        Integer.toString(10, 16);  
        Integer.toBinaryString(10);  
        Integer.toOctalString(10);  
        Integer.toHexString(10);  
  
        // String转型为Integer  
        new Integer("10");  
        Integer.valueOf("10");  
        Integer.decode("10");  
        // String转型为Integer带进制  
        Integer.valueOf("10", 2);  
        Integer.valueOf("10", 8);  
        Integer.valueOf("10", 16);  
        // String转型为int  
        Integer.parseInt("10");  
        // String转型为int带进制  
        Integer.parseInt("10", 2);  
        Integer.parseInt("10", 8);  
        Integer.parseInt("10", 16);  
  
        // 返回符号 1为正 -1为负 0为0  
        Integer.signum(10);  
        // 返回byte  
        new Integer(10).byteValue();  
        // 返回short  
        new Integer(10).shortValue();  
        // 返回int  
        new Integer(10).intValue();  
        // 返回long  
        new Integer(10).longValue();  
        // 返回double  
        new Integer(10).doubleValue();  
        // 返回float  
        new Integer(10).floatValue();  
        // 比较此对象与指定对象  
        new Integer(10).equals(10);  
        // 在数字上比较两个 Integer 对象  
        new Integer(10).compareTo(10);  
  
        // 最大值最小值  
        int max = Integer.MAX_VALUE;  
        int min = Integer.MIN_VALUE;  
  
    }  
}  

Integer的缓存机制

[java] view plain copy
public class Test {  
    public static void main(String[] args) {  
        Integer a = 100;  
        /* 
         * 如果使用这种方法为i赋值 
         * Integer类有一个缓存机制 
         * Integer类认为认为-128~127之间的整数是我们经常用到的数值 
         * 因为100在这个范围就不生成对象,使用缓存好的对象 
         */  
        Integer b = 100;  
        if (a == b) {  
            System.out.println("a==b");  
        } else {  
            System.out.println("a!=b");  
        }  
        Integer aa = 200;  
        // 因为200不在这个范围生成新的对象  
        Integer bb = 200;  
        if (aa == bb) {  
            System.out.println("aa==bb");  
        } else {  
            System.out.println("aa!=bb");  
        }  
        // 如果使用构造方法就没有缓存  
        Integer aaa = new Integer(100);  
        Integer bbb = new Integer(100);  
        if (aaa == bbb) {  
            System.out.println("aaa==bbb");  
        } else {  
            System.out.println("aaa!=bbb");  
        }  
    }  
}  
打印:  
    a==b  
    aa!=bb  
    aaa!=bbb  

valueOf() VS parseXxx()

[plain] view plain copy
valueOf()可以以基本数据类型和字符串为参数,返回的是封装类对象的引用  
parseXxx()只能以字符串为参数,返回的是基本数据类型的值  

isNaN()

[plain] view plain copy
判断Double,Float对象封装的值是否是NaN  
只有浮点数对应的封装类具有该方法  
该方法被重载了  
    一个无参数的,非静态的,boolean isNaN()  
    一个是有参数的,静态的,static boolean isNaN(x)  
        x代表float或者double  

案例

[java] view plain copy
package com.itlwc;  
  
public class Test {  
    public static void main(String[] args) {  
        Double d = new Double(12.0%0);  
        if(d.isNaN()){  
            System.out.println("封装的对象值为NaN");  
        }else{  
            System.out.println("封装的对象值为"+d);  
        }  
    }  
}  
/* 
打印结果: 
    封装的对象值为NaN 
*/  

java.math.BigInteger

[java] view plain copy
package com.itlwc;  
  
import java.math.BigInteger;  
  
public class Test {  
    public static void main(String[] args) {  
        BigInteger bi1 = new BigInteger("222222222222222222222");  
        BigInteger bi2 = new BigInteger("111111111111111111111");  
        System.out.println("bi1+bi2: "+ bi1.add(bi2));  
        System.out.println("bi1-bi2: "+ bi1.subtract(bi2));  
        System.out.println("bi1*bi2: "+ bi1.multiply(bi2));  
        System.out.println("bi1/bi2: "+ bi1.divide(bi2));  
        System.out.println("bi1%bi2: "+ bi1.mod(bi2));  
        System.out.println("bi1的负数: "+ bi1.negate());  
        //取bi1的符号  
        if(bi1.signum()==1){  
            System.out.println("bi1为整数");  
        }else{  
            System.out.println("bi1为负数");  
        }  
        //bi1与bi2的大小  
        if(bi1.compareTo(bi2)>0){  
            System.out.println("bi1大于bi2");  
        }else{  
            System.out.println("bi1小于bi2");  
        }  
    }  
}  
/* 
打印结果: 
    bi1+bi2: 333333333333333333333 
    bi1-bi2: 111111111111111111111 
    bi1*bi2: 24691358024691358024641975308641975308642 
    bi1/bi2: 2 
    bi1%bi2: 0 
    bi1的负数: -222222222222222222222 
    bi1为整数 
    bi1大于bi2 
*/  

java.math.BigDecimal 精确计算

[java] view plain copy
package com.itlwc;  
  
import java.math.BigDecimal;  
  
public class Test {  
    public static void main(String[] args) {  
  
        BigDecimal bd1 = new BigDecimal("3.8");  
        BigDecimal bd2 = new BigDecimal("0.7");  
        BigDecimal bd3 = new BigDecimal("3.800");  
        System.out.println("bd1 = " + bd1);  
        System.out.println("bd2 = " + bd2);  
        System.out.println("bd3 = " + bd3);  
        System.out.println("bd1 + bd2 = " + bd1.add(bd2));  
        System.out.println("bd1 - bd2 = " + bd1.subtract(bd2));  
        System.out.println("bd1 * bd2 = " + bd1.multiply(bd2));  
        System.out.println("bd1 / bd2 = "  
                + bd1.divide(bd2, BigDecimal.ROUND_HALF_DOWN));  
        System.out.println("bd3 / bd2 = "  
                + bd3.divide(bd2, BigDecimal.ROUND_HALF_UP));  
        // 将bd1与bd2进行比较  
        if (bd1.compareTo(bd3) == 0) {  
            System.out.println("bd1 = " + bd1 + " bd3 = " + bd3  
                    + " 则bd1与bd3是相等的！！");  
        }  
  
        // 1  
        BigDecimal bigD1 = BigDecimal.ONE;  
        // 10  
        BigDecimal bigD2 = BigDecimal.TEN;  
        // 0  
        BigDecimal bigD3 = BigDecimal.ZERO;  
  
    }  
}  
/* 
打印结果: 
    bd1 = 3.8 
    bd2 = 0.7 
    bd3 = 3.800 
    bd1 + bd2 = 4.5 
    bd1 - bd2 = 3.1 
    bd1 * bd2 = 2.66 
    bd1 / bd2 = 5.4 
    bd3 / bd2 = 5.429 
    bd1 = 3.8 bd3 = 3.800 则bd1与bd3是相等的！！ 
*/  

0 0