Java浅,深拷贝;内,外部类的学习了解

news2024/11/22 23:33:08

目录

浅拷贝

深拷贝

内部类

匿名内部类

实例内部类

静态内部类

外部类


浅拷贝

简单理解:定义了A,A里面有age和num,拷贝成为B,B里面有age和num

package demo1浅克隆和深克隆;

    //interfaces 是定义了一个接口
    //implements是使用这个接口的关键字
    //implements Cloneable:使用这个接口并且克隆一份
    class Person implements Cloneable{
        //声明
        public int age;
        //调用使用
        public Person(int age){
            this.age=age;
        }

        //这个方法是用于复制当前类的一个实例
        //通过调用该方法,可以得到一个与原始对象相同属性的新对象。
        @Override
        protected Object clone() throws CloneNotSupportedException {
            //uper是关键字,它被用于引用当前类的父类或直接父类中的方法、属性等。
            return super.clone();
        }

        //这个代码段定义了一个类toString()
        //它会将实例中的属性打印成一个字符串
        //例如,在这里,它会根据Person类中定义的age属性
        //生成如下输出:Person{age=30}
        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    '}';
        }
    }

    public class Test克隆案例浅拷贝 {

        public static void main(String[] args) throws CloneNotSupportedException {

            Person person1=new Person(10);
            Person person2= (Person) person1.clone();
            System.out.println(person1);
            System.out.println(person2);

        }

    }



深拷贝

简单理解:定义了A,A里面有age和num,修改A中age变成k,拷贝成为B,B里面有k和num

package demo1浅克隆和深克隆;

//加的类,副加函数克隆
class Money implements Cloneable{
    public double money=19.9;

    //证明我能被克隆
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

//主函数克隆
class Jkl implements Cloneable{
    public int age;

    //加的成员
    public Money m;

    //构造方法
    public Jkl(int age){
        this.age=age;

        //在构造方法里面进行实例化一次
        this.m=new Money();

    }

    //在主函数里面调用附加函数克隆
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //return super.clone();

        //用Jkl来接收克隆出来的对象,再进行修改
        Jkl tmp=(Jkl) super.clone();

        //main中是jkl1调用克隆出19.9
        tmp.m=(Money) this.m.clone();
        //tmp是常量最后会自动释放
        //所以用jkl2来指向tmp指向的值
        return tmp;
    }

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


public class Test深拷贝 {

        public static void main(String[] args) throws CloneNotSupportedException {

            Jkl jkl1=new Jkl(10);
            Jkl jkl2= (Jkl) jkl1.clone();

            System.out.println(jkl1);
            System.out.println(jkl2);

            System.out.println("==================");

            //修改成下面这样的形式
            System.out.println(jkl1.m.money);
            System.out.println(jkl2.m.money);

            System.out.println("==================");
            jkl2.m.money=99.99;
            System.out.println(jkl1.m.money);
            System.out.println(jkl2.m.money);

        }

}

内部类

将一个类定义在另一个类的内部

匿名内部类

package demo内部类;

//一个类一个字节码文件

//定义一个接口,接口里面定义一个方法 给匿名内部类
interface A{
    void testA();
}

public class Test匿名内部类 {

    public static void main(String[] args) {
        //匿名内部类
        //下面代码可以认为:有一个类,实现了A接口并且重写了A接口中的方法
        //匿名写法调用方式1
        /*new A(){

            @Override
            public void testA() {
                System.out.println("hehe");
            }
        }.testA();*/

        //匿名写法调用方式2
        A a = new A(){
            //重写我的testA()方法
            @Override
            public void testA() {
                System.out.println("hehe");
            }
        };
        //能够访问的是,没有被修改过的数据(变量的捕获)
        //即默认访问被final修饰的量(常量)
        a.testA();
    }

}

实例内部类

package demo内部类;

/*
* 1.如何获取实例内部类
* 2.在实例内部类中,是否可以定义静态的成员变量?
*   public static final int data6=6;中间加个final
*   因为final是修饰常量,实力内部类要依赖普通类
* 3.当实例内部类和普通类都定义了的public int data1;
*   在实例内部类中打印的data1是先打印data1所在的类
* (this.data也是)一样的,所以输出11111.
*   如果我硬要用实例内部类中的data1打印普通类(在实例内部类外面)的data1值
*   那么就:普通类名+this.data1(OuterClass.this.data1)
*
*   实例内部类的缺点:每次使用都要创建一个普通类,通过它来引用实例内部类
*                   静态内部类则不用这样
*
* */




//OuterClass这个普通类
class OuterClass{

