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

目录

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; 编译报错
        }
}

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

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

相关文章

jupyter lab build失败，提示需要安装版本＞=12.0.0的nodejs但其实已从官网安装18.17.0版本 的解决方法

jupyter lab build失败，提示需要安装版本＞=12.0.0的nodejs但其实已从官网安装18.17.0版本 的解决方法

出现的问题如题目所示，这个问题差点要把我搞死了。。。但还是在没有重装的情况下解决了😘。 问题来源 初衷是想安装lsp扩展，直接在jupyter lab网页界面的extensions中搜索lsp并点击install krassowski/jupyterlab-lsp，会提示需要…
阅读更多...
tomcat虚拟主机配置演示

tomcat虚拟主机配置演示

一.新建用于显示的index.jsp文件，写入内容 二.修改tomcat/apache-tomcat-8.5.70/conf/server.xml配置文件 匹配到Host那部分，按上面格式在后面添加自己的域名和文件目录信息 主要是修改name和docBase 保存退出重启tomcat，确保tomcat运行…
阅读更多...
QT笔记——QT自定义事件

QT笔记——QT自定义事件

我们有时候想发送自定义事件 1：创建自定义事件，首先我们需要知道它的条件 1：自定义事件需要继承QEvent 2：事件的类型需要在 QEvent::User 和 QEvent::MaxUser 范围之间，在QEvent::User之前 是预留给系统的事件 3&#…
阅读更多...
python免费下载安装教程,python编程软件 免安装

python免费下载安装教程,python编程软件 免安装

本篇文章给大家谈谈python免费下载安装教程，以及python编程软件 免安装，希望对各位有所帮助，不要忘了收藏本站喔。 百度网盘 请输入提取码 提取码: wifx 下载好记得把python文件解压，里面有32位和64位的，根据自己配置…
阅读更多...
【工作中问题解决实践 十】一次内存泄露排查-MAT使用指南

【工作中问题解决实践 十】一次内存泄露排查-MAT使用指南

最近体验了一把当医生的感觉，定位病根病因，感觉这种要揪出问题的感觉很爽，并不觉得麻烦，这里将整个排查过程记录一下，方便之后再遇到类似问题有应对之道。 问题背景 2023-07-18 早上还在睡梦中的俺被一条条报警消息铛…
阅读更多...
Spring事务管理

Spring事务管理

1.什么是事务 数据库事务是指作为单个逻辑工作单元执行的一系列操作，这些操作要么一起成功，要么一起失败，是一个不可分割的工作单元。 涉及到事务的场景非常多，一个 service 中往往需要调用不同的 dao 层方法，这些方法…
阅读更多...
区块链技术助力慈善，为您的善举赋予全新力量！

区块链技术助力慈善，为您的善举赋予全新力量！

我们怀揣着一颗温暖的心，秉承着公开透明的理念，带着信任与责任，倾力打造了一套区块链技术驱动的去中心化捐赠与物资分发系统，通过智能生态网络（IEN）解决捐赠不透明问题的系统，让您的善举直接温暖…
阅读更多...
Linux命令200例：cd用于改变当前工作目录（常用）

Linux命令200例：cd用于改变当前工作目录（常用）

🏆作者简介，黑夜开发者，全栈领域新星创作者✌。CSDN专家博主，阿里云社区专家博主，2023年6月csdn上海赛道top4。 🏆数年电商行业从业经验，历任核心研发工程师，项目技术负责人。 &…
阅读更多...
【Rust】Rust学习 第五章使用结构体组织相关联的数据

【Rust】Rust学习 第五章使用结构体组织相关联的数据

5.1 定义结构体并实例化结构体 定义结构体，需要使用 struct 关键字并为整个结构体提供一个名字。结构体的名字需要描述它所组合的数据的意义。接着，在大括号中，定义每一部分数据的名字和类型，我们称为 字段（field&…
阅读更多...
数据结构--最小生成树

数据结构--最小生成树

数据结构–最小生成树 连通图 \color{red}连通图 连通图的生成树是 包含图中全部顶点的一个极小连通子图 \color{red}包含图中全部顶点的一个极小连通子图 包含图中全部顶点的一个极小连通子图。 若图中顶点数为n，则它的生成树含有 n-1 条边。对生成树而言&#xff…
阅读更多...
断路器回路电阻试验

