final、static、接口

最新推荐文章于 2024-07-31 19:38:21 发布
最新推荐文章于 2024-07-31 19:38:21 发布
阅读量167 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Java_DDDog/article/details/106153717
版权

【final、static、接口】

今日内容

  • final关键字

  • static

  • 接口

第一章 final关键字

1.1 概述

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了final 关键字，用于修饰不可改变内容。

  • final： 不可改变。可以用于修饰类、方法和变量。
    • 类：被修饰的类，不能被继承。
    • 方法：被修饰的方法，不能被重写。
    • 变量：被修饰的变量，不能被重新赋值。

1.2 使用方式

修饰类

格式如下：

final class 类名 {
  
}

查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

修饰方法

格式如下：

修饰符 final 返回值类型 方法名(参数列表){
    //方法体
}

重写被 final修饰的方法，编译时就会报错。

修饰变量

  • 局部变量——基本类型

基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：

public class FinalDemo1 {
    public static void main(String[] args) {
        // 声明变量，使用final修饰
        final int a;
        // 第一次赋值 
        a = 10;
        // 第二次赋值
        a = 20; // 报错,不可重新赋值
    }
}

思考，如下两种写法，哪种可以通过编译？

写法1：

final int c = 0;
for (int i = 0; i < 10; i++) {
    c = i;
    System.out.println(c);
}

写法2：

for (int i = 0; i < 10; i++) {
    final int c = i;
    System.out.println(c);
}

根据 final 的定义，写法1报错！写法2，为什么通过编译呢？因为每次循环，都是一次新的变量c。这也是大家需要注意的地方。

  • 局部变量——引用类型

引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改，代码如下：

public class FinalDemo2 {
    public static void main(String[] args) {
        // 创建 User 对象
        final   User u = new User();
        
        // 创建 另一个 User对象
        // u = new User(); // 报错，指向了新的对象，地址值改变。

        // 调用setName方法
        u.setName("张三"); // 可以修改
    }
}
  • 成员变量

成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

  1. 显示初始化；

    public class User {
    final String USERNAME = "张三";
    private int age;
}

  2. 构造方法初始化。

    public class User {
    final String USERNAME ;
    private int age;
    public User(String username, int age) {
        this.USERNAME = username;
        this.age = age;
    }
}

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

小结：final修饰类，类不能被继承。 final修饰方法，方法不能被重写。final修饰变量，变量不能被改值。

第二章 static关键字

2.1 概述

static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。static修饰的成员被多个对象共享。static修饰的成员属于类，但是会影响每一个对象。被static修饰的成员又叫类成员**，不叫对象的成员。

2.2 定义和使用格式

类变量

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

  • 类变量：使用 static关键字修饰的成员变量。

定义格式：

static 数据类型 变量名；

举例：

static String room；

比如说，同学们来黑马程序员学校学习,那么我们所有同学的学校都是黑马程序员, 不因每个同学不同而不同。

所以，我们可以这样定义一个静态变量school，代码如下：

public class Student {
  private String name;
  private int age;
  // 类变量，记录学生学习的学校
  public static String school = "黑马程序员学校";

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

  // 打印属性值
  public void show() {
    System.out.println("name=" + name + ", age=" + age + ", shool=" + shool );
  }
}

public class StuDemo {
  public static void main(String[] args) {
    Student s1 = new Student("张三", 23);
    Student s2 = new Student("李四", 24);
    Student s3 = new Student("王五", 25);
    Student s4 = new Student("赵六", 26);

    s1.show(); // Student : name=张三, age=23, shool=黑马程序员学校
    s2.show(); // Student : name=李四, age=24, shool=黑马程序员学校
    s3.show(); // Student : name=王五, age=25, shool=黑马程序员学校
    s4.show(); // Student : name=赵六, age=26, shool=黑马程序员学校
  }
}

静态方法

当static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。

  • 类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

定义格式：

修饰符 static 返回值类型 方法名 (参数列表){ 
	// 执行语句 
}

举例：在Student类中定义静态方法

