Java-对对象的拷贝、抽象类和接口的区别、Object类、对象的比较方法和内部类

news2025/10/31 21:19:32

目录

1.Clonable接口和深拷贝

2.抽象类和接口的区别

3.Object类

4.获取对象的信息

 5.对象比较方法equals

6.内部类

1.Clonable接口和深拷贝

        Java 中内置了一些很有用的接口, Clonable 就是其中之一，Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常。

 

class Students  implements Cloneable {
    public String name;
    public int age;

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

    public Students(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "{" +
                "name=" + name +
                ", age=" + age +
                "}";
    }
}
public class text {
    public static void main(String[] args) throws CloneNotSupportedException {
        Students student1=new Students("张三",10);
        Students student2=(Students) student1.clone();//强制类型转化
        System.out.println(student1);
        System.out.println(student2);
    }
}

class Money{
    public double m=25.0;
}
class Students  implements Cloneable {
    public String name;
    public int age;
    public Money money=new Money();

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

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

    @Override
    public String toString() {
        return "{" +
                "name=" + name + " "+
                ", age=" + age +" "+
                ", money=" + money.m +
                '}';
    }
}


public class text {
    public static void main(String[] args) throws CloneNotSupportedException {
        Students student1=new Students("张三",10);
        Students student2=(Students) student1.clone();
        System.out.println(student1);
        System.out.println(student2);
        System.out.println("====");
        student1.money.m=15.0;
        System.out.println(student1);
        System.out.println(student2);
    }
}

 

         通过clone，我们只是拷贝了Students对象，但是Students对象中的Money对象，并没有拷贝，通过student1这个引用修改了m的值后，student2这个引用访问m的时候，值也发生了改变。

class Money implements Cloneable{
    public double m=25.0;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Students  implements Cloneable {
    public String name;
    public int age;
    public Money money=new Money();

    @Override  //深拷贝，将引用的对象（student1）中的对象也拷贝到目标对象中
    protected Object clone() throws CloneNotSupportedException {
        Students temp=(Students) super.clone();
        temp.money=(Money)this.money.clone();
        return temp;
    }

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

    @Override
    public String toString() {
        return "{" +
                "name=" + name + " "+
                ", age=" + age +" "+
                ", money=" + money.m +
                '}';
    }
}


public class text {
    public static void main(String[] args) throws CloneNotSupportedException {
        Students student1=new Students("张三",10);
        Students student2=(Students) student1.clone();
        System.out.println(student1);
        System.out.println(student2);
        System.out.println("====");
        student1.money.m=15.0;
        System.out.println(student1);
        System.out.println(student2);
    }
}

 

        通过clone，我们拷贝Students对象，同时将Students对象中的Money对象也进行拷贝。通过student1这个引用修改了m的值后，student2这个引用访问m的时候，值不会发生改变。

2.抽象类和接口的区别

        抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别，
        核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。
        抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类.万一不小心创建了 Animal 的实例, 编译器会及时提醒我们。

3.Object类

        Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。

        例如：使用Object接收所有类的对象。。

class Person{

}
class Student{

}
public class Test {
        public static void main(String[] args) {
        function(new Person());
        function(new Student());
        }
        public static void function(Object object) {
                System.out.println(object);
        }

}

        Object类中有以下方法

4.获取对象的信息

        如果要打印对象中的内容，可以直接重写Object类中的toString()方法。

// Object类中的toString()方法实现
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
 

 5.对象比较方法equals

        在Java中，==进行比较时：如果==左右两侧是基本类型变量，比较的是变量中值是否相同；
如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同；如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的。

/ /Object类中的equals方法
public boolean equals(Object obj) {
        return (this == obj); // 使用引用中的地址直接来进行比较
}

class Person{
        private String name ;
        private int age ;
        public Person(String name, int age) {

                this.age = age ;
                this.name = name ;
        }
}
public class Test {
        public static void main(String[] args) {
                Person p1 = new Person("zhangsan", 20) ;
                Person p2 = new Person("lisi", 20) ;
                int a = 10;
                int b = 10;

                System.out.println(a == b); 
                System.out.println(p1 == p2); 
                System.out.println(p1.equals(p2));

        }
}