    //普通的成员变量
    public int data1=1;
    private int data2=2;
    public static int data3=3;

    //普通的成员内部类
    //实例内部类
    class InnerClass{
        public int data1=11111;
        public int data4=4;
        private int data5=5;
        public static final int data6 = 6;

        //定义普通的成员方法
        public void test(){
            System.out.println(data1);
            System.out.println(OuterClass.this.data1);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
            System.out.println("内部类的test方法");
        }
    }

    //普通类自己的方法
    public void test(){
        System.out.println("外部类的test方法");
    }

}

public class Test实例内部类 {

    public static void main(String[] args) {
        //如何使用内部类

        //先声明正常类的调用

        //外部类名   外部对象名
        OuterClass outerClass=new OuterClass();
        System.out.println(outerClass.data1);
        System.out.println("==================");

        //再在正常内部类上调用实例内部类
        //1.总结:获取一个实例内部类对象,依赖于外部类对象(外部类名.内部类名 内部对象名 =外部对象名.new 内部类名)
        //                                                                  用对象
        //调用方式1
        OuterClass.InnerClass innerClass=outerClass.new InnerClass();
        innerClass.test();

        //调用方式2
        //因为outerClass=new OuterClass(); 所以替换掉outerClass
        //OuterClass.InnerClass innerClass2=new OuterClass().new InnerClass();
        //innerClass2.test();

    }


}

静态内部类

package demo内部类;

/*
*1.如何获取实例内部类
* (外部类名.内部类名 内部对象名=new 外部类名.内部类名)
* 2.在实例内部类中,是否可以定义非静态(外部)的成员变量?
*   直接在静态里面声明就可以去使用了
*       OuterClass outerClass=new OuterClass();
        System.out.println(outerClass.data1);
*/



//在同一个包里面重名了,所以加上2来区分
class OuterClass2 {
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;

    //静态内部类---不依赖外部对象
    static class InnerClass {
        //当此语句被屏蔽了,data1也不会打印OuterClass2中data1=1的值
        //public int data1=111;
        public int data4=4;
        private int data5=5;
        public static  int data6 = 6;

        public void test(){
            OuterClass outerClass=new OuterClass();
            System.out.println(outerClass.data1);

            System.out.println("==========");
            //System.out.println(data1);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
            System.out.println("内部类的test方法");
        }

    }

}


public class Test静态内部类 {

    public static void main(String[] args) {
        //静态的东西是需要 (外部类名.内部类名 内部对象名=new 外部类名.内部类名)去访问的
        //                                            用类名
        OuterClass2.InnerClass innerClass=new OuterClass2.InnerClass();
        innerClass.test();

    }

}

外部类

将一个类定义在一个方法的内部

//抽象类
public abstract class Shape {
    private String color;

    public Shape(String color) {
        this.color = color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public abstract void draw();
}

public class Circle extends Shape {
    private int radius;

    public Circle(String color, int radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle of radius " + radius + " with color " + getColor());
    }
}

public class Rectangle extends Shape {
    private int width;
    private int height;

    public Rectangle(String color, int width, int height) {
        super(color);
        this.width = width;
        this.height = height;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle of width " + width + " and height " + height + " with color " + getColor());
    }
}

//接口
public interface Flyable {
    void fly();
}

public class Bird implements Flyable {
    public void fly() {
        System.out.println("Bird is flying...");
    }
}

public class Airplane implements Flyable {
    public void fly() {
        System.out.println("Airplane is flying...");
    }
}


//外部类
public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle("Red", 10);
        Rectangle rectangle = new Rectangle("Blue", 20, 30);

        circle.draw();
        rectangle.draw();

