JavaSE Object(类): hashCode getClass() toString() equals(Object obj)

最新推荐文章于 2022-08-03 15:26:19 发布
最新推荐文章于 2022-08-03 15:26:19 发布
阅读量119 收藏
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43563187/article/details/110874263
版权

day11目录：

Object(类)
	public int hashCode()
	public final Class getClass()
	public String toString()
	public boolean equals(Object obj)

11.17_常见对象(API概述以及Object类的概述)(掌握)

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

11.18_常见对象(Object类的hashCode()方法)(掌握)

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

public class MyTest {
    public static void main(String[] args) {
        //java.lang 包下的类 不需要导入包
        // public class Object类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
        //Object 类，是所有类的顶层父类，所有类都是直接或间接继承自她
        //创建对象
        Object obj = new Object();
        System.out.println(obj);
        int i = obj.hashCode();
        System.out.println(i);

        Object obj2 = new Object();
        System.out.println(obj2);
        int i1 = obj2.hashCode();
        System.out.println(i1);

    }
}

· 学习到后面，会和“集合”的知识有关

11.19_常见对象(Object类的getClass()方法)(掌握)

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

public class MyTest2 {
    public static void main(String[] args) {
        Object object = new Object();
        System.out.println(object);
        //返回该类的字节码文件对象。Object.java--->Object.class---->加载进内存--->JVM会为Object.class创建对象---->通过getClass()获取字节码文件对象
        //Class 这个类型，用来表示是 字节码文件类型
        Class<?> aClass = object.getClass();

        Object object2 = new Object();
        System.out.println(object2);
        Class<?> aClass1 = object2.getClass();

        System.out.println(object==object2);//false

        System.out.println(aClass==aClass1); //true 字节码文件是一份
    }
}

· 学习到后面，会和“反射”的知识有关

11.20_常见对象(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()方法

public class MyTest {
    public static void main(String[] args) {
        Object obj = new Object();
        //toString();获取该对象的地址值，以字符串的形式返回。
        String s = obj.toString();
        System.out.println(s);
        System.out.println(obj); //当你打印对象名的时候，默认这个对象就在调用toString()方法
        System.out.println(obj.toString());

    }
}

在这里插入图片描述

public class MyTest2 {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.setAge(23);
        //int i = student.hashCode();
       // Class<? extends Student> aClass = student.getClass();
        String s = student.toString();
        System.out.println(s);
        System.out.println(student);
        //两者结果一样:org.westos.demo2.Student@61bbe9ba

        /*
        *    public String toString() {
                 return getClass().getName() + "@" + Integer.toHexString(hashCode());
           }
        *
        * */
        //我们觉得父类的toString()老是获取对象的地址值，我觉得意义不大，我想要获取我认为有意义的数据。比如我们想要看我的成员变量的值是什么，觉得有意义

    }
}

子类重写了父类的tostring方法：

public class Student extends Object{
    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;
    }

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

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

//输出结果：Student{name='张三', age=23}

当打印一个对象时，没打印地址值，说明该方法被重写了。例如：Scanner方法被重写了：

public class MyTest3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
         //1.地址值。 2.其他的
         //以后，当你输出一个对象名的时候，如果输出的不是地址值，说明该类重写过toString();
        System.out.println(scanner);

    }
}

11.21_常见对象(Object类的equals()方法)(掌握)

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

public class MyTest3 {
    public static void main(String[] args) {
        Student s1 = new Student("崔继轩", 18);
        Student s2 = new Student("卢佳苗", 19);
        System.out.println(s1);
        System.out.println(s2);
        // == 他比如是比较引用类型，比较的是两个对象的地址值是否相同
        System.out.println(s1==s2); //false

        //equals() 默认也是在比较两个对象的地址值是否相同
        boolean b = s1.equals(s2);
        /*
        public boolean equals (Object obj){
            return (this == obj);
        }
         */
        System.out.println(b);
    }
}

public class MyTest4 {
    public static void main(String[] args) {
        Student s1 = new Student("崔继轩", 18); //name  age
        Student s2 = new Student("崔继轩", 18);
        //Object类中的equals()方法，默认是比较两个对象是否相等，
        //但是有的时候，我们的子类认为，老是比较两个对象的地址值，是否相同意义不大
        //子类想比较一些，他认为有意义的东西，比如我们自定义的这个Student类认为，只要两个对象的成员变量值一样，就认为这两个对象相同


        boolean b = s1.equals(new Dog()); //ClassCastException

        boolean b2 = s1.equals(s1);
        //比较性能：
        System.out.println(b);
        System.out.println(b2);
    }
}

class Dog{

}

11.22_常见对象(Object类的equals()方法代码优化)(掌握)

A:案例演示
	Object类的equals()方法代码优化
		a: 提高效率
		b: 提高健壮性(instanceof)	
