Skip to content
程序猿DD程序猿DD
主页
最新发布
Java新特性
玩转IDEA
旧版博客open in new window
社区交流open in new window
  • Java 18

    • 指定UTF-8为默认字符集
      • 简单Web服务器
        • 新增@snippet标签
        • Java 17

          • 密封类
            • switch的模式匹配(预览)
            • Java 16

              • record类
                • 声明record类
                  • record类详解
                    • 定义成员函数
                    • instanceof增强
                      • Stream转List增强
                        • Stream.toList()的性能比较
                        • Java 15

                          • 文本块
                            • 隐藏类
                            • Java 14

                              • switch表达式增强
                              • Java 13

                                • Java 12

                                  • Java 11

                                    • 移除JavaEE和CORBA模块
                                    • Java 10

                                      • 局部变量的类型推断
                                      • Java 9

                                        • 交互式编程环境JShell
                                          • 不可变集合的快捷创建方法

                                          Java 16 新特性:record类

                                          程序猿DD原创2022年5月10日
                                          • Java
                                          • Java 16
                                          大约 2 分钟

                                          此页内容
                                          • 声明record类
                                          • record类详解
                                          • 定义成员函数

                                          # Java 16 新特性:record类

                                          以前我们定义类都是用class关键词,但从Java 16开始,我们将多一个关键词record,它也可以用来定义类。record关键词的引入,主要是为了提供一种更为简洁、紧凑的final类的定义方式。

                                          下面就来具体了解record类的细节。

                                          # 声明record类

                                          声明record类的基础语法:

                                          record range(int start, int end){}
                                          

                                          我们知道class类可以在单独文件中生命,也可以在其他类中申明。那么record类也一样,它有这几种申明方式:

                                          1. 单独文件申明:
                                          public record range(int start, int end){}
                                          
                                          1. 在类内部申明:
                                          public class DidispaceTest {
                                              public record range(int start, int end){}
                                          }
                                          
                                          1. 函数内申明:
                                          public class DidispaceTest {
                                            public void test() {
                                              public record range(int start, int end){}
                                            }
                                          }
                                          

                                          # record类详解

                                          在知道了如何申明之后,你一定会想用record申明的就那么点元素,它到底会具备什么能力呢?

                                          因为record关键词申明类主要是为了简化一些类的申明,所以它本质就是一类特殊的class,或者说是某一个模版的class。

                                          record申明的类,具备这些特点:

                                          1. 它是一个final类
                                          2. 自动实现equals、hashCode、toString函数
                                          3. 成员变量均为public属性

                                          所以,对于之前写的range类,它等价于一个这样的类:

                                          public final class range{
                                              final int start;
                                              final int end;
                                          
                                              public range(int start, int end) {
                                                  this.start = start;
                                                  this.end = end;
                                              }
                                          
                                              @Override
                                              public boolean equals(Object o) {
                                                  if (this == o) return true;
                                                  if (o == null || getClass() != o.getClass()) return false;
                                                  range range = (range) o;
                                                  return start == range.start && end == range.end;
                                              }
                                          
                                              @Override
                                              public int hashCode() {
                                                  return Objects.hash(start, end);
                                              }
                                          
                                              @Override
                                              public String toString() {
                                                  return "range{" +
                                                          "start=" + x +
                                                          ", end=" + y +
                                                          '}';
                                              }
                                          
                                              public int start(){
                                                  return start;
                                              }
                                          
                                              public int end(){
                                                  return end;
                                              }
                                          }
                                          

                                          因为一些函数是隐藏的,在range定义的时候,我们看不到,所以我们可以尝试写这样一段测试代码来验证一下:

                                          @Test
                                          public void test() {
                                            range r = new range(100, 200);
                                            log.info(r.toString());
                                          
                                            range r2 = new range(100, 200);
                                            log.info(String.valueOf(r.equals(r2)));
                                          }
                                          

                                          # 定义成员函数

                                          因为record申明的本质也是类,那么定义成员函数肯定也是可以的。

                                          比如,我们可以这样在record类中定义成员函数:

                                          record range(int start, int end){
                                            int distance(){
                                              return end - start;
                                            }
                                          }
                                          

                                          然后,就可以这样调用它:

                                          range r = new range(100, 200);
                                          r.distance();
                                          

                                          本期视频:https://www.bilibili.com/video/BV1vY4y1b71m/open in new window

                                          如果您学习过程中如遇困难?可以加入我们超高质量的技术交流群open in new window,参与交流与讨论,更好的学习与进步!另外,不要走开,关注我,持续更新Java新特性专栏open in new window!

                                          上次编辑于: 2022/5/21 02:29:53
                                          贡献者: dd
                                          下一页
                                          instanceof增强
                                          © 2016 - 2022 didispace.com 版权所有
                                          沪ICP备14037150号-3
                                          Copyright © 2022 程序猿DD