java入门之Object

最新推荐文章于 2021-12-03 23:33:20 发布
最新推荐文章于 2021-12-03 23:33:20 发布
阅读量1.2k 收藏
点赞数
分类专栏： java 文章标签： java object hashcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boyas/article/details/117888450
版权

回顾Object常用方法

public native int hashCode()
public boolean equals(Object obj)
protected native Object clone() throws CloneNotSupportedException
public String toString()
public final native Class<?> getClass()
protected void finalize() throws Throwable {}
public final native void notify()
public final native void notifyAll()
public final native void wait(long timeout) throws InterruptedException
public final void wait(long timeout, int nanos) throws InterruptedException
public final void wait() throws InterruptedException

equals()

其实equals方法在之前的文章中简单拿来与==作比较，这里分析更详细些，因此将之前的文章删了。

1. 等价关系

两个对象具有等价关系，需要满足以下五个条件：

Ⅰ 自反性

x.equals(x);//true

Ⅱ 对称性

x.equals(y) == y.equals(x); // true

Ⅲ 传递性

if (x.equals(y) && y.equals(z))
x.equals(z); // true;

Ⅳ ⼀一致性

多次调用 equals() 方法结果不变

x.equals(y) == x.equals(y); // true

Ⅴ 与 null 的比较

对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false

x.equals(null); // false;
2. 等价与相等
  • 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
  • 对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价
Integer x = new Integer(1);
Integer y = new Integer(1);
System.out.println(x.equals(y)); // true
System.out.println(x == y); // false
3. 实现
  • 检查是否为同一个对象的引用，如果是直接返回 true；
  • 检查是否是同一个类型，如果不是，直接返回 false；
  • 将 Object 对象进行转型；
  • 判断每个关键域是否相等。
public class EqualExample {
		private int x;
		private int y;
		private int z;
public EqualExample(int x, int y, int z) {
		this.x = x;
		this.y = y;
		this.z = z;
}
@Override
public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        EqualExample that = (EqualExample) o;
        if (x != that.x) return false;
        if (y != that.y) return false;
        return z == that.z;
    }
}

hashCode()

hashCode() 返回哈希值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价，这是因为计算哈希值具有随机性，两个值不同的对象可能计算出相同的哈希值。

在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象哈希值也相等。

HashSet 和 HashMap 等集合类使用了 hashCode() 方法来计算对象应该存储的位置，因此要将对象添加到这些集合类中，需要让对应的类实现 hashCode() 方法。

下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象。但是 EqualExample 没有实现 hashCode() 方法，因此这两个对象的哈希值是不同的，最终导致集合添加了两个等价的对象。

EqualExample e1 = new EqualExample(1, 1, 1);
EqualExample e2 = new EqualExample(1, 1, 1);
System.out.println(e1.equals(e2)); // true
HashSet<EqualExample> set = new HashSet<>();
set.add(e1);
set.add(e2);
System.out.println(set.size()); // 2

理想的哈希函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的哈希值上。这就要求了哈希函数要把所有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。

R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位，最左边的位丢失。并且一个数与 31 相乘可以转换成移位和减法： 31*x ==(x<<5)-x ，编译器会自动进行这个优化。

toString()

默认返回ToStringExample@1b6d3586 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。

public class ToStringExample {
    private int number;

    public ToStringExample(int number) {
        this.number = number;
    }

    public static void main(String[] args) {
        ToStringExample example = new ToStringExample(123);
        System.out.println(example.toString());
    }
}

在这里插入图片描述

clone()

1. cloneable

clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例clone() 方法。

public class CloneExample {
	private int a;
	private int b;
}

CloneExample e1 = new CloneExample();
// CloneExample e2 = e1.clone(); // clone()方法在java.lang.Objcet里具有受保护的访问权限，必须重写才能访问

重写 clone() 得到以下实现:

public class CloneExample {
    private int a;
    private int b;

    @Override
    public CloneExample clone() throws CloneNotSupportedException {
        return (CloneExample) super.clone();
    }