public static void showNum() {
  System.out.println("num:" +  numberOfStudent);
}
  • 静态方法调用的注意事项：

    • 静态方法可以直接访问类变量和静态方法。

    • 静态方法不能直接访问非静态成员变量或成员方法。非静态成员方法可以直接访问类变量或静态方法。

      主要是因为先加载类到方法区，直接使用类名调用静态方法了，而此时还没有对象，而非静态方法必须有对象才可以运行。所以静态方法中不能使用非静态成员。但是非静态方法可以使用静态成员，因为对象已经有了，说明类肯定存在了(先有类后有对象)

    • 静态方法中，不能使用this关键字。

小贴士：静态方法只能访问静态成员。

调用格式

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

格式：

// 访问类变量
类名.类变量名；

// 调用静态方法
类名.静态方法名(参数)；

调用演示，代码如下：

public class StuDemo2 {
  public static void main(String[] args) {      
    // 访问类变量
    System.out.println(Student.numberOfStudent);
    // 调用静态方法
    Student.showNum();
  }
}

小结：static修饰的内容是属于类的，可以通过类名直接访问

第三章 接口

3.1 概述

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8）。

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

public class 类名.java–>.class

public interface 接口名.java–>.class

引用数据类型：数组，类，接口。

接口的使用，它不能创建对象，但是可以被实现（implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

3.2 定义格式

public interface 接口名称 {
    // 抽象方法
    // 默认方法
    // 静态方法
}

含有抽象方法

抽象方法：使用abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

代码如下：

public interface InterFaceName {
    public abstract void method();
}

含有默认方法和静态方法

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。

静态方法：使用 static 修饰，供接口直接调用。

代码如下：

public interface InterFaceName {
    public default void method() {
        // 执行语句
    }
    public static void method2() {
        // 执行语句    
    }
}

小结：定义接口时就是将定义类的class改成了interface，并且接口中的内容也有了一些变化。

3.3 基本的实现

实现的概述

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

非抽象子类实现接口：

  1. 必须重写接口中所有抽象方法。
  2. 继承了接口的默认方法，即可以直接调用，也可以重写。

实现格式：

class 类名 implements 接口名 {
    // 重写接口中抽象方法【必须】
  	// 重写接口中默认方法【可选】
}

抽象方法的使用

必须全部实现，代码如下：

定义接口：

public interface LiveAble {
    // 定义抽象方法
    public abstract void eat();
    public abstract void sleep();
}

定义实现类：

public class Animal implements LiveAble {
    @Override
    public void eat() {
        System.out.println("吃东西");
    }

    @Override
    public void sleep() {
        System.out.println("晚上睡");
    }
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象  
        Animal a = new Animal();
        // 调用实现后的方法
        a.eat();
        a.sleep();
    }
}
输出结果：
吃东西
晚上睡

默认方法的使用

可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

  1. 继承默认方法，代码如下：

定义接口：

public interface LiveAble {
    public default void fly(){
        System.out.println("天上飞");
    }
}

定义实现类：

public class Animal implements LiveAble {
	// 继承，什么都不用写，直接调用
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象  
        Animal a = new Animal();
        // 调用默认方法
        a.fly();
    }
}
输出结果：
天上飞
  1. 重写默认方法，代码如下：

定义接口：

public interface LiveAble {
    public default void fly(){
        System.out.println("天上飞");
    }
}

定义实现类：

public class Animal implements LiveAble {
    @Override
    public void fly() {
        System.out.println("自由自在的飞");
    }
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象  
        Animal a = new Animal();
        // 调用重写方法
        a.fly();
    }
}
输出结果：
自由自在的飞

静态方法的使用

静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，代码如下：

定义接口：

public interface LiveAble {
    public static void run(){
        System.out.println("跑起来~~~");
    }
}

定义实现类：

public class Animal implements LiveAble {
	// 无法重写静态方法
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // Animal.run(); // 【错误】无法继承方法,也无法调用
        LiveAble.run(); // 
    }
}
输出结果：
跑起来~~~

小结： 类实现接口使用的是implements关键字，并且一个普通类实现接口，必须要重写接口中的所有的抽象方法

3.4 接口的多实现

之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

实现格式：