         Person类重写equals方法后，然后比较：

class Person{
        ...
        @Override
        public boolean equals(Object obj) {
                if (obj == null) {
                return false ;
                }

                if(this == obj) {
                        return true ;
                }

                // 不是Person类对象
                if (!(obj instanceof Person)) {
                        return false ;
                }

                Person person = (Person) obj ; // 向下转型，比较属性值
                return this.name.equals(person.name) && this.age==person.age ;
        }

}

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

6.内部类

        当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服 务，那么这个内部的完整结构最好使用内部类。在 Java 中， 可以将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类 。内部类也是封装的一种体现。
 // OutClass是外部类
public class OutClass {
         // InnerClass是内部类
         class InnerClass {
        }
}
        注意： 定义在 class 类名 {}花括号外部的，即使是在一个文件里，都不能称为内部类；内部类和外部类共用同一个 java 源文件，但是经过编译之后，内部类会形成单独的字节码文件。
public class A {
        ...
}
class B {
        ...
}//A、B是两个独立的类
        1. 内部类的分类
                根据内部类在一个类的位置可以分为实例内部类、静态内部类和局部内部类。
public class OutClass {
        //成员位置： 实例内部类（未被static修饰）
        public class InnerClass1{
        }
        // 成员位置：静态内部类
        static class InnerClass2{
        }
        public void method(){
                // 方法中定义内部类： 局部内部类：几乎不用
                class InnerClass5{
                }
        }
}
        2. 内部类
              在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类。
              1. 实例内部类  
public class OutClass {
        private int a;
        static int b;
        int c;
        public void methodA(){
                a = 10;
                System.out.println(a);
        }
        public static void methodB(){
                System.out.println(b);
        } 
        // 实例内部类：未被static修饰
        class InnerClass{
                int c;
                public void methodInner(){
                        // 实例内部类中可以直接访问外部类中任意访问限定符修饰的成员
                        a = 100;
                        b =200;
                        methodA();
                        methodB();
                        // 如果具有相同名称成员时，优先访问的是内部类自己的

                        c = 300;
                        System.out.println(c);
                        // 如果要访问外部类同名成员，使用外部类名称.this.同名成员名字 

                        OutClass.this.c = 400;

                        System.out.println(OutClass.this.c);
                   }
        } 
        public static void main(String[] args) {
        // 外部类：对象创建 以及 成员访问
        OutClass outClass = new OutClass();
        System.out.println(outClass.a);
        System.out.println(OutClass.b);
        System.out.println(outClass.c);
        outClass.methodA();
        outClass.methodB();
        // 创建实例内部类对象

        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
        // 也可以先将外部类对象先创建出来，然后再创建实例内部类对象(常用)
        OutClass.InnerClass innerClass2 = outClass.new InnerClass();
        innerClass2.methodInner();
        }
}

        注意：外部类中的任何成员都可以在实例内部类方法中直接访问；实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束；实例内部类对象必须在先有外部类对象前提下才能创建 ；实例内部类的非静态方法中包含了一个指向外部类对象的引用；外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

        2.静态内部类

public class OutClass {
        private int a;
        static int b;
        public void methodA(){
                a = 10;
                System.out.println(a);
        }
        public static void methodB(){
                System.out.println(b);
        }
        // 静态内部类：被static修饰的成员内部类
        static class InnerClass{
                public void methodInner(){
                        // 在内部类中只能访问外部类的静态成员
                        // a = 100; // 编译报错，a不是静态成员变量
                        b =200;
                        // methodA(); // 编译报错，methodB()不是静态成员方法
                        methodB();
                }
        }
        public static void main(String[] args) {

                // 静态内部类对象创建 、成员访问
                OutClass.InnerClass innerClass = new OutClass.InnerClass();
                innerClass.methodInner();
         }
}

        注意：在静态内部类中只能访问外部类中的静态成员；创建静态内部类对象时，不需要先创建外部类对象。

        3.匿名内部类

interface IA {
    void test();
}
public class text {
    public static void main(String[] args) {
        //匿名内部类
        IA a = new IA() {
            @Override
            public void test() {
                System.out.println("这是重写了接口的方法！");
            }
        };
        a.test();
        new IA() {
            @Override
            public void test() {
                System.out.println("这是重写了接口的方法！");
            }
        }.test();
    }
}

        4.局部内部类