B:最终版
	自动生成

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 obj) { //Object obj=s2; s2 dog
        if(this==obj){
            return true;
        }
        //判断传过来的这个对象，是不是学生类型，如果是学生类型，我就向下转型，如果不是直接返回false
        //instanceof 判断一个对象或引用，是不是该类型的一个引用
        if(!(obj instanceof Student)){
            return false;
        }
        //比较两个对象的成员变量值是否一样。
        //obj.name 多态形式访问成员变量，编译看左边，运行也看左边。
        //向下转型
        Student s2= (Student) obj;
        //"崔继轩"=="崔继轩" 比较的是地址值 如果是比较两个字符串，字面上的内容是否相同，我们用equals()
         //boolean f = "崔继轩".equals("崔继轩");
        //String 类重写了equals方法来比较两个字符串字面上的内容是否相同
        return this.name.equals(s2.name)&&this.age==s2.age;

    }
   
}

11.23_常见对象(Object类的clone() 方法)(掌握)

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

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

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

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

在这里插入图片描述
浅克隆：只克隆了0X001
深克隆：克隆了0X001和0X002

	public class MyTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        DogFood dogFood = new DogFood("王中王");
        Dog dog = new Dog("小白", 2, dogFood);
        dog.dogFood.name="金锣";
         //调用clone()方法属于浅克隆
        //对象的浅克隆：就是克隆一个对象的时候，
        //如果被克隆的对象中维护了另外一个类的对象，
        //这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
        Dog dog1= (Dog) dog.clone();
        dog1.name="小黑";
        dog1.dogFood.name="双汇";

        System.out.println(dog.name); //小白
        System.out.println(dog.age); //2
        System.out.println(dog.dogFood.name);//双汇

        System.out.println("==========================");
        System.out.println(dog1.name);//小黑
        System.out.println(dog1.age);//2
        System.out.println(dog1.dogFood.name); //双汇
    }
}
class Dog implements Cloneable {
    String name;
    int age;
    DogFood dogFood;
    public Dog() {
    }
    public Dog(String name, int age, DogFood dogFood) {
        this.name = name;
        this.age = age;
        this.dogFood = dogFood;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone(); //继续调用父类的克隆逻辑
    }
}
class DogFood{
    String name;

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

11.23_day11重点总结

Object类的equals 方法是默认比较两个对象是否相等，但是有时候我们的子类认为，老是比较两个对象的地址值是否相同意义不大。

子类想比较一些他们认为有意义的东西，比如我们自定义的Student类认为，只要两个对象的成员变量值一样。

如果是比较两个字符串的字面内容是相同，我们用equals()。String类重写了equals方法来比较两个字符串字面上的内容

instanceof----判断一个对象或引用是不是一个该类型的一个引用----obj instanceof Student

以后你定义一个方法时，得从方法的健壮性（周全）先考虑，性能方面的优化

==和equals方法的区别：

==是比较运算符，可以比较基本数据类型，也可以用来比较引用数据类型；比较基本数据类型：比较的是两个值是否相等；比较的是引用数据类型：比较的是两个对象的地址值是否相同。

equals是Objetc类中的一个方法，默认比较的是两个对象的地址值是否相同，但是有些类会重写Object类中的equals()方法，去比较他认为的有用的东西。比如String类，他也重写了父类的equals()方法，比较的是两个字符串，字面上的内容是否相同。如果使我们自定义的类型，一般会重写，去比较两个对象的成员变量值是否一样。

Favorites—书签–ctrl 点

//TODO 。。。在下方RUn的旁边能找到

标记接口–Cloneable—接口中没有任何方法，就是给类打一个标记，告诉JVM可能要实现某种操作，让JVM能支持某种操作。

克隆一个对象时，需要注意以下两点：