class 类名 extends 父类名 implements 接口名1,接口名2,接口名3... {
    // 重写接口中抽象方法【必须】
  	// 重写接口中默认方法【不重名时可选】
}

[ ]： 表示可选操作。

抽象方法

接口中，有多个抽象方法时，实现类必须重写所有抽象方法**。如果抽象方法有重名的，只需要重写一次。**代码如下：

定义多个接口：

interface A {
    public abstract void showA();
    public abstract void show();
}

interface B {
    public abstract void showB();
    public abstract void show();
}

定义实现类：

public class C implements A,B{
    @Override
    public void showA() {
        System.out.println("showA");
    }

    @Override
    public void showB() {
        System.out.println("showB");
    }

    @Override
    public void show() {
        System.out.println("show");
    }
}

默认方法

接口中，有多个默认方法时，实现类都可继承使用。**如果默认方法有重名的，必须重写一次。**代码如下：

定义多个接口：

interface A {
    public default void methodA(){}
    public default void method(){}
}

interface B {
    public default void methodB(){}
    public default void method(){}
}

定义实现类：

public class C implements A,B{
    @Override
    public void method() {
        System.out.println("method");
    }
}

静态方法

接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

优先级的问题

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。代码如下：

定义接口：

interface A {
    public default void methodA(){
        System.out.println("AAAAAAAAAAAA");
    }
}

定义父类：

class D {
    public void methodA(){
        System.out.println("DDDDDDDDDDDD");
    }
}

定义子类：

class C extends D implements A {
  	// 未重写methodA方法
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        C c = new C();
        c.methodA(); 
    }
}
输出结果:
DDDDDDDDDDDD

小结： 一个类可以实现多个接口，多个接口之间使用逗号隔开即可。

3.5 接口的多继承【了解】

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。**如果父接口中的默认方法有重名的，那么子接口需要重写一次。**代码如下：

定义父接口：

interface A {
    public default void method(){
        System.out.println("AAAAAAAAAAAAAAAAAAA");
    }
}

interface B {
    public default void method(){
        System.out.println("BBBBBBBBBBBBBBBBBBB");
    }
}

定义子接口：

interface D extends A,B{
    @Override
    public default void method() {
        System.out.println("DDDDDDDDDDDDDD");
    }
}

小贴士：

子接口重写默认方法时，default关键字保留。

子类重写默认方法时，default关键字不可以保留。

小结：接口和接口之间是继承的关系，而不是实现。一个接口可以继承多个接口。

3.6 其他成员特点

成员位置

1.抽象方法

2.默认方法

3.静态方法

4.私有方法

5.常量

  • 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
  • 接口中，没有构造方法，不能创建对象。
  • 接口中，没有静态代码块。

3.7接口和抽象类

抽象类：
	本质是一个类class
	抽象类有构造方法，抽象类我们不能创建对象
	可以有抽象方法
接口：
	本质是一个interface
	接口没有构造方法，也不能创建对象
	方法不加修饰符，自动就是抽象方法
	
接口的作用：
	弥补了单继承的问题，因为接口可以同时实现多个
	
共同点：
	接口和抽象类都要有子类。

3.8抽象类和接口的综合案例

  • 案例图：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-shXNuWl4-1589587269346)(E:/itcast/day02/笔记/img/运动员案例.png)]

  • 用到的知识点：

    ​ 类、抽象类、接口、继承、实现

  • 代码实现：

    //人类
public abstract class Person {
    //姓名
    String name;
    //年龄
    int age;

    //构造方法
    public Person() {
    }

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

//运动员类
public abstract class Athlete extends Person {

    //提供自己的构造方法
    public Athlete() {
        //super();
    }

    public Athlete(String name, int age) {
        super(name, age);
    }

    //学习
    public abstract void study();
}

//教练类
public abstract class Coach extends Person {
    //编号
    String id;
    //空参构造
    public Coach() {
    }

    //有参构造
    public Coach(String name, int age, String id) {
        //姓名和年龄赋值给父类
        super(name, age);
        //编号赋值给自己的成员变量
        this.id = id;
    }
    
