Java基础知识小结（内部类、BigInteger、枚举、接口、重写重载和序列化）

news2024/9/24 0:32:59

一、Java内部类

1、内部类

在Java中，也可以嵌套类（类中的类）。嵌套类的目的是将属于同一类的类分组，这使代码更具可读性和可维护性。
要访问内部类，请创建外部类的对象，然后创建内部类的对象：

class OuterClass {
  int x = 10;

  class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}

// 输出 15 (5 + 10)

2、私有的内部类

与"常规"类不同，内部类可以是private 私有的或 protected受保护的。 如果不希望外部对象访问内部类，请将该类声明为private：

class OuterClass {
  int x = 10;

  private class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}

3、Static 内部类

内部类也可以是static静态的，这意味着您可以在不创建外部类的对象的情况下访问它：
与 static静态属性和方法一样，static静态内部类无权访问外部类的成员。

class OuterClass {
  int x = 10;

  static class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass.InnerClass myInner = new OuterClass.InnerClass();
    System.out.println(myInner.y);
  }
}

// 输出 5

4、从内部类访问外部类

内部类的一个优点是，它们可以访问外部类的属性和方法：

class OuterClass {
  int x = 10;

  class InnerClass {
    public int myInnerMethod() {
      return x;
    }
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.myInnerMethod());
  }
}

// 输出 10

二、Java大数BigInteger、BigDecimal

如果基本的整数和浮点数精度不够用，可以使用java.math包中的BigInteger、BigDecimal类处理包含任意长度的数字序列的数值。

1、BigInteger实现任意精度的整数运算

大数的创建

//valueOf()方法将普通的数值转换为大数
        BigInteger a=BigInteger.valueOf(100);
        //使用一个带字符串参数的构造器
        BigInteger b=new BigInteger("1332433344333");
        //内置常量ZERO、ONE这些
        BigInteger c=BigInteger.ZERO;

大数的运算

Scanner in=new Scanner(System.in);
        String s1=in.nextLine();
        String s2=in.nextLine();
        BigInteger a=new BigInteger(s1);
        BigInteger b=new BigInteger(s2);
        //加法add()
        BigInteger c=a.add(b);
        System.out.println(c);
        //乘法multiply()
        BigInteger d=a.multiply(b);
        System.out.println(d);
        //减法subtract()
        BigInteger e=a.subtract(b);
        System.out.println(e);
        //除法divide()
        BigInteger f=a.divide(b);
        System.out.println(f);
        //取余数mod()
        BigInteger g=a.mod(b);
        System.out.println(g);

其他方法

Scanner in=new Scanner(System.in);
        String s1=in.nextLine();
        String s2=in.nextLine();
        BigInteger a=new BigInteger(s1);
        BigInteger b=new BigInteger(s2);
        //开平方根
        //BigInteger c=a.sqrt();//java 9才有
        //比较两个大数的大小
        // a<b返回负数，a>b返回正数，a==b返回0
        int num=a.compareTo(b);
        String flag= num>=0 ? (num>0 ? "a大":"相等"):"b大";
        System.out.println(flag);

2、BIgDecimal 实现任意精度的浮点数运算

其他方法与BIgInteger类似

Scanner in=new Scanner(System.in);
        String s1=in.nextLine();
        String s2=in.nextLine();
        BigDecimal a=new BigDecimal(s1);
        BigDecimal b=new BigDecimal(s2);
        //除法，并指定舍入方式
        BigDecimal c=a.divide(b,BigDecimal.ROUND_HALF_UP);//四舍五入

三、Java中常量、枚举类型

1、常量

特点：

  • 在程序运行过程中一直不会改变，用关键字final修饰，也被称为“final变量”；
  • 在整个程序中只能被赋值一次，赋值后便不可修改，为所有对象共享；
  • 常量名一般使用全大写；

声明常量的标准语法：

final 数据类型 常量名=值;

如果要使某个常量在一个类的多个方法中都能够使用，可以声明为类常量，使用 static final 修饰

