【JAVA |再谈接口、Object、内部类】Object类中子类重写，Cloneable 接口、比较器、内部类

✨✨谢谢大家捧场，祝屏幕前的小伙伴们每天都有好运相伴左右，一定要天天开心哦！✨✨ 
🎈🎈作者主页： 🎈丠丠64-CSDN博客🎈


✨✨ 帅哥美女们，我们共同加油！一起进步！✨✨ 

目录

一、前言

二、Obiect类

1.获取对象信息的打印

2.比较类中对象的异同

-equals方法

-hashcode方法

三、接口实现实例

-Comparable接口

-排序一个数组成员元素

1.直接使用接口Comparable

2.构造新的比较器

四、对象的拷贝

1.Cloneable拷贝

-浅拷贝

-深拷贝

一、前言

上一篇我们介绍了抽象类以及接口的相关知识，这篇我们来接着探讨一下关于接口的实例，并且认识一下所有类的父类Object

二、Obiect类

Object时JAVA中默认提供的一个类，所有的类都是继承Oject，换句话来说Oject是所有类的父类，这样就可以说在有需要实现一些功能的时候，子类方法就可以用重写来实现

1.获取对象信息的打印

我们首先来看这样一段代码

public class Person {
    public int age;
    public String name;

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

public class Test {
    public static void main(String[] args){
        Person person = new Person(16,"张三");
        System.out.println(person);
    } 
}

我们目的想要实现传入变量名字以后，打印出对应的成员属性，传入println（）中是否能实现呢？

事实却是输出了这样一个值，为什么呢？我们跳转println函数定义去看

我们发现实现的最终函数是这个toString（）前半部分是全路径，后面部分是类似地址一样的东西（后面会说）

toString()是Object的子类，所以我们只需要重写toString（），就可以随意实现我们的功能，所以修改一下这个代码重写toString（）

public class Person {
    public int age;
    public String name;

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

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

即可实现我们的功能

2.比较类中对象的异同

首先我们先来看一段代码

        Person person1 = new Person(16,"张三");
        System.out.println(person1);

        Person person2 = new Person(16,"张三");
        System.out.println(person2);

        System.out.println(person1 == person2);

对于两个不同的变量，但是里面的成员属性却相同，比较person1和person2，他两会相等吗？

运行结果来看，两者是不同的，我们屏蔽掉刚写的toString（）来看一下结果

发现原来是他们类似于地址一样的东西不一样！两个对象比较的其实是类似于地址的地址!

两个对象以不同的位置进行分配

-equals方法

在JAVA在有一个方法也是用来比较两个对象是否相等，就是equals（），我们跳转到定义去看

System.out.println(person1.equals(person2));

我发现它的定义只是这样（其中的this指谁调用equals谁就是this），跟刚才的person1 == person2没有区别，我们要实现我们的功能，对成员中的属性进行比较，因为equals是Object的子类，就要对其进行重写

@Override
    public boolean equals(Object o) {
        if (this == o) {        
            return true;        //如果指向同一个对象为真
        }

        if (o == null || getClass() != o.getClass()) {
            return false;        //如果对象属性为空或者不是一个东西了为假
        }

        Person person = (Person) o;//向下转型比较属性值
                                //判断对象中各个属性，都为真才为真
        return age == person.age && Objects.equals(name, person.name);
    }

通过调用自己重写的方法，这样这段代码就可以实现我们所需要的功能了，比较两个对象中各属性是否相等

        System.out.println(person1.equals(person2));

比较对象中内容是否相同的时候，一定要重写 equals方法         

-hashcode方法

刚才在调用toString方法时我们看见了hashCode()这个方法，他帮我算了一个具体的对象位置，该方法是一个native方法，底层是由C/C++代码写的。我们看不到。

public native int hashCode();

我们来看一下这两个的值为多少 

System.out.println(person1.hashCode());
System.out.println(person2.hashCode());

因为两者所分配的空间不同，所以对象位置也不相同，返回的值也就不相同，倘若我们现在想要实现，为两个名字相同，年龄相同的对象，将存储在同一个位置，hashcode是Object的子类，我们就要重写hashcode()方法