    //教学
    //父类中不知道到底教啥 定义成抽象方法  在子类中自己重写
    public abstract void teach();
}

//篮球运动员
public class BasketAthlete extends Athlete implements English{

    //构造方法

    public BasketAthlete() {
    }

    public BasketAthlete(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println(age +"岁的篮球运动员"+name + "在打篮球");
    }

    @Override
    public void speakEnglish() {
        System.out.println("篮球运动员出国说英语");
    }
}

//篮球教练
public class BasketCoach extends Coach implements English{
    //构造方法
    public BasketCoach() {
    }

    public BasketCoach(String name, int age, String id) {
        super(name, age, id);
    }

    @Override
    public void teach() {
        System.out.println("编号为" + id + "年龄为" + age + "姓名叫" + name + "的篮球教练教扣篮");
    }

    @Override
    public void speakEnglish() {
        System.out.println("篮球教练出国说英语");
    }
}

public class FootAthlete extends Athlete {
    //构造方法

    public FootAthlete() {
    }

    public FootAthlete(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println(age + "岁的足球运动员" + name + "在踢足球");
    }
}

//足球教练
public class FootCoath extends Coach {
    //构造方法

    public FootCoath() {
    }

    public FootCoath(String name, int age, String id) {
        super(name, age, id);
    }

