java 查看数据类型类型

一、API概述

  API是应用程序编程接口
  Java API是java提供给我们使用的类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用

二、Object类概述

  类层次结构的根类
  所有类都直接或者间接的继承自该类
  构造方法
  public Object()

三、Object类的方法

  1、hashCode()方法
   public int hashCode()
    a、返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
    b、不同对象的hashCode()不同
    c、不是对象的实际地址值，可以理解为逻辑地址值。

public class MyTest1 {
    public static void main(String[] args) {
        Test test1 = new Test();
        Test test2 = new Test();
        System.out.println(test1.hashCode());
        System.out.println(test2.hashCode());
    }
}
class Test{}

运行结果
356573597
1735600054

  2、getClass()方法
   public final class getClass()
    a、返回此Object的运行时类
    b、可以通过class类中的一个方法，获取对象的真实类的全名称。
  public String getName()

public class MyTest {
    public static void main(String[] args) {
        Object obj1 = new Object();
        Class class1 = obj1.getClass();
        Object obj2 = new Object();
        Class class2 = obj2.getClass();

        System.out.println(obj1==obj2);
        System.out.println(class1==class2);
        System.out.println("--------------------");
        Test test = new Test();
        Class<? extends Test> class3 = test.getClass();
        System.out.println(class3.getName());
    }
}
class Test {
}
运行结果
false
true
--------------------
com.mi.demo5.Test

  3、toString()方法
  public String toString()
  a、返回该对象的字符串表示
   源代码：

public String toString() {
   					 return getClass().getName() + "@" + Integer.toHexString(hashCode());
				}

  b、从源代码看出，返回值是getClass().getName() + “@” + Integer.toHexString(hashCode());，也就是物理地址名+@+逻辑地址值
  c、由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。重写是将该类的所有的成员变量组成返回

public class MyTest {
    public static void main(String[] args) {
        Person person = new Person("洛天依",15);
        System.out.println(person.toString());
        System.out.println("============================");
        Person2 person2 = new Person2("言和",17);
        System.out.println(person2);

    }
}
class Person{
        String name;
        int age;
        public Person(String name,int age){
            this.name = name;
            this.age=age;
        }
    public String toString(){
            return name+age+"岁";
    }
}
class Person2{
    String name ;
    int age ;
    public Person2(String name,int age){
        this.name = name;
        this.age=age;
    }
}

运行结果：
洛天依15岁
============================
com.mi.demo5.Person2@1540e19d

  4、equals()方法
  指示其他某个对象是否与此对象“相等”
    源代码：

public boolean equals(Object obj) {
    					return (this == obj);
				}

  默认情况下比较的是对象的引用是否相等
  由于比较对象的引用没有意义，一般建议重写该方法。一般用于比较成员变量的值是否相等

public class MyTest {
    public static void main(String[] args) {
        Person person = new Person();
        Person2 person2 = new Person2();
        System.out.println(person.equals(person2)); //默认方法，比较的是对象的地址值是否相同
        System.out.println("================================");
        Person3 person3 = new Person3("言和","girl");
        Person3 person31 = new Person3("言和", "girl");
        System.out.println(person3.equals(person31));//重写方法过后，比较的是对象的成员是否相等
    }
}
class Person{
    String name = "天依";
    String sex = "girl";
    }

class Person2{
    String name = "天依";
    String sex = "girl";
    }
class Person3{
    String name;
    String sex;
    public Person3(String name,String sex){
        this.name=name;
        this.sex=sex;
    }
    public boolean equals(Object obj){
        if(this==obj){
            return true;
        }else if(!(obj instanceof Person3)){  //instanceof 判断一个引用，是否是，该类型的一个引用
            return false;
        }
        Person3 per = (Person3) obj;  //向下转型，将Object类转为和要比较对象一样的类
        return this.name.equals(per.name)&&this.sex.equals(per.sex);
    }
}
运行结果
false
================================
true

  5、clone()方法
  clone()的权限修饰符是受保护的，在用的时候，让该类重写该方法，并把该方法的权限修饰符改为public
  对象的克隆分为浅克隆和深克隆，使用clone()方法采用的是浅克隆的方式
  对象的浅克隆要注意的细节：
  1、如果一个对象需要调用clone()方法克隆，那么该对象所属的类必须要实现Cloneable接口
  2、Cloneable接口只不过是一个表示接口而已，没有任何方法。
  3、对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
  4、对象的浅克隆不会调用到构造方法的
  对象的深克隆采用IO流来实现，使用 ObjectOutputStream将对象写入文件中，然后再用 ObjectInputStream读取出来，详见：深克隆

public class MyTest2 {
    public static void main(String[] args) throws CloneNotSupportedException{
        CatFood catFood = new CatFood("小鱼干");
        Cat cat1 = new Cat("小黑",233,catFood);
        cat1.catFood.name="小饼干";
        Cat cat2 = (Cat) cat1.clone();
 //对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
        cat2.catFood.name="小肉干";
        System.out.println(cat1.catFood.name);
        System.out.println(cat2.catFood.name);
    }
}
class Cat implements Cloneable{
    String name;
    int age;
    CatFood catFood;
    public Cat(){

    }
    public Cat(String name,int age,CatFood catFood){
        this.name=name;
        this.age=age;
        this.catFood=catFood;
    }
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}
class CatFood{
    String name;
    public CatFood(String name){
        this.name=name;
    }
}
运行结果：
小肉干
小肉干