 @Override
    public int hashCode() {

        return Objects.hash(age, name);
    }

再输出我们结果，发现经过一系列算法，两个对象出现了同一位置

两个对象的hash值不一样，hashcode方法用来确定对象在内存中存储的位置是否相同

三、接口实现实例

我们先看这样一个代码

public class Student {
    public int age;
    public String name;

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

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

}

当我们想实现两个变量之间的比较，是不是直接比较他们两个变量是否相等然后返回布尔值就行了呢？答案是错的，引用类型变量不可以这样比较，直接比较会报错

public class Test {
    public static void main(String[] args){
        Student student1 = new Student(12,"小明");
        Student student2 = new Student(15,"小美");

        System.out.println(student1 > student1);
    }

}

-Comparable接口

自定义想要比较大小，就要实现这个接口

我们应该在Student这个类给它加上一个Comparable接口，再把Student传进去就可以进行比较了

public class Student implements Comparable<Student>{
    public int age;
    public String name;

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

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

}

但是我们发现还是会报错，我们跳转过去定义查看

发现需要按照自己的需求去重写这个compareTo方法

假如说我们需要按照年龄去比较两个对象，于是就可以这样重写

@Override
    public int compareTo(Student o) {
        return this.age - o.age;  //大于输出正数，小于输出负数，相等输出0
    }

这样就不会报错了

System.out.println(student1.compareTo(student2));
System.out.println(student2.compareTo(student1));

输出结果

-排序一个数组成员元素

1.直接使用接口Comparable

先实现一个学生的类，并且使用接口Comparable

public class Student implements Comparable<Student>{
    public int age;
    public String name;

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

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

    @Override
    public int compareTo(Student o) {
        return this.age - o.age;  //大于输出正数，小于输出负数，相等输出0
    }
}

定义一个学生的数组

Student[] students = new Student[3];

students[0] = new Student(18,"小明");
students[1] = new Student(15,"小礼");
students[2] = new Student(21,"小花");

然后根据冒泡排序对学生的年龄对其排序

public static void my_sort(Comparable[] comparable){
        for (int i = 0; i < comparable.length - 1; i++) {
            for (int j = 0; j < comparable.length - 1 - i; j++) {
                if (comparable[j].compareTo(comparable[j+1]) > 0){
                    Comparable tmp = comparable[j];
                    comparable[j] = comparable[j+1];
                    comparable[j+1] = tmp;
                }
            }
        }
    }

打印出结果，对其学生年龄进行排序

my_sort(students);
System.out.println(Arrays.toString(students));

结果成立

但是这种方法也有很大的危害，对类的侵入性比较强，也不够灵活

2.构造新的比较器

所以基于上述的的危害我们可以进行优化

对于年龄比较，我们新建一个类AgeComparator，并对其compare进行重写即可

class AgeComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1,Student o2) {
        return o1.age - o2.age;  
    }
}

对于名字比较，我们新建一个类NameComparator，并对其compare进行重写即可

class NameComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

我们来实现一下，分别以年龄跟名字比较

        Student student1 = new Student(12,"zahngsan");
        Student student2 = new Student(15,"lisi");

        NameComparator nameComparator = new NameComparator();
        System.out.println(nameComparator.compare(student1, student2));

        AgeComparator ageComparator = new AgeComparator();
        System.out.println(ageComparator.compare(student1, student2));

结果成立，且互不干扰，这就是比较器的好处，比较灵活，对类的侵入性不强

四、对象的拷贝

我们先构造一个类，并且实例化一个对象

public class Person {
    public int age;

