10.Java面向对象-Object(类)

10.Java面向对象-Object(类)

一、API概述以及Object类的概述

A:API(Application Programming Interface) 
	应用程序编程接口
B:Java API
	就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
	我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。
C:Object类概述
	类层次结构的根类
	所有类都直接或者间接的继承自该类
D:构造方法
	public Object()
	回想面向对象中为什么说：
	子类的构造方法默认访问的是父类的无参构造方法

二、Object类的hashCode()方法

A:案例演示
	public int hashCode()
		a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
		b:不同对象的，hashCode()一般来说不会相同。
	  	   但是，同一个对象的hashCode()值肯定相同。
		c:不是对象的实际地址值，可以理解为逻辑地址值。	

package org.westos.java9;

class test{
    public static void main(String[] args) {
        animal animal = new animal();
        System.out.println(animal.hashCode()); //356573597
        animal=new animal();
        System.out.println(animal.hashCode()); //1735600054
    }
}

class animal{

}

三、Object类的getClass()方法

A:案例演示
	public final Class getClass()
		a:返回此 Object 的运行时类。
		b:可以通过Class类中的一个方法，获取对象的真实类的全名称。	
		public String getName()

package org.westos.java9;

class test{
    public static void main(String[] args) {
        animal animal = new animal();
        //返回该类的字节码文件对象。
        // Object.java--->Object.class---->加载进内存--->JVM会为Object.class创建对象---->通过getClass()获取字节码文件对象
        //Class 这个类型，用来表示是 字节码文件类型
        //对应此处为animal.java--->animal.class
        System.out.println(animal.getClass()); //class org.westos.java9.animal
        animal=new animal();
        System.out.println(animal.getClass()); //class org.westos.java9.animal 相等
        System.out.println(animal.getClass().getName()); //org.westos.java9.animal 对象的真实类的全名称

    }
}

class animal{

}

四、Object类的toString()方法

A:案例演示
	public String toString()
	a:返回该对象的字符串表示。
		源代码:
		 	public String toString() {
   					 return getClass().getName() + "@" + Integer.toHexString(hashCode());
				}
	b:它的值等于： 
		getClass().getName() + '@' + Integer.toHexString(hashCode()) 
	c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
	  怎么重写, 一般是将该类的所有的成员变量组成返回即可
B:最终版
	自动生成
C: 直接输出对应的名称,就是调用对象的toString()方法

package org.westos.java9;

class test{
    public static void main(String[] args) {
        animal animal = new animal();
/*        public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }*/
/*        System.out.println(animal); //org.westos.java9.animal@1540e19d
        System.out.println(animal.toString()); //org.westos.java9.animal@1540e19d 相等
        animal=new animal();
        System.out.println(animal.toString()); //org.westos.java9.animal@677327b6 不相等
        animal=new animal();*/
        System.out.println(animal); //animal{age=0, name='null'}
        animal=new animal(15,"lily");
        System.out.println(animal); //animal{age=15, name='lily'}
        System.out.println(animal.toString()); //animal{age=15, name='lily'}
    }
}

class animal{
    int age;
    String name;

    @Override
    public String toString() {
        return "animal{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public animal(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public animal() {
    }
}

五、Object类的equals()方法

A:案例演示
	a:指示其他某个对象是否与此对象“相等”。 
		源代码: 	
				public boolean equals(Object obj) {
    					return (this == obj);
				}
	b:默认情况下比较的是对象的引用(地址值)是否相同。
	c:由于比较对象的引用没有意义，一般建议重写该方法。一般用于比较成员变量的值是否相等
	d:==和equals()的区别。(面试题)

package org.westos.java11;

public class Test3 {
    public static void main(String[] args) {
        Student student = new Student("lt", 18);
        Student student1 = new Student("lt", 18);
        Dog dog = new Dog("lt", 18);
        Dog dog1=dog;
       /* System.out.println(student.equals(student1)); //不重写equals方法则返回false，地址值是不相等的
        System.out.println(student.equals(student1)); //重写equals方法后则返回true
        System.out.println(student.equals(student));*/
        //org.westos.java11.Dog cannot be cast to org.westos.java11.Student
        System.out.println(student.equals(dog)); // instanceof 判断一个对象或引用，是不是该类型的一个引用
        System.out.println(student.equals(student1)); //true
        System.out.println(dog.equals(student)); //false
        System.out.println(dog1.equals(dog)); //true
        /*==:
        当比较的是基本类型时,比较的是值的大小是否相等；
        当比较的是引用类型时,比较的是地址值是否相等；
         equals():
         默认情况下比较的是两个引用的地址值大小是否相等,可以通过重写该方法来完成自己所需的功能,
         如String这个类就重写了equals()方法,比较的是字符串每个字符是否相同。
        */
    }
}

class Student{
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if(this==obj){
            return true;
        }
        if(!(obj instanceof Student)){
            return false;
        }
        Student a= (Student) obj;
        return this.age==a.age && this.name.equals(a.name);
    }

/*    @Override //系统自动生成
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }*/
}
class Dog{
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }
/*    public boolean equals(Object obj) {
        return (this == obj);
    }*/
}

六、Object类的equals()方法代码优化

A:案例演示
	Object类的equals()方法代码优化
		a: 提高效率 // if(this==obj){return true;}
		b: 提高健壮性(instanceof)//if(!(obj instanceof Student)){return false;}
B:最终版
	自动生成

七、Object类的clone() 方法

clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public
 	对象的浅克隆:浅克隆和深克隆
​	使用clone()方法采用的是浅克隆的方式

 	对象浅克隆要注意的细节： 

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

 	对象的深克隆(后面讲)：采用IO流来实现  使用 ObjectOutputStream 将对象写入文件中,然后再用ObjectInputStream读取回来

package org.westos.java11;

public class Test4 {
    public static void main(String[] args) throws CloneNotSupportedException {
        DogFood food = new DogFood("wanwan");
        DogDog dog = new DogDog(5, "xiaobai", food); //调用了构造方法
        //虽然创建的对象与上一个对象的成员变量值完全相同,但是与克隆的不同之处在于它调用了构造方法
        //DogDog dog1 = new DogDog(5, "xiaobai", food);
        Object clone = dog.clone(); //没有调用构造方法 同时属于浅克隆
        DogDog dogclone= (DogDog) clone;
        dogclone.age=4;
        //dogclone.food.name="shuanghui";
        dogclone.food=new DogFood("shuanghui");
        System.out.println(dog.age); //5
        System.out.println(dog.name); //xiaobai
        System.out.println(dog.food.name); //如果没有new DogFood()就是 shuanghui,如果new DogFood()就是 wanwan
        System.out.println(dogclone.age); //4
        System.out.println(dogclone.name); //xiaobai
        System.out.println(dogclone.food.name); //shuanghui


    }
}

class DogDog implements Cloneable{

/*  Cloneable只是一个标识接口,没有任何方法,给这个类作一个标识,使JVM知道这个类需要使用克隆方法
    public interface Cloneable {
    }
*/

    int age;
    String name;
    DogFood food;

    public DogDog(int age, String name, DogFood food) {
        System.out.println("构造方法创建了");
        this.age = age;
        this.name = name;
        this.food = food;
    }

    @Override // 可以改为 public
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class DogFood{
    String name;

    public DogFood(String name) {
        this.name = name;
    }
}