public class Main
{
    public static final double PI=3.14;
    public static void main(String[] args)
    {
        System.out.println(PI*2*2);
    }
}

当定义的final变量属于类常量时，必须在定义的时候就赋值，否则会出错。

public class Main
{
    static final double PI=3.14;//必须在定义时就赋值
    public static void main(String[] args)
    {
        final double p;//可以分开
        p=2.2;
        System.out.println(PI*p*2);
    }
}

2、枚举类型

变量的取值只在一个有限的集合内，枚举类型包括有限个命名的值。
例如，杯子有小中大三种型号

public class Main
{
    public enum Size{SMALL,MEDIUM,LARGE};
    public static void main(String[] args)
    {
        Size cupSize=Size.SMALL;
        System.out.println(cupSize);
    }
}

SMALL

比较两个枚举类型的值时，可以直接使用==。
枚举类的定义

public enum Size
    {
        SMALL("S"),MEDIUM("M"),LARGE("L");
        private String cupSize;
        //构造器总是私有的，所以private可以忽略不写
        Size(String cupSize)
        {
            this.cupSize=cupSize;
        }
        public String getCupSize()
        {
            return cupSize;
        }
    }

枚举类型中的常用方法
在这里插入图片描述
综合应用：

import java.util.*;
public class Main
{
    public enum Size
    {
        SMALL("S"),MEDIUM("M"),LARGE("L");
        private String cupSize;
        //构造器总是私有的，所以private可以忽略不写
        Size(String cupSize)
        {
            this.cupSize=cupSize;
        }
        public String getCupSize()
        {
            return cupSize;
        }
    }
    public static void main(String[] args)
    {
        Scanner in=new Scanner(System.in);
        String input=in.next().toUpperCase();
        Size size=Enum.valueOf(Size.class,input);//将普通字符串转换为枚举实例
        System.out.println("size="+size);
        System.out.println("cupSize="+size.getCupSize());
        if(size==Size.MEDIUM)
        {
            System.out.println("YES");
        }
    }
}


medium
size=MEDIUM
cupSize=M
YES

四、Java使用接口

1、定义接口

接口中的方法是抽象的、公有的，一个类可以实现多个接口。

Java 8 新增：引入默认方法，静态方法，用default关键字来定义
Java 9 新增：私有方法和私有静态方法，用private修饰，私有方法必须包含方法体，必须是具体方法，且私有方法只能在该接口内使用或访问。

2、引用接口

关键字：implements
定义接口

package 基础语法;

public interface JieOne {
	int add(int a,int b);
}

引用接口

package 基础语法;

class SiZeYunSuan implements JieOne,JieTwo,JieThree,JieFour{
	public int add(int a,int b) {
		return a+b;
	}
	public int sub(int a,int b) {
		return a-b;
	}
	@Override
	public int umul(int a, int b) {
		// TODO 自动生成的方法存根
		return a/b;
	}
	@Override
	public int mul(int a, int b) {
		// TODO 自动生成的方法存根
		return a*b;
	}
	
}
public class UseInterface {
	public static void main(String[] args) {
		SiZeYunSuan t=new SiZeYunSuan();
		System.out.println("a+b="+t.add(2, 5));
		System.out.println("a-b="+t.sub(2, 5));
		System.out.println("a*b="+t.mul(2, 5));
		System.out.println("a/b="+t.umul(2, 5));
	}
}

在接口的实现过程中规定：

能为所有的接口提供实现的功能； 能遵循重写的所有规则； 能保持相同的返回数据类型。 接口完全支持多继承，可以有多个直接父接口，用英文逗号隔开。

五、Java方法的重写和重载

1、重写

建立在继承关系上，在子类中重新编写来自父类的方法来满足需求。

规则：