    public Person(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}

public class Test {
    public static void main(String[] args){
     Person person1 = new Person(19);
    }
}

实例化的对象person1他在内存中是这样分配的，对象的属性在堆区开辟了空间地址由persin1保存

倘若我们要实现对变量person1进行一份拷贝，如何实现呢？

1.Cloneable拷贝

我们先介绍Cloneable接口，我们先跳转过定义，可以看到是一个空接口

又称为标记接口：证明当前类是可以被克隆的

我们实例化第二个对象，用JAVA中提供的clone 方法，创建一个对象的 "拷贝"

Person person2 = person1.clone();

但是我们发现报错了，我们还要经过以下三步

clone属于Obiect中的方法，我们转到clone的定义，发现他的访问权限是protected，直接访问不到只能够重写这个方法

但是同时呢我们发现还多了一个 throws CloneNotSupportedException这样的东西，必须是编译时处理，所以我们也要在main主函数上加上 throws CloneNotSupportedException

同时呢用我们发现它的返回值为Object，父类访问子类中的方法就是发生向下转型强转为Person类型

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person(19);
        Person person2 = (Person) person1.clone();
    }
}

同时也要加接口，来证明这个类可以被克隆

public class Person implements Cloneable{
    public int age;

    public Person(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

不加接口则会报错

至此编译正常通过

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person(19);
        Person person2 = (Person) person1.clone();

        System.out.println(person1);
        System.out.println(person2);
    }
}

成功克隆

-浅拷贝

我们来看以下的这段代码

构造了个Money、Perso两个类，重写了clone

class Money {
    public double m = 99.99;
}

class Person implements Cloneable{
    public Money money = new Money();

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

person1拷贝一份persona2，并且修改persinal2的值，理想的结果应该是persinal2的m值被修改，person1的不变

public class Test{
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person) person1.clone();
        System.out.println("通过person2修改前的结果");
        System.out.println(person1.money.m);
        System.out.println(person2.money.m);

        person2.money.m = 13.6;
        System.out.println("通过person2修改后的结果");
        System.out.println(person1.money.m);
        System.out.println(person2.money.m);
    }

但是输出结果并不是这样，我们发现persona1中的m也被修改了，为什么会这样呢？

我们发现拷贝只拷贝了一份新的对象，并没有拷贝对象中的元素，对象中的元素位置没有被改变，两个对象中的m指向了同一块内存，同一个吗，对象中的元素没有被克隆，所以两者都可以修改，这种没有完全拷贝就称为浅拷贝

-深拷贝

  我们对以上的代码进行修改，将clone进行重写，将对象中的对象也进行拷贝，这个问题就解决了

@Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person) super.clone();
        tmp.money = this.money.clone();
    }

深浅拷贝说白了就是重写clone方法实现的，方法内部实现的不一样

希望对你有帮助

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/637685.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

python写页面自动截图

python写页面自动截图