        定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解下语法格式。

public class OutClass {
         int a = 10;
        public void method(){
                int b = 10;
                // 局部内部类：定义在方法体内部
                // 不能被public、static等访问限定符修饰
                class InnerClass{
                        public void methodInnerClass(){
                                System.out.println(a);
                                System.out.println(b);
                        }
                }
                // 只能在该方法体内部使用，其他位置都不能用
                InnerClass innerClass = new InnerClass();
                innerClass.methodInnerClass();
        }
        public static void main(String[] args) {
                // OutClass.InnerClass innerClass = null; 编译报错
        }
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

人工智能学习07--pytorch23--目标检测：Deformable-DETR训练自己的数据集

人工智能学习07--pytorch23--目标检测：Deformable-DETR训练自己的数据集

参考 https://blog.csdn.net/qq_44808827/article/details/125326909https://blog.csdn.net/dystsp/article/details/125949720?utm_mediumdistribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0-125949720-blog-125326909.235^v38^pc_releva…
阅读更多...
react中hooks的理解与使用

react中hooks的理解与使用

一、作用 我们知道react组件有两种写法一种是类组件，另一种是函数组件。而函数组件是无状态组件，如果我们要想改变组件中的状态就无法实现了。为此，在react16.8版本后官方推出hooks，用于函数组件更改状态。 二、常用API 1、use…
阅读更多...
（Yolov5常见bug）RuntimeError: “slow_conv2d_cpu“ not implemented for ‘Half‘问题解决

（Yolov5常见bug）RuntimeError: “slow_conv2d_cpu“ not implemented for ‘Half‘问题解决

今天用Yolov5目标检测模型进行Flask部署的时候，遇见一个问题：RuntimeError: "slow_conv2d_cpu" not implemented for Half。在王宏网上查阅了很久，发现大多数都是在讲有关Half的精度问题。 具体报错如下： 他人的解决方…
阅读更多...
Git小乌龟的安装及使用

Git小乌龟的安装及使用

1.先下载git，按照相应的系统，https://git-scm.com/downloads，然后，一直next即可完成安装 2.安装git小乌龟，https://tortoisegit.org/download/，同样的，一直next即可完成安装，但是&a…
阅读更多...
「从零入门推荐系统」22：chatGPT、大模型在推荐系统中的应用

「从零入门推荐系统」22：chatGPT、大模型在推荐系统中的应用

作者 | gongyouliu 编辑 | gongyouliu 提示：全文2.5万字，预计阅读时长2小时，可以先收藏再慢慢阅读。 我们在上一章介绍了chatGPT、大模型的基本概念、核心技术原理等基础知识，有了这些背景知识的铺垫，下面我们来介绍ch…
阅读更多...
从零开始，探索Python变量的奥秘！

从零开始，探索Python变量的奥秘！

在Python这个充满魔力的编程世界中，变量是一门必须深入了解的基础知识。无论你是初学者还是有经验的开发者，掌握变量的基本语法对于编写优雅、高效的代码至关重要。本篇博客将带你从零开始，深入探索Python变量的奥秘，让你在编程之…
阅读更多...
FBX SDK开发快速上手指南

FBX SDK开发快速上手指南

一段时间以来，我一直想制作一个 FBX Exporter 将 FBX 文件转换为我自己的格式。 整个过程不是很顺利，主要是FBX的官方文档不是很清楚。 另外，由于 FBX 格式被许多应用程序使用，而不仅仅是游戏引擎，因此提供的示例代码没…
阅读更多...
Linux操作系统~Linux基础知识相关题

Linux操作系统~Linux基础知识相关题

整卷阅览： 想要获取试卷原版请点击以下链接下载： https://download.csdn.net/download/qq_53142796/88168132https://download.csdn.net/download/qq_53142796/88168132 解题过程： 选择题（每小题2分，共30分&#xff…
阅读更多...
【设计模式】-建造者模式

【设计模式】-建造者模式

Java建造者模式：创建复杂对象的灵活构建者 在软件开发中，我们经常遇到需要创建一个复杂对象的情况。如果使用传统的构造函数进行对象创建，可能会导致构造函数参数过多，难以管理和维护。建造者模式（Builder Pattern&am…
阅读更多...
FFmpeg中硬解码后深度学习模型的图像处理dnn_processing(一)

FFmpeg中硬解码后深度学习模型的图像处理dnn_processing(一)

ffmpeg 硬件解码 ffmpeg硬件解码可以使用最新的vulkan来做，基本上来说，不挑操作系统是比较重要的，如果直接使用cuda也是非常好的选择。 AVPixelFormat sourcepf AV_PIX_FMT_NV12;// AV_PIX_FMT_NV12;// AV_PIX_FMT_YUV420P;AVPixelFormat d…
阅读更多...
Linux-centos花生壳实现内网穿透

Linux-centos花生壳实现内网穿透

Linux-centos花生壳实现内网穿透 官网教程 1.安装花生壳 下载网址 点击复制就可以复制下载命令了 wget "https://dl.oray.com/hsk/linux/phddns_5.2.0_amd64.rpm" -O phddns_5.2.0_amd64.rpm# 下载完成之后会多一个rpm文件 [rootlocalhost HuaSheng]# ls phddns_…
阅读更多...
UE5+Paperzd问题

UE5+Paperzd问题

TopDown的2D游戏，遇到两个问题，第一问题是游戏一开始就会从tilemap上掉下去。第二个问题是没法和图层2上的物体做碰撞。 一、碰撞问题 1、创建的TileSet后，左侧选中一个tile后，一定要点击上边的Add Box，否则创建出来的…
阅读更多...
jenkins的cicd操作

jenkins的cicd操作

cicd概念 持续集成（ Continuous Integration） 持续频繁的（每天多次）将本地代码“集成”到主干分支，并保证主干分支可用 持续交付（Continuous Delivery） 是持续集成的下一步，持续…
阅读更多...
Julia 字典和集合

Julia 字典和集合

数组是一种集合，此外 Julia 也有其他类型的集合，比如字典和 set（无序集合列表）。 字典 字典是一种可变容器模型，且可存储任意类型对象。 字典的每个键值 key>value 对用 > 分割，每个键值对之间用逗…
阅读更多...
STM32的电动自行车信息采集上报系统（学习）

STM32的电动自行车信息采集上报系统（学习）

摘要 针对电动自行车实时监管不便的问题，设计了一种基于STM32的电动自行车信息采集系统，通过获取电池、位置和行驶状态信息并上报到服务器中，实现实时监管。 通过多路串口请求电池、行驶状态和位置信息，以并发方式进行数据接收、…
阅读更多...
亿欧智库：2023中国宠物行业新趋势洞察报告（附下载）

亿欧智库：2023中国宠物行业新趋势洞察报告（附下载）

关于报告的所有内容，公众【营销人星球】获取下载查看 核心观点 户外赛道本质上迎合了全球共性需求的增长，从养宠意愿的转化到养宠生活的需求，多层次的需求推动行业发展新趋势 从需求端进行分析，可以将养宠意愿的转化分为三个层…
阅读更多...
nginx部署以及反向代理多域名实现HTTPS访问

nginx部署以及反向代理多域名实现HTTPS访问

nginx部署以及反向代理多域名实现 1.nginx部署 1.1 编写nginx部署文件 docker-compose.yml version: 3 services: nginx:restart: always image: nginx:1.20container_name: nginx-mainports:- 80:80- 443:443volumes: # 基础配置- /opt/nginx_main/nginx-info/nginx.conf:/…
阅读更多...
并查集模板-两个操作：合并集合和查询两个元素是否属于同一个集合

并查集模板-两个操作：合并集合和查询两个元素是否属于同一个集合

一、链接 836. 合并集合 二、题目 一共有 nn 个数，编号是 1∼n1∼n，最开始每个数各自在一个集合中。 现在要进行 mm 个操作，操作共有两种： M a b，将编号为 aa 和 bb 的两个数所在的集合合并，如果两个数…
阅读更多...
在 aosp 中启用 Material You design

在 aosp 中启用 Material You design

作者：Mr_万能胶 近期研究了一下如何在 aosp 中启用 Material You design，在把踩过的坑记录一下，方便后续有厂商可以快速集成。 本文基于 aosp 最新代码，版本号为 Android 13，并使用 Cuttlefish 快速验证。 Material …
阅读更多...
消息队列项目(3)

消息队列项目(3)

Message 存储 由于 Message 以后会是一个比较庞大的数据, 放在数据库里并不合适, 因此我们要将它放在二进制文件中 因为 Message 和 Queue 是捆绑在一起的, 因此我们将目录名设置成 QueueName, 然后这些目录是存储在之前的 data 里 就像这样: 在 testQueue 中有包含两个文件…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023