重写方法不能比被重写方法限制更严格的访问级别，即访问权限可以扩大不能缩小； final修饰的方法和静态方法都不能重写；
返回类型和参数列表保持相同； 抽象方法必须在具体类中重写；
无论被重写方法是否抛出异常，重写方法都可以抛出任何非强制异常；但重写方法不能抛出新的强制性异常，或则比被重写方法声明的范围更广的强制性异常。反之则可以。

2、重载overload

同一类中可以有两个或多个方法具有相同的方法名，但是要保证它们的参数不同，

方法重载中参数列表不同的含义是：参数的个数不同或者是参数类型不同。另外，返回类型不能用来区分方法重载

package 基础语法;

public class Chongzai {
	int max(int a,int b) {
		System.out.println("int max:");
		return a>b?a:b;
	}
	int max(short a,short b) {
		System.out.println("int max(short):");
		return a>b?a:b;
	}
	public static void main(String args[]) {
		Chongzai tChongzai=new Chongzai();
		tChongzai.max(3, 4);
		short a=3;//先定义为short，否则默认int
		short b=4;
		tChongzai.max(a, b);
		
	}
}

六、序列化

1、序列化与反序列化

package com.java.main;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class TestObject
{
	public static void main(String[] args)
	{
		ObjectStream objectStream = new ObjectStream();
		objectStream.testObjectOutputStream();
		objectStream.testObjectInputStream();
	}
}
class ObjectStream
{
	/*
	 * 序列化过程：将内存中的Java对象保存到磁盘中或者通过网络传输出去
	 */
	public void testObjectOutputStream()
	{
		ObjectOutputStream oos = null;
		try
		{
			oos = new ObjectOutputStream(new FileOutputStream("D:\\CODE\\codeeclipse\\Java基础\\src\\com\\java\\main\\data.txt"));
			oos.writeObject(new String("你好Java"));
			oos.flush(); // 刷新一下
		}catch(IOException e)
		{
			e.printStackTrace();
		}finally
		{
			if(oos != null)
			{
				try
				{
					oos.close();
				} catch (IOException e)
				{
					e.printStackTrace();
				}
			}
		}
	}
	/*
	 * 反序列化过程：将磁盘中的对象还原成内存中的Java对象
	 * 
	 */
	public void testObjectInputStream()
	{
		ObjectInputStream ois = null;
		try
		{
			ois = new ObjectInputStream(new FileInputStream("D:\\CODE\\codeeclipse\\Java基础\\src\\com\\java\\main\\data.txt"));
			Object obj = ois.readObject();
			String string = (String)obj;
			System.out.println(string);
		}catch(IOException e)
		{
			e.printStackTrace();
		} catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}finally
		{
			if(ois != null)
			{
				try
				{
					ois.close();
				} catch (IOException e)
				{
					e.printStackTrace();
				}
			}
		}
	}
}

自定义的类的对象如果需要序列化与反序列化，就需要实现Serializable接口，而且该类要提供一个全局常量serialVersionUID（用来标识序列化版本）
自定义类的所有属性都必须可序列化

class Person implements Serializable
{
	/**
	 * 需要提供一个全局常量 serialVersionUID 
	 */
	private static final long serialVersionUID = 1L;
	