        Bird bird = new Bird();
        Airplane airplane = new Airplane();

        bird.fly();
        airplane.fly();
    }
}

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

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

相关文章

火语言RPA流程组件介绍--浏览器页面操作

🚩【组件功能】:浏览器页面前进,后退,刷新及停止等操作 配置预览 配置说明 丨操作类型 后退/前进/刷新 丨超时时间 支持T或# 输入仅支持整型 页面操作超时时间 丨执行后后等待时间(ms) 支持T或# 当前组件执行完成后继续等待…

Spring框架常见漏洞

文章目录 SpEL注入攻击Spring H2 Database Console未授权访问Spring Security OAuth2远程命令执行漏洞(CVE-2016-4977)Spring WebFlow远程代码执行漏洞(CVE-2017-4971)Spring Data Rest远程命令执行漏洞(CVE-2017-8046)Spring Messaging远程命令执行漏洞(CVE-2018-1270)Spring …

Python酷库之旅-第三方库Pandas(119)

目录 一、用法精讲 526、pandas.DataFrame.head方法 526-1、语法 526-2、参数 526-3、功能 526-4、返回值 526-5、说明 526-6、用法 526-6-1、数据准备 526-6-2、代码示例 526-6-3、结果输出 527、pandas.DataFrame.idxmax方法 527-1、语法 527-2、参数 527-3、…

C语言刷题日记(附详解)(5)

一、选填部分 第一题: 下面代码在64位系统下的输出为( ) void print_array(int arr[]) {int n sizeof(arr) / sizeof(arr[0]);for (int i 0; i < n; i)printf("%d", arr[i]); } int main() {int arr[] { 1,2,3,4,5 };print_array(arr);return 0; } A . 1…

vi | vim基本使用

vim三模式&#xff1a;① 输入模式 ②命令模式 ③末行模式&#xff08;编辑模式&#xff09; vim四模式&#xff1a;① 输入模式 ②命令模式 ③末行模式&#xff08;编辑模式&#xff09; ④V模式 一、命令模式进入输入模式方法&#xff1a; 二、命令模式基…

Hybrid接口的基础配置

Hybrid模式是交换机端口的一种配置模式&#xff0c;它允许端口同时携带多个VLAN&#xff08;虚拟局域网&#xff09;的流量。Hybrid端口可以指定哪些VLAN的数据帧被打上标签&#xff08;tagged&#xff09;和哪些VLAN的数据帧在发送时去除标签&#xff08;untagged&#xff09;…

828华为云征文|部署知识库问答系统 MaxKB

828华为云征文&#xff5c;部署知识库问答系统 MaxKB 一、Flexus云服务器X实例介绍1.1 云服务器介绍1.2 核心竞争力1.3 计费模式 二、Flexus云服务器X实例配置2.1 重置密码2.2 服务器连接2.3 安全组配置 三、部署 MaxKB3.1 MaxKB 介绍3.2 Docker 环境搭建3.3 MaxKB 部署3.4 Max…

