object类及其常用方法：hasCode、getClass、toString、equals、clone

最新推荐文章于 2021-02-26 17:27:27 发布
最新推荐文章于 2021-02-26 17:27:27 发布
阅读量242 收藏 1
点赞数
文章标签： Java自学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yalu_123456/article/details/90023088
版权

API

1.API(Application Programming Interface)
应用程序编程接口
2.Java API
就是Java提供给我们使用的类，，
我们不需要关心这些类是如何实现的，只需要学习这些类如何使用
3.Object类概述
类层次结构的根类
所有类都直接或者间接的继承自该类

hasCode方法

hasCode 返回对象的哈希值，不同对象的哈希值是不同的；
不是对象的实际地址值，可以理解为逻辑地址值。
int i = obj.hashCode();

public class MyTest {
    public static void main(String[] args) {
      //  JavaAPI Java给我们提供好的一些类，我们得学会使用他
    //  Object 是所有类的顶层父类，所有类都是直接或间接继承自他

       // java.lang 此包下的类，可以不用导包
        //创建Object类对象
        Object obj = new Object();
        //看下Object中的成员方法
      //  int hashCode () 返回该对象的哈希码值。不同对象的哈希码值，是不一样的。
      //  System.out.println(obj);
        int i = obj.hashCode();
        System.out.println(i);
        Object obj2 = new Object();
        int i1 = obj2.hashCode();
        System.out.println(i1);
    }
}

Object类的getClass()方法

返回此 Object 的运行时类,获取该类的字节码文件对象;
Class<?> getClass () 返回该类的字节码文件对象

import java.io.ObjectOutputStream;
public class MyTest {
    public static void main(String[] args) {
        //Object 所有类的顶层父类
        Object obj = new Object();
        int i = obj.hashCode(); //不同对象的哈希值是不一样的
        //Object.class---->字节码文件对象
         Class aClass = obj.getClass(); //获取该类的字节码文件对象
        String s = obj.toString(); //获取该对象的地址值的字符串形式

案例：

public class MyTest2 {
    public static void main(String[] args) {
        //Object.class 字节码文件加载进内存-----JVM就会为Object.class文件创建一个对象。
        Object obj = new Object();
        Class clazz = obj.getClass(); //Object.class---->字节码文件对象。
        Object obj2 = new Object();
        Class aClass = obj2.getClass();
        Object obj3 = new Object();
        Class aClass1 = obj3.getClass();


        System.out.println(obj==obj2); //false
        System.out.println(clazz==aClass);
        System.out.println(aClass==aClass1);

    }
}

Object类的toString()方法

获取该对象的地址值的字符串表现形式,这里注意是地址值；

案例一：

public class MyTest {
    public static void main(String[] args) {
        Object obj = new Object();
        String s = obj.toString(); //获取该对象的地址值的字符串表现形式
        System.out.println(s);
        Object o = new Object();
        System.out.println(o.toString());


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



    }
}

案例二：

import java.net.SocketTimeoutException;

public class MyTest2 {
    public static void main(String[] args) {
        Student student = new Student();
        int i = student.hashCode();
        System.out.println(i);
        Class<? extends Student> aClass = student.getClass();
        System.out.println(aClass.getName());
        System.out.println(student.toString());
        System.out.println("--------------------------");
        Student student1 = new Student("张三", 23);
        //System.out.println(student1.getName());
        //System.out.println(student1.getAge());
        student1.show();
        //一般情况下，我们自定义的类，都喜欢重写父类toString()方法，让他打印成员变量的值，当你根据你实际情况，可以打印其他任何内容
        System.out.println(student1.toString());
        //子类如果对父类的方法实现不满意，子类可以重写
    }
}


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);
    }

    @Override
    public String toString() {
        return "姓名："+this.name+"==="+"年龄"+this.age;
    }
}

案例三：

public class MyTest {
    public static void main(String[] args) {
        Teacher teacher = new Teacher("张三", 23);
        System.out.println(teacher);

    }
}

class Teacher{
    private String name;
    private int age;

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