断路器回路电阻试验

试验目的 断路器回路电阻主要取决于断路器动、 静触头的接触电阻, 其大小直接影响正常 运行时的发热情况及切断短路电流的性能, 是反应安装检修质量的重要数据。 试验设备 回路电阻测试仪 厂家： 湖北众拓高试代销 试验接线 对于单断口的断路器, 通过断口两端的接线…
阅读更多...
WebRTC 之音视频同步

WebRTC 之音视频同步

在网络视频会议中， 我们常会遇到音视频不同步的问题， 我们有一个专有名词 lip-sync 唇同步来描述这类问题，当我们看到人的嘴唇动作与听到的声音对不上的时候，不同步的问题就出现了 而在线会议中， 听见清晰的声音是优先…
阅读更多...
redis 集群 2：分而治之 —— Codis

redis 集群 2：分而治之 —— Codis

在大数据高并发场景下，单个 Redis 实例往往会显得捉襟见肘。首先体现在内存上，单个 Redis 的内存不宜过大，内存太大会导致 rdb 文件过大，进一步导致主从同步时全量同步时间过长，在实例重启恢复时也会消耗很长的数据加载…
阅读更多...
Mysql主从搭建 基于DOCKER

Mysql主从搭建 基于DOCKER

创建目录 #主节点目录 mkdir -p /home/data/master/mysql/#从节点目录 mkdir -p /home/data/slave/mysql/创建配置文件 # 主节点配置 touch /home/data/master/mysql/my.cnf# 从节点配置 touch /home/data/slave/mysql/my.cnf编辑配置文件 主节点配置文件 vim /home/data/m…
阅读更多...
前沿分享-鱼形机器人

前沿分享-鱼形机器人

可能并不太前沿了，是21年底的新闻了，但是看见了就顺便发一下吧。 大概就是，通过在pH响应型水凝胶中编码不同的膨胀速率而构建了一种环境适应型变形微机器人,让微型机器人直接向癌细胞输送药物从而减轻药物带来副作用。 技术原理是&#xff0c…
阅读更多...
【51单片机】晨启科技，7针OLED显示驱动程序，STC89C52RC

【51单片机】晨启科技，7针OLED显示驱动程序，STC89C52RC

文章目录 原理图oled.coled.hmain.c 原理图 sbit OLED_SCLP4^3;//SCL-D0 sbit OLED_SDAP4^1;//SDA-D1 sbit OLED_RES P3^6;//RES sbit OLED_DC P3^7;//DC sbit OLED_CSP2^7; //CS oled.c #include "OLED.h"//******************************说明*******************…
阅读更多...
APP外包开发的Flutter框架

APP外包开发的Flutter框架

Flutter 是一种流行的开源UI框架，由谷歌开发，用于构建跨平台的移动应用程序。它使用一套统一的代码库，可以在多个平台上（如Android、iOS、Web、桌面等）保持一致的外观和行为。今天和大家分享一些基于 Flutter 开发的常…
阅读更多...
初次使用GPU云服务器

初次使用GPU云服务器

前言： 在体验了GPU云服务器（GPU Cloud Computing，GPU）后，我认为这是一个非常强大的弹性计算服务。它为深度学习、科学计算、图形可视化、视频处理等多种应用场景提供了强大的GPU算力，能够满足各类用户的计算…
阅读更多...
如何使Python Docker镜像安全、快速、小巧

如何使Python Docker镜像安全、快速、小巧

一、说明 在微服务领域，拥有安全、高效和紧凑的 Docker 映像对于成功部署至关重要。本博客将探讨有助于构建此类映像的关键因素，包括不以 root 用户身份运行映像的重要性、在构建映像时更新和升级包、在编写 Dockerfile 指令时考虑 Docker 的层架构&…
阅读更多...
ZIG：理解未来编程语言的视角

ZIG：理解未来编程语言的视角

文章目录 摘要：引言：性能简洁性和模块化避免常见错误和陷阱总结：参考资料📑: 摘要： 本文介绍了新兴编程语言ZIG的目标和特点，包括高性能、简洁性和模块化，并分析了这些特点是如何通过语言设计来…
阅读更多...
最新文章

Copyright @ 2022~2023