Leetcode—322. 零钱兑换【中等】(memset(dp,0x3f, sizeof(dp))

2024每日刷题&#xff08;159&#xff09; Leetcode—322. 零钱兑换 算法思想 dp实现代码 class Solution { public:int coinChange(vector<int>& coins, int amount) {int m coins.size();int n amount;int dp[m 1][n 1];memset(dp, 0x3f, sizeof(dp));dp[0][…

基于springboot+vue+uniapp的驾校报名小程序

开发语言&#xff1a;Java框架&#xff1a;springbootuniappJDK版本&#xff1a;JDK1.8服务器&#xff1a;tomcat7数据库&#xff1a;mysql 5.7&#xff08;一定要5.7版本&#xff09;数据库工具&#xff1a;Navicat11开发软件&#xff1a;eclipse/myeclipse/ideaMaven包&#…

使用随机森林模型在digits数据集上执行分类任务

程序功能 使用随机森林模型对digits数据集进行手写数字分类任务。具体步骤如下&#xff1a; 加载数据&#xff1a;从digits数据集中获取手写数字图片的特征和对应的标签。 划分数据&#xff1a;将数据集分为训练集和测试集&#xff0c;测试集占30%。 训练模型&#xff1a;使用…

鸿蒙开发笔记_电商严选02_登录页面跳转到我的页面、并传值

鸿蒙开发笔记整理,方便以后查阅! 由于上班较忙,只能抽空闲暇时间,快速整理更新中。。。 登录页面跳转到我的页面、并传值 效果图 我的设置页面 /*** 我的设置页面*/ import CommonConstants from ./CommonConstants import ItemData from ./ItemData import DataModel fr…

某个图形商标驳回,不建议做驳回复审!

近日一四川的网友联系到普推知产商标老杨&#xff0c;咨询看驳回的商标可以做驳回复审不&#xff0c;是个纯图形商标&#xff0c;这个一看是一标多类&#xff0c;就是在一个商标名称是申请两个类别&#xff0c;42类部分通过&#xff0c;35类全部驳回。 35类和42类引用的近似商标…

07_Python数据类型_集合

Python的基础数据类型 数值类型&#xff1a;整数、浮点数、复数、布尔字符串容器类型&#xff1a;列表、元祖、字典、集合 集合 集合&#xff08;set&#xff09;是Python中一个非常强大的数据类型&#xff0c;它存储的是一组无序且不重复的元素&#xff0c;集合中的元素必须…

SpringBoot 消息队列RabbitMQ死信交换机

介绍 生产者发送消息时指定一个时间&#xff0c;消费者不会立刻收到消息&#xff0c;而是在指定时间之后才收到消息。 死信交换机 当一个队列中的消息满足下列情况之一时&#xff0c;就会成为死信(dead letter) 消费者使用basic.reject或 basic.nack声明消费失败&#xff0…

LidarView之定制版本

介绍 LidarView软件定制开发需要关注几点&#xff1a;1.应用程序名称&#xff1b;2.程序logo&#xff1b;3.Application版本号&#xff1b;4.安装包版本号 应用程序名称 在项目的顶层cmake里边可以指定程序名称 project(LidarView)需要指定跟Superbuild一样的编译类型 set…

英语学习之fruit

目录 不熟悉熟悉 不熟悉 breadfruit 面包果 date 椰枣 raspberry 覆盆子 blackberry 黑莓 blackcurrant 黑加仑&#xff0c;黑醋栗 plum 李子 熟悉 apple 苹果&#x1f34e; coconut 椰子&#x1f965; banana 香蕉&#x1f34c; tomato 西红柿 pear 梨子 watermelon 西瓜…

30款免费好用的工具,打工人必备!

免费工具软件&#xff0c;办公人必备&#xff0c;提升工作效率 启动盘制作&#xff1a;Ventoype工具&#xff1a;微PEwindows/office jh工具&#xff1a;HEU KMS Activator桌面资料转移工具&#xff1a;个人资料专业工具右键菜单管理&#xff1a;ContextMenuManager驱动安装&a…

【面试八股总结】GMP模型

GMP概念 G&#xff08;Goroutine&#xff09;&#xff1a;代表Go协程&#xff0c;是参与调度与执行的最小单位。 存储Goroutine执行栈信息、状态、以及任务函数等。G的数量无限制&#xff0c;理论上只受内存的影响。Goroutines 是并发执行的基本单位&#xff0c;相比于传统的线…

虽难必学系列:Netty

Netty 是一个基于 Java 的高性能、异步事件驱动的网络应用框架&#xff0c;广泛用于构建各类网络应用&#xff0c;尤其是在高并发、低延迟场景下表现出色。作为一个开源项目&#xff0c;Netty 提供了丰富的功能&#xff0c;使得开发者可以轻松构建协议服务器和客户端应用程序。…

Nginx从入门到入土(一):DNS域名解析

前言 hostName&#xff0c;在Linux系统上是一个命令&#xff0c;用来显示和设置系统的主机名称。其实它就是域名。 常见的域名有我们熟悉的taobao.com;baidu.com等等。 我们在地址栏输入baidu.com 进入的就是此页面。我们看到地址栏里显示的是www.baidu.com 。 注意&#xf…