    //利用软件重写toString（）方法  alt+insert 选toStirng()方法，就会重写
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Object类的equals()方法

a:指示其他某个对象是否与此对象“相等”。
源代码:

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

b:默认情况下比较的是对象的引用是否相同。
c:由于比较对象的引用没有意义，一般建议重写该方法。一般用于比较成员变量的值是否相等
d:==和equals()的区别。(面试题)
==比较两个对象地址值是否相同；equals比较两个变量值是否相同；

案例一：

public class MyTest {
    public static void main(String[] args) {
        Object obj = new Object();
        Object obj2 = new Object();
        // boolean equals (Object obj) 判断两个对象的地址值是否相同
        System.out.println(obj == obj2);
        boolean b = obj.equals(obj2);

        //public boolean equals (Object obj){
        //    return (this == obj);
        //}
       //System.out.println(b);

        System.out.println("---------------------");
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("张三", 23);
        System.out.println(s1 == s2);//false
        //System.out.println(s1.equals(s2)); //true
        //我觉得，s1.equals(s2) 比较两个对象的地址值，是否相同，对我来说意义不大，我认为的是，只要两个对象的成员变量的值一样，我就认为这两个对象一样。那么我就得重写父类的equals()方法，让他去比较两个对象的成员变量的值是否相同

        boolean b1 = s1.equals(new Teacher());//ClassCastException 类型转换异常
        System.out.println(b1);

        System.out.println("---------------");
        boolean b2 = s1.equals(s1);
        System.out.println(b2);

    }
}

class Student {
    private String name;
    private int age;

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

    @Override
    public boolean equals(Object obj) {
        //如果是自己跟自己比，直接就是true
        if (this == obj) {
            return true;
        }

        // 让他去比较两个对象的成员变量的值是否相同
        //我怎么判断这个obj 是Student类型的。
        //A:
        //关系运算符有哪些
        //        == ,!= , < , > , <= , >= , instanceof(后面讲解)
        //instanceof 判断一个引用，是否是，该类型的一个引用
        if (!(obj instanceof Student)) {
            return false;
        }
        //向下转型
        Student stu = (Student) obj;
        //"张三"=="张三" 0x001==0x002
        // this.name.equals(stu.name) 比较两个字符串的内容是否相同
        //String extends Object{
        //   //字符串类，也认为父类的equals方法不满意，字符串这个类想要比较，连个字符串的内容是否相同
        // 所以字符串也重写了父类的equals方法 去比较两个字符串的内容是否相同
        // }
        return this.name.equals(stu.name) && this.age == stu.age;
    }
}

class Teacher {

}

案例二：
**
Object 类中的equals方法默认比较的是，两个对象的地址值是否相同，
那么很多类，都觉得这种比较方法意义不大，都会重写，按照自己的比较方式去比较
我们自定义的类，重写equals方法是比较两个对象的成员变量的值是否相同 **

public class MyTest {
    public static void main(String[] args) {
       /* Object 类中的equals方法默认比较的是，两个对象的地址值是否相同，
        那么很多类，都觉得这种比较方法意义不大，都会重写，按照自己的比较方式去比较
        我们自定义的类，重写equals方法是比较两个对象的成员变量的值是否相同
        */

        System.out.println(new Student("张三", 23).equals(new Student("张三", 23)));

    }
}


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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //alt+insert
    @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);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Object类的clone() 方法

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

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

  1. ** 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。**

  2. Cloneable接口只不过是一个标识接口而已，没有任何方法。

  3. 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。

  4. 对象的浅克隆也不会调用到构造方法的。

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

public class MyTest {
    public static void main(String[] args) throws CloneNotSupportedException {
      //  protected Object clone () 创建并返回此对象的一个副本。
        Dog dog = new Dog();
        System.out.println(dog);
        dog.name="小黑";
        dog.age=10;
        System.out.println(dog.name);//小黑
        System.out.println(dog.age);//10

        // dog=new Dog();
        Dog dog1= (Dog) dog.clone();
        System.out.println(dog1);
        System.out.println(dog1.name);//小白，小黑
        System.out.println(dog1.age); //23 10
        //CloneNotSupportedException 克隆不支持异常

        Dog dog2 = new Dog();
        Dog dog3 = (Dog) dog2.clone();
        System.out.println(dog3.name);
        System.out.println(dog3.age);


    }
}
    //此类实现了 Cloneable 接口，以指示 Object.clone()方法可以合法地对该类实例进行按字段复制。
    //
    //    如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法，则会导致抛出 CloneNotSupportedException 异常。

//Cloneable 没有任何抽象方法的接口，是一个标记接口
class Dog extends Object implements Cloneable{
    String name="小白";
    int age=23;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //调用父类的clone功能
        return super.clone();
    }
}

案例二：
1.对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份 。

2.深克隆：克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象 克隆的时候不仅要克隆这个对象，还有克隆这个对象里面维护的那个对象 深克隆：可以通过序列化流来实现，后期学到IO流的时候讲

