day02 final、static、接口

最新推荐文章于 2024-10-17 19:11:48 发布
最新推荐文章于 2024-10-17 19:11:48 发布
阅读量88 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45487447/article/details/115234487
版权
本文详细介绍了Java中的final、static和接口的关键概念。final用于声明不可改变的类、方法和变量，防止继承和改写。static关键字修饰的成员变量和方法属于类，无需对象即可访问。接口作为方法集合，包含抽象方法、默认方法和静态方法，一个类可以实现多个接口并重写其方法。通过实例展示了抽象类和接口的应用，强调了它们在多继承和扩展性上的不同角色。
摘要由CSDN通过智能技术生成

day02 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. 显示初始化；（试过，不可以，没有提供修改的入口）

  2. 此时无法修改值

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

  3. 构造方法初始化。

  4. 也无法修改值，没有set方法

    public class User {
    final String USERNAME ;
    private int age;
    public User(String username, int age) {
        this.USERNAME = username;
        this.age = age;
    }
}
  1. final 修饰的参数

final 关键字还可以修饰参数，它意味着参数在方法体内不能被再修改：

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

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

第二章 static关键字

2.1 概述

修饰成员变量

修饰方法

在《Java编程思想》P86页有这样一段话：

“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”

这段话虽然只是说明了static方法的特殊之处，但是可以看出static关键字的基本作用，简而言之，一句话来描述就是：

方便在没有创建对象的情况下来进行调用（方法/变量）。

很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。

2.2 定义和使用格式

类变量

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

static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

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类中定义静态方法

class MyObject {
private static String s1="s1";
private  String s2="s2";

public MyObject(){}

public void print(){
   System.out.println(s1);
   System.out.println(s2);
}

public static void print2(){
   System.out.println(s1);
}
}
class a{
 public static void main(String[] args) {
   MyObject.print2();
 }
    @Test
	 public void tt(){
	 	MyObject.print2();
	 }
}

在上面的代码中，由于print2方法是独立于对象存在的，可以直接用过类名调用。

假如说可以在静态方法中访问非静态方法/变量的话，那么如果在main方法中有下面一条语句：

MyObject.print2();

此时对象都没有，str2根本就不存在，所以就会产生矛盾了。同样对于方法也是一样，由于你无法预知在print1方法中是否访问了非静态成员变量，所以也禁止在静态成员方法中访问非静态成员方法。

而对于非静态成员方法，它访问静态成员方法/变量显然是毫无限制的。

因此，如果说想在不创建对象的情况下调用某个方法，就可以将这个方法设置为static。我们最常见的static方法就是main方法，至于为什么main方法必须是static的，现在就很清楚了。因为程序在执行main方法的时候没有创建任何对象，因此只有通过类名来访问。

另外记住，即使没有显示地声明为static，类的构造器实际上也是静态方法。

  • 静态方法调用的注意事项：
    • 静态方法可以直接访问类变量和静态方法。
    • 静态方法不能直接访问普通成员变量或成员方法。成员方法可以直接访问类变量或静态方法。
    • 静态方法中，不能使用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 其他成员特点

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

3.7 抽象类和接口的练习

通过实例进行分析和代码演示抽象类和接口的用法。

1、举例：

​ 犬：

​ 行为：

​ 吼叫；

​ 吃饭；

​ 缉毒犬：

​ 行为：

​ 吼叫；

​ 吃饭；

​ 缉毒；

2、思考：

​ 由于犬分为很多种类，他们吼叫和吃饭的方式不一样，在描述的时候不能具体化，也就是吼叫和吃饭的行为不能明确。当描述行为时，行为的具体动作不能明确，这时，可以将这个行为写为抽象行为，那么这个类也就是抽象类。