  1. Object类中的克隆方法是个受保护的方法，为了能够调用到，我们可以让这个类重写克隆方法，把方法的权限修饰符改为public
  2. 为了克隆能够被支持，需要该类实现Cloneable这个标记接口

注意：克隆时不调构造方法

两个概念：深克隆、浅克隆

调用clone()属于浅克隆：就是只克隆了一个对象的地址值。

Hoooooope!
关注
专栏目录
浅谈javaSE 面向对象(Object类toString)
09-02
`Object`类是所有Java类的根类，它提供了若干基本的方法，包括`toString()`、`hashCode()`和`getClass()`，这些方法在日常开发中经常被使用。 `toString()`方法是`Object`类的一个成员，它的主要功能是返回对象的...
pandas的java版本_5分钟入门pandas
weixin_39631899的博客
02-27 4707
pandas是在数据处理、数据分析以及数据可视化上都有比较多的应用，这篇文章就来介绍一下pandas的入门。劳动节必须得劳动劳动1. 基础用法以下代码在jupyter中运行，Python 版本3.6。首先导入 pandasimport pandas as pd# 为了能在jupyter中展示图表%matplotlib inline# 从csv文件读取数据，也可从excel、json文件中读取# 也...
Panda白话 - 再认识JAVA反射
FightingITPanda的博客
05-19 254
最近学习路线：AOP原理 -> JDK 动态代理 -> java 反射 真是人生无常，大肠包小肠呀～～ 反射 定义：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 这个定义看了n遍，每次都是？？？（小朋友你是否有很多问号？） 最近又看了书、文章、视频，有了新的理解，码下来。。万一对你有用 知识储备（面试高频）： 类加载机制 j.
Java——多态——toString()方法
XQC_KKK的博客
09-08 298
Java——多态——toString()方法 语法： getClass().getName()+"@"+Integer.toHexstring(hashCode()); getClass().getName()代表返回对象所属类的类名。 hashCode()代表返回该对象的哈希值。 Integer.toHexstring(hashCode())代表将对象的哈希值用16进制表示。 案例： //定义 Animal类——重写 Object的 toString()方法 class Animal14 {
【Java基础】之深入讨论equals()和hashcode()方法
王廷云的博客
05-06 336
这篇文章将详解介绍 Java 的 equals() 与 hashCode() 方法 我们知道 Object 类是类继承结构的基础，所以是每一个类的父类，所有的对象，包括数组，都实现了在 Object 类中定义的方法。而在 Object 类中有两个非常重要的方法： public boolean equals(Object obj) public int hashCode() 这两个方法是息息相关...
Java基础知识（二十）常用类一（Object类）
L缶神的博客
01-20 490
常用类---Object类中的一些方法
JavaSE之Object与Object类
07-21
在Java编程语言中，`Object`类是所有类的根类，这意味着无论是自定义的类还是内置的类，它们最终都会继承自`Object`。这个类包含了一些基础的方法，供所有的Java对象使用。以下是关于`Object`类及其相关知识点的详细...
JavaSe知识总结：多线程.xmind
10-19
思维导图：含括多线程概念，线程创建开启方式，线程安全，线程状态及常见问题
JavaSe知识总结：I/O流.xmind
10-19
思维导图，含括流概念，流分类，流关系的图文展示等
Java 从入门到精通全程笔记(JavaSE+JavaEE :史上最全笔记）
04-14
JavaSE+JavaEE企业级开发 全程笔记免费下载，内容详尽，doc文档,共173页,六号字体，双栏排版。 *、Java 基础， *、web， *、数据库（Mysql Oracle jdbc Hibernate hql/sql）， *、JSP， *、Ajax *、Struts， *、...
day06-Object的几个方法
NULL_YM
04-04 133
Object类中的几个方法 toString() hashCode() getClass() finalize()和clone() ArrayList的toString()源码解析 HashSet保证元素唯一性的源码解析 TreeSet保证元素排序的源码解析 TreeSet保证元素唯一性和比较器排序的原理及代码实现 TreeSet的add()源码解析 ...
在API中这么定义toString()等同于 getClass().getName() + '@' + Integer.toHexString(hashCode())
weixin_37878255的博客
02-13 978
验证final修饰的变量是引用不能变，还是引用的对象不能变  * StringBuilder 线程不安全 但速度快  * 引用初始化以后不能被改变 --- 不是指变量的值不可变，而是指向的变量地址不可变  * @author Tomato  *  */ public class TestFinal {     public static void main(String[] args) {    ...
【Tablesaw】Java数据框架和可视化库，Java中的 “Pandas”
简简单单的学习笔记，致力于帮助更多前进路上的朋友~
08-03 6826
Tablesaw是一款Java的数据可视化库，本文主要介绍了基于Tablesaw进行数据出力的基本操作，包括加载数据，对数据进行操作等，类比Python中的Pandas库。
Java——Object类
panda_burn的博客
04-29 121
一、Object类 （一）API概述以及Object类的概述 A:API(Application Programming Interface) 应用程序编程接口 B:Java API 就是Java提供给我们使用的类，这些类将底层的实现封装了起来， 我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。 C:Object类概述 类层次结构的根类 所有类都直接或者间接的继承自该类 D:构造方法 ...
Object类及常用方法（getClass()、hashCode()、toString()）
zhu_fangyuan的博客
07-15 371
1. Object类 package com.fy.t2; public class TestObject { public static void main(String[] args) { method(new Student()); System.out.println(); } public static void method(Object obj) { } public static void goHome(Object obj) { } public
object(类)
xiangbaoo的博客
06-25 168
API概述以及Object类的概述 A:API(Application Programming Interface) 应用程序编程接口 B:Java API 就是Java提供给我们使用的类，这些类将底层的实现封装了起来， 我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。 C:Object类概述 类层次结构的根类 所有类都直接或者间接的继承自该类 D:构造方法 public Object...
11.常见对象（Object(类)中得 hashCode，getClass，toString，equals，clone方法）
weixin_62520626的博客
11-07 246
1.API概述以及Object类的概述 1.API(Application Programming Interface) 应用程序编程接口 2.Java API 就是Java提供给我们使用的类，这些类将底层的实现封装了起来， 我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。 3.Object类概述 类层次结构的根类 所有类都直接或者间接的继承自该类 4.构造方法 public Object() 回想面向对象中为什么说： 子类的...
常见对象_Object类的概述、hashCode()方法、getClass()方法、toString()方法
辐_射的博客
11-01 1236
package cn.itcast_01; /* * Object:类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。 * 每个类都直接或者间接的继承自Object类。 * * Object类的方法: * public int hashCode():返回该对象的哈希码值。 * 注意:哈希值是根据哈希算法计算出来的一个值,这个值和地址值有关,但是不是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值