Object与包装类

1.Object类

Object是所有类的顶级超类,其中有两个经常被子类重写的方法:

toString()与equals().

package object;

/**
 * Object是所有类的顶级超类.里面有几个经常被子类重写的方法,其中包括toString和equals
 */
public class Demo {
    public static void main(String[] args) {
        Point p = new Point(1,2);
        /*
            Object已经实现了toString方法.若不重写，直接继承下来时返回的字符串内容为当前对象的地址信息.格式为:类名@地址.
            toString方法实际开发中很少直接写代码去调用它,都是在不经意间被自动执行的.
            例如在使用System.out.println输出时.与字符串连接操作时.
         */
        //System.out.println(Object obj)输出给定对象toString返回的字符串到控制台
        System.out.println(p);
        

        //字符串连接操作时,会将非String类型的对象调用toString转换为字符串后拼接.
        String line = "这是一个Point:" + p;
        System.out.println(line);

        Point p2 = new Point(1,2);
        System.out.println("p2:"+p2);
        /*
            对于引用类型而言,变量保存的值是对象的地址.
            ==比较是比较两个变量的值是否相等,因此对于引用类型而言就是比较地址是否相等,那么意思就是比较是否为同一个对象.

            equals是Object定义的另一个方法,意图是比较两个对象的内容是否相同.但是如果子类不重写这个方法,则没有实际意义,因为Object实现时内部仍然是用==比较的!
            String类自己重写了equals，不需要再重写；自己定义的类需要重写equals
         */
        System.out.println(p == p2);//false
        System.out.println(p.equals(p2));//true
    }
}

• 派生类重写equals(）的基本规则：
  • 两个对象必须是同一个类型，若类型不同则返回false
  • 若参数对象为null，则返回false
  • 原则上两个对象要比较对象的属性（内容）是否相同

2.包装类

基本类型	引用类型
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Booelan

java定义了8个包装类,目的是为了解决基本类型不能直接参与面向对象开发的问题,使得基本类型可以通过包装类的实例以对象的形式存在.

• 其中数字类型的包装类都继承自java.lang.Number,而char和boolean的包装类直接继承自Object
• Number是一个抽象类,定义了一些方法,目的是让包装类可以将其表示的基本类型转换为其他数字类型.

package integer;

public class IntegerDemo1 {
    public static void main(String[] args) {
        //基本类型转换为包装类
        int i = 123;
        //java推荐我们使用包装类的静态方法valueOf将基本类型转换为包装类,而不是直接new
        Integer i1 = Integer.valueOf(i);//Integer会重用-128-127之间的整数对象
        Integer i2 = Integer.valueOf(i);
        System.out.println(i1==i2);//true
        System.out.println(i1.equals(i2));//true

        double dou = 123.123;
        Double dou1 = Double.valueOf(dou);//Double则是直接new
        Double dou2 = Double.valueOf(dou);
        System.out.println(dou1==dou2);//false
        System.out.println(dou1.equals(dou2));//true

        //包装类转换为基本类型
        int in = i1.intValue();//获取包装类对象中表示的基本类型值
        double doub = i1.doubleValue();
        System.out.println(in);//123
        System.out.println(doub);//123.0

        in = dou1.intValue();//大类型转小类型可能存在丢精度!
        doub = dou1.doubleValue();
        System.out.println(in);//123
        System.out.println(doub);//123.123
    }
}

3.包装类常用功能

package integer;

public class IntegerDemo2 {
    public static void main(String[] args) {
        //1可以通过包装类获取其表示的基本类型的取值范围
        //获取int的最大值和最小值?
        int imax = Integer.MAX_VALUE;
        System.out.println(imax);
        int imin = Integer.MIN_VALUE;
        System.out.println(imin);

        long lmax = Long.MAX_VALUE;
        System.out.println(lmax);
        long lmin = Long.MIN_VALUE;
        System.out.println(lmin);

        /*
            2字符串转换为基本类型的前提是该字符串正确描述了基本类型可以保存的值,否则
            会抛出异常:NumberFormatException
         */
        String str = "123";
//        String str = "123.123";//这个字符串不能解析为int值!
        int d = Integer.parseInt(str);
        System.out.println(d);//123
        double dou = Double.parseDouble(str);
        System.out.println(dou);//123.123
    }
}

Integer和int之间对比时Integer会进行拆箱为int类型，再进行基本类型的对比
对于自动装箱来说，要是在-128~127之间，会直接返还给你一个数，不用开辟新的空间，如果不在范围，则在堆中新建一个Integer对象。

4.自动拆装箱特性

JDK5之后推出了一个新的特性:自动拆装箱
基本类型和包装类之间可以直接赋值，无需做转换操作
该特性是编译器认可的.当编译器编译源代码时发现有基本类型和引用类型相互赋值使用时会自动补充代码来完成他们的转换工作,这个过程称为自动拆装箱.

package integer;

public class IntegerDemo3 {
    public static void main(String[] args) {
        /*
            触发自动拆箱特性,编译器会补充代码将包装类转换为基本类型,下面的代码会变为:
            int i = new Integer(123).intValue();
         */
        int i = new Integer(123);
        /*
            触发编译器自动装箱特性,代码会被编译器改为:
            Integer in = Integer.valueOf(123);
         */
        Integer in = 123;
    }
}

5.方法摘要

//1.构造方法摘要
Integer i1=new Integer(12);//int ------->Integer
Integer i2=new Integer(“12”);//String ------>Integer
//2：自动装箱（自动转换）int -------->Integer
Integer i3=12;//Integer i3=Integer.valueOf(12);
//3：自动拆箱 Integer ---------->int
int i4=i1;
//4：方法摘要
//（1）比较两个包装类所对应的int数据
i1.compareTo(i2); 
return(x<y)?-1:((x==y)?0:1)
//（2）
Integer i5=12;Integer i6=12;
System.out.println(i5==i6)//true
Integer i5=129;Integer i6=129;
System.out.println(i5==i6)//false
//对于自动装箱来说，要是在-128~127之间，会直接返还给你一个数，不用开辟新的空间，如果不在范围，则在堆中新建一个Integer对象。
（3）intValue//以int类型返回Integer的值    Integer----->int
int i7=i1.intValue//i7=12
（4）int i8=Integer.parseInt(“12”)//i8=12   String------>int
（5）i1.toString（）  // 12   Integer------->String
（6）valueOf //将指定类型转换为Integer类型
（7）MAX_VALUE/MIN_VALUE//获取基本类型的最大/最小值·