from selenium import webdriver def take_screenshot(url, file_path):driver webdriver.Chrome()driver.get(url)driver.save_screenshot(file_path)driver.quit() if __name__ __main__:take_screenshot(http://baidu.com, D:\桌面\wang.png)要安装selenium还要安装google…
阅读更多...
React类组件生命周期详解

React类组件生命周期详解

在React的类组件中&#xff0c;从组件创建到组件被挂载到页面中&#xff0c;这个过程react存在一系列的生命周期函数&#xff0c;最主要的生命周期函数是componentDidMount、componentDidUpdate、componentWillUnmount 生命周期图例如下 1. componentDidMount组件挂载 如果你…
阅读更多...
网络安全资源和参考指南

网络安全资源和参考指南

由美国国防部&#xff08;DoD&#xff09;发布的《网络安全资源和参考指南》&#xff0c;旨在为美国政府、商业部门以及美国盟友和伙伴之间的安全合作提供有用的、现成的参考资料。文档涵盖了网络安全规范、最佳实践、政策和标准&#xff0c;这些都是由美国联邦政府、国防部以及…
阅读更多...
KubeSphere 社区双周报｜2024.05.09-05.23

KubeSphere 社区双周报｜2024.05.09-05.23

KubeSphere 社区双周报主要整理展示新增的贡献者名单和证书、新增的讲师证书以及两周内提交过 commit 的贡献者&#xff0c;并对近期重要的 PR 进行解析&#xff0c;同时还包含了线上/线下活动和布道推广等一系列社区动态。 本次双周报涵盖时间为&#xff1a;2024.05.09-05.23…
阅读更多...
CCF20230301——田地丈量

CCF20230301——田地丈量

CCF20230301——田地丈量 代码如下&#xff1a; #include<bits/stdc.h> using namespace std; int main() {int n,a,b;cin>>n>>a>>b;int x1,x2,y1,y2,x,y,sum0;for(int i0;i<n;i){cin>>x1>>y1>>x2>>y2;xmin(x2,a)-max(x1,…
阅读更多...
【科普知识】伺服电机中的内置制动器

【科普知识】伺服电机中的内置制动器

在工业自动化和机器人技术快速发展的今天&#xff0c;伺服电机作为核心驱动元件&#xff0c;其性能与功能直接影响整个系统的运行效率与稳定性。 近年来&#xff0c;一体化伺服电机技术不断融合创新&#xff0c;并逐步加入了许多新的硬件和软件的功能&#xff0c;为工业自动化领…
阅读更多...
SpringBoot+Vue开发记录（五）-- 数据库设计

SpringBoot+Vue开发记录（五）-- 数据库设计

我去&#xff0c;时隔这么久又开始了QAQ。主要是还是自己太懒了。 本篇文章的主要内容是数据库设计。 先简单创建个数据库&#xff1a; 这是创建好了的&#xff1a; 一、数据库设计 先就做一个很简单的设计&#xff0c;里面就只有用户和题。 大概就这样&#xff1a; 二、创…
阅读更多...
GQL 来了！ISO/IEC 正式发布 GQL 数据库国际标准！

GQL 来了！ISO/IEC 正式发布 GQL 数据库国际标准！

历时四年筹备&#xff0c;超过20个国家的标准和技术专家参与制定&#xff0c;ISO/IEC GQL &#xff08;图查询语言&#xff09;标准于2024年4月12日正式发布&#xff01; 作为国际标准化组织&#xff08;ISO&#xff09;继 1987年 发布SQL后&#xff0c;唯一发布的数据库查询语…
阅读更多...
express路由的介绍与使用

express路由的介绍与使用

一、什么是路由&#xff1f; 官方&#xff1a;路由确定了应用程序如何响应客户端对特定端点的请求 通俗来说&#xff1a;在Web开发中&#xff0c;路由是指根据不同的请求路径和请求方法&#xff0c;将请求分发到相应的处理函数、模块或中间件。简单来说&#xff0c;就是URL到…
阅读更多...
【运维心得】双WAN配置的一个误区

【运维心得】双WAN配置的一个误区

目录 双WAN配置及优势 实际案例 解决之道 最后总结 双WAN配置及优势 什么是双WAN配置&#xff0c;这里就不多赘述&#xff0c;简单的说&#xff0c;首先你要有一台支持双WAN口的路由器&#xff0c;目前大多数企业级路由器都具备了这个功能。甚至有些家用路由器也有此类功能…
阅读更多...
揭秘：水滴式粉碎机为何如此受欢迎

揭秘：水滴式粉碎机为何如此受欢迎

在粉碎机市场中&#xff0c;水滴式粉碎机以其D特的设计和G效的性能脱颖而出&#xff0c;成为众多用户的选择产品。那么&#xff0c;水滴式粉碎机究竟有何魅力&#xff0c;能够赢得如此广泛的赞誉呢&#xff1f; 首先&#xff0c;水滴式粉碎机的G效性能是其受欢迎的关键因素之一…
阅读更多...
【软件设计师】下午题总结-数据流图、数据库、统一建模语言

【软件设计师】下午题总结-数据流图、数据库、统一建模语言

下午题总结 1 试题一1.1 结构化语言 2 试题二弱实体增加权限增加实体间联系和联系的类型 3 试题三3.1 UML关系例子 3.2 例子&#xff08;2016上半年&#xff09;3.3 设计类分类3.3.1 接口类3.3.2 控制类3.3.3 实体类 3.4 简答题3.4.1 简要说明选择候选类的原则3.4.2 某个类必须…
阅读更多...
基于EBAZ4205矿板的图像处理：09基于sobel边缘检测的图像锐化

基于EBAZ4205矿板的图像处理：09基于sobel边缘检测的图像锐化

基于EBAZ4205矿板的图像处理&#xff1a;09基于sobel边缘检测的图像锐化 项目全部文件 随后会上传项目全部文件 先看效果 锐化的有点过头了&#xff0c;不过我也懒得改了&#xff0c;想要改也很简单&#xff0c;无非就是给卷积运算后的结果加个系数&#xff0c;通过改系数调…
阅读更多...
Java面试真题日常练习

Java面试真题日常练习

题目&#xff1a;反转字符串 描述&#xff1a;编写一个函数&#xff0c;输入一个字符串&#xff0c;将其反转并返回结果。 解题思路&#xff1a;可以使用两个指针&#xff0c;一个指向字符串的开头&#xff0c;一个指向字符串的末尾&#xff0c;然后不断交换两个指针所指的字符…
阅读更多...
什么是 UUID，uuid

什么是 UUID，uuid

文章目录 一、是什么二、为什么三、怎么用 标题&#xff1a;深入探讨UUID&#xff1a;全球唯一标识符的秘密 一、是什么 在当今数字化时代&#xff0c;唯一标识符&#xff08;UUID&#xff09;在计算机科学领域扮演着重要的角色。UUID是一种用于标识信息的唯一字符串&#xff0…
阅读更多...
探索编程乐趣：绘制螺旋图的奇幻之旅

探索编程乐趣：绘制螺旋图的奇幻之旅

新书上架~&#x1f447;全国包邮奥~ python实用小工具开发教程http://pythontoolsteach.com/3 欢迎关注我&#x1f446;&#xff0c;收藏下次不迷路┗|&#xff40;O′|┛ 嗷~~ 目录 一、引言&#xff1a;编程的魔法世界 二、绘制螺旋图的准备工作 三、代码实战&#xff1a;…
阅读更多...
jetcache缓存

jetcache缓存

1 介绍 是阿里的双极缓存&#xff0c;jvm-->redis-->数据库 文档&#xff1a;jetcache/docs/CN at master alibaba/jetcache GitHub 2 注意事项 使用的实体类一定实现序列化接口定时刷新注解&#xff0c;慎用 它会为每一个key创建一个定时器 &#xff1a;场景为&…
阅读更多...
opencv--形态学(开运算、闭运算、形态学梯度、顶帽、黑帽)

opencv--形态学(开运算、闭运算、形态学梯度、顶帽、黑帽)

开运算 先腐蚀再膨胀&#xff0c;消除细小点、毛刺、连接点等等情况 闭运算 先膨胀再腐蚀&#xff0c;填充孔洞、增强连接点等等情况&#xff0c;或者大家说的增加明亮度 形态学梯度 使用膨胀的图减去腐蚀的图&#xff0c;简单理解就是二值化后形状膨胀后会使得物体变大&am…
阅读更多...
14 vue学习：透传Attributes

14 vue学习：透传Attributes

Attributes 继承 “透传 attribute”指的是传递给一个组件&#xff0c;却没有被该组件声明为 [props]或 [emits]的 attribute 或者 v-on 事件监听器。最常见的例子就是 class、style 和 id。 当一个组件以单个元素为根作渲染时&#xff0c;透传的 attribute 会自动被添加到根元…
阅读更多...
【openlayers系统学习】3.5colormap详解（颜色映射）

【openlayers系统学习】3.5colormap详解（颜色映射）

五、colormap详解&#xff08;颜色映射&#xff09; ​colormap​ 包是一个很好的实用程序库&#xff0c;用于创建颜色图。该库已作为项目的依赖项添加&#xff08;1.7美化&#xff08;设置style&#xff09;&#xff09;。要导入它&#xff0c;请编辑 main.js​ 以包含以下行…
阅读更多...
最新文章

Copyright @ 2022~2023