JAVA入门———API概述 AND object类下的方法

API

• Application Programming Interface——应用程序编程接口
• Java API——Java提供的类，只需学会使用

object

• object是一个顶层父类，所有的类都直接或间接地继承它
• object下有很多的系统自带的方法，例如：hashcode（），equal（），toString（）等等

hashcode（）

• 定义：返回该对象的哈希码值
• new出来的不同对象的哈希码值不同，同一个对象哈希码值一定相同

	  Object obj = new Object();
      int code = obj.hashCode();
       System.out.println(code);
       
       Object obj2 = new Object();
       int code2 = obj2.hashCode();
       System.out.println(code2);

getclass（）

• 返回此Object运行时的类

  Object obj = new Object();
        System.out.println(obj);
        Object obj2 = new Object();
        System.out.println(obj2);

        Class c = obj.getClass();
        Class c1 = obj2.getClass();
        System.out.println(c == c1);

toString（）

• 返回该对象的字符串表示，打印对象的地址值

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

注：子类可以重些父类的toString()方法，打印你想要看的东西

		.........
        Object obj = new Object();
        String name = obj.toString();
        System.out.println(name);
        System.out.println(obj);//打印出全限定类名——包名+类名—java.lang.Object@1b6d3586
        Student stu = new Student();
        System.out.println(stu);
    }
}
class Student{
    int a = 20;
    @Override
    public String toString() {
        return "Student{" +
                "a=" + a +
                '}';
    }
}

equals（）

• 判断某个对象是否与本对象的地址值相等
• 原代码：
  public boolean equals(Object obj) { return (this == obj); }
• 优点：提高效率，提高健壮性（和 == 相比较）

==作用： 运算符，可以比较基本数据类型，也可以比较引用数据类型

比较基本数据类型，比较的是两个值是否相同
比较引用数据类型，比较的是地址值是否相同

equals()作用： Object类中的方法，只能比较引用数据类型，比较的是两个对象的地址值是否相同

public class demo5 {
    public static void main(String[] args) {
        student stu1 = new student("李华",15);
        student stu2 = new student("李华", 15);
        boolean b = stu1.equals(stu2);
        System.out.println(b);
    }
}
class student {
    private String name;
    private int age;
    public student() {}
    public student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) {
        //从非空判断
        if(obj == null){
            return false;
        }
        //从效率判断
        if(this == obj){
            return true;
        }
        //判断一个对象（引用）是不是该类型的对象（引用）
        if(!(obj instanceof student)){
            return false;
        }
        //向下转型
        student stu = (student) obj;
        return this.age == stu.age&&this.name.equals(stu.name);
    }
}

重写方法可自动写出

// 可自动写出：Generate——equals（）and hashcode（）
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        teacher teacher = (teacher) o;
        return age == teacher.age &&
                Objects.equals(name, teacher.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

clone（）

• 接口中没有任何的抽象方法的接口——标记接口：给该类打一个标记 告诉JVM要完成某种操作
• clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public
  使用clone()方法采用的是浅克隆的方式

注意：

1. 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
2. Cloneable接口只不过是一个标识接口而已，没有任何方法。
3. 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
4. 对象的浅克隆也不会调用到构造方法的。

public class demo7 {
    public static void main(String[] args) throws CloneNotSupportedException {
        dog d1 = new dog("汪汪", 5);
        System.out.println(d1.name);
        System.out.println(d1.age);
        dog d2 = (dog) d1.clone();
        d2.name = "wangwang";
        System.out.println(d2.name);
        System.out.println(d2.age);
    }
}
class dog extends Object implements Cloneable{
    String name;
    int age;
    public dog(String name,int age){
        this.name = name;
        this.age = age;
    }
    //重写克隆方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}