import java.io.ObjectOutputStream;
import java.util.zip.DeflaterOutputStream;
public class MyTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        //克隆时注意两点：1.这个clone方法是一个受保护的方法，我们在使用时，需要子类重写一下，但是重写逻辑还是用父类的clone逻辑
        //2.这个类必须实现一个Cloneable接口，这样克隆才会被支持

        //Dog dog = new Dog();
        //dog.name="旺财";
        //dog.age=10;
        //Dog dog1 = (Dog) dog.clone();
        //dog1.name="小黑";
        //dog1.age=19;
        //System.out.println(dog.name);//
        //System.out.println(dog.age);
        //System.out.println(dog1.name);
        //System.out.println(dog1.age);
        System.out.println("---------------------");
        DogFood dogFood = new DogFood("王中王");
        Dog dog = new Dog("旺财", 3, dogFood);
        dog.dogFood.name = "双汇";
        Dog dog1 = (Dog) dog.clone();
        dog1.dogFood.name = "金锣";

        System.out.println(dog.dogFood.name);//
        System.out.println(dog1.dogFood.name);//

        new Object().hashCode();

        //对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把
        //另外一个对象也克隆一份。

        //深克隆：克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象 克隆的时候不仅要克隆这个对象，还有克隆这个对象里面维护的那个对象  深克隆：可以通过序列化流来实现，后期学到IO流的时候讲

    }
}

class Dog implements Cloneable {
    public String name;
    public int age;
    public DogFood dogFood;

