1.API概述以及Object类的概述
1.API(Application Programming Interface)
应用程序编程接口
2.Java API
就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。
3.Object类概述
类层次结构的根类
所有类都直接或者间接的继承自该类
4.构造方法
public Object()
回想面向对象中为什么说：
子类的构造方法默认访问的是父类的无参构造方法
2.Object类的hashCode()方法
public int hashCode()
a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
b:不同对象的，hashCode()一般来说不会相同。
但是，同一个对象的hashCode()值肯定相同。
c:不是对象的实际地址值，可以理解为逻辑地址值。
//import java.lang.Object; //java.lang 包下的类，导入语句可以省略不写
public class MyTest{
public static void main(String[] args) {
//java.lang
//Object 所有类的顶层父类，所有类都是直接或间接继承自他
Object obj= new Object();
System.out.println(obj);
//a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
int i = obj.hashCode();
System.out.println(i);
Object obj2 = new Object();
System.out.println(obj2);
int i1 = obj2.hashCode();
System.out.println(i1);
//不同对象的哈希码值，是不一样的。
}
}3.Object类的getClass()方法
public final Class getClass()
a:返回此 Object 的运行时类。
b:可以通过Class类中的一个方法，获取对象的真实类的全名称。
public String getName()
public class MyTest2 {
public static void main(String[] args) {
//Object.java--编译----Object.class(字节码文件)----->Object.class加载，
// 虚拟机就会创建该字节码文件的对象。用Classs类型来表示字节码类型
Object obj = new Object();
//获取该类的字节码文件对象。
Class<?> aClass = obj.getClass();
Object obj2 = new Object();
Class<?> aClass1 = obj2.getClass();
System.out.println(obj==obj2); //false
Object object3 = new Object();
Class<?> aClass2 = object3.getClass();
System.out.println(aClass==aClass1); //true
System.out.println(aClass1 == aClass2);
}
}
4.Object类的toString()方法
1.案例演示
public String toString()
a:返回该对象的字符串表示。
源代码:
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
b:它的值等于：
getClass().getName() + '@' + Integer.toHexString(hashCode())
c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
怎么重写, 一般是将该类的所有的成员变量组成返回即可
2.最终版
自动生成
3.直接输出对应的名称,就是调用对象的toString()方法
学生类：
public class Student extends Object{
}测试类：
public class MyTest {
public static void main(String[] args) {
Object obj = new Object();
//toString() 方法或对象的地址值，以字符串形式返回。
String s = obj.toString();
System.out.println(s);
//当你打印对象名的时候，其实后面调用了toString()方法，只是我们经常省略不写。
System.out.println(obj);
Student student = new Student();
System.out.println(student.toString());
int i = student.hashCode();
System.out.println(i);
Class<? extends Student> aClass = student.getClass();
System.out.println(aClass);
}
}
在Student类中重写toString方法 ：
Student类：
public class Student {
private String name;
private int 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;
}
public void show() {
System.out.println(name + "====" + age);
}
/*
@Override
public String toString() {
return "姓名:"+name+" 年龄："+age;
}
*/
//一般我们自定义的类，重写toString()方法时，是喜欢输出成员变量的值
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}测试类：
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.setName("zhangsan");
student.setAge(23);
// String name = student.getName();
// int age = student.getAge();
// System.out.println(name+"===="+age);
student.show();
/*
public String toString () {
return this.getClass().getName() + "@" + Integer.toHexString(hashCode());
}
*/
/*
* Object 类中的toString()方法的默认实现，是打印对象的地址值，
* 但是有些子类，觉得打印对象的地址值，意义不大，他想打印一下，自己认为有意义的东西
* 比如我们自定义的类 Student 他想打印成员变量的值，而是对象的地址值，那这个Student子类，应该重写父类toString()方法，来打印成员变量的值。
*
* */
System.out.println(student.toString());
}
}如果你以后打印一个对象名，没有输出地址值，说明该类重写了父类Object类的toString();
比如Scanner就重写了toString方法：
import java.util.Scanner;
public class MyTest2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//如果你以后打印一个对象名，没有输出地址值，说明该类重写了父类Object类的toString();
System.out.println(scanner);
}
}
5.Object类的equals()方法
1.案例演示
a:指示其他某个对象是否与此对象“相等”。
源代码:
public boolean equals(Object obj) {
return (this == obj);
}
b:默认情况下比较的是对象的引用是否相同。
c:由于比较对象的引用没有意义，一般建议重写该方法。一般用于比较成员变量的值是否相等
d:==和equals()的区别。(面试题)
没有重写equals方法之前，比较两个对象得地址值是否相等：
Student类：
public class Student {
private String name;
private int 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;
}
public boolean equals(Object obj){
return this==obj;
}
}测试类：
public class MyTest {
public static void main(String[] args) {
Object obj = new Object();
Object obj2= new Object();
//== 号可以判断两个对象的地址值，是否相同
System.out.println(obj==obj2);
/*
* public boolean equals(Object obj) {
return (this == obj);
}
*
* */
boolean b = obj.equals(obj2);
System.out.println(b);
Student student = new Student();
Student student1 = new Student();
System.out.println(student==student1);
student.equals(student1);
}
}重写equals方法之后，比较两个对象得成员变量是否相等：
Student类：
public 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;
}
public void show() {
System.out.println(name + "====" + age);
}
//重写equals方法： 比较两个对象的成员变量的值是否相同。
// boolean b = s1.equals(s2);
/*
* 代码的健壮性。考虑周全一些。在从性能上考虑
*
* */
@Override
public boolean equals(Object obj) { // Object obj=s2 Student
//对传入的参数做非空判断
if(obj==null){
return false;
}
//从性能上来考虑
if(this==obj){
return true;
}
//多态形式访问成员变量，编译看左边，运行看左边。
//向下转型，得判断 instanceof
// instanceof 判断一个引用或对象，是不是该类型的引用或对象
if (!(obj instanceof Student)) { //判断obj这个引用 是不是Student类型的引用
return false;
}
//向下转型
Student s2= (Student) obj;
// 23==24 && "李四"=="李四"
// String 引用类型 ==号比较两个对象比较的是地址值 我们现在的意思是想要比较这两个字符串字面上的内容是否相同
//我们要比较两个字符串，字面上的内容是否相同，要调用字符串中的 equals() 方法来比较
return this.age == s2.age && this.name.equals(s2.name);
}
}
测试类：
public class MyTest2 {
public static void main(String[] args) {
Student s1 = new Student("张三", 23);
Student s2 = new Student("张三", 23);
/*
* Object类中的 equals() 方法的默认实现，是比较两个对象的地址值，是否相同
* 但是我们我们现在是先要这样比：我们认为如果两个对象的的成员变量的值，一样，我就认为两个对象相等。
* 也就是我们不想比较两个对象的地址值，而是比较两个对象的成员变量的值是否相同。
* 那么我们就得重写 equals() 方法 按照我们自己的方式来比较。
*
* */
Dog dog = new Dog();
s2=null;
boolean b =s1.equals(null);
System.out.println(b);
}
}用狗类来举例转型异常：
public class Dog {
}
6.Object类的equals()方法代码优化
1.案例演示
Object类的equals()方法代码优化
a: 提高效率
b: 提高健壮性(instanceof)
2.最终版
自动生成
自动生成equals方法：
import java.util.Objects;
public 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 o) {
//如果自己跟自己比较，直接true
if (this == o) {
return true;
}
// 判断一个引用或对象，是不是该类型的引用或对象
//s1.getClass()==s2.getClass();
// instanceof 判断一个引用或对象，是不是该类型的引用或对象
if (o==null||this.getClass() != o.getClass()) {
return false;
}
//向下转型
Student student = (Student) o;
/*
* public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
*
* */
//return this.age == s2.age && this.name.equals(s2.name);
return this.age == student.age && Objects.equals(name, student.name);
}
}
7.Object类的clone() 方法
clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public 对象的浅克隆:浅克隆和深克隆 使用clone()方法采用的是浅克隆的方式
对象浅克隆要注意的细节：
如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
Cloneable接口只不过是一个标识接口而已，没有任何方法。
对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把 另外一个对象也克隆一份。
对象的浅克隆也不会调用到构造方法的。
对象的深克隆(后面讲)：采用IO流来实现 使用 ObjectOutputStream 将对象写入文件中,然后再用ObjectInputStream读取回来
普通克隆：
public class MyTest{
public static void main(String[] args) throws CloneNotSupportedException {
// protected Object clone () 创建并返回此对象的一个副本。
//1.clone() 的权限修饰符是受保护的, 在用的时候, 让该类重写该方法,重写逻辑继续调用父类的克隆逻辑, 并把该方法的权限修饰符改为public
//2.如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
//3.Cloneable接口只不过是一个标识接口而已，没有任何方法。
Dog dog = new Dog("小白", 2);
Dog dog2 = (Dog) dog.clone();
System.out.println(dog);
System.out.println(dog2.toString());
}
}
// Cloneable 接口里面没有任何抽象方法，这个接口，就是个标记接口，给类打个标记，目的告诉JVM要执行克隆操作
class Dog implements Cloneable{
String name;
int age;
public Dog() {
}
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone(); //继续调用父类Object的克隆
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}浅克隆：
public class MyTest {
public static void main(String[] args) throws CloneNotSupportedException {
/*
* 3. 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，
* 这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
4. 对象的浅克隆也不会调用到构造方法的。
*
* */
DogFood dogFood = new DogFood("金锣");
Dog dog = new Dog("小白", 2, dogFood);
dog.dogFood.foodName="王中王";
//克隆
Dog dog2 = (Dog) dog.clone();
dog2.dogFood.foodName="玉米肠";
System.out.println(dog.dogFood.foodName); // 玉米肠
System.out.println(dog2.dogFood.foodName); // 玉米肠
}
}
class Dog implements Cloneable {
String name;
int age;
//成员变量，DogFood类型
DogFood dogFood;
public Dog() {
}
public Dog(String name, int age, DogFood dogFood) {
System.out.println("构造方法调用了");
this.name = name;
this.age = age;
this.dogFood = dogFood;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone(); //继续调用父类Object的克隆
}
}
class DogFood {
String foodName="双汇";
public DogFood() {
}
public DogFood(String foodName) {
this.foodName = foodName;
}
}