​ 可是有的犬还有其他额外功能，而这个功能并不在这个事物的体系中 , 例如 : 缉毒犬。缉毒的这个功能有好多种动物都有 , 例如 : 缉毒猪 , 缉毒鼠。我们可以将这个额外功能定义接口中 ,让缉毒犬继承犬且实现缉毒接口 , 这样缉毒犬既具备犬科自身特点也有缉毒功能。

//定义缉毒接口 缉毒的词组(anti-Narcotics)比较长,在此使用拼音替代
interface JiDu{
    //缉毒
	public abstract void jiDu();
}
//定义犬科,存放共性功能
abstract class Dog{
    //吃饭
	public abstract void eat();
    //吼叫
	public abstract void roar();
}
//缉毒犬属于犬科一种，让其继承犬科，获取的犬科的特性，
//由于缉毒犬具有缉毒功能，那么它只要实现缉毒接口即可，这样即保证缉毒犬具备犬科的特性，也拥有了缉毒的功能
class JiDuQuan extends Dog implements JiDu{
	public void jiDu() {
	}
	void eat() {
	}
	void roar() {
	}
}

//缉毒猪
class JiDuZhu implements JiDu{
	public void jiDu() {
	}
}

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

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

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

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

weixin_45487447
关注
专栏目录
为什么final通常与static连用
m1234ilu的博客
10-16 1107
Java关键字final、static使用总结，以及String类为什么是final类
weixin_30443731的博客
09-12 319
一、Static static表示“全局”或者“静态”的意思 用来修饰成员变量和成员方法，也可以形成静态static代码块。 1.非static数据和方法 类中普通声明的数据和方法都是非static的，即不加static进行修饰，对于这类数据和方法我们在使用的时候都是只能通过创建对象实例后，通过实例进行调用。 public class StaticTest { ...
java接口，private，final，static组合（课堂）
501846585_QQAndroid_java
01-14 1142
package com.qianfeng.day10.demo5;   //private final static组合修饰接口中的属性   //运用场景：工具类  public class SingleInstance {               //3、一个可以缓存唯一实例的对象        privatefinal
学点儿Java_Day8_接口、final、static、工具类
Mr_Tang4的博客
03-22 730
接口是一个纯粹的抽象类（接口里面所有的方法都是抽象方法）接口就是一个规范(标准)，他没有提供任何是实现，具体的功能由实现接口的子类去实现。接口就是一个规范，可插拔（可以被替换，首先定义一个标准（接口），大家都遵守这个标准，就可以实现互相之间替换）① 接口是一个纯粹的抽象类，接口里面的方法都是抽象方法：public abstract② 接口里面所有的属性：(public static final) double PI = 3.14;接口中的所有属性****,见后面。
（static、接口和多态）javaSE查漏补缺day02
休哥哥的博客
11-18 463
static+多态1.子父类之间可以实现方法的重载。2.构造方法调用自己的构造方法，只能用this()不能用类名（）？3.static修饰变量，加载到方法区的，静态存储区。4.static final 静态常量，公有且不能更改。5.静态成员和方法--优先普通成员和方法进入内存6.静态方法中，不能使用this，super关键字？7.静态代码块：初始化某些静态成员属性的。8.类加载时的初始化顺序9.一个类实现了一个接口同时继承了一个父类，若再父类和接口中出现同名同类型成员变量会怎么样？10.必须先继承后实现（否
《Head First Java》Day3 接口与多态 重载构造函数 static和final
Zheng_LH
08-06 140
《Head First Java》Day3接口与多态重载构造函数Static & Final 接口与多态 重载构造函数 Static & Final 每日一乐
day07 final、单例设计模式、枚举、抽象类、接口
zhangnobill的博客
07-21 1226
修饰符 enum 枚举类名{名称1，名称2...；X,Y,Z;abstract修饰类，这个类就是抽象类。abstract修饰方法，这个方法就是抽象方法。只有方法签名，不能写方法体。修饰符 abstract class 类名{ 修饰符 abstract 返回值类型 方法名称(形参列表)；
private static final long serialVersionUID = 1L
early_day的博客
04-21 3942
很显然这行代码的意思是将SerialVersionUID的值定义为一个常量，那这是干什么的呢？ 解决这个问题，首先要了解包含SerialVersionUID的Serializable接口是什么？ Serializable：一个对象序列化的接口，一个类只有实现了Serializable接口，它的对象才能被序列化。Serializable是java.io包中定义的、用于实现Java类的序列化操作而提供的一个语义级别的接口。Serializable序列化接口没有任何方法或者字段，只是用于标识可序列化的语义。
day01-继承，final，static，权限修饰符总结
06-29
通过今天的学习内容进行总结，避免遗忘，加强记忆
day11_static、内部类、权限、参数传递、复习.pdf
11-02
使用`public static final`关键字定义的变量通常被视为静态常量，其名称通常采用全大写字母和下划线分隔的约定，例如： ```java public class Constants { public static final int MAX_VALUE = 100; } ``` ...
day11【final、权限、内部类】1
08-04
Java 中的 final 关键字、权限修饰符和内部类 final 关键字是 Java 中的一个重要概念，它用于修饰类、方法和变量，以确保它们不可被改变。下面我们将详细介绍 final 关键字的概念、使用方式和特点。 final 关键字...
java中的修饰符static与静态方法及final的用法
奔跑的乌龟的专栏
11-08 4011
一、static   修饰属性，方法，代码块 1、静态方法：    使这个方法成为整个类所公有的方法，可以用   类名.方法名  直接访问           注意：static修饰的方法，不能直接访问（可以通过组合方式访问）本类中的非静态(static)成员（包括方法和属性）          本类的非静态（static）方法可以访问本类的静态成员（包括方法和属性），可以调用静态方法
static、final关键字、public等四种权限修饰符
qq_42424228的博客
07-20 763
static的概念 成员变量使用static 成员变脸加了static之后，这个成员变量不再属于某一个单独的对象，而是属于这个类创建出来的所有对象。所有对象共享同一数据。
内部类 static final
weixin_50837529的博客
07-30 234
既然有内部类那肯定有外部类，什么是外部类，就是没有被其它类包裹的类就是外部类而内部类就是被其他类包裹的类内部类的对象为Outer.Inner需要先通过创建外部类才能创建内部类外部类声明为static之后爆红，因为不允许这样修饰它，但是内部类可以被static进行修饰。我们声明一个静态方法在内部类中控制台中打印出这句话，可见是可以访问到的。访问静态成员变量这段代码如何执行，说说你的答案this是指代当前的对象Outer.this是Outer类的引用。...
Day27_7 Java学习之final、枚举与接口
weixin_43717536的博客
07-27 335
1.实例有限而且固定的类，在Java里被称为枚举类。2.Java枚举是一个特殊的类，一般表示一组常量。3.声明枚举时必须使用enum关键字，各个常量使用逗号,来分割。解析1.接口（英文Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。2.接口是Java中的一种类型【引用数据类型】方法，常量。3.接口是Java中的一种类型，没有构造方法，而且是抽象类型，不能直接创建对象使用。4.和抽象类很相似，需要定义子类去实现接口。.........
java 异常包装
最新发布
fdvvg的博客
10-17 215
通过异常包装，可以在Java中有效地处理和传递异常。这样做不仅能保持原始异常的信息，还能为上层调用者提供更多的上下文信息。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 357
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
private static final long serialVersionUID = 1L;
08-19
在Java中，private static final long serialVersionUID = 1L; 是一个用于序列化和反序列化的特殊字段。它的作用是确保在类的结构发生改变时仍能够正确地反序列化对象。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [private static final Long serialVersionUID= 1L详解](https://blog.csdn.net/m0_50370837/article/details/129017300)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* [private static final long serialVersionUID = 1L](https://blog.csdn.net/early_day/article/details/124331014)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值