    @Override
    public void teach() {
        System.out.println("编号为" + id + "年龄为" + age + "姓名叫" + name + "的足球教练教射门");
    }
}

//接口
public interface English {
    //学英语（抽象方法）
    void speakEnglish();
}

public class Demo测试类 {
    public static void main(String[] args) {
        //足球教练
        FootCoath fc = new FootCoath("柳岩",20,"001");
        //调用方法
        fc.teach();


        System.out.println("--------------");
        //篮球运动员
        BasketAthlete ba = new BasketAthlete("蔡徐坤",35);
        ba.study();
        ba.speakEnglish();
    }
}

​ 讲完抽象类和接口后,相信有许多同学会存有疑惑,两者的共性那么多,只留其中一种不就行了,这里就得知道抽象类和接口从根本上解决了哪些问题.

​ 一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口, 接口弥补了Java的单继承

​ 抽象类为继承体系中的共性内容, 接口为继承体系中的扩展功能

​ 接口还是后面一个知识点的基础(lambada)

Java_DDDog
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
抽象类实现接口的意义以及static与final的用法
qq30211478的博客
09-08 631
（一）抽象类和接口的注意事项 （二）接口 1、定义接口和接口中的方法，都是隐式抽象的。就是可以省略abstract，（写不写abstract都会识别），接口本质就是一个特殊的抽象类。 public 【abstract】 interface Person{ public 【static final】 String name=“aaa”； public 【abstract】void ...
Java基础11(接口 static关键字)
qq_52897007的博客
05-09 905
类--- class 接口--- interface修饰符 interface I接口名{1.抽象方法:public abstrcat 返回值类型 方法名();其中public abstrcat可以省略2.静态常量:public static final 数据类型 常量名=值;其中public static final可以省略[注]:●接口中的所有的修饰符均是public●常量自带 public static final//常量 有默认修饰符 变量不可存在。
Java中final关键字和接口
weixin_63541561的博客
12-18 456
final 用于修饰成员变量、局部变量、方法（不可以是构造方法）、类 接口定义：一种特殊的抽象类，用来定义功能，更彻底的抽象
Java接口以及static和final关键字
qq_52676445的博客
10-18 707
对Java接口和static、final关键字进行了简要总结
java final static顺序_java语言中 public static final的顺序在执行过程中有什么区别吗？...
weixin_42236014的博客
02-16 1190
final:final可以用来修饰：类、属性和方法用于修饰类：表示该类不可以被继承用于修饰属性：表示该属性不可以被修改用于修饰方法：表示该方法不可以被重写但是，final不可以用于修饰接口和抽象类staticstatic可以用作修饰：类、属性、方法、代码块用于修饰类：普通类不允许声明为静态的，只有内部类才可以。被static修饰的内部类可以直接作为一个普通类来使用。而不需要实例一个外部类用于修饰属...
接口中 public static final的关键字的作用
HurryRabbit的博客
04-08 519
static是为了让其成为类的成员，而不是对象的成员，这样用起来就方便了 public是为了方便访问 final则是表明这是个常量，不能修改 private的对象，然后定义get、set是为了访问控制，是一种常规的封装 综上，public static final可以让访问变得很方便，而且不会被修改。一般可以放配置信息，还有一些状态码的定义。 ...
【Java】为什么接口interface里的 变量是 static final 的？
u010900754的专栏
04-10 3822
今天突然问自己，接口的变量为什么是static和final的？static：必须。因为接口是可以多继承的。如果一个类实现了两个接口，且两个接口都具有相同名字的变量，此时这个变量可以被实现类使用，那么如果不是static的，这个变量来自哪一个接口就会产生歧义，所以实现类使用接口中的变量必须通过接口名指定，也就只能定为static的。看下面的例子：public interface iface1 { ...
static java 内存_final, static,final static 分别放在jvm内存的什么地方?
weixin_39946327的博客
02-20 3970
比如我写一个类：publicclassJvmTest{publicstaticStringst_static="hellostatic";publicfinalStringst_final="hellofinal";publicstaticfinalStringst_final_str="hellofinalstatic";publicstatic...
Java学习笔记(三)：接口中的变量，为什么是static final修饰的呢？
扛麻袋的少年的博客
04-24 1479
接口其实相当于更严格的一种公共类： ①接口中的数据对所有实现类只有一份，所以是static ②要使实现类为了向上转型成功(即：拿到的属性数据都是一样的)，所以必须是final。 比如接口A，A有变量value。实现类A1，A2，可以向上转型。假如代码中有一句： A a= null; a = new A1()或A2...
java，接口的变量为啥要是public static final？
热门推荐
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
08-01 1万+
jdk1.8中， 接口中的变量默认是public static final 接口中的方法默认是 public abstract，除非是static方法或者默认方法 接口中的变量默认是public static final？ public：接口可以被不同包的不同类实现，是公有的， static：一个类继承多个接口时，即使存在同名变量也不会混淆。如果每个接口都含有一个名为a的成员变量，那么在该类中可...
Java关键字final、static使用总结
08-30
Java中的final和static是两个非常重要的关键字，它们在编程中有着特定的作用和用途。 首先，final关键字用于声明不可变的对象、方法或类。当我们说一个东西是final时，意味着它不能被修改或重写。 1. **final类**...
Java final static abstract关键字概述
09-02
1. **成员变量**：接口中可以声明成员变量，这些变量默认为`public static final`类型，即常量，必须初始化。 2. **成员方法**：接口中的成员方法只有方法签名，没有方法体，即默认为`public abstract`。 3. **访问...
Java修饰符 abstract,static,final 的区别详解
09-05
Java修饰符`abstract`, `static`, `final`是Java编程语言中的关键概念，它们分别用于定义类、方法和变量的不同特性。以下是对这三个修饰符的详细解释： **1. abstract修饰符** `abstract`用于定义抽象类和抽象方法...
static与final的异同
01-14
在Java编程语言中，`static`和`final`都是关键字，它们用于定义不同的特性，但同时也有一些相似之处。下面我们将详细探讨这两个关键字的区别和用法。 首先，`static`关键字是用来声明类级别的变量或方法，这意味着...
static & main方法 & 代码块 & final & 接口 & 内部类
06-21
Java编程语言中的`static`, `main`方法, 代码块, `final`关键字, 接口和内部类是核心概念，对于理解和编写高效、可维护的Java程序至关重要。以下是对这些概念的详细解释： 1. **`static`关键字**： - `static`...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 499
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
最新发布
Karen198的博客
07-31 276
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 285
1.导入hutool的maven依赖。2.直接复制一下代码运行。
private static final long serialVersionUID
08-02
private static final long serialVersionUID是一个在Java中用于序列化的特殊字段。它是一个长整型的常量，用于标识序列化类的版本号。[1]在Java中，当一个类实现了Serializable接口时，它的对象可以被序列化和反...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值