	private String name;
	private int age;
	public Person(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public int getAge()
	{
		return age;
	}
	public void setAge(int age)
	{
		this.age = age;
	}
	@Override
	public String toString()
	{
		return "Person [name=" + name + ", age=" + age + "]";
	}	
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class TestObject
{
	public static void main(String[] args)
	{
		ObjectStream objectStream = new ObjectStream();
		objectStream.testObjectOutputStream();
		objectStream.testObjectInputStream();
	}
}
class ObjectStream
{
	/*
	 * 序列化过程：将内存中的Java对象保存到磁盘中或者通过网络传输出去
	 */
	public void testObjectOutputStream()
	{
		ObjectOutputStream oos = null;
		try
		{
			oos = new ObjectOutputStream(new FileOutputStream("D:\\CODE\\codeeclipse\\Java基础\\src\\com\\java\\main\\data.txt"));
			oos.writeObject(new Person("张三", 21)); // 序列化自定义的类对象person
			oos.flush(); // 刷新一下
		}catch(IOException e)
		{
			e.printStackTrace();
		}finally
		{
			if(oos != null)
			{
				try
				{
					oos.close();
				} catch (IOException e)
				{
					e.printStackTrace();
				}
			}
		}
	}
	/*
	 * 反序列化过程：将磁盘中的对象还原成内存中的Java对象
	 * 
	 */
	public void testObjectInputStream()
	{
		ObjectInputStream ois = null;
		try
		{
			ois = new ObjectInputStream(new FileInputStream("D:\\CODE\\codeeclipse\\Java基础\\src\\com\\java\\main\\data.txt"));
			Object obj = ois.readObject();
			Person person = (Person)obj;
			System.out.println(person);
		}catch(IOException e)
		{
			e.printStackTrace();
		} catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}finally
		{
			if(ois != null)
			{
				try
				{
					ois.close();
				} catch (IOException e)
				{
					e.printStackTrace();
				}
			}
		}
	}
}

2、RandomAccessFile

既可以实现输入，也可以实现输出

package com.java.main;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

public class TestRandom
{
	public static void main(String[] args)
	{
		RandomAccessFile raf1 = null;
		RandomAccessFile raf2 = null;
		try
		{
			raf1 = new RandomAccessFile(new File("C:\\Users\\zzps\\Pictures\\Saved Pictures\\手写签名照.jpg"), "r");
			raf2 = new RandomAccessFile(new File("C:\\Users\\zzps\\Pictures\\Saved Pictures\\手写签名照1.jpg"), "rw");
			
			byte[] bBuffer = new byte[1024];
			int len;
			while((len = raf1.read(bBuffer)) != -1)
			{
				raf2.write(bBuffer, 0, len);
			}
		}catch(IOException e)
		{
			e.printStackTrace();
		}finally
		{
			if(raf1 != null)
			{
				try
				{
					raf1.close();
				} catch (IOException e)
				{
					// TODO 自动生成的 catch 块
					e.printStackTrace();
				}
			}
			
			if(raf2 != null)
			{
				try
				{
					raf2.close();
				} catch (IOException e)
				{
					// TODO 自动生成的 catch 块
					e.printStackTrace();
				}
			}
		}
	}
}

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

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

相关文章

Java基础知识题(一)

Java基础知识题(一)

文章目录 前言 一 Java语言 1. Java为什么不直接实现Iterator接口&#xff0c;而是实现Iterable 2. 解释为什么Java被称作是“平台无关的编程语言”&#xff1f; 3. 请描述JDK和JRE的区别 &#xff1f; 4. 简述什么是值传递和引用传递&#xff1f;重点 5. 简述什么是迭…
阅读更多...
智慧工地监管云平台源码 建筑施工一体化信息管理系统源码

智慧工地监管云平台源码 建筑施工一体化信息管理系统源码

智慧工地管理云平台系统是一种利用人工智能和物联网技术来监测和管理建筑工地的系统。它可以通过感知设备、数据处理和分析、智能控制等技术手段&#xff0c;实现对工地施工、设备状态、人员安全等方面的实时监控和管理。 智慧工地平台系统工作原理&#xff1a; 1、感知设备的…
阅读更多...
读书笔记--数据治理的应用实践与展望

读书笔记--数据治理的应用实践与展望

继延续上一篇文章&#xff0c;终于到数据治理这本书的收尾了&#xff0c;这段时间忙&#xff0c;一直没有及时更新这部分内容&#xff0c;本文主要讲述一些相对成熟的数据治理应用实践案例、数据治理的6大准备工作、6大误区和5个技术展望&#xff0c;希望对大家在开展数据治理工…
阅读更多...
Cpp学习——list的模拟实现

Cpp学习——list的模拟实现

目录 一&#xff0c;实现list所需要包含的三个类 二&#xff0c;三个类的实现 1.list_node 2.list类 3.iterator_list类 三&#xff0c;功能实现 1.list类里的push_back() 2.iterator类里的运算符重载 3&#xff0c;list类里面的功能函数 1.insert&#xff08;&#xff…
阅读更多...
vue技术学习

vue技术学习

vue快速入门 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>vue快速入门</title> </head> <body> <!--老师解读 1. div元素不是必须的&#xff0c;也可以是其它元素&#xff0…
阅读更多...
【C++】做一个飞机空战小游戏(十)——子弹击落炮弹、炮弹与飞机相撞

【C++】做一个飞机空战小游戏(十)——子弹击落炮弹、炮弹与飞机相撞

[导读]本系列博文内容链接如下&#xff1a; 【C】做一个飞机空战小游戏(一)——使用getch()函数获得键盘码值 【C】做一个飞机空战小游戏(二)——利用getch()函数实现键盘控制单个字符移动【C】做一个飞机空战小游戏(三)——getch()函数控制任意造型飞机图标移动 【C】做一个飞…
阅读更多...
回归预测 | MATLAB实现SA-SVM模拟退火算法优化支持向量机多输入单输出回归预测（多指标，多图）

回归预测 | MATLAB实现SA-SVM模拟退火算法优化支持向量机多输入单输出回归预测（多指标，多图）

回归预测 | MATLAB实现SA-SVM模拟退火算法优化支持向量机多输入单输出回归预测&#xff08;多指标&#xff0c;多图&#xff09; 目录 回归预测 | MATLAB实现SA-SVM模拟退火算法优化支持向量机多输入单输出回归预测&#xff08;多指标&#xff0c;多图&#xff09;效果一览基本…
阅读更多...
【华为鸿蒙3.0/荣耀安卓12使用VMOS Pro的激活方式】

【华为鸿蒙3.0/荣耀安卓12使用VMOS Pro的激活方式】

关于华为鸿蒙3.0/荣耀安卓12如何解除进程限制&#xff0c;这里提供以下教程供小伙伴们参考。 需要准备&#xff1a;电脑一台&#xff0c;数据线一根。 第一步&#xff1a;打开手机USB调试模式。 确保USB数据线已连接手机和电脑&#xff0c;打开手机“开发者选项”&#xff0…
阅读更多...
Monitor.Analog产品老化试验软件概要设计

Monitor.Analog产品老化试验软件概要设计

Monitor.Analog产品老化试验软件概要设计&#xff1a; 1. 引言&#xff1a; 模拟量采集软件的目标是实现对模拟量信号的采集、处理和展示。该软件旨在提供一个用户友好的界面&#xff0c;允许用户配置采集参数、实时监测模拟量信号&#xff0c;并提供数据分析和导出功能。 2. 功…
阅读更多...
K210学习笔记——三角函数下的目标追踪

K210学习笔记——三角函数下的目标追踪

各位正在读文章的朋友们你们好&#xff0c;本人为非专业学生&#xff0c;如有不对的地方&#xff0c;期待您的指正。 目标追踪的意思是&#xff1a;识别到目标物体&#xff0c;通过舵机转动&#xff0c;朝向目标物体. 实验器材&#xff1a;二自由度舵机云台加两个SG90舵机&…
阅读更多...
预警：传统的QA岗位将被DevOps淘汰

预警：传统的QA岗位将被DevOps淘汰

导读在大多数机构或公司里&#xff0c;软件开发过程主要遵循一个或多个开发模型&#xff0c;例如瀑布模型或敏捷模型。在瀑布模型中&#xff0c;测试活动一般都在后期进行。软件开发完成后&#xff0c;缺陷被QA团队找出&#xff0c;然后再被修复。后两个活动不断循环和重复&…
阅读更多...
Python基础语法入门(第二十三天)——正则表达式

Python基础语法入门(第二十三天)——正则表达式

正则表达式是一种文本模式&#xff0c;用于匹配字符串&#xff0c;它是由字符和特殊字符组成的模式。正则表达式可以用于验证、搜索、替换和提取字符串。其能够应用于各种编程语言和文本处理工具中&#xff0c;如Python、Java、JavaScript等。 正则表达式在线测试工具&#xf…
阅读更多...
Spring源码编译-for mac

Spring源码编译-for mac

超详细的spring源码编译 记&#xff1a;编译成功时间&#xff1a;2023.08.19 环境准备&#xff1a; 1.idea 2023.1.1 Community Edition 2.jdk1.8 3.gradlegradle-5.6.4 4.spring源码(版本&#xff1a;spring-framework-v5.2.25.RELEASE) 一.spring源码下载 github 加速网站&…
阅读更多...
stm32单片机4个开关控制8个LED灯，4种不同模式参考源代码（附带PROTEUS电路图）

stm32单片机4个开关控制8个LED灯，4种不同模式参考源代码（附带PROTEUS电路图）

//main.c文件 /* USER CODE BEGIN Header */ /********************************************************************************* file : main.c* brief : Main program body************************************************************************…
阅读更多...
0101前期准备-大数据学习

0101前期准备-大数据学习

文章目录 1 前言2 配置VMware虚拟机2.1 设置主机名和固定IP2.2 本地系统与Linux系统配置主机名映射2.3 配置虚拟机之间用户的SSH免密互通2.4 安装JDK环境2.5 关闭防火墙和SELinux2.6 更新时区和同步时间2.7 保存虚拟机快照 结语 1 前言 我们从基础的hadoop开始学起&#xff0c;…
阅读更多...
Python上楼梯问题：递归解法探究（斐波那契变种）（记忆化递归）

Python上楼梯问题：递归解法探究（斐波那契变种）（记忆化递归）

文章目录 上楼梯问题&#xff1a;递归解法探究问题定义解决方案1. 递归2. 记忆化递归关于python memo{}默认参数和字典的语法语法功能版本信息注意事项 结论 上楼梯问题&#xff1a;递归解法探究 在这篇文章中&#xff0c;将对上楼梯问题进行深入探讨。上楼梯问题是一种常见的…
阅读更多...
2D应用开发是选择WebGL 还是选择Canvas？

2D应用开发是选择WebGL 还是选择Canvas？

推荐&#xff1a;使用 NSDT场景编辑器 助你快速搭建可二次编辑的3D应用场景 在介绍WebGL和Canvas的区别和联系之前&#xff0c;需要先了解它们各自的定义和特点。 WebGL是一种基于标准HTML5的技术&#xff0c;用于在Web浏览器中实时渲染3D图形。它是由Khronos Group开发的一套…
阅读更多...
C++系列-内存模型

C++系列-内存模型

内存模型 内存模型四个区代码区全局区栈区堆区内存开辟和释放在堆区开辟数组 内存模型四个区 不同区域存放的数据生命周期是不同的&#xff0c;更为灵活。 代码区&#xff1a;存放函数体的二进制代码&#xff0c;操作系统管理。全局区&#xff1a;存放全局变量&#xff0c;常…
阅读更多...
工厂模式的三种姿态？

工厂模式的三种姿态？

在软件工程中常见的设计模式——工厂模式。工厂模式是一种有力的工具&#xff0c;用于创建对象实例的方式&#xff0c;可以帮助我们更好地组织代码和降低耦合性。在本文中&#xff0c;我将为大家详细介绍工厂模式的三种姿态&#xff0c;同时通过举例和代码演示来帮助大家更好地…
阅读更多...
Docker环境安装elasticsearch和kibana

Docker环境安装elasticsearch和kibana

一、安装elasticsearch 创建es-network&#xff0c;让es、kibana在同一个网段&#xff1a; docker network create --driverbridge --subnet192.168.1.10/24 es-network运行elasticsearch docker run -d \ --name elasticsearch \ # 容器名 --hostname elasticsearch # 主机…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023