    public static void main(String[] args) {
        CloneExample e1 = new CloneExample();
        try {
            CloneExample e2 = e1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述
以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。

应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，j就会抛出CloneNotSupportedException。

public class CloneExample implements Cloneable {
	private int a;
	private int b;
	@Override
	public Object clone() throws CloneNotSupportedException {
		return super.clone();
}
2. 浅拷贝

拷贝对象和原始对象的引用类型引用同一个对象。

public class ShallowCloneExample implements Cloneable {
    private int[] arr;

    public ShallowCloneExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }

    @Override
    protected ShallowCloneExample clone() throws CloneNotSupportedException {
        return (ShallowCloneExample) super.clone();
    }
    
    public static void main(String[] args) {
        ShallowCloneExample e1 = new ShallowCloneExample();
        ShallowCloneExample e2 = null;
        try {
            e2 = e1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        e1.set(2, 222);
        System.out.println(e2.get(2)); 
    }
}

在这里插入图片描述

3. 深拷贝

拷贝对象和原始对象的引用类型引用不同对象。

public class DeepCloneExample implements Cloneable {
    private int[] arr;

    public DeepCloneExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }

    @Override
    protected DeepCloneExample clone() throws CloneNotSupportedException {
        DeepCloneExample result = (DeepCloneExample) super.clone();
        result.arr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            result.arr[i] = arr[i];
        }
        return result;
    }

    public static void main(String[] args) {
        DeepCloneExample e1 = new DeepCloneExample();
        DeepCloneExample e2 = null;
        try {
            e2 = e1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        e1.set(2, 222);
        System.out.println(e2.get(2));
    }
}

在这里插入图片描述

4. clone() 的替代方案

使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。因此最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。

public class CloneConstructorExample {
    private int[] arr;

    public CloneConstructorExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public CloneConstructorExample(CloneConstructorExample original) {
        arr = new int[original.arr.length];
        for (int i = 0; i < original.arr.length; i++) {
            arr[i] = original.arr[i];
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }

    public static void main(String[] args) {
        CloneConstructorExample e1 = new CloneConstructorExample();
        CloneConstructorExample e2 = new CloneConstructorExample(e1);
        e1.set(2, 222);
        System.out.println(e2.get(2));
    }
}

在这里插入图片描述

༄༊心灵骇客༣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java基础[object 1]
0x00的博客
07-23 247
* 多态概述     *事物存在的多种形态 * 多态前提     要有继承关系     要有方法重写     要有父类引用指向子类对象     class Test{         public static void main(String[] args){             Cat c = new Cat();             c.eat();             Sy...
每日一练12：java Object类详解 （一）
zqyoncemore的专栏
07-08 176
java的Object类是所有类的父类，JDK中的类和用户自定义的类都默认继承于Object类。因为所有的类都继承于Object类，各个类定义时省略了extends Object这一声明。Object中包含若干个方法如clone、equals、hashCode、getClass、finalize、toString、wait、notify、notifyAll()。接下来对这些方法进行介绍。 一、clone方法 该方法是实现对象的拷贝，只有实现了Cloneable接口的类才可以调用该方法，否则抛出Clone
day08【常用API】课上
weixin_43525993的博客
06-18 127
1.Object类(掌握) 在java中Object类是最顶层父类，所有类默认都继承Object.也就是说所有类都可以使用Obejct类中的方法。如果Object类中的方法体实现的功能不是我们的类需要的，我们需要在子类中重写该方法修改方法体，使用子类对象运行直接运行子类重写之后的方法。 1.该类属于java.lang包，不需要导包 1.1 toString()方法 String toString() 返回该对象的字符串表示。 代码演示： package com.itheima.sh.object_01
JavaSE(3)关键字和Object
server643的博客
12-03 291
JavaSE基础Day3部分—关键字、Object 前言 今天主要的是了解关键字，能够知道Object的基本内容和继承的部分。 1、关键字 1.1 final关键字 final是一个声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能够被改变的常量。 final可以用在修饰类、方法和变量（包括成员变量和局部变量）。 首先修饰类时，表明这个类不能被继承。并且在final类中修饰的所有成员方法都会被隐式地指定为final方法。 其次修饰方法时，通过final将方法锁定，以防任何继承类修改它的含义。
Java-9.17
Desperate_gh的博客
09-17 330
Object 通用方法 equals() 等价关系 两个对象具有等价关系，需要满足以下五个条件： Ⅰ 自反性 x.equals(x); // true Ⅱ 对称性 x.equals(y) == y.equals(x); // true Ⅲ 传递性 if (x.equals(y) && y.equals(z)) x.equals(z); // true; Ⅳ 一致性 多次调用 equals() 方法结果不变 x.equals(y) == x.equals(y); // tru
JAVA入门-Object类、Class类
12-22
在Java编程语言中，Object类和Class类是两个非常基础且重要的概念，它们构成了Java类层次结构的基础。让我们深入了解一下这两个关键概念。 首先，我们来谈谈Object类。Object类是所有Java类的顶级父类，无论是...
java入门课程资料.zip
05-28
这个"java入门课程资料.zip"压缩包包含了一系列的学习资源，旨在帮助初学者掌握Java的基础知识。让我们逐一探讨这些文件可能涵盖的重要知识点。 首先，我们看到文件列表中有"01-05"和"6-10"这样的命名，这可能代表...
java小白入门.rar
08-06
其次，**OOP（Object-Oriented Programming，面向对象编程）**是Java的核心特性： 1. **类与对象**：深入理解类的构造器、属性和方法，以及对象的创建和使用。 2. **封装**：如何通过访问修饰符（public、private、...
Java入门练习50题
11-03
"Java入门练习50题"旨在帮助新手巩固基础，通过实践加深理解。以下将对这些练习进行详细解释，以期为你的Java学习之旅提供有力的支持。 1. **基础语法** - 变量声明：了解如何声明并初始化各种类型的变量，包括...
Java SE编程入门教程 java object（共9页）.pptx
12-04
Java SE编程入门涉及众多基础知识，这里我们主要关注Java对象、Object类及其常用方法。Java语言是一种面向对象的编程语言，所有类都直接或间接地继承自Object类，它位于核心库`java.lang`包中。 1. **Object类**： ...
对称加密和非对称加密的区别
ETFOX
08-13 9万+
简介: 对称加密: 加密和解密的秘钥使用的是同一个. 非对称加密:与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。 对称加密算法: 密钥较短，破译困难，除了数据加密标准（DES），另一个对称密钥加密系统是国际数据加密算法（IDEA），它比DES的加密性好，且对计算机性能要求也没有那么高. 优点: 算法公开、计算量小...
抽象代数学习笔记（7）对称群与置换群
bubingyang的博客
07-22 1万+
抽象代数学习笔记（7）对称群与置换群我刚接触抽象代数的那段时间，一直在考虑一个问题，抽象代数有什么实际应用。后来听说，群在研究一些具有对称性质的对象时有奇效。于是我试着用群去描述一些简单的几何变换，发现确实如此。这就是我在置换那篇文章的最后让大家思考等边三角形变换的原因。 如果大家在看群的定义时，回想一下集合 S={1,2,...n}S=\{1,2,...n\} 上的所有置换，不难发现这些置换也能构
Java踩坑笔记：基本类型与包装类之间的自动转换
07-08 164
示例如下： Integer x = 400; Integer y = x; x++; System.out.println(x == y);//false 这里可以“解yan释shi”为x和y都是基本类型，具有值语义（雾），x自增后y不变。 Integer x = 400; Integer y = x; System.out.println(x == y);/...
实对称矩阵及其几大性质
热门推荐
qq_24690701的博客
08-19 11万+
做机器学习的过程中，难免会与矩阵打交道，而实对称矩阵更是其中常用的矩阵之一。所以，下面将介绍一下什么是实对称矩阵，并介绍一下它的几个性质（这也是很多笔试题中常考的点） 定义：如果有n阶矩阵A，其矩阵的元素都为实数，且矩阵A的转置等于其本身（aij=aji）(i,j为元素的脚标)，则称A为实对称矩阵。 主要性质： 1.实对称矩阵A的不同特征值对应的特征向量是正交的（网易笔试题曾考过）。 2....
数据结构与算法---Manacher算法
it浅阳的博客
05-15 492
manacher算法是处理回文子串的一种经典算法。处理回文子串一般使用暴力匹配，动态规划，中心扩散，以及manachar。 在写manacher算法前我们先了解一下中心扩散以及动态规划。暴力匹配比较简单就不再阐述了。 中心扩散法 中心扩散法，顾名思义就是以某一个位置为中心，向周围扩散，直到满足条件或到达边界。中心扩散法的思路是：遍历每一个索引，以这个索引为中心，利用“回文串”中心对称的特点，往两边扩散，看最多能扩散多远。 代码实现： public String longestPalindrome1(Str
Nginx配置
被隐藏的博客
05-16 114
查看Nginx进程 tasklist /fi "imagename eq nginx.exe" 启动 start nginx 停止 nginx -s stop nginx -s quit 完整有序的停止nginx 检查端口占用： netstat -ano | findstr 0.0.0.0:80 或 netstat -ano | findstr "80" 重新加载配置文件 nginx...
性质：自反、反自反、对称、反对称、传递、互斥
sandalphon4869的博客
04-09 2万+
假设集合A，以及基于A上的关系R 自反： 如果a是A的元素，那么<a,a>是R的元素 反自反：如果a是A的元素，那么<a,a>不是R的元素 对称： 如果<a,b>是R的元素，那么<b,a>是R的元素 反对称：如果<a,b>，<b,a>是R的元素，那么a,b相等 传递： 如果<a,b>，<b,c>...
RSA算法原理——（3）RSA加解密过程及公式论证
猪哥
07-04 6万+
上期（RSA简介及基础数论知识）为大家介绍了：互质、欧拉函数、欧拉定理、模反元素 这四个数论的知识点，而这四个知识点是理解RSA加密算法的基石，忘了的同学可以快速的过一遍。 一、目前常见加密算法简介 二、RSA算法介绍及数论知识介绍 三、RSA加解密过程及公式论证 二、RSA加解密过程及公式论证 今天的内容主要分为三个部分： rsa密钥生成过程： 讲解如何生成公钥和私钥 rs...
Java入门基础.pdf
《Java入门基础.pdf》是一本介绍Java入门基础知识的文件，文件共包括五个章节。在前言部分，介绍了本书的目录和简要说明。接着，在第1章中，详细介绍了Java开发入门的相关概念，包括JDK、JRE、JVM的区别与联系。在第...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

༄༊心灵骇客༣

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值