Java语言基础

常见对象

用程序编程接口 API(Application Programming Interface)

1. Java API
   就是Java提供给我们使用的类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。
2. Object类概述
   顶层父类，类层次结构的根类；
   所有类都直接或者间接的继承自该类
3. 构造方法
   public Object()
   就像子类的构造方法默认访问的是父类的无参构造方法

Object(类)

• hashCode()方法
  public int hashCode()；

1. 返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
2. 不同对象的，hashCode()一般来说不会相同。
   但是，同一个对象的hashCode()值肯定相同。
3. 不是对象的实际地址值，可以理解为逻辑地址值。

• getClass()方法
  public final Class getClass()；

1. 返回此 Object 的运行时类。
2. 可以通过Class类中的一个方法，获取对象的真实类的全名称。
   public String getName()

• toString()方法
  public String toString()；

1. 返回该对象的字符串表示。
2. 它的源代码:
   public String toString() {
   return getClass().getName() + “@” + Integer.toHexString(hashCode());
   }
3. 它的值等于：
   getClass().getName() + ‘@’ + Integer.toHexString(hashCode())
4. 由于默认情况下的数据对我们来说没有意义，一般重写该方法，将该类的所有的成员变量组成返回即可
5. 直接输出对应的名称,就是调用对象的toString()方法

//例1：
class MyTest extends Student{
    public static void main(String[] args) {
        Object obj = new Object();
        int hashCode = obj.hashCode();
        System.out.println(hashCode);//打印结果：1325547227
        Class aClass = obj.getClass();//Object.class---->JVM为这个文件创建的对象，获取出来
        System.out.println(aClass);//打印结果：class java.lang.Object
        String string = obj.toString();
        System.out.println(string);//打印结果：java.lang.Object@4f023edb
        Student student = new Student();
        System.out.println(student);//打印结果：Student{a=200}
    }
}
class Student {//省略的格式：class Student extends Object
    int a=200;
    //重写toString()方法
    @Override
    public String toString() {
        return "Student{" +
                "a=" + a +
                '}';
    }
}

• equals()方法

1. 指示其他某个对象是否与此对象“相等”。
   源代码:
   public boolean equals(Object obj) {
   return (this == obj);
   }
2. 默认情况下比较的是对象的引用是否相同。
3. 由于比较对象的引用没有意义，一般建议重写该方法，一般用于比较成员变量的值是否相等。
4. == 和 equals() 的区别：
   = = 是一个比较运算符，他可以比较基本数据类，也可以比较引用数据类型；
   比较基本数据类型，比较的是两个值是否相同,比较引用数据类型，比较的是地址值是否相同；
   equals() 是Object类中的方法，只能比较引用数据类型，比较的是两个对象的地址值是否相同。

//例2：比较两个对象
class MyTest {
    public static void main(String[] args) {
        Object obj = new Object();
        Object obj2 = new Object();
        System.out.println(obj==obj2);//结果：false
        boolean b = obj.equals(obj2);
        System.out.println(b);//结果：false
        }
}

5. 由于比较两个对象的地址值是否相同意义不大，我们需要重写equals()方法；比较两个对象的成员变量的值，如果一模一样，就认为两个对象一样。

//例3：创建一个Student类，比较它的两个对象成员变量是否相同，
      //通过重写equals()方法，并从以下的几个方面完善自己的方法
class MyTest {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("张三", 23);
        boolean b = s1.equals(s2);//调用重写后的equals方法
        System.out.println(b);//打印结果：true
    }
}
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;
        }
        //从*健壮性*考虑，上面传过来的这个引用，是不是该类的引用
        //instanceof 判断一个对象（引用）是不是该类型的一个引用
        if (!(obj instanceof Student)) {
            return false;
        }
        //向下转型
        Student stu = (Student) obj;
        //String 类 是引用类型，你用 == 来比较两个字符串，比较的是两个字符串地址值，是否一样
        //如果你想要比较两个字符串的字面值内容是否一样，就调用equals()方法来比较，
        //String exends Object{} String 也重写了equals()方法来比两个字符串的内容是否相同
        return this.age == stu.age && this.name.equals(stu.name);//比较age和name是否相同
    }
}

• clone() 方法

1. clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public
2. 对象的克隆:浅克隆和深克隆,使用clone()方法采用的是浅克隆的方式
3. 对象的浅克隆：就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
4. 对象浅克隆要注意的细节：
   a.） 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
   b.）Cloneable接口只不过是一个标识接口而已，没有任何方法，就是给该类打一个标记，是告诉JVM我要完成某种操作；
   d.） 对象的浅克隆也不会调用到构造方法的。

Cloneable接口的源代码：
public interface Cloneable {
}

//例4：创建一个Dog类，然后浅克隆该类的一个对象
class MyTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        // protected Object clone () 创建并返回此对象的副本。
        //clone()方法是受保护的 你让子类重写一些，把方法的修饰符改为public 重写逻辑还是使用父类的
        Dog dog = new Dog("旺财", 3);
        System.out.println(dog.name);//打印结果：旺财
        System.out.println(dog.age);//打印结果：3
        Dog dog2 = (Dog) dog.clone();//调用clone方法
        dog2.name="布鲁斯";
        dog2.age=5;
        System.out.println(dog2.name);//打印结果：布鲁斯
        System.out.println(dog2.age);//打印结果：5
    }
}
class Dog extends Object implements Cloneable{
    String name;
    int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //clone() 方法的重写
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

//下篇再见…谢谢