    public Dog() {
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

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

class DogFood {
    public String name;

    public DogFood(String name) {
        this.name = name;
    }
}
dream_Felix
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
object类的常见方法
qq_46130168的博客
12-12 1639
object类的常见方法 1.object类的hascode方法 返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。 不是对象的实际地址值，可以理解为逻辑地址值。 public class Test02 { public static void main(String[] args) { Object o1 = new Object();
Object类：equals(); hashCode(); getClass(); toString(); clone();方法的使用与重写
y_Engineer的博客
06-26 310
Object类 一、Object类概述 类层次结构的根类，即所有类都直接或者间接的继承自该类。 二、Object类的常用方法 1、Object类的equals()方法 A：功能：指示其他某个对象是否与此对象“相等”。 B：源代码： public boolean equals(Object obj) { return (this == obj); } C：注意：默...
Object类中hashCode()方法、equals()方法、getClass()方法、toString()方法和clone()方法总结
MAX_YanBangbang的博客
06-28 536
hashCode()方法 在弄清楚hashCode之前我们需要先了解一下Object类 //Object 是我们所有类的顶层父类，所有类都是直接或间接继承自他 //创建Object类的对象 :Object obj = new Object(); Object 类和我们学过的所有类具有相同的性质，只不过它是所有类的顶层父类。 下面是hashCode()介绍 //hashCode() 返回一个对象的...
Object类下 方法简介(toString、equals、hasCode、getClass...)
krismile__qh的博客
03-20 489
1.tostring方法 1. Object类 的 toString方法 返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于:getClass().getName() + '@' + Integer.toHexString(hashCode()) 例如：（我们一般认为输出的是地址） ...
【java】Object类的常用方法（equals()和getClass()）
XiaoChen~Coder
10-25 354
Object 是Java类库中的一个特殊类，也是所有类的父类。当一个类被定义后，如果没有指定继承的父类，那么默认父类就是 Object 类。因此，以下两个类是等价的。 public class MyClass{…} 等价于 public class MyClass extends Object {…} 由于 Java 中的所有类都是由 Object 类派生出来的，因此在 Obje...
java中hashcode()和equals()方法详解
08-11
`equals()`方法同样定义于`Object`类中，用于判断两个对象是否相等。默认情况下，`equals()`方法仅仅比较两个对象的引用是否相同，即两个对象是否指向内存中的同一位置。为了使得`equals()`方法更加有用，程序员通常...
CursoJava:NélioAlves的Udemy课程
05-11
对象类别构造函数，getter，setter，toString，equals，hasCode方法； 超载; 封装； 保留字这个； 遗产; 多态性内存中对象，数组和列表的行为； 枚举； 对象的组成； 异常处理; 使用Scanner进行数据输入和读取文件...
详解Java中用于查找对象哈希码值的hashCode()函数
09-02
然而，由于没有重写`equals()`方法，系统默认使用`Object`类的`equals()`，这比较的是对象的引用，而不是它们的属性值。因此，尽管`a`和`b`的`hashCode()`相同，但它们被视为不同的对象，不能被HashSet视为重复项。 ...
lombok-1.16.16源码和文档
04-18
  默认情况下，会使用所有非瞬态(non-transient)和非静态(non-static)字段来生成equals和hascode方法，也可以指定具体使用哪些属性。 @ToString   生成toString方法，默认情况下，会输出类名、所有属性，属性会...
java集合知识-map、set等
12-13
一般情况下，如果自定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。 建立对象判断是否相同的依据。 import java.util.HashSet; import java.util.Iterator; import java.util....
JAVA中returncode_Java中的return
weixin_36302134的博客
02-26 947
比如你写了一个叫getInt的类public int getInt(){//这个类的意思就是一个具有返回值类型为int的类了//通常如果不需要返回值的话 这里就写void。。。。//你的具体代码return 一个int型的变量;}返回值是必须有的，作用就是把固定不变的。常用的代码封装起来 写在类里 每次用到的时候就调用就行了 如果需要这个共能返回一个值，甚至一个对象 就需要用返回值了就是用re...
Object、equal方法、hashCode方法、clone方法、toString方法
fzw159753的博客
04-17 155
**Object类** Object类是java默认提供的类。Java中除了Object类，所有的类都是有继承关系的。默认会继承Object类，即所有的对象都可以用Object进行接收 Object类位于java.lang包中，该包中包含着Java最基础和核心的类，在编译时会自动导入。 Object类是参数的最高统一类型。 1.toString（）的核心目的在于取得对象信息。 Str...
java的equals、hashcode和Clone方法
chenpeng19910926的专栏
11-03 1521
（1）关键技术剖析：（Object类的这三个方法） v equals方法：比较两个对象是否相等，结果为boolean型。 v hashCode方法：获得两个对象的hash码，结果为int型。 v Clone方法：克隆当前对象，结果为Object型。 class T { int a; public T(int a) { super(); this.a = a; } public 
C# Object.GetType()获取对象的类类型/获取类的类型
热门推荐
天马3798
01-09 4万+
一、C#获取对象的类类型方式 方式1.所有类隐式继承自Object，然而Object类中的GetType()就可以获取当前对象的类，对应的类型 // // 摘要: // 获取当前实例的 System.Type。 // // 返回结果: // 当前实例的准确运行时类型。
Object类及常用方法（hashCode()、getClass()、toString()、equals()、clone() ）
baolingye的博客
04-22 389
Object类及常用方法 一、概述 Java API Java提供给我们使用的类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用 Object类 类层次结构的根类，所有类都直接或间接的继承自该类 Object类构造方法 public Object()，子类的构造方法默认访问父类的无参构造 二、Object类的hashCode()方法 ​ p...
Java的Object类中equals()、hashCode()、toString()方法重写讲解
lds_include
08-03 509
Object类中equals()、hashCode()、toString()方法重写讲解 equals()方法： 定义：对于任何非空引用值 A 和 B，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（A == B 具有值 true）。 重写规则： 判断一定相等（引用一致） 判断一定不等（类型不一致） 判断可能相等（需要把当前的对象给强转之后进行比较） 重写后的比较：与重...
如何重写Java中的equals、hascode方法
Moonbow
02-22 840
Java中,只有8种基本类型不是对象,例如:4种整形类型(byte, short, int,long),2种浮点类型(flout, double),boolean, char不是对象,其他的所有类型,不论是对象数组,列表等都扩展了Object类.了解学习Object中方法的设计原理和实现方式有助于更好的学习理解java语言. 下面,我们首先学习一下Object中的equals方法. 判断两个对
JAVA源码分析之---Object类(二)---hashCode,equals,clone方法的使用
风景美如画的博客
07-11 638
咱们继续第3个方法： public native int hashCode(); 这个方法native修饰，java本身不实现，由c/c++来实现，具体根据所依赖的平台来。 这个方法返回该对象的哈希代码值，在java里，专门有一个类是java.util.HashMap，这个值根据哈希表来的。
面试题-结合其他技术，描述Object类型常用方法的作用及使用场景（如hashCode()、equals()、clone()）
赵大土的博客
12-17 376
Object类的方法 toString() 在打印对象时被调用，将对象信息转变为字符串返回，默认输出对象地址 public String toString(){ return getClass().getName()+"@"+Integer.toHexString(hashCode()); } hashCode() 用来返回对象的物理地址的哈希码值 public native int hash...
hascode和equals
最新发布
09-07
equals方法也是Object类中的方法，用于判断两个对象是否相等。在默认情况下，equals方法比较的是对象的内存地址，即判断两个对象是否是同一个对象。但是在一些自定义的类中，我们可以重写equals方法来根据对象的属性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值