java基础之常用类Object，包装类

-常用类

Object

• 最大父类,也称为祖宗类. 所有类都直接或间接的继承自Object

常用方法

1. Class getClass() : 获取引用的实际对象类型

    Animal a1 = new Dog();
           Animal a2 = new Cat();
           Dog dog = new Dog();
           //获取实际对象类型
           System.out.println(a1.getClass());//com.by.entity.Dog
           System.out.println(a2.getClass());//com.by.entity.Cat
           //判断a1和a2是否相同
           System.out.println(a1.getClass() == a2.getClass());//f
           System.out.println(a1.getClass() == dog.getClass());//t

2. int hashCode() : 获取当前对象的哈希码值

   • 重写原因: 该方法默认关注对象地址,地址不同则哈希码值不同. 但是开发过程中某些情况下我们需要关注的是对象内容,内容一致则哈希码值必定一致,所以需要对其重写

   • 重写规则:

     1. 整型: 直接相加

     2. 小数类型: 强转int后相加

     3. 引用类型: 属性名.hashCode()相加

        • 类库中的引用类型: 该方法已经提供过重写,所以直接调用方法即可

        • 自定义的引用类型: 需要先将自定义类型的该方法重写,再进行调用

3. boolean equals(Object o): 判断当前对象与参数对象是否相同

   • 重写原因: 该方法默认比较对象地址,但是在开发过程中,某些情况下需要比较双方内容,所以需要提供重写

   • 重写规则:

     public boolean equals(Object o) {
             //自反性
             if (this == o) {
                 return true;//自己和自己比,一定相同
             }
             //非空判断 和 类型比较
             if (o == null || this.getClass()!=o.getClass()) {
                 return false;//与null值比或者实际对象类型不一致,一定不同
             }
             //类型强转
             当前类名 引用名 = (当前类名) o;
             //比较属性值
            return 让当前对象的属性与引用名的属性进行比较,多个属性值之间的比较&&连接;
         }

     • 比较属性值:

       1. 基本类型: ==直接比较

       2. 引用类型:

          • 类库中的引用类型: 对equals已经提供过重写,所以可以直接调用

          • 自定义的引用类型: 对自定义类型中的equals也进行重写,然后调用

     package com.by.entity;
     ​
     ​
     public class Student {
         private String name;
         private int age;
         private double score;
         private Teacher tea;
     ​
     ​
         @Override
         public int hashCode() {
             return age+(int)score+name.hashCode()+ tea.hashCode();
         }
     ​
         public boolean equals(Object o) {//Object o=new Student();
             //自反性
             if (this == o) {
                 return true;//自己和自己比,一定相同
             }
             //非空判断 和 类型比较
             if (o == null || this.getClass()!=o.getClass()) {
                 return false;//与null值比或者实际对象类型不一致,一定不同
             }
             //类型强转
             Student s = (Student) o;
             //比较属性值
            return this.age==s.age && this.score==s.score && this.name.equals(s.name) && this.tea.equals(s.tea);
     ​
         }
     ​
     //省略getter\setter\构造
     }
     ​
     package com.by.entity;
     ​
     public class Teacher {
         private String name;
     ​
         public int hashCode(){
             return name.hashCode();
         }
     ​
         public boolean equals(Object o) {
             //自反性
             if (this == o) {
                 return true;
             }
             //非空判断+类型比较
             if (o == null || this.getClass() != o.getClass()) {
                 return false;
             }
             //类型强转
             Teacher t = (Teacher) o;
             //属性值比较
             return this.name.equals(t.name);
         }
         
     //省略getter\setter\构造
     ​
     }

4. String toString() : 用来返回当前对象的信息

   • 重写原因: 该方法默认获取对象地址返回,但是实际开发中,通常查看的是对象的内容,所以需要重写

   • 重写规则: 根据查看需求拼接属性值返回即可

   • 使用:

     • 在直接查看引用时可以自动调用

5. void finalize() : 用来进行垃圾回收

   • 垃圾回收机制: 当内存满到不足以支撑新对象的创建时,虚拟机会调用垃圾对象的该方法对其进行回收销毁,以此来释放空间

   • 垃圾对象判断标准: 没有任何引用指向的对象 (零引用机制)

   • 手动垃圾回收: 可以借助垃圾回收期GC,通过在代码中书写System.gc()来实现手动的垃圾回收

包装类

• 作用为将八大基本类型包装为引用类型

byte	short	int	long	float	double	char	boolean
Byte	Short	Integer	Long	Float	Double	Character	Boolean

基本类型与包装类型

基转包

1. 利用构造

   包装类型 引用名=new 包装类名(基本类型);

2. 利用valueOf

   包装类型 引用名=包装类名.valueOf(基本类型);

包转基

1. 利用xxxValue

   基本类型 变量名=包装类型引用名.xxxValue();
   注:xxx对应的是基本类型名

自动转换

• JDK5.0之后,为了方便操作,提供了自动封箱与拆箱,使得基本类型与包装类型之间可以自动转换

• 封箱: 基本类型转包装类型

• 拆箱: 包装类型转基本类型

 int a1=10;
        //1.构造
        Integer i1 = new Integer(a1);
        //2. valueOf
        Integer i2 = Integer.valueOf(a1);
        //包转基
        int a2 = i2.intValue();
        //自动转换
        Integer i3 = a1;
        int a3 = i3;

基本类型与String

基转String

1. 字符串拼接

   String 引用名=基本类型+"";
   String 引用名=""+基本类型;

2. 利用valueOf

   String 引用名=String.valueOf(基本类型);

String转基

1. 利用parseXxx方法

   基本类型 变量名=对应的包装类名.parseXxx(String类型);
   注:Xxx对应的是基本类型名,首字母大写

必须包装String中的数据是基本类型能够盛放的数据,否则执行时会触发NumberFormatException数据类型转换异常

  int a1 = 100;
        //字符串拼接
        String s1 = a1 + "abc";
        String s2 = "" + a1;
        String s3=String.valueOf(a1);
        //String转基
        int a2 = Integer.parseInt(s2);
       // int a3 = Integer.parseInt(s1);//100abc 报错

包装类型与String

包转String

1. 字符串拼接

   String 引用名=包装类型+"";
   String 引用名=""+包装类型;

2. 利用toString

   String 引用名=包装类型引用名.toString();

String转包

与基转包一致

必须保证String的值为包装类型能够盛放的值

Integer i1 = 100;
        //字符串拼接
        String s1 = i1 + "qwe";
        String s2 = "" + i1;
        //toString
        String s3 = i1.toString();
        //String转包
        Integer i2 = new Integer(s2);
        Integer i3 = Integer.valueOf(s3);
​
       // Integer i4 = new Integer(s1); 报错

整数缓冲区

官方认定-128至127是最常用的256个数字，为了减少包装类型使用反复数字带来的空间浪费，所以在方法区中设立了整数缓冲区，用来存放这256个数字，当包装类型使用的数字在此范围内，则直接引用缓冲区地址，不再额外开辟对象空间，以此达到节省空间的目的

==比较引用类型地址时，优先使用堆中的对象地址

Integer i1 = 200;
        Integer i2 = 200;
        System.out.println(i1 == i2);//f
​
        Integer i3 = 100;
        Integer i4 = 100;
        System.out.println(i3 == i4);//t
​
        Integer i5 = new Integer(100);
        Integer i6 = new Integer(100);
        System.out.println(i5 == i6);//f
​
​
        System.out